Comment initialiser un tableau en une seule étape à l'aide de Ruby?

J'initialise un tableau de cette façon:

array = Array.new
array << '1' << '2' << '3'

Est-il possible de le faire en une seule étape? Si oui, comment?

+1 juste pour le roman d'une seule ligne répété à pousser. 🙂
légèrement plus courte: array = Array.new << 1 << 2 << 3 😉
Qui crée un tableau de Fixnums au lieu d'un tableau de chaînes de caractères.
je voulais juste mentionner qu'il peut même être plus courte. Vous avez juste à changer 1 à '1'.

InformationsquelleAutor user502052 | 2011-02-05

182

Vous pouvez utiliser un littéral de tableau:
```
array = [ '1', '2', '3' ]
```
Vous pouvez également utiliser une gamme:
```
array = ('1'..'3').to_a  # parentheses are required
# or
array = *('1'..'3')      # parentheses not required, but included for clarity
```
Pour les tableaux des espaces délimités par des chaînes, vous pouvez utiliser Pour cent syntaxe de la Chaîne de:
```
array = %w[ 1 2 3 ]
```
Vous pouvez également passer d'un bloc à Array.new pour déterminer la valeur de chaque entrée sera:
```
array = Array.new(3) { |i| (i+1).to_s }
```
Enfin, bien que cela ne produit pas le même tableau de trois cordes que les autres réponses ci-dessus, notez également que vous pouvez utiliser des agents recenseurs en Ruby 1.8.7+ pour créer des tableaux; par exemple:
```
array = 1.step(17,3).to_a
#=> [1, 4, 7, 10, 13, 16]
```
- Plus un pour la réponse détaillée, même si je préfère splat sur to_a ([*'1'..'3']).
- Je suis d'accord, j'étais sous l' (à tort) l'impression que tu ne pouvais pas splat des plages dans 1.8.6. Je vais ajouter que, grâce! Notez que vous n'avez pas besoin de splat dans un littéral de tableau (sauf si vous êtes la composition ainsi que le splat).
- Je sais, c'est juste que j'utilise surtout splat à cet effet (compositing), et j'aime aussi le fait qu'il montre ce que vous vous retrouvez avec.
- Aussi, la méthode de la classe Array::[] peuvent être utilisés: Array[ "1","2","3"] #=> ["1","2","3"] (je ne pense pas que cette méthode n'a rien à voir avec le littéral de tableau constructeur). Vous pouvez également utiliser le haut-niveau du Noyau#Array (nom de la méthode ressemble à un nom de classe) Array(1..5) #=> [1,2,3,4,5]
- ce que l' * ne? où je peux trouver de la documentation pour qui?
- Voir les sections "Tableau de Coercition" sur ce lien ou sur ce lien.
InformationsquelleAutor Phrogz
17

Oneliner:
```
array = [] << 1 << 2 << 3   #this is for fixnums.
```
ou
```
 a = %w| 1 2 3 4 5 |
```
ou
```
 a = [*'1'..'3']
```
ou
```
 a = Array.new(3, '1')
```
ou
```
 a = Array[*'1'..'3']
```
- pourquoi serait-on en bas de vote, c'est ....?
- Je n'ai pas voter, mais je suppose parce que ce invoqué trois méthodes et de manière progressive pousse le tableau, par opposition à [1,2,3] qui ne une seule initialisation. Aussi, le vôtre est plus de caractères. Aussi, vous avez créé un tableau de Fixnums alors que l'OP a une question sur un tableau de chaînes de caractères.
InformationsquelleAutor pankajdoharey
8

Avec les réponses ci-dessus , vous pouvez le faire aussi
```
    =>  [*'1'.."5"]   #remember *
    => ["1", "2", "3", "4", "5"]
```
- Dans 1,9 vous pouvez également le faire de cette façon: >> [*?1..?5] #=> ["1", "2", "3", "4", "5"].
InformationsquelleAutor RameshVel
7

Pour le prouver Il n'y a Plus De On Six Façons De le Faire:
```
plus_1 = 1.method(:+)
Array.new(3, &plus_1) # => [1, 2, 3]
```
Si 1.méthode(:+) n'était pas possible, vous pouvez également faire de
```
plus_1 = Proc.new {|n| n + 1}
Array.new(3, &plus_1) # => [1, 2, 3]
```
Sûr, c'est exagéré dans ce scénario, mais si plus_1 était vraiment une expression longue, vous pouvez la mettre sur une ligne distincte de la création de la matrice.

InformationsquelleAutor Andrew Grimm
3

Si vous avez un Tableau de chaînes de caractères, vous pouvez également initialiser comme ceci:

array = %w{1 2 3}

juste séparer chaque élément à n'importe quel espace

InformationsquelleAutor John Douthat
2

Pour créer un tableau que vous pouvez faire:
```
array = ['1', '2', '3']
```
InformationsquelleAutor Reese Moore
2

Vous pouvez faire
```
array = ['1', '2', '3']
```
Comme d'autres l'ont noté, vous pouvez également initialiser un tableau avec des %w notation comme suit:
```
array = %w(1 2 3)
```
ou
```
array = %w[1 2 3]
```
Veuillez noter que dans les deux cas, chaque élément est une chaîne de caractères, plutôt que d'un nombre entier.
Donc, si vous voulez un tableau dont les éléments sont des entiers, vous ne devriez pas envelopper chaque élément avec des apostrophes:
```
array_of_integers = [1, 2, 3]
```
Aussi, vous n'avez pas besoin de mettre une virgule entre les éléments (ce qui est nécessaire lors de la création d'un tableau sans cette %w notation). Si vous faites ceci (qui je le faisais souvent par erreur), comme dans:
```
wrong_array = %w(1, 2, 3)
```
ses éléments seront trois cordes ---- "1,", "2,", "3". Donc, si vous n':
```
puts wrong_array
```
la sortie sera:
```
1,
2,
3
=>nil
```
qui n'est pas ce que nous voulons ici.

Espère que cela aide à clarifier le point!

InformationsquelleAutor tg_freelancer
1

Vous pouvez initialiser un tableau en une seule étape par écrit les éléments de la [] comme ceci:
```
array = ['1', '2', '3']
```
InformationsquelleAutor sepp2k
0

Vous pouvez simplement le faire avec %w notation en ruby tableaux.
```
array = %w(1 2 3)
```
Il va ajouter de la matrice des valeurs 1,2,3 à la arrayand imprimer la sortie comme ["1", "2", "3"]

InformationsquelleAutor Prabhakar

Vous devez vous connecter pour publier un commentaire.