Jak dołączyć obiekt (np. Ciąg lub liczbę) do tablicy w JavaScript?

Użyj Array.prototype.pushmetody, aby dołączyć wartości do tablicy:

// initialize array
var arr = [
  "Hi",
  "Hello",
  "Bonjour"
];

// append new value to the array
arr.push("Hola");

console.log(arr);

Możesz użyć tej push()funkcji, aby dodać więcej niż jedną wartość do tablicy w jednym wywołaniu:

// initialize array
var arr = ["Hi", "Hello", "Bonjour", "Hola"];

// append multiple values to the array
arr.push("Salut", "Hey");

// display all values
for (var i = 0; i < arr.length; i++) {
  console.log(arr[i]);
}

Aktualizacja

Jeśli chcesz dodać elementy jednej tablicy do drugiej, możesz użyć firstArray.concat(secondArray):

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

arr = arr.concat([
  "dragonfruit",
  "elderberry",
  "fig"
]);

console.log(arr);

Aktualizacja

Tylko dodatek do tej odpowiedzi, jeśli chcesz dołączyć dowolną wartość na początku tablicy, która oznacza pierwszy indeks, możesz użyć Array.prototype.unshiftdo tego celu.

var arr = [1, 2, 3];
arr.unshift(0);
console.log(arr);

Obsługuje także dodawanie wielu wartości jednocześnie push.

Jeśli dodajesz tylko jedną zmienną, to push()działa dobrze. Jeśli chcesz dołączyć 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);

Concat nie wpływa ar1i, o ar2ile nie zostanie ponownie przypisany, 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 testy porównawcze (każdy test = 500 tys. Dołączonych elementów, a wyniki są średnimi z wielu przebiegów) wykazały:

Firefox 3.6 (Mac):

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

Safari 5.0 (Mac):

• Małe tablice: arr[arr.length] = bjest szybszy (90ms vs. 115ms)
• Duże tablice: arr[arr.length] = bjest 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 (160 ms)

Bardziej podoba mi się arr.push()składnia, ale myślę, że lepiej mi będzie z arr[arr.length]wersją, przynajmniej w czystej prędkości. Chciałbym zobaczyć wyniki uruchomienia IE.

Moje pętle testów porównawczych:

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żna wywoływać z wieloma argumentami, które zostaną dołączone do tablicy w kolejności. Na przykład:

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

W rezultacie możesz użyć push.apply, aby dołączyć tablicę do innej tablicy w taki sposób:

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

Przypisami ES5 ma więcej informacji na temat tego, co dokładnie wcisnąć i zastosować zrobić.

Aktualizacja 2016: dzięki spreadowi nie potrzebujesz applyjuż tego , np .:

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

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

Możesz użyć pushi applyfunkcji, aby dołączyć dwie tablice.

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

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

Dołącza się array2do array1. Teraz array1zawiera [11, 32, 75, 99, 67, 34]. Ten kod jest znacznie prostszy niż pisanie forpętli w celu skopiowania każdego elementu w tablicy.

Dzięki nowemu operatorowi rozkładania ES6 łączenie dwóch tablic za pomocą pushstaje 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ść arr2na końcu arr.

Przykład Babel REPL

Jeśli arrjest tablicą i valjest wartością, którą chcesz dodać użyj:

arr.push(val);

Na przykład

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

Użyj concat:

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

Javascript z ECMAScript 5 standardowego, który jest obsługiwany przez większość przeglądarek teraz, można użyć apply(), aby dołączyć array1do 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, FF i IE Edge, możesz użyć spreadoperatora:

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

array2.push(...array1);

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

spreadOperator zastąpi array2.push(...array1);ze array2.push(3, 4, 5);gdy przeglądarka myśli logikę.

Punkt bonusowy

Jeśli chcesz utworzyć inną zmienną do przechowywania wszystkich elementów z obu tablic, możesz to zrobić:

ES5 var combinedArray = array1.concat(array2);

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

Operator rozkładania ( ...) ma rozłożyć wszystkie elementy z kolekcji.

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

A jeśli chcesz dodać rekord gdo array ( var a=[]), możesz użyć:

a.push('g');

push()Metoda dodaje nowe elementy do końca 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ż udzielona, ​​ale spójrzmy na kilka innych sposobów dodawania elementów do tablicy.

unshift()Metoda dodaje nowe elementy na początek 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

Wreszcie concat()metoda służy 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

Istnieje kilka sposobów dołączenia tablicy w JavaScript:

1)push() sposób dodaje jeden lub większą liczbę elementów na koniec tablicy i zwraca nową długość tablicy.

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

Wynik:

[1, 2, 3, 4, 5]

2)unshift() sposób dodaje jeden lub większą liczbę elementów do początku tablicy i zwraca nową długość tablicy:

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

Wynik:

[4, 5, 1, 2, 3]

3)concat() sposób jest stosowany 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);

Wynik:

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

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

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

Wynik:

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

5)splice() sposób zmienia zawartość tablicy poprzez usunięcie elementów i / lub dodania nowych elementów:

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

Wynik:

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

6) Możesz 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);

Wynik:

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

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

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

zachowując oryginalną tablicę niezmienną.

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

myArray[i + 1] = someValue;

Jednak jeśli nie wiesz, możesz albo użyć

myArray.push(someValue);

jak sugerują inne odpowiedzi, lub możesz użyć

myArray[myArray.length] = someValue; 

Zauważ, że tablica jest oparta na zerach, więc .l zwracają najwyższy indeks plus jeden.

Pamiętaj też, że nie musisz dodawać w kolejności i możesz faktycznie pomijać wartości, jak w

myArray[myArray.length + 1000] = someValue;

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

Dlatego dobrą praktyką jest używanie pętli przez JavaScript w celu sprawdzenia, czy wartość rzeczywiście istnieje w tym momencie.

Można to zrobić w następujący sposób:

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

jeśli masz pewność, że nie masz żadnych zer w tablicy, możesz po prostu:

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

Oczywiście upewnij się, że w tym przypadku nie używasz jako warunku myArray [i] (jak niektórzy ludzie w Internecie sugerują na podstawie tego, że gdy i jest większy niż najwyższy indeks, zwróci niezdefiniowany, co daje wynik fałszywe)

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łącz wiele 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

Dołącz tablicę

//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żna go również używać z tablicami dwuwymiarowymi. Pętla nie jest wymagana.

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

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

b = b.concat (a);

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

Niech właściwość length tablicy zadziała:

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

myarray.length zwraca liczbę ciągów w tablicy. JS ma wartość zerową, więc kluczem do następnego elementu tablicy będzie bieżąca długość tablicy. DAWNY:

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

Po prostu chcę dodać fragment kodu w celu nieniszczącego dodania elementu.

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

Dołącz wartość do tablicy

Ponieważ Array.prototype.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 tylko:

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

Jeśli używasz ES6, możesz to zrobić za pomocą operatora spreadu .

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

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

arr.push(...arr2);

możesz to zrobić za pomocą 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' ]

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

stosowanie:

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

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

Dodaj pojedynczy element

Aby dołączyć pojedynczy element do tablicy, użyj push()metody dostarczonej przez obiekt Array:

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

push() mutuje oryginalną tablicę.

Aby zamiast tego utworzyć nową tablicę, użyj concat()metody Array:

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

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

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

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

Dołącz wiele elementów

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

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

Możesz także użyć concat()metody, którą widziałeś wcześniej, przekazując 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, ta metoda nie mutuje oryginalnej tablicy, ale zwraca nową tablicę.

Pierwotnie opublikowane na

Możesz .push () tę wartość w. Przykład: array.push (wartość);

Jeśli chcesz dołączyć jedną wartość do tablicy, po prostu użyj metody push. Doda nowy element na końcu tablicy.

Ale jeśli zamierzasz dodać wiele elementów, zapisz elementy w nowej tablicy i połącz drugą tablicę z pierwszą tablicą ... w dowolny sposób.

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 dołączania do Array w javascript, ale mamy push i cofnij , wyobraź sobie, że masz tablicę poniżej:

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

i lubimy dodawać wartość do tej tablicy, możemy to zrobić, arr.push (6), a to doda 6 na końcu tablicy:

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

możemy również użyć cofania, zobacz, jak możemy zastosować to:

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

Są to główne funkcje dodawania lub dodawania 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"]

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

Aby dołączyć obiekt (taki jak ciąg lub liczbę) do tablicy, użyj -
array.push(toAppend);

Dołączanie 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]);
}

Możesz użyć 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 także spróbować mentodu długości np array[aray.length] = 'test';