Ruby Language
Tableaux

Syntaxe

• a = [] # utilisant un littéral de tableau
• a = Array.new # équivalent à l'utilisation d'un littéral
• a = Array.new (5) # crée un tableau avec 5 éléments de valeur nulle.
• a = Array.new (5, 0) # crée un tableau avec 5 éléments avec une valeur par défaut de 0.

#carte

#map , fourni par Enumerable, crée un tableau en invoquant un bloc sur chaque élément et en collectant les résultats:

[1, 2, 3].map { |i| i * 3 }
# => [3, 6, 9]

['1', '2', '3', '4', '5'].map { |i| i.to_i }
# => [1, 2, 3, 4, 5]

Le tableau d'origine n'est pas modifié. un nouveau tableau est renvoyé contenant les valeurs transformées dans le même ordre que les valeurs source. map! peut être utilisé si vous souhaitez modifier le tableau d'origine.

Dans la méthode map , vous pouvez appeler la méthode ou utiliser proc pour tous les éléments du tableau.

# call to_i method on all elements
%w(1 2 3 4 5 6 7 8 9 10).map(&:to_i)
# => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# using proc (lambda) on all elements
%w(1 2 3 4 5 6 7 8 9 10).map(&->(i){ i.to_i * 2})
# => [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

map est synonyme de collect .

Créer un tableau avec le constructeur littéral []

Les tableaux peuvent être créés en joignant une liste d'éléments entre crochets ( [ et ] ). Les éléments de tableau dans cette notation sont séparés par des virgules:

array = [1, 2, 3, 4]

Les tableaux peuvent contenir n'importe quel type d'objet dans n'importe quelle combinaison sans restriction de type:

array = [1, 'b', nil, [3, 4]]

Créer un tableau de chaînes

Des tableaux de chaînes peuvent être créés à l'aide de la syntaxe de pourcentage de ruby:

array = %w(one two three four)

C'est fonctionnellement équivalent à définir le tableau comme suit:

array = ['one', 'two', 'three', 'four']

Au lieu de %w() vous pouvez utiliser d'autres paires de délimiteurs: %w{...} , %w[...] ou %w<...> .

Il est également possible d'utiliser des délimiteurs arbitraires non alphanumériques, tels que: %w!...! , %w#...# ou %w@...@ .

%W peut être utilisé à la place de %w pour incorporer l'interpolation de chaîne. Considérer ce qui suit:

var = 'hello'

%w(#{var}) # => ["\#{var}"]
%W(#{var}) # => ["hello"]

Plusieurs mots peuvent être interprétés en échappant à l'espace avec un \.

%w(Colorado California New\ York) # => ["Colorado", "California", "New York"]

Créer un tableau de symboles

array = %i(one two three four)

Crée le tableau [:one, :two, :three, :four] .

Au lieu de %i(...) , vous pouvez utiliser %i{...} ou %i[...] ou %i!...!

De plus, si vous souhaitez utiliser l'interpolation, vous pouvez le faire avec %I

a = 'hello'
b = 'goodbye'
array_one = %I(#{a} #{b} world)
array_two = %i(#{a} #{b} world)

Crée les tableaux: array_one = [:hello, :goodbye, :world] array_two = [:"\#{a}", :"\#{b}", :world] array_one = [:hello, :goodbye, :world] et array_two = [:"\#{a}", :"\#{b}", :world]

Créer un tableau avec Array :: new

Un tableau vide ( [] ) peut être créé avec la méthode de classe Array::new , Array::new :

Array.new    

Pour définir la longueur du tableau, passez un argument numérique:

Array.new 3 #=> [nil, nil, nil]

Il existe deux manières de remplir un tableau avec des valeurs par défaut:

• Passer une valeur immuable en deuxième argument.
• Passez un bloc qui obtient l'index actuel et génère des valeurs mutables.

Array.new 3, :x #=> [:x, :x, :x]

Array.new(3) { |i| i.to_s } #=> ["0", "1", "2"]

a = Array.new 3, "X"            # Not recommended.
a[1].replace "C"                # a => ["C", "C", "C"]

b = Array.new(3) { "X" }        # The recommended way.
b[1].replace "C"                # b => ["X", "C", "X"]

Manipulation des éléments du tableau

Ajouter des éléments:

[1, 2, 3] << 4
# => [1, 2, 3, 4]

[1, 2, 3].push(4)
# => [1, 2, 3, 4]

[1, 2, 3].unshift(4)
# => [4, 1, 2, 3]

[1, 2, 3] << [4, 5]
# => [1, 2, 3, [4, 5]]

Suppression d'éléments:

array = [1, 2, 3, 4]
array.pop
# => 4
array
# => [1, 2, 3]

array = [1, 2, 3, 4]
array.shift
# => 1
array
# => [2, 3, 4]

array = [1, 2, 3, 4]
array.delete(1)
# => 1
array
# => [2, 3, 4]

array = [1,2,3,4,5,6]
array.delete_at(2) // delete from index 2
# => 3  
array 
# => [1,2,4,5,6] 


array = [1, 2, 2, 2, 3]
array - [2]
# => [1, 3]    # removed all the 2s
array - [2, 3, 4]
# => [1]       # the 4 did nothing

Combinaison de tableaux:

[1, 2, 3] + [4, 5, 6]
# => [1, 2, 3, 4, 5, 6]

[1, 2, 3].concat([4, 5, 6])
# => [1, 2, 3, 4, 5, 6]

[1, 2, 3, 4, 5, 6] - [2, 3]
# => [1, 4, 5, 6]

[1, 2, 3] | [2, 3, 4]
# => [1, 2, 3, 4]

[1, 2, 3] & [3, 4]
# => [3]

Vous pouvez également multiplier les tableaux, par exemple

[1, 2, 3] * 2
# => [1, 2, 3, 1, 2, 3]

Union des tableaux, intersection et différence

x = [5, 5, 1, 3]
y = [5, 2, 4, 3]

Union ( | ) contient des éléments des deux tableaux, avec les doublons supprimés:

x | y
=> [5, 1, 3, 2, 4]

Intersection ( & ) contient des éléments présents à la fois dans le premier et le second tableau:

x & y
=> [5, 3]

Difference ( - ) contient des éléments présents dans le premier tableau et non présents dans le second tableau:

x - y
=> [1]

Filtrage de tableaux

Souvent, nous ne voulons opérer que sur des éléments d'un tableau qui remplissent une condition spécifique:

Sélectionner

Renvoie les éléments correspondant à une condition spécifique

array = [1, 2, 3, 4, 5, 6]
array.select { |number| number > 3 } # => [4, 5, 6]

Rejeter

Renvoie les éléments qui ne correspondent pas à une condition spécifique

array = [1, 2, 3, 4, 5, 6]
array.reject { |number| number > 3 } # => [1, 2, 3]

Les deux #select et #reject renvoient un tableau, ils peuvent donc être chaînés:

array = [1, 2, 3, 4, 5, 6]
array.select { |number| number > 3 }.reject { |number| number < 5 }
  # => [5, 6]

Injecter, réduire

Injecter et réduire sont des noms différents pour la même chose. Dans d'autres langues, ces fonctions sont souvent appelées des plis (comme foldl ou foldr). Ces méthodes sont disponibles sur chaque objet Enumerable.

Inject prend une fonction à deux arguments et l'applique à toutes les paires d'éléments du tableau.

Pour le tableau [1, 2, 3] nous pouvons ajouter tous ces éléments avec la valeur de départ de zéro en spécifiant une valeur de départ et bloquer comme suit:

[1,2,3].reduce(0) {|a,b| a + b} # => 6

Ici, nous passons à la fonction une valeur de départ et un bloc qui dit d'ajouter toutes les valeurs ensemble. Le bloc est d'abord exécuté avec 0 comme a et 1 car b prend alors le résultat de la prochaine a , nous ajoutons alors 1 à la deuxième valeur 2 . Ensuite, nous prenons le résultat de cela ( 3 ) et ajoutons cela au dernier élément de la liste (également 3 ) en nous donnant notre résultat ( 6 ).

Si nous omettons le premier argument, il définira a comme étant le premier élément de la liste. L'exemple ci-dessus est donc identique à:

[1,2,3].reduce {|a,b| a + b} # => 6

De plus, au lieu de passer un bloc avec une fonction, nous pouvons passer une fonction nommée en tant que symbole, soit avec une valeur de départ, soit sans symbole. Avec ceci, l'exemple ci-dessus pourrait être écrit comme:

[1,2,3].reduce(0, :+) # => 6

ou en omettant la valeur de départ:

[1,2,3].reduce(:+) # => 6

Accès aux éléments

Vous pouvez accéder aux éléments d'un tableau par leurs index. La numérotation des index de tableaux commence à 0 .

%w(a b c)[0] # => 'a'
%w(a b c)[1] # => 'b'

Vous pouvez recadrer un tableau à l'aide de la plage

%w(a b c d)[1..2] # => ['b', 'c'] (indices from 1 to 2, including the 2)
%w(a b c d)[1...2] # => ['b'] (indices from 1 to 2, excluding the 2)

Cela retourne un nouveau tableau, mais n'affecte pas l'original. Ruby prend également en charge l'utilisation d'indices négatifs.

%w(a b c)[-1] # => 'c'
%w(a b c)[-2] # => 'b'

Vous pouvez combiner des indices positifs et négatifs

%w(a b c d e)[1...-1] # => ['b', 'c', 'd']

Autres méthodes utiles

Utilisez d' first pour accéder au premier élément d'un tableau:

[1, 2, 3, 4].first # => 1

Ou d' first(n) pour accéder aux n premiers éléments retournés dans un tableau:

[1, 2, 3, 4].first(2) # => [1, 2]

De même pour le last et le last(n) :

[1, 2, 3, 4].last    # => 4
[1, 2, 3, 4].last(2) # => [3, 4]

Utilisez sample pour accéder à un élément aléatoire dans un tableau:

[1, 2, 3, 4].sample  # => 3
[1, 2, 3, 4].sample  # => 1

Ou sample(n) :

[1, 2, 3, 4].sample(2) # => [2, 1]
[1, 2, 3, 4].sample(2) # => [3, 4]

Tableau bidimensionnel

En utilisant le constructeur Array::new , vous pouvez initialiser un tableau avec une taille donnée et un nouveau tableau dans chacun de ses emplacements. Les tableaux internes peuvent également recevoir une taille et une valeur initiale.

Par exemple, pour créer un tableau 3x4 de zéros:

array = Array.new(3) { Array.new(4) { 0 } }

Le tableau généré ci-dessus ressemble à ceci quand il est imprimé avec p :

[[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]

Vous pouvez lire ou écrire des éléments comme ceci:

x = array[0][1]
array[2][3] = 2

Les tableaux et l'opérateur splat (*)

L'opérateur * peut être utilisé pour décompresser les variables et les tableaux afin qu'ils puissent être transmis en tant qu'arguments individuels à une méthode.

Cela peut être utilisé pour envelopper un objet unique dans un tableau s'il ne l'est pas déjà:

def wrap_in_array(value)
  [*value]
end

wrap_in_array(1)
#> [1]

wrap_in_array([1, 2, 3])
#> [1, 2, 3]

wrap_in_array(nil)
#> []

Dans l'exemple ci-dessus, la méthode wrap_in_array accepte un argument, value .

Si value est un Array , ses éléments sont décompressés et un nouveau tableau contenant ces éléments est créé.

Si value est un objet unique, un nouveau tableau contenant cet objet unique est créé.

Si value est nil , un tableau vide est renvoyé.

L'opérateur splat est particulièrement utile lorsqu'il est utilisé comme argument dans les méthodes dans certains cas. Par exemple, il permet nil , des valeurs uniques et des tableaux à traiter de manière cohérente:

def list(*values)
  values.each do |value|
    # do something with value
    puts value
  end
end

list(100)
#> 100

list([100, 200])
#> 100
#> 200

list(nil)
# nothing is outputted

Décomposition

Tout tableau peut être rapidement décomposé en affectant ses éléments à plusieurs variables. Un exemple simple:

arr = [1, 2, 3]
# ---
a = arr[0]
b = arr[1]
c = arr[2]
# --- or, the same
a, b, c = arr

Précédant une variable avec l'opérateur splat ( * ) y place un tableau de tous les éléments qui n'ont pas été capturés par d'autres variables. S'il n'en reste plus, un tableau vide est attribué. Une seule splat peut être utilisée dans une seule tâche:

a, *b = arr       # a = 1; b = [2, 3]
a, *b, c = arr    # a = 1; b = [2]; c = 3
a, b, c, *d = arr # a = 1; b = 2; c = 3; d = []
a, *b, *c = arr   # SyntaxError: unexpected *

La décomposition est sûre et ne génère jamais d'erreurs. nil s sont assignés là où il n'y a pas assez d'éléments, correspondant au comportement de l'opérateur [] lors de l'accès à un index hors limites:

arr[9000] # => nil
a, b, c, d = arr # a = 1; b = 2; c = 3; d = nil

La décomposition tente d'appeler implicitement to_ary sur l'objet affecté. En implémentant cette méthode dans votre type, vous avez la possibilité de la décomposer:

class Foo
  def to_ary
    [1, 2]
  end
end
a, b = Foo.new # a = 1; b = 2

Si l'objet décomposé ne répond pas respond_to? to_ary , il est traité comme un tableau à élément unique:

1.respond_to?(:to_ary) # => false
a, b = 1 # a = 1; b = nil

La décomposition peut également être imbriquée en utilisant une expression de décomposition délimitée par () à la place de ce qui serait sinon un seul élément:

arr = [1, [2, 3, 4], 5, 6]
a, (b, *c), *d = arr # a = 1; b = 2; c = [3, 4]; d = [5, 6]
#   ^^^^^

C'est effectivement l'opposé de splat .

En fait, toute expression de décomposition peut être délimitée par () . Mais pour le premier niveau, la décomposition est facultative.

a, b = [1, 2]
(a, b) = [1, 2] # the same thing

Bordure: un identifiant unique ne peut pas être utilisé comme motif de déstructuration, externe ou imbriqué:

(a) = [1] # SyntaxError
a, (b) = [1, [2]] # SyntaxError

Lors de l'affectation d' un littéral de tableau à une expression de déstructuration, external [] peut être omis:

a, b = [1, 2]
a, b =  1, 2  # exactly the same

Ceci est connu sous le nom d' affectation parallèle , mais il utilise la même décomposition sous le capot. Ceci est particulièrement pratique pour échanger des valeurs de variables sans employer de variables temporaires supplémentaires:

t = a; a = b; b = t # an obvious way
a, b = b, a         # an idiomatic way
(a, b) = [b, a]     # ...and how it works

Les valeurs sont capturées lors de la construction du côté droit de l'affectation. L'utilisation des mêmes variables comme source et destination est donc relativement sûre.

Transformez un tableau multidimensionnel en un tableau unidimensionnel (aplati)

[1, 2, [[3, 4], [5]], 6].flatten  # => [1, 2, 3, 4, 5, 6]

Si vous avez un tableau multidimensionnel et que vous devez en faire un tableau simple (à une dimension), vous pouvez utiliser la méthode #flatten .

Obtenir des éléments de tableau uniques

Si vous avez besoin de lire des éléments de tableau en évitant les répétitions , utilisez la méthode #uniq :

a = [1, 1, 2, 3, 4, 4, 5]
a.uniq
#=> [1, 2, 3, 4, 5]

Au lieu de cela, si vous souhaitez supprimer tous les éléments dupliqués d'un tableau, vous pouvez utiliser #uniq! méthode:

a = [1, 1, 2, 3, 4, 4, 5]
a.uniq!
#=> [1, 2, 3, 4, 5]

Alors que la sortie est la même, #uniq! stocke également le nouveau tableau:

a = [1, 1, 2, 3, 4, 4, 5]
a.uniq
#=> [1, 2, 3, 4, 5]
a
#=> [1, 1, 2, 3, 4, 4, 5]

a = [1, 1, 2, 3, 4, 4, 5]
a.uniq!
#=> [1, 2, 3, 4, 5]
a
#=> [1, 2, 3, 4, 5]

Obtenez toutes les combinaisons / permutations d'un tableau

La méthode de permutation , lorsqu'elle est appelée avec un bloc, produit un tableau à deux dimensions constitué de toutes les séquences ordonnées d'une collection de nombres.

Si cette méthode est appelée sans bloc, elle retournera un enumerator . Pour convertir en tableau, appelez la méthode to_a .

Par contre, la méthode de combination , lorsqu'elle est appelée avec un bloc, produit un tableau à deux dimensions composé de toutes les séquences d'une collection de nombres. Contrairement à la permutation, l'ordre est ignoré dans les combinaisons. Par exemple, [1,2,3] est identique à [3,2,1]

L'appel de la méthode de combinaison seule aboutira à un énumérateur. Pour obtenir un tableau, appelez la méthode to_a .

Les méthodes repeated_combination et repeated_permutation sont similaires, sauf que le même élément peut être répété plusieurs fois.

Par exemple, les séquences [1,1] , [1,3,3,1] , [3,3,3] ne seraient pas valides dans les combinaisons et les permutations régulières.

Créer un tableau de chiffres ou de lettres consécutifs

Cela peut être facilement accompli en appelant Enumerable#to_a sur un objet Range :

(1..10).to_a    #=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

(a..b) signifie qu'il inclura tous les nombres entre a et b. Pour exclure le dernier numéro, utilisez a...b

a_range = 1...5
a_range.to_a       #=> [1, 2, 3, 4]

ou

('a'..'f').to_a    #=> ["a", "b", "c", "d", "e", "f"]
('a'...'f').to_a   #=> ["a", "b", "c", "d", "e"]

Un raccourci pratique pour créer un tableau est [*a..b]

[*1..10]           #=> [1,2,3,4,5,6,7,8,9,10]
[*'a'..'f']        #=> ["a", "b", "c", "d", "e", "f"]

Supprimer tous les éléments nil d'un tableau avec #compact

Si un tableau contient un ou plusieurs éléments nil et qu'ils doivent être supprimés, Array#compact ou Array#compact! des méthodes peuvent être utilisées, comme ci-dessous.

array = [ 1, nil, 'hello', nil, '5', 33]

array.compact # => [ 1, 'hello', '5', 33]

#notice that the method returns a new copy of the array with nil removed,
#without affecting the original

array = [ 1, nil, 'hello', nil, '5', 33]

#If you need the original array modified, you can either reassign it

array = array.compact # => [ 1, 'hello', '5', 33]

array = [ 1, 'hello', '5', 33]

#Or you can use the much more elegant 'bang' version of the method

array = [ 1, nil, 'hello', nil, '5', 33]

array.compact # => [ 1, 'hello', '5', 33]

array = [ 1, 'hello', '5', 33]

Enfin, notez que si #compact ou #compact! sont appelés sur un tableau sans éléments nil , ceux-ci seront nuls.

array = [ 'foo', 4, 'life']

array.compact # => nil

array.compact! # => nil

Créer un tableau de nombres

La manière normale de créer un tableau de nombres:

numbers = [1, 2, 3, 4, 5]

Les objets de plage peuvent être largement utilisés pour créer un tableau de nombres:

numbers = Array(1..10) # => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

numbers = (1..10).to_a # => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

#step méthodes #step et #map nous permettent d'imposer des conditions sur la gamme des nombres:

odd_numbers = (1..10).step(2).to_a # => [1, 3, 5, 7, 9]

even_numbers = 2.step(10, 2).to_a # => [2, 4, 6, 8, 10]

squared_numbers = (1..10).map { |number| number * number } # => [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

Toutes les méthodes ci-dessus chargent les chiffres avec impatience. Si vous devez les charger paresseusement:

number_generator = (1..100).lazy # => #<Enumerator::Lazy: 1..100>

number_generator.first(10) # => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Lancer à Array à partir de n'importe quel objet

Pour obtenir Array à partir de n'importe quel objet, utilisez Kernel#Array .

Ce qui suit est un exemple:

Array('something') #=> ["something"]
Array([2, 1, 5])   #=> [2, 1, 5]
Array(1)           #=> [1]
Array(2..4)        #=> [2, 3, 4]
Array([])          #=> []
Array(nil)         #=> []

Par exemple, vous pouvez remplacer la méthode join_as_string par le code suivant

def join_as_string(arg)
  if arg.instance_of?(Array)
    arg.join(',')
  elsif arg.instance_of?(Range)
    arg.to_a.join(',')
  else
    arg.to_s
  end
end

join_as_string('something') #=> "something"
join_as_string([2, 1, 5])   #=> "2,1,5"
join_as_string(1)           #=> "1"
join_as_string(2..4)        #=> "2,3,4"
join_as_string([])          #=> ""
join_as_string(nil)         #=> ""

au code suivant.

def join_as_string(arg)
  Array(arg).join(',')
end