Jeśli dodajesz tylko jedną zmienną, to push() działa dobrze. Jeśli chcesz dodać inną tablicę, użyj concat():

var ar1 = [1, 2, 3];
var ar2 = [4, 5, 6];

var ar3 = ar1.concat(ar2);

alert(ar1);
alert(ar2);
alert(ar3);

Konkatedra Nie dotyczy ar1 i ar2, chyba że zostanie przypisana, na przykład:

var ar1 = [1, 2, 3];
var ar2 = [4, 5, 6];

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

Wiele świetnych informacji tutaj .

Niektóre szybkie benchmarking (każdy test = 500K dołączonych elementów, a wyniki są średnie z wielu uruchomień) wykazały, co następuje:

Firefox 3.6 (Mac):

• małe tablice: arr[arr.length] = b jest szybszy (300ms vs. 800ms)
• duże tablice: arr.push(b) jest szybszy (500ms vs. 900ms)

Safari 5.0 (Mac):

• małe tablice: arr[arr.length] = b jest szybszy (90ms vs. 115ms)
• duże tablice: arr[arr.length] = b jest szybszy (160ms vs. 185ms)

Google Chrome 6.0 (Mac):

• małe tablice: brak znaczącej różnicy (A Chrome jest szybki! Tylko ~38ms !!)
• duże tablice: brak znaczącej różnicy (160ms)

Bardziej podoba mi się składnia arr.push(), ale myślę, że byłoby lepiej z wersją arr[arr.length], przynajmniej w surowej szybkości. Chciałbym jednak zobaczyć wyniki biegu IE.

Moje pętle porównawcze:

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;
    }
}

Myślę, że warto wspomnieć, że push może być wywoływany z wieloma argumentami, które będą dołączane do tablicy w kolejności. Na przykład:

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

W wyniku tego można użyć push.apply to append a array to another array like so:

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

Adnotacja ES5 ma więcej informacji na temat tego, co dokładnie push i apply zrobić.

Aktualizacja 2016: z spread, nie potrzebujesz już tego apply, like:

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

arr.push(...['fourth', 'fifth']);
console.log(arr) ;

Możesz użyć funkcji push i apply do dołączenia dwóch tablic.

var array1 = [11, 32, 75];
var array2 = [99, 67, 34];

Array.prototype.push.apply(array1, array2);
console.log(array1);

Doda array2 do array1. Teraz array1 zawiera [11, 32, 75, 99, 67, 34]. Ten kod jest znacznie prostszy niż pisanie pętli for do kopiowania każdego elementu tablicy.

Z nowym operatorem rozproszenia ES6 łączenie dwóch tablic za pomocą push staje się jeszcze łatwiejsze:

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

To dodaje zawartość arr2 na koniec arr.

Babel REPL Example

Jeśli arr jest tablicą, a {[3] } jest wartością, którą chcesz dodać użyj:

arr.push(val);

Np.

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

Użycie concat:

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

Javascript ze standardem ECMAScript 5, który jest obecnie obsługiwany przez większość przeglądarek, możesz użyć apply(), aby dołączyć array1 do 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 ze standardem ECMAScript 6 , który jest obsługiwany przez Chrome i FF oraz IE Edge, możesz użyć operatora spread:

"use strict";
let array1 = [3, 4, 5];
let array2 = [1, 2];

array2.push(...array1);

console.log(array2); // [1, 2, 3, 4, 5]

Operator spread zastąpi array2.push(...array1); na array2.push(3, 4, 5);, gdy przeglądarka myśli logicznie.

Punkt bonusowy

Jeśli chcesz utworzyć inny zmienna aby przechowywać wszystkie elementy z obu tablic, możesz to zrobić:

ES5 var combinedArray = array1.concat(array2);

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

Operator spreadu (...) polega na rozłożeniu wszystkich elementów ze zbioru.

Jeśli chcesz dołączyć dwie tablice -

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

Wtedy możesz użyć:

var c = a.concat(b);

I jeśli chcesz dodać rekord g do array (var a=[]) to możesz użyć:

a.push('g');

Istnieje kilka sposobów na dodanie tablicy w JavaScript:

1) metoda push() dodaje jeden lub więcej elementów na końcu tablicy i zwraca nową długość tablicy.

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

Wyjście:

[1, 2, 3, 4, 5]

2) metodaunshift() dodaje jeden lub więcej elementów na początku tablicy i zwraca nową długość tablicy:

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

Wyjście:

[4, 5, 1, 2, 3]

3) metoda concat() służy do łączenia dwóch lub więcej tablic. Ta metoda nie zmienia istniejących tablic, ale zamiast tego zwraca nową tablicę.

var arr1 = ["a", "b", "c"];
var arr2 = ["d", "e", "f"];
var arr3 = arr1.concat(arr2);
console.log(arr3);

Wyjście:

[ "a", "b", "c", "d", "e", "f" ]

4) możesz użyć właściwości .length tablicy, aby dodać element na końcu tablicy:

var ar = ['one', 'two', 'three'];
ar[ar.length] = 'four';
console.log( ar ); 

Wyjście:

 ["one", "two", "three", "four"]

5) metoda splice() zmienia zawartość tablicy poprzez usunięcie istniejących elementów i / lub dodanie nowych elementów:

var myFish = ["angel", "clown", "mandarin", "surgeon"];
myFish.splice(4, 0, "nemo");
//array.splice(start, deleteCount, item1, item2, ...)
console.log(myFish);

Wyjście:

["angel", "clown", "mandarin", "surgeon","nemo"]

6) możesz można również dodać nowy element do tablicy, po prostu określając nowy indeks i przypisując wartość:

var ar = ['one', 'two', 'three'];
ar[3] = 'four'; // add new element to ar
console.log(ar);

Wyjście:

["one", "two","three","four"]

Metoda push() dodaje nowe pozycje na końcu tablicy i zwraca nową długość. Przykład:

var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.push("Kiwi");

// The result of fruits will be:
Banana, Orange, Apple, Mango, Kiwi

Dokładna odpowiedź na twoje pytanie jest już dostępna, ale przyjrzyjmy się innym sposobom dodawania elementów do tablicy.

Metoda unshift() dodaje nowe pozycje na początku tablicy i zwraca nową długość. Przykład:

var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.unshift("Lemon", "Pineapple");

// The result of fruits will be:
Lemon, Pineapple, Banana, Orange, Apple, Mango

I wreszcie, metoda concat() jest używana do łączenia dwóch lub więcej tablic. Przykład:

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

Teraz możesz skorzystać ze składni ES6 i po prostu zrobić:

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

Zachowanie niezmienności oryginalnej tablicy.

Jeśli znasz najwyższy indeks (taki jak przechowywany w zmiennej "i"), możesz zrobić

myArray[i + 1] = someValue;

Jeśli jednak nie wiesz, możesz użyć

myArray.push(someValue);

Jak sugerowały inne odpowiedzi, lub możesz użyć

myArray[myArray.length] = someValue; 

Zauważ, że tablica jest równa zero .długość zwraca najwyższy indeks plus jeden.

Zauważ również, że nie musisz dodawać w kolejności i możesz faktycznie pominąć wartości, jak w

myArray[myArray.length + 1000] = someValue;

W takim przypadku wartości pomiędzy będą miały wartość undefined.

Jest to zatem dobra praktyka podczas wykonywania pętli przez JavaScript w celu sprawdzenia, czy wartość rzeczywiście istnieje w tym momencie.

Można to zrobić za pomocą czegoś takiego:

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

Jeśli jesteś pewien, że nie masz żadnych zer w tablicy, możesz po prostu zrobić:

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

Oczywiście upewnij się w tym przypadku, że nie używasz jako warunek myArray [i] (jak niektórzy ludzie przez internet sugerują w oparciu o koniec, że tak szybko, jak i jest większa niż najwyższy indeks zwróci undefined, który ewaluuje na false)

Dołącz Pojedynczy Element

//Append to the end
arrName.push('newName1');

//Prepend to the start
arrName.unshift('newName1');

//Insert at index 1
arrName.splice(1, 0,'newName1');
//1: index number, 0: number of element to remove, newName1: new element


// Replace index 3 (of exists), add new element otherwise.
arrName[3] = 'newName1';

Dołączanie Wielu Elementów

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

Append array

//join two or more arrays
arrName.concat(newAry1, newAry2);
//newAry1,newAry2: Two different arrays which are to be combined (concatenated) to an existing array

concat(), oczywiście może być również używany z tablicami 2 wymiarowymi. Nie wymaga zapętlania.

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

Var b = [ ["a", " b"], ["c", "d"]];

B = B.concat(a);

Alarm (b[2][1]); // wynik 2

Niech właściwość array length wykona pracę:

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

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

Chcę tylko dodać fragment dla nieniszczącego dodawania elementu.

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

Dołączenie wartości do tablicy

Od Array.prototyp.push dodaje jeden lub więcej elementów na końcu tablicy i zwraca nową długość tablicy , czasami chcemy po prostu uzyskać nową aktualną tablicę, abyśmy mogli zrobić coś takiego:

const arr = [1, 2, 3];
const val = 4;

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

Lub po prostu:

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

Jeśli używasz ES6, możesz użyć do tego operatora spread .

var arr = [
    "apple",
    "banana",
    "cherry"
];

var arr2 = [
    "dragonfruit",
    "elderberry",
    "fig"
];

arr.push(...arr2);

Możesz to zrobić używając nowej funkcji 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' ]

Dodaj pojedynczy element

Aby dodać pojedynczy element do tablicy, użyj push() metoda dostarczona przez obiekt Array:

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

push() mutuje oryginalną tablicę.

Aby utworzyć nową tablicę, użyj concat() metoda Tablicy:

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

Zauważ, że concat() w rzeczywistości nie dodaje elementu do tablicy, ale tworzy nową tablicę, którą możesz przypisać do innej zmiennej lub przypisać do oryginalnej tablicy (deklarując ją jako let, Jak nie można ponownie przypisać const):

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

let fruits = ['banana', 'pear', 'apple']
fruits = fruits.concat('mango')

Dołączanie wielu elementów

Aby dodać wiele elementów do tablicy, można użyć push() wywołując go z wieloma argumentami:

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

Możesz również użyć concat() metoda, którą widziałeś wcześniej, przekazująca listę elementów oddzielonych przecinkiem:

const fruits = ['banana', 'pear', 'apple']
const allfruits = fruits.concat('mango', 'melon', 'avocado')
console.log(allfruits)

Lub tablica:

const fruits = ['banana', 'pear', 'apple']
const allfruits = fruits.concat(['mango', 'melon', 'avocado'])
console.log(allfruits)

Pamiętaj, że jak opisano wcześniej metoda ta nie mutuje oryginalnej tablicy, ale zwraca nową / align = "left" /

Originally posted at

Jeśli chcesz połączyć 2 tablice bez duplikatu, możesz wypróbować poniższy kod

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

Użycie:

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

Wyjście: [1,2,3,4,5]

Ty .push() tę wartość w. Przykład: array.push (value);

Jeśli chcesz dodać pojedynczą wartość do tablicy, po prostu użyj metody push. Spowoduje dodanie nowego elementu na końcu tablicy.

Ale jeśli chcesz dodać wiele elementów, Zapisz elementy w nowej tablicy i połącz drugą tablicę z pierwszą tablicą...tak czy siak.

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

Nie mamy funkcji append dla tablicy w javascript, ale mamy push i unshift, wyobraź sobie, że masz tablicę poniżej:

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

I chcemy dodać wartość do tej tablicy, możemy zrobić, arr.naciśnięcie (6) spowoduje dodanie 6 na końcu tablicy:

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

Również możemy użyć unshift, spójrz jak możemy zastosować to:

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

Są to główne funkcje do dodawania lub dołączania nowych wartości do tablic.

Możesz użyć metody 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"]

Możesz użyć funkcji push (), jeśli chcesz dodać wartości np. arr.push("Test1", "Test2");

Jeśli masz tablicę możesz użyć concat() np. Array1.concat(Array2)

Jeśli masz tylko jeden element do dodania, możesz również spróbować lengthod np. array[aray.length] = 'test';

push() dodaje nowy element na końcu tablicy.
pop() usuwa element z końca tablicy.

Aby dodać obiekt (np. łańcuch lub liczbę) do tablicy użyj -
array.push(toAppend);

Dodawanie elementów do tablicy

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]);
}