Comment ajoutez-vous un tableau à un autre tableau dans Ruby et ne vous retrouvez-vous pas avec un résultat multidimensionnel?

somearray = ["some", "thing"]

anotherarray = ["another", "thing"]

somearray.push(anotherarray.flatten!)

j'esperais

["some","thing","another","thing"]

Vous avez une idée réalisable, mais #flatten!est au mauvais endroit - il aplatit son récepteur, de sorte que vous pouvez l' utiliser pour transformer [1, 2, ['foo', 'bar']]en [1,2,'foo','bar'].

J'oublie sans doute certaines approches, mais vous pouvez concaténer :

a1.concat a2
a1 + a2              # creates a new array, as does a1 += a2

ou ajouter / ajouter :

a1.push(*a2)         # note the asterisk
a2.unshift(*a1)      # note the asterisk, and that a2 is the receiver

ou épissure :

a1[a1.length, 0] = a2
a1[a1.length..0] = a2
a1.insert(a1.length, *a2)

ou ajouter et aplatir :

(a1 << a2).flatten!  # a call to #flatten instead would return a new array

Vous pouvez simplement utiliser l' +opérateur!

irb(main):001:0> a = [1,2]
=> [1, 2]
irb(main):002:0> b = [3,4]
=> [3, 4]
irb(main):003:0> a + b
=> [1, 2, 3, 4]

Vous pouvez tout lire sur la classe array ici: http://ruby-doc.org/core/classes/Array.html

L'approche la plus propre consiste à utiliser la méthode Array # concat ; il ne créera pas de nouveau tableau (contrairement à Array # + qui fera la même chose mais créera un nouveau tableau).

Directement à partir des documents ( http://www.ruby-doc.org/core-1.9.3/Array.html#method-i-concat ):

concat (other_ary)

Ajoute les éléments de other_ary à soi.

Donc

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

Array # concat n'aplatira pas un tableau multidimensionnel s'il est passé en argument. Vous devrez gérer cela séparément:

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

Enfin, vous pouvez utiliser notre gem corelib ( https://github.com/corlewsolutions/corelib ) qui ajoute des aides utiles aux classes de base Ruby. En particulier, nous avons une méthode Array # add_all qui aplatira automatiquement les tableaux multidimensionnels avant d'exécuter le concat.

Méthode simple qui fonctionne avec la version Ruby> = 2.0 mais pas avec les versions plus anciennes:

irb(main):001:0> a=[1,2]
=> [1, 2]
irb(main):003:0> b=[3,4]
=> [3, 4]
irb(main):002:0> c=[5,6]
=> [5, 6]
irb(main):004:0> [*a,*b,*c]
=> [1, 2, 3, 4, 5, 6]

Essayez ceci, il combinera vos tableaux en supprimant les doublons

array1 = ["foo", "bar"]
array2 = ["foo1", "bar1"]

array3 = array1|array2

http://www.ruby-doc.org/core/classes/Array.html

Pour plus de documentation, regardez "Set Union"

Voici deux façons, notez dans ce cas que la première façon assigne un nouveau tableau (se traduit par somearray = somearray + anotherarray)

somearray = ["some", "thing"]

anotherarray = ["another", "thing"]

somearray += anotherarray # => ["some", "thing", "another", "thing"]

somearray = ["some", "thing"]
somearray.concat anotherarray # => ["some", "thing", "another", "thing"]

a = ["some", "thing"]
b = ["another", "thing"]

Pour ajouter bà aet stocker le résultat dans a:

a.push(*b)

ou

a += b

Dans les deux cas, adevient:

["some", "thing", "another", "thing"]

mais dans le premier cas, les éléments de bsont ajoutés au atableau existant , et dans le second cas, les deux tableaux sont concaténés ensemble et le résultat est stocké dans a.

(array1 + array2).uniq

De cette façon, vous obtenez d'abord les éléments array1. Vous n'aurez aucun doublon.

En élaborant la réponse de @ Pilcrow, la seule réponse appropriée pour les énormes tableaux est concat( +) car elle est rapide et n'alloue pas un nouvel objet à récupérer les ordures lors de son fonctionnement dans une boucle.

Voici la référence:

require 'benchmark'

huge_ary_1 = Array.new(1_000_000) { rand(5_000_000..30_000_00) }

huge_ary_2 = Array.new(1_000_000) { rand(35_000_000..55_000_00) }

Benchmark.bm do |bm|
  p '-------------------CONCAT ----------------'
  bm.report { huge_ary_1.concat(huge_ary_2) }

  p '------------------- PUSH ----------------'
  bm.report { huge_ary_1.push(*huge_ary_2)  }
end

Résultats:

       user     system      total        real
"-------------------CONCAT ----------------"
  0.000000   0.000000   0.000000 (  0.009388)
"------------------- PUSH ----------------"
  example/array_concat_vs_push.rb:13:in `block (2 levels) in <main>': stack level too deep (SystemStackError)

Comme vous pouvez le voir en utilisant pushjette une ERREUR : stack level too deep (SystemStackError)lorsque les tableaux sont assez grands.

La question, essentiellement, est "comment concaténer des tableaux en Ruby". Naturellement, la réponse est d'utiliser concatou +comme mentionné dans presque toutes les réponses.

Une extension naturelle de la question serait "comment effectuer la concaténation ligne par ligne des tableaux 2D dans Ruby". Lorsque j'ai googlé "matrices de concaténation rubis", cette question SO était le meilleur résultat, alors j'ai pensé laisser ma réponse à cette question (non demandée mais liée) ici pour la postérité.

Dans certaines applications, vous souhaiterez peut-être "concaténer" deux tableaux 2D en ligne. Quelque chose comme,

[[a, b], | [[x],    [[a, b, x],
 [c, d]] |  [y]] =>  [c, d, y]]

C'est quelque chose comme "augmenter" une matrice. Par exemple, j'ai utilisé cette technique pour créer une seule matrice d'adjacence pour représenter un graphique à partir d'un tas de matrices plus petites. Sans cette technique, j'aurais dû parcourir les composants d'une manière qui aurait pu être source d'erreurs ou frustrante. J'aurais peut-être dû faire un each_with_index, par exemple. Au lieu de cela, j'ai combiné zip et aplatir comme suit,

# given two multi-dimensional arrays that you want to concatenate row-wise
m1 = [[:a, :b], [:c, :d]]
m2 = [[:x], [:y]]

m1m2 = m1.zip(m2).map(&:flatten)
# => [[:a, :b, :x], [:c, :d, :y]]

Juste une autre façon de le faire.

[somearray, anotherarray].flatten
=> ["some", "thing", "another", "thing"]

["some", "thing"] + ["another" + "thing"]

Si les nouvelles données peuvent être un tableau ou un scalaire et que vous souhaitez empêcher l'imbrication des nouvelles données s'il s'agissait d'un tableau, l'opérateur splat est génial! Il retourne un scalaire pour un scalaire et une liste décompactée d'arguments pour un tableau.

1.9.3-p551 :020 > a = [1, 2]
 => [1, 2] 
1.9.3-p551 :021 > b = [3, 4]
 => [3, 4] 
1.9.3-p551 :022 > c = 5
 => 5 
1.9.3-p551 :023 > a.object_id
 => 6617020 
1.9.3-p551 :024 > a.push *b
 => [1, 2, 3, 4] 
1.9.3-p551 :025 > a.object_id
 => 6617020 
1.9.3-p551 :026 > a.push *c
 => [1, 2, 3, 4, 5] 
1.9.3-p551 :027 > a.object_id
 => 6617020 

Je suis surpris que personne ne l'ait mentionné reduce, ce qui fonctionne bien lorsque vous disposez d'un tableau de tableaux:

lists = [["a", "b"], ["c", "d"]]
flatlist = lists.reduce(:+)  # ["a", "b", "c", "d"]

a = ['a', 'b']
b = ['c', 'd']
arr = [a, b].flatten

Cela ne supprimera pas les doublons, mais

a|b

supprime les doublons.

Je trouve plus facile de pousser ou d'ajouter des tableaux, puis de les aplatir en place, comme suit:

somearray = ["some", "thing"]
anotherarray = ["another", "thing"]
somearray.push anotherarray # => ["some", "thing", ["another", "thing"]]
#or
somearray << anotherarray # => ["some", "thing", ["another", "thing"]]
somearray.flatten!  # => ["some", "thing", "another", "thing"]
somearray # => ["some", "thing", "another", "thing"]

somearray = ["certains", "chose"]

anotherarray = ["autre", "chose"]

un tableau + un autre tableau