Come si aggiunge un array a un altro array in Ruby e non si ottiene un risultato multidimensionale?

somearray = ["some", "thing"]

anotherarray = ["another", "thing"]

somearray.push(anotherarray.flatten!)

Mi aspettavo

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

Hai un'idea praticabile, ma la #flatten!è nel posto sbagliato - si appiattisce il suo ricevitore, così si potrebbe usare per trasformare [1, 2, ['foo', 'bar']]in [1,2,'foo','bar'].

Senza dubbio dimentico alcuni approcci, ma puoi concatenare :

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

o anteporre / aggiungere :

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

o giuntura :

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

oppure aggiungi e appiattisci :

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

Puoi semplicemente usare l' +operatore!

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]

Puoi leggere tutto sulla classe di array qui: http://ruby-doc.org/core/classes/Array.html

L'approccio più pulito consiste nell'utilizzare il metodo Array # concat ; non creerà un nuovo array (diversamente dall'Array # + che farà la stessa cosa ma creerà un nuovo array).

Direttamente dai documenti ( http://www.ruby-doc.org/core-1.9.3/Array.html#method-i-concat ):

concat (other_ary)

Aggiunge gli elementi di other_ary a se stesso.

Così

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

Array # concat non appiattirà un array multidimensionale se viene passato come argomento. Dovrai gestirlo separatamente:

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

Infine, puoi usare la nostra gemma corelib ( https://github.com/corlewsolutions/corelib ) che aggiunge utili aiutanti alle classi principali di Ruby. In particolare abbiamo un metodo Array # add_all che appiattirà automaticamente gli array multidimensionali prima di eseguire il concat.

Metodo semplice che funziona con la versione di Ruby> = 2.0 ma non con le versioni precedenti:

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]

Prova questo, combinerà i tuoi array rimuovendo i duplicati

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

array3 = array1|array2

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

Ulteriore documentazione guarda "Set Union"

Ecco due modi, nota in questo caso che il primo modo assegna un nuovo array (si traduce in 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"]

Per aggiungere balla ae memorizzare il risultato in a:

a.push(*b)

o

a += b

In entrambi i casi, adiventa:

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

ma nel primo caso, gli elementi di bvengono aggiunti aall'array esistente e nel secondo caso i due array vengono concatenati insieme e il risultato viene archiviato a.

(array1 + array2).uniq

In questo modo si ottengono prima gli elementi array1. Non otterrai duplicati.

Elaborando la risposta di @ Pilcrow l'unica risposta adatta per array di grandi dimensioni è concat( +) poiché è veloce e non alloca un nuovo oggetto da raccogliere in modo inutile quando si opera all'interno di un ciclo.

Ecco il punto di riferimento:

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

risultati:

       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)

Come puoi vedere, usa pushun ERRORE : stack level too deep (SystemStackError)quando le matrici sono abbastanza grandi.

La domanda, in sostanza, è "come concatenare le matrici in Ruby". Naturalmente la risposta è usare concato +come menzionato in quasi ogni risposta.

Un'estensione naturale della domanda sarebbe "come eseguire la concatenazione di array 2D in Ruby". Quando ho cercato su Google "matrici concatenate di rubini", questa domanda SO è stata il miglior risultato, quindi ho pensato di lasciare la mia risposta a quella domanda (non richiesta ma correlata) qui per i posteri.

In alcune applicazioni potresti voler "concatenare" due array 2D in ordine di riga. Qualcosa di simile a,

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

Questo è qualcosa come "aumentare" una matrice. Ad esempio, ho usato questa tecnica per creare una singola matrice di adiacenza per rappresentare un grafico da un gruppo di matrici più piccole. Senza questa tecnica avrei dovuto scorrere i componenti in un modo che avrebbe potuto essere soggetto a errori o frustrante a cui pensare. Potrei aver dovuto fare un each_with_index, per esempio. Invece ho combinato zip e appiattire come segue,

# 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]]

Solo un altro modo di farlo.

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

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

Se i nuovi dati potrebbero essere una matrice o uno scalare e si desidera impedire che i nuovi dati vengano nidificati se fosse una matrice, l'operatore splat è fantastico! Restituisce uno scalare per uno scalare e un elenco decompresso di argomenti per un array.

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 

Sono sorpreso che nessuno abbia menzionato reduce, il che funziona bene quando si dispone di una serie di array:

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

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

Questo non rimuoverà i duplicati, ma

a|b

rimuove i duplicati.

Trovo più facile spingere o aggiungere array e poi appiattirli in posizione, in questo modo:

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 = ["some", "thing"]

anotherarray = ["another", "thing"]

somearray + anotherarray