Como acrescentar algo a um array?

Como eu adiciono um object (como uma string ou um número) a um array em JavaScript?

Use a function push() para append a uma matriz:

 // initialize array var arr = [ "Hi", "Hello", "Bonjour" ]; // append new value to the array arr.push("Hola"); console.log(arr); 

Se você está apenas anexando uma única variável, então o push() funciona bem. Se você precisar acrescentar outro array, use concat() :

 var ar1 = [1, 2, 3]; var ar2 = [4, 5, 6]; var ar3 = ar1.concat(ar2); alert(ar1); alert(ar2); alert(ar3); 

Vai cuspir:

 "1,2,3" "4,5,6" "1,2,3,4,5,6" 

A concat não afeta ar1 e ar2 menos que seja reatribuída, por exemplo:

 ar1 = ar1.concat(ar2); alert(ar1); 

Exibirá:

 "1,2,3,4,5,6" 

Muita informação aqui

Alguns testes de desempenho rápidos (cada teste = 500.000 elementos anexados e os resultados são médias de várias execuções) mostraram o seguinte:

Firefox 3.6 (Mac):

  • Matrizes pequenas: arr[arr.length] = b é mais rápido (300ms vs. 800ms)
  • Matrizes grandes: arr.push(b) é mais rápido (500ms vs. 900ms)

Safari 5.0 (Mac):

  • Matrizes pequenas: arr[arr.length] = b é mais rápido (90ms vs. 115ms)
  • Arrays grandes: arr[arr.length] = b é mais rápido (160ms vs. 185ms)

Google Chrome 6.0 (Mac):

  • Matrizes pequenas: sem diferença significativa (e o Chrome é RÁPIDO! Apenas ~ 38ms !!)
  • Matrizes grandes: sem diferença significativa (160ms)

Eu gosto da syntax arr.push() melhor, mas eu acho que ficaria melhor com a versão arr[arr.length] , pelo menos na velocidade bruta. Eu adoraria ver os resultados de uma execução do IE.


Meus loops de benchmarking:

 function arrpush_small() { var arr1 = []; for (a = 0; a < 100; a++) { arr1 = []; for (i = 0; i < 5000; i++) { arr1.push('elem' + i); } } } function arrlen_small() { var arr2 = []; for (b = 0; b < 100; b++) { arr2 = []; for (j = 0; j < 5000; j++) { arr2[arr2.length] = 'elem' + j; } } } function arrpush_large() { var arr1 = []; for (i = 0; i < 500000; i++) { arr1.push('elem' + i); } } function arrlen_large() { var arr2 = []; for (j = 0; j < 500000; j++) { arr2[arr2.length] = 'elem' + j; } } 

Eu acho que vale a pena mencionar que o push pode ser chamado com múltiplos argumentos, que serão anexados ao array em ordem. Por exemplo:

 var arr = ['first']; arr.push('second', 'third'); console.log(arr); // ['first', 'second', 'third'] 

Como resultado disso, você pode usar o push.apply para append um array a outro array da seguinte forma:

 arr.push.apply(arr, ['forth', 'fifth']); console.log(arr); // ['first', 'second', 'third', 'forth', 'fifth'] 

O ES5 anotado tem mais informações sobre exatamente o que fazer e aplicar .

Atualização de 2016: com o spread , você não precisa mais se apply , como:

 arr.push(...['fourth', 'fifth']); console.log(arr) // ['first', 'second', 'third', 'fourth', 'fifth'] 

Você pode usar a function push e apply para append duas matrizes.

 var array1 = [11, 32, 75]; var array2 = [99, 67, 34]; Array.prototype.push.apply(array1, array2); 

Ele adicionará array2 a array1 . Agora array1 contém [11, 32, 75, 99, 67, 34] . Esse código é muito mais simples do que gravar loops para copiar todos os itens da matriz.

Se arr é um array, e val é o valor que você deseja adicionar use:

 arr.push(val); 

Por exemplo

 arr = ['a', 'b', 'c']; arr.push('d'); console.log(arr); 

irá registrar:

 ['a', 'b', 'c', 'd'] 

Use concat :

 a = [1, 2, 3]; b = [3, 4, 5]; a = a.concat(b); 

a agora contém todos os elementos, [1, 2, 3, 3, 4, 5] .

Referência: https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/concat

Com o novo operador de spread ES6, unir duas matrizes usando push torna-se ainda mais fácil:

 var arr = [1, 2, 3, 4, 5]; var arr2 = [6, 7, 8, 9, 10]; arr.push(...arr2); console.log(arr); // [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; 

Isso adiciona o conteúdo de arr2 no final de arr .

Exemplo REPL de Babel

Se você quiser acrescentar dois arrays –

 var a = ['a', 'b']; var b = ['c', 'd']; 

então você poderia usar:

 var c = a.concat(b); 

E se você quiser adicionar o registro g ao array ( var a=[] ), então você pode usar:

 a.push('g'); 

Javascript com ECMAScript 5 padrão que é suportado pela maioria dos navegadores agora, você pode usar apply() para append array1 a array2 .

 var array1 = [3, 4, 5]; var array2 = [1, 2]; Array.prototype.push.apply(array2, array1); console.log(array2); // [1, 2, 3, 4, 5] 

Javascript com ECMAScript 6 padrão que é suportado pelo Chrome e FF e IE Edge, você pode usar o operador spread :

 "use strict"; let array1 = [3, 4, 5]; let array2 = [1, 2]; array2.push(...array1); console.log(array2); // [1, 2, 3, 4, 5] 

O operador de spread replaceá array2.push(...array1); com array2.push(3, 4, 5); quando o navegador está pensando a lógica.

Ponto de bônus

Se você quiser criar outra variável para armazenar todos os itens de ambas as matrizes, você pode fazer isso:

ES5 var combinedArray = array1.concat(array2);

ES6 const combinedArray = [...array1, ...array2]

O operador de spread ( ... ) deve distribuir todos os itens de uma coleção.

O método push() adiciona novos itens ao final de uma matriz e retorna o novo tamanho. Exemplo:

 var fruits = ["Banana", "Orange", "Apple", "Mango"]; fruits.push("Kiwi"); // The result of fruits will be: Banana, Orange, Apple, Mango, Kiwi 

A resposta exata para a sua pergunta já foi respondida, mas vamos ver algumas outras maneiras de adicionar itens a uma matriz.

O método unshift() adiciona novos itens ao início de um array e retorna o novo tamanho. Exemplo:

 var fruits = ["Banana", "Orange", "Apple", "Mango"]; fruits.unshift("Lemon", "Pineapple"); // The result of fruits will be: Lemon, Pineapple, Banana, Orange, Apple, Mango 

Por fim, o método concat() é usado para unir duas ou mais matrizes. Exemplo:

 var fruits = ["Banana", "Orange"]; var moreFruits = ["Apple", "Mango", "Lemon"]; var allFruits = fruits.concat(moreFruits); // The values of the children array will be: Banana, Orange, Apple, Mango, Lemon 

Existem algumas maneiras de append uma matriz em JavaScript:

1) O método push() adiciona um ou mais elementos ao final de um array e retorna o novo tamanho do array.

 var a = [1, 2, 3]; a.push(4, 5); console.log(a); 

Se você conhece o maior índice (como armazenado em uma variável “i”), então você pode fazer

 myArray[i + 1] = someValue; 

No entanto, se você não sabe, então você pode usar

 myArray.push(someValue); 

como outras respostas sugeridas, ou você pode usar

 myArray[myArray.length] = someValue; 

Observe que a matriz é baseada em zero, portanto, comprimento retorna o índice mais alto mais um.

Observe também que você não tem que adicionar em ordem e você pode realmente pular valores, como em

 myArray[myArray.length + 1000] = someValue; 

Nesse caso, os valores entre terão um valor indefinido.

Portanto, é uma boa prática fazer um loop por meio de um JavaScript para verificar se um valor realmente existe nesse ponto.

Isso pode ser feito por algo como o seguinte:

 if(myArray[i] === "undefined"){ continue; } 

Se você tem certeza de que não possui zeros no array, você pode simplesmente fazer:

 if(!myArray[i]){ continue; } 

Claro que certifique-se, neste caso, que você não usa a condição myArray [i] (como algumas pessoas na internet sugerem com base no final que, assim que eu for maior, o índice mais alto retornará indefinido, o que resulta em falso)

Agora, você pode tirar proveito da syntax do ES6 e apenas fazer:

 let array = [1, 2]; console.log([...array, 3]); 

Deixe a propriedade length do array fazer o trabalho:

 myarray[myarray.length] = 'new element value added to the end of the array'; 

myarray.length retorna o número de seqüências na matriz. JS é baseado em zero, então a próxima chave de elemento da matriz será o comprimento atual da matriz. EX:

 var myarray = [0, 1, 2, 3], myarrayLength = myarray.length; //myarrayLength is set to 4 

concat() , é claro, pode ser usado com matrizes bidimensionais também. Nenhum loop requerido.

var a = [[1, 2], [3, 4]];

var b = [[“a”, “b”], [“c”, “d”]];

b = b.concat (a);

alerta (b [2] [1]); // resultado 2

Só quero adicionar um trecho para adição não destrutiva de um elemento.

 var newArr = oldArr.concat([newEl]); 

você pode fazer isso usando o novo recurso javascript Es 6:

 // initialize array var arr = [ "Hi", "Hello", "Bangladesh" ]; // append new value to the array arr= [...arr , "Feni"]; // or you can put a variable value var testValue = "Cool"; arr = [...arr , testValue ]; console.log(arr); // final output [ 'Hi', 'Hello', 'Bangladesh', 'Feni', 'Cool' ] 

se você quiser combinar 2 arrays sem a duplicata, você pode tentar o código abaixo

 array_merge = function (arr1, arr2) { return arr1.concat(arr2.filter(function(item){ return arr1.indexOf(item) < 0; })) } 

uso:

 array1 = ['1', '2', '3'] array2 = ['2', '3', '4', '5'] combined_array = array_merge(array1, array2) 

Saída: [1,2,3,4,5]

Se você estiver usando o ES6, pode usar o operador de dispersão para fazer isso.

 var arr = [ "apple", "banana", "cherry" ]; var arr2 = [ "dragonfruit", "elderberry", "fig" ]; arr.push(...arr2); 

Se você quiser acrescentar um único valor em uma matriz, simplesmente use o método push … Ele adicionará um novo elemento no final da matriz. Mas se você pretende adicionar vários elementos, armazene os elementos em uma nova matriz e concorde com a segunda matriz … da maneira que desejar.

 arr=['a','b','c']; arr.push('d'); //now print the array in console.log and it will contain 'a','b','c','d' as elements. 

Você .push () nesse valor. Exemplo: array.push (valor);

Anexar um valor a um array

Como o Array.prototype.push adiciona um ou mais elementos ao final de uma matriz e retorna o novo tamanho da matriz , às vezes queremos apenas obter a nova matriz atualizada para que possamos fazer algo assim:

 const arr = [1, 2, 3]; const val = 4; arr.concat([val]); // [1, 2, 3, 4] 

Ou apenas:

 [...arr, val] // [1, 2, 3, 4] 

Nós não temos a function append para Array em javascript, mas temos push e unshift , imagine que você tenha o array abaixo:

 var arr = [1, 2, 3, 4, 5]; 

e nós adicionamos um valor a este array, podemos fazer, arr.push (6) e ele adicionará 6 ao final do array:

 arr.push(6); // return [1, 2, 3, 4, 5, 6]; 

Também podemos usar unshift, veja como podemos aplicar isso:

 arr.unshift(0); //return [0, 1, 2, 3, 4, 5]; 

São funções principais para adicionar ou acrescentar novos valores aos arrays.

Anexar elemento único

 //Append at first arrName.push('newName1'); //Append at last arrName.unshift('newName1'); //Append at index 1 arrName.splice(1, 0,'newName1'); //1: index number, 0: number of element to remove, newName1: new element //Append at index 3 arrName[3] = 'newName1'; 

Anexar vários elementos

 //Append from index number 1 arrName.splice(1, 0,'newElemenet1', 'newElemenet2', 'newElemenet3'); //1: index number from where append start, //0: number of element to remove, //newElemenet1,2,3: new elements 

Matriz de acréscimo

 //join two or more array arrName.concat(newAry1, newAry2); //newAry1,newAry2: Two different array which is to be append to the existing array 

Você pode usar o método push.

 Array.prototype.append = function(destArray){ destArray = destArray || []; this.push.call(this,...destArray); return this; } var arr = [1,2,5,67]; var arr1 = [7,4,7,8]; console.log(arr.append(arr1));// [7, 4, 7, 8, 1, 4, 5, 67, 7] console.log(arr.append("Hola"))//[1, 2, 5, 67, 7, 4, 7, 8, "H", "o", "l", "a"] 

Usando o método push() , um item será anexado a um array. Veja o exemplo abaixo.

  array=['a','b','c']; array.push('d') console.log(array); 

push() adiciona um novo elemento ao final de um array.
pop() remove um elemento do final de um array.

Para append um object (como uma string ou um número) a um array use –
array.push(toAppend);

Anexar um único item

Para acrescentar um único item a um array, use o método push() fornecido pelo object Array:

 const fruits = ['banana', 'pear', 'apple'] fruits.push('mango') console.log(fruits) 

Anexando itens em uma matriz

 let fruits =["orange","banana","apple","lemon"]; /*array declaration*/ fruits.push("avacado"); /* Adding an element to the array*/ /*displaying elements of the array*/ for(var i=0; i < fruits.length; i++){ console.log(fruits[i]); }