Mevcut bir JavaScript dizisini yeni bir dizi oluşturmadan başka bir diziyle genişletme

Mevcut bir JavaScript dizisini başka bir diziyle genişletmenin, yani Python'un extendyöntemini taklit etmenin bir yolu yok gibi görünüyor .

Aşağıdakileri başarmak istiyorum:

>>> a = [1, 2]
[1, 2]
>>> b = [3, 4, 5]
[3, 4, 5]
>>> SOMETHING HERE
>>> a
[1, 2, 3, 4, 5]

Bir a.concat(b)yöntem olduğunu biliyorum , ama sadece birincisini genişletmek yerine yeni bir dizi oluşturur. Ne zaman aönemli ölçüde daha büyük b(yani bir kopyalama değil a) verimli çalışan bir algoritma istiyorum .

_{Not: Bu kopyası olmaması bir diziye şey eklemek nasıl? - Buradaki amaç, bir dizinin tüm içeriğini diğerine eklemek ve "yerinde", yani genişletilmiş dizinin tüm öğelerini kopyalamadan yapmaktır.}

.pushYöntem birden fazla argüman alabilir. İkinci dizinin tüm öğelerini bağımsız değişken olarak iletmek için yayma işlecini kullanabilirsiniz .push:

>>> a.push(...b)

Tarayıcınız ECMAScript 6'yı desteklemiyorsa, .applybunun yerine şunları kullanabilirsiniz :

>>> a.push.apply(a, b)

Ya da belki de daha net olduğunu düşünüyorsanız:

>>> Array.prototype.push.apply(a,b)

Dizi bçok uzunsa , tüm bu çözümlerin yığın taşması hatasıyla başarısız olacağını unutmayın (sorun tarayıcıya bağlı olarak yaklaşık 100.000 öğede başlar).
Bunun byeterince kısa olduğunu garanti edemiyorsanız , diğer cevapta açıklanan standart döngü tabanlı bir teknik kullanmalısınız.

_{Güncelleme 2018 : Daha iyi bir cevap benim bir yeni biridir : a.push(...b). Soruyu asla gerçekten cevaplamadığı için artık bunu oylamayın, ancak Google'da ilk hit olan 2015'teki bir hackti :)}

Basitçe "JavaScript dizi genişletmek" için arama yaptı ve buraya var olanlar için, çok iyi kullanabilirsiniz Array.concat.

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

Concat, iş parçacığı başlatıcısı istemediği için yeni dizinin bir kopyasını döndürür. Ama umursamayabilirsiniz (kesinlikle çoğu kullanım için bu iyi olacaktır).

Bunun için forma operatörü şeklinde güzel ECMAScript 6 şekeri de var:

const a = [1, 2, 3];
const b = [...a, 5, 4, 3];

(Ayrıca kopyalar.)

Döngü tabanlı bir teknik kullanmalısınız. Bu sayfada, kullanımına dayalı diğer yanıtlar .applybüyük diziler için başarısız olabilir.

Oldukça kısa döngü tabanlı bir uygulama:

Array.prototype.extend = function (other_array) {
    /* You should include a test to check whether other_array really is an array */
    other_array.forEach(function(v) {this.push(v)}, this);
}

Ardından aşağıdakileri yapabilirsiniz:

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

Eklediğimiz.apply dizi büyük olduğunda DzinX'in yanıtı (push.apply kullanarak) ve diğer temel yöntemler başarısız olur (testler benim için büyük olanın Chrome'da yaklaşık 150.000 giriş ve Firefox'ta> 500.000 giriş olduğunu gösteriyor). Bu hatayı bu jsperf dosyasında görebilirsiniz .

İkinci bağımsız değişken olarak büyük bir dizi ile 'Function.prototype.apply' çağrıldığında çağrı yığını boyutu aşıldığı için bir hata oluşur. (MDN, Function.prototype.apply komutunu kullanarak çağrı yığını boyutunu aşmanın tehlikeleri hakkında bir not içerir - "Uygula ve yerleşik işlevleri" başlıklı bölüme bakın.)

Bu sayfadaki diğer cevaplarla hız karşılaştırması için bu jsperf'e ( EaterOfCode sayesinde) göz atın. Döngü tabanlı uygulama, kullanım hızına benzer Array.push.apply, ancak biraz daha yavaş olma eğilimindedir Array.slice.apply.

İlginç bir şekilde, eklediğiniz dizi seyrek ise, forEachyukarıdaki temel yöntem seyreklikten yararlanabilir ve .applytemel yöntemlerden daha iyi performans gösterebilir ; Bunu kendiniz test etmek istiyorsanız bu jsperf'e göz atın .

Bu arada, (olduğu gibi!) ForEach uygulamasını daha da kısaltmak için cazip olmayın:

Array.prototype.extend = function (array) {
    array.forEach(this.push, this);
}

çünkü bu çöp sonuçları üretir! Neden? Çünkü Array.prototype.forEachçağırdığı işleve üç argüman sağlar - bunlar: (element_value, element_index, source_array). Tüm bunlar, forEach"forEach (this.push, this)" kullanırsanız, her yineleme için ilk dizinize aktarılacaktır!

Bugünlerde en şık olanı hissediyorum:

arr1.push(...arr2);

Yayılma operatörü MDN makale ES2015 (ES6) bu güzel şekerli yol bahseder:

Daha iyi bir itme

Örnek: push genellikle bir diziyi mevcut bir dizinin sonuna itmek için kullanılır. ES5'te bu genellikle şu şekilde yapılır:

var arr1 = [0, 1, 2];
var arr2 = [3, 4, 5];
// Append all items from arr2 onto arr1
Array.prototype.push.apply(arr1, arr2);

ES6'da yayılma ile birlikte:

var arr1 = [0, 1, 2];
var arr2 = [3, 4, 5];
arr1.push(...arr2);

Not Do arr2büyük olması çağrı yığını jcdude cevabı gereğince, taşmaları, çünkü (000 100 hakkında kalemleri altında tutmak) olamaz.

apply()JavaScript'i neden kullandığımızı anlamanıza yardımcı olacak birkaç kelime :

apply()Yöntem, belirli bir bir işlevini çağırır thisdeğeri ve bağımsız değişkenler, bir dizi olarak verdi.

Push , diziye eklenecek öğelerin bir listesini bekler . Ancak apply()yöntem, işlev çağrısı için beklenen bağımsız değişkenleri dizi olarak alır. Bu push, bir dizinin elemanlarını yerleşik push()yöntemle kolayca başka bir diziye dönüştürmemizi sağlar .

Şu dizilere sahip olduğunuzu düşünün:

var a = [1, 2, 3, 4];
var b = [5, 6, 7];

ve basitçe bunu yapın:

Array.prototype.push.apply(a, b);

Sonuç:

a = [1, 2, 3, 4, 5, 6, 7];

Aynı şey ES6'da forma operatörü (" ...") şu şekilde yapılabilir :

a.push(...b); //a = [1, 2, 3, 4, 5, 6, 7]; 

Daha kısa ve daha iyi, ancak şu anda tüm tarayıcılarda tam olarak desteklenmiyor.

Eğer istediğiniz Ayrıca eğer hareket diziden şeyi bile aboşaltma, bsüreç içinde, bunu yapabilirsiniz:

while(b.length) {
  a.push(b.shift());
} 

ve sonuç aşağıdaki gibi olacaktır:

a = [1, 2, 3, 4, 5, 6, 7];
b = [];

JQuery kullanmak istiyorsanız $ .merge () var

Misal:

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

Sonuç: a = [1, 2, 3, 4, 5]

a.push.apply(a, b)Yukarıda açıklanan yöntemi seviyorum ve isterseniz her zaman böyle bir kütüphane işlevi oluşturabilirsiniz:

Array.prototype.append = function(array)
{
    this.push.apply(this, array)
}

ve böyle kullan

a = [1,2]
b = [3,4]

a.append(b)

Bunu kullanarak yapmak mümkündür splice():

b.unshift(b.length)
b.unshift(a.length)
Array.prototype.splice.apply(a,b) 
b.shift() // Restore b
b.shift() // 

Ancak daha çirkin olmasına rağmen push.apply, en azından Firefox 3.0'da daha hızlı değil.

Bu çözüm benim için çalışıyor (ECMAScript 6'nın spread operatörünü kullanarak):

let array = ['my', 'solution', 'works'];
let newArray = [];
let newArray2 = [];
newArray.push(...array); // Adding to same array
newArray2.push([...array]); // Adding as child/leaf/sub-array
console.log(newArray);
console.log(newArray2);

Aşağıda olduğu gibi uzatmak için bir çoklu dolgu oluşturabilirsiniz. Diziye eklenir; Yerinde ve geri dön, böylece diğer yöntemleri zincirleyebilirsiniz.

if (Array.prototype.extend === undefined) {
  Array.prototype.extend = function(other) {
    this.push.apply(this, arguments.length > 1 ? arguments : other);
    return this;
  };
}

function print() {
  document.body.innerHTML += [].map.call(arguments, function(item) {
    return typeof item === 'object' ? JSON.stringify(item) : item;
  }).join(' ') + '\n';
}
document.body.innerHTML = '';

var a = [1, 2, 3];
var b = [4, 5, 6];

print('Concat');
print('(1)', a.concat(b));
print('(2)', a.concat(b));
print('(3)', a.concat(4, 5, 6));

print('\nExtend');
print('(1)', a.extend(b));
print('(2)', a.extend(b));
print('(3)', a.extend(4, 5, 6));

body {
  font-family: monospace;
  white-space: pre;
}

Cevapları birleştirmek ...

Array.prototype.extend = function(array) {
    if (array.length < 150000) {
        this.push.apply(this, array)
    } else {
        for (var i = 0, len = array.length; i < len; ++i) {
            this.push(array[i]);
        };
    }  
}

İkiden fazla diziyi birleştirmek için başka bir çözüm

var a = [1, 2],
    b = [3, 4, 5],
    c = [6, 7];

// Merge the contents of multiple arrays together into the first array
var mergeArrays = function() {
 var i, len = arguments.length;
 if (len > 1) {
  for (i = 1; i < len; i++) {
    arguments[0].push.apply(arguments[0], arguments[i]);
  }
 }
};

Ardından şu şekilde arayın ve yazdırın:

mergeArrays(a, b, c);
console.log(a)

Çıktı: Array [1, 2, 3, 4, 5, 6, 7]

Cevap çok basit.

>>> a = [1, 2]
[1, 2]
>>> b = [3, 4, 5]
[3, 4, 5]
>>> SOMETHING HERE
(The following code will combine the two arrays.)

a = a.concat(b);

>>> a
[1, 2, 3, 4, 5]

Concat, JavaScript dizesi birleştirmesine çok benzer şekilde davranır. İşlevi çağırdığınız dizinin sonundaki concat işlevine koyduğunuz parametrenin bir birleşimini döndürür. Temel nokta, döndürülen değeri bir değişkene atamanız veya kaybolmasıdır. Yani mesela

a.concat(b);  <--- This does absolutely nothing since it is just returning the combined arrays, but it doesn't do anything with it.

150.000'den fazla kayıt Array.extendyerine kullanın Array.push.

if (!Array.prototype.extend) {
  Array.prototype.extend = function(arr) {
    if (!Array.isArray(arr)) {
      return this;
    }

    for (let record of arr) {
      this.push(record);
    }

    return this;
  };
}

Çok basit, forma operatörlerine güvenmez veya bu bir sorun varsa geçerli değildir.

b.map(x => a.push(x));

Bu konuda bazı performans testleri yaptıktan sonra, son derece yavaş, ancak yeni bir dizi oluşturmama sorusunu cevaplıyor. Concat önemli ölçüde daha hızlı, hatta jQuery bile $.merge().

https://jsperf.com/merge-arrays19b/1