Como você adiciona uma matriz a outra matriz no Ruby e não acaba com um resultado multidimensional?

somearray = ["some", "thing"]

anotherarray = ["another", "thing"]

somearray.push(anotherarray.flatten!)

eu esperava

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

Você tem uma idéia viável, mas o #flatten!é no lugar errado - ele achata o seu receptor, para que você possa usá-lo para transformar [1, 2, ['foo', 'bar']]em [1,2,'foo','bar'].

Sem dúvida, estou esquecendo algumas abordagens, mas você pode concatenar :

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

ou acrescentar / acrescentar :

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

ou emenda :

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

ou acrescentar e achatar :

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

Você pode apenas usar o +operador!

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]

Você pode ler tudo sobre a classe array aqui: http://ruby-doc.org/core/classes/Array.html

A abordagem mais limpa é usar o método Arrat # concat ; ele não criará uma nova matriz (diferente da Matriz # +, que fará a mesma coisa, mas criará uma nova matriz).

Diretamente dos documentos ( http://www.ruby-doc.org/core-1.9.3/Array.html#method-i-concat ):

concat (other_ary)

Anexa os elementos de other_ary a self.

assim

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

A matriz # concat não achatará uma matriz multidimensional se for passada como argumento. Você precisará lidar com isso separadamente:

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

Por fim, você pode usar a nossa corelib gem ( https://github.com/corlewsolutions/corelib ), que adiciona ajudantes úteis às classes principais do Ruby. Em particular, temos um método Array # add_all que achatará automaticamente as matrizes multidimensionais antes de executar a concat.

Método fácil que funciona com a versão Ruby> = 2.0, mas não com versões mais antigas:

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]

Tente isso, ele combinará suas matrizes removendo duplicatas

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

array3 = array1|array2

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

Mais documentação veja "Set Union"

Aqui estão duas maneiras, observe, neste caso, que a primeira maneira atribui uma nova matriz (traduz-se em 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"]

Para anexar ba ae armazenar o resultado em a:

a.push(*b)

ou

a += b

Em qualquer um dos casos, atorna-se:

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

mas no primeiro caso, os elementos de bsão anexados à amatriz existente e, no último caso, as duas matrizes são concatenadas juntas e o resultado é armazenado em a.

(array1 + array2).uniq

Dessa forma, você obtém os elementos do array1 primeiro. Você não receberá duplicatas.

Ao elaborar a resposta do @ Pilcrow, a única resposta adequada para grandes matrizes é concat( +), pois é rápida e não aloca um novo objeto a ser coletado como lixo ao operar dentro de um loop.

Aqui está a referência:

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

Resultados:

       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)

Como você pode ver, usando pushthrows um ERRO : stack level too deep (SystemStackError)quando as matrizes são grandes o suficiente.

A questão, essencialmente, é "como concatenar matrizes em Ruby". Naturalmente, a resposta é usar concatou +como mencionado em quase todas as respostas.

Uma extensão natural para a pergunta seria "como executar concatenação em linha de matrizes 2D em Ruby". Quando pesquisei "matrizes de concatenação de rubi" no Google, essa pergunta do SO foi o principal resultado, então pensei em deixar minha resposta para essa pergunta (não solicitada, mas relacionada) aqui para a posteridade.

Em alguns aplicativos, convém concatenar duas matrizes 2D em linhas. Algo como,

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

Isso é algo como "aumentar" uma matriz. Por exemplo, usei essa técnica para criar uma única matriz de adjacência para representar um gráfico de várias matrizes menores. Sem essa técnica, eu teria que percorrer os componentes de uma maneira que poderia ter sido propensa a erros ou frustrante de se pensar. Eu poderia ter que fazer um each_with_index, por exemplo. Em vez disso, combinei o zíper e o achatamento da seguinte maneira:

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

Apenas outra maneira de fazer isso.

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

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

Se os novos dados puderem ser uma matriz ou escalar, e você desejar impedir que os novos dados sejam aninhados, se for uma matriz, o operador splat é incrível! Ele retorna um escalar para um escalar e uma lista descompactada de argumentos para uma matriz.

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 

Estou surpreso que ninguém tenha mencionado reduce, o que funciona bem quando você tem uma matriz de matrizes:

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

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

Isso não remove dups, mas

a|b

remove dups.

Acho mais fácil empurrar ou anexar matrizes e achatá-las no lugar, da seguinte maneira:

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 = ["alguns", "coisa"]

anotherarray = ["outro", "coisa"]

somearray + anotherarray