Bir JavaScript dizisi bildirirken “Array ()” ve “[]” arasındaki fark nedir?

Bunun gibi bir dizi bildirme arasındaki gerçek fark nedir:

var myArray = new Array();

ve

var myArray = [];

Bir fark vardır, ancak bu örnekte hiçbir fark yoktur.

Daha ayrıntılı yöntemi kullanarak: new Array()parametrelerde bir ekstra seçenek vardır: yapıcıya bir sayı iletirseniz, bu uzunlukta bir dizi alırsınız:

x = new Array(5);
alert(x.length); // 5

Dizi oluşturmanın farklı yollarını göstermek için:

var a = [],            // these are the same
    b = new Array(),   // a and b are arrays with length 0

    c = ['foo', 'bar'],           // these are the same
    d = new Array('foo', 'bar'),  // c and d are arrays with 2 strings

    // these are different:
    e = [3]             // e.length == 1, e[0] == 3
    f = new Array(3),   // f.length == 3, f[0] == undefined

;

Başka bir fark, kullanırken new Array(), yığın boyutunu etkileyen dizinin boyutunu ayarlayabilmenizdir. Bu , dizinin boyutu yığının boyutunu aştığında gerçekleşen ve yeniden oluşturulması gereken yığın taşmaları ( Array.push'ın Performansı vs Array.unshift ) alıyorsanız faydalı olabilir . Bu nedenle, kullanım durumuna bağlı olarak new Array()taşma sırasında bir performans artışı olabilir, çünkü taşmanın olmasını önleyebilirsiniz.

İşaret edildiği gibi bu cevap , new Array(5)aslında beş eklemez undefineddiziye öğeler. Sadece beş öğe için yer ekler. ArrayBu şekilde kullanmanın array.lengthhesaplamalara güvenmeyi zorlaştırdığını unutmayın .

Örtük diziyle bir dizi oluşturma ve dizi yapıcısı arasındaki fark, ince ancak önemlidir.

Kullanarak bir dizi oluşturduğunuzda

var a = [];

Yorumlayıcıya yeni bir çalışma zamanı dizisi oluşturmasını söylüyorsunuz. Hiçbir ekstra işleme gerek yoktur. Bitti.

Eğer kullanırsan:

var a = new Array();

Tercümana söylüyorsun, ben yapıcıyı çağırmak istiyorum "Array " demek ve bir nesne oluşturmak . Daha sonra çağrılacak kurucuyu bulmak için yürütme bağlamınızı arar ve dizinizi oluştururken onu çağırır.

"Peki, bu hiç önemli değil. Onlar aynı!" Diye düşünebilirsiniz. Maalesef bunu garanti edemezsiniz.

Aşağıdaki örneği alın:

function Array() {
    this.is = 'SPARTA';
}

var a = new Array();
var b = [];

alert(a.is);  // => 'SPARTA'
alert(b.is);  // => undefined
a.push('Woa'); // => TypeError: a.push is not a function
b.push('Woa'); // => 1 (OK)

Yukarıdaki örnekte, ilk çağrı beklediğiniz gibi 'SPARTA'yı uyaracaktır. İkincisi olmaz. Sonunda tanımsız görürsünüz. Ayrıca b'nin push, diğerinin olmadığı gibi yerel Array nesnesi işlevlerinin tamamını içerdiğini de unutmayın .

Bunun olmasını beklemenize rağmen, sadece []bununla aynı olmayan gerçeği gösterir new Array().

Sadece []bir dizi istediğinizi biliyorsanız sadece kullanmak en iyisidir . Ayrıca etrafta dolaşmayı ve Array'ı yeniden tanımlamayı önermiyorum ...

Henüz bir yanıttan bahsedilmeyen önemli bir fark var.

Bundan:

new Array(2).length           // 2
new Array(2)[0] === undefined // true
new Array(2)[1] === undefined // true

new Array(2)Eşdeğer olduğunu düşünebilirsiniz [undefined, undefined], ancak DEĞİL!

Şunu deneyelim map():

[undefined, undefined].map(e => 1)  // [1, 1]
new Array(2).map(e => 1)            // "(2) [undefined × 2]" in Chrome

Görmek? Anlambilim tamamen farklıdır! Öyleyse neden böyle?

ES6 Spec 22.1.1.2'ye göre, görevi Array(len)sadece özelliği lengthargüman olarak ayarlanmış yeni bir dizi oluşturmak lenve bu kadar, yani bu yeni oluşturulan dizi içinde gerçek bir öğe yok .

İşlev map(), spesifikasyon 22.1.3.15'e göre önce kontrol HasPropertyeder ve geri aramayı çağırır, ancak şu şekilde ortaya çıkar:

new Array(2).hasOwnProperty(0) // false
[undefined, undefined].hasOwnProperty(0) // true

Bu nedenle, oluşturulan dizilerde her zamanki gibi çalışan yineleme işlevlerini bekleyemezsiniznew Array(len) .

BTW, Safari ve Firefox'un bu duruma göre çok daha iyi bir "baskısı" var:

// Safari
new Array(2)             // [](2)
new Array(2).map(e => 1) // [](2) 
[undefined, undefined]   // [undefined, undefined] (2) 

// Firefox
new Array(2)             // Array [ <2 empty slots> ]
new Array(2).map(e => 1) // Array [ <2 empty slots> ]
[undefined, undefined]   // Array [ undefined, undefined ]

Zaten Chromium'a bir sorun gönderdim ve onlardan bu kafa karıştırıcı baskıyı düzeltmelerini istedim: https://bugs.chromium.org/p/chromium/issues/detail?id=732021

GÜNCELLEME: Zaten düzeltildi. Chrome artık şu şekilde yazdırıldı:

new Array(2)             // (2) [empty × 2]

İşin tuhafı, Chrome'dan new Array(size)neredeyse 2 kat daha hızlı []ve FF ve IE'de yaklaşık aynı (bir dizi oluşturup doldurarak ölçülen). Yalnızca dizinin yaklaşık boyutunu biliyorsanız önemlidir. Verdiğiniz uzunluktan daha fazla öğe eklerseniz, performans artışı kaybedilir.

Daha doğrusu: Array(bellek ayırmayan hızlı sabit bir zaman işlemidir, wheras []türü ve değeri ayarlayan doğrusal bir zaman işlemidir.

Daha fazla bilgi için, aşağıdaki sayfada neden asla kullanmanız gerekmediği açıklanmaktadırnew Array()

Asla new Object()JavaScript'te kullanmanız gerekmez . {} Bunun yerine değişmez nesneyi kullanın. Benzer şekilde, kullanmayın new Array(), [] bunun yerine değişmez diziyi kullanın. JavaScript'teki diziler, Java'daki diziler gibi bir işe yaramaz ve Java benzeri sözdiziminin kullanılması sizi şaşırtacaktır.

Kullanmayın new Number, new Stringya da new Boolean. Bu formlar gereksiz nesne paketleyicileri üretir. Bunun yerine basit değişmez değerleri kullanın.

Ayrıca yorumları kontrol edin - new Array(length)form herhangi bir yararlı amaca hizmet etmez (en azından bugünün JavaScript uygulamalarında).

Daha iyi anlamak için []ve new Array():

> []
  []
> new Array()
  []
> [] == []
  false
> [] === []
  false
> new Array() == new Array()
  false
> new Array() === new Array()
  false
> typeof ([])
  "object"
> typeof (new Array())
  "object"
> [] === new Array()
  false
> [] == new Array()
  false

Yukarıdaki sonuç, Windows 7'deki Google Chrome konsolundan alınmıştır.

İlki varsayılan nesne yapıcı çağrısıdır. İsterseniz parametrelerini kullanabilirsiniz.

var array = new Array(5); //initialize with default length 5

İkincisi boş olmayan bir dizi oluşturma olanağı sağlar:

var array = [1, 2, 3]; // this array will contain numbers 1, 2, 3.

Fredrik'in iyi örneğine dayanan bu örnekle başlayarak daha spesifik bir şekilde açıklayabilirim.

var test1 = [];
test1.push("value");
test1.push("value2");

var test2 = new Array();
test2.push("value");
test2.push("value2");

alert(test1);
alert(test2);
alert(test1 == test2);
alert(test1.value == test2.value);

Sadece dizilere başka bir değer ekledim ve dört uyarı yaptım: Birinci ve ikinci değerler hakkında emin olmak için her dizide depolanan değeri vermektir. Aynı dönecekler! Şimdi üçüncü olanı deneyin, yanlış döndürür, çünkü

JS, test1'i bir veri türü dizisine sahip bir VARIABLE olarak ele alır ve test2'yi bir dizinin işlevselliğiyle bir NESNE olarak ele alır ve burada birkaç küçük fark vardır.

İlk fark test1 dediğimizde, bir değişkeni düşünmeden çağırır, sadece bu değişkente depolanan değerleri veri türünü dikkate almadan döndürür! Ancak, test2'yi çağırdığımızda Array () işlevini çağırır ve sonra "Push" değerlerimizi "Value" özelliğinde depolar ve test2'yi uyardığımızda da olur, "Value" değerini döndürür , dizi nesnesinin özelliğini .

Bu yüzden test1'in test2'ye eşit olup olmadığını kontrol ettiğimizde elbette asla doğruya dönmeyeceklerdir, biri bir işlevdir ve diğeri bir değişkendir (dizi türüyle), aynı değere sahip olsalar bile!

Bundan emin olmak için, .value eklendiğinde 4. uyarıyı deneyin; gerçek dönecektir. Bu durumda JS'ye "İşlevin ister değişken olsun, kabın türünü göz ardı ederek, lütfen her kapta depolanan değerleri karşılaştırın ve bize ne gördüğünüzü söyleyin!" tam da böyle oluyor.

Umarım arkasındaki fikri net bir şekilde söyledim ve kötü İngilizcem için üzgünüm.

Diziyi herhangi bir uzunluk olmadan başlattığınızda hiçbir fark yoktur. Yani var a = []&var b = new Array() aynıdır.

Ancak diziyi uzunluğunda olduğu gibi başlatırsanız var b = new Array(1);, dizi nesnesinin uzunluğunu 1 olarak ayarlar. var b = []; b.length=1; .

Array_object.push yaptığınızda, son öğeden sonra öğe ekler ve uzunluğu artırır.

var b = new Array(1);
b.push("hello world");
console.log(b.length); // print 2

vs

var v = [];
a.push("hello world");
console.log(b.length); // print 1

Birincisi varsayılan nesne yapıcı çağrısıdır. Çoğunlukla dinamik değerler için kullanılır.

var array = new Array(length); //initialize with default length

statik diziler oluşturulurken ikinci dizi kullanılır

var array = [red, green, blue, yellow, white]; // this array will contain values.

Büyük bir fark yok, temelde aynı şeyi yapıyorlar ama farklı şekillerde yapıyorlar, ama okumaya devam edin, W3C'deki şu ifadeye bakın:

var cars = ["Saab", "Volvo","BMW"];

ve

var cars = new Array("Saab", "Volvo", "BMW");

Yukarıdaki iki örnek tamamen aynıdır. Yeni Array () kullanmaya gerek yoktur.
Basitlik, okunabilirlik ve yürütme hızı için ilkini kullanın (dizi değişmez yöntemi).

Ancak aynı zamanda, new Arraykötü uygulama olarak kabul edilen sözdizimini kullanarak yeni dizi oluşturmak :

Yeni Diziden Kaçının ()

JavaScript'in yerleşik dizi yapıcısı yeni Array () kullanmaya gerek yoktur.
Bunun yerine [] kullanın.
Bu iki farklı ifadenin her ikisi de points adlı yeni bir boş dizi oluşturur:

var points = new Array();         // Bad
var points = [];                  // Good 

Bu iki farklı ifadenin her ikisi de 6 sayı içeren yeni bir dizi oluşturur:

var points = new Array(40, 100, 1, 5, 25, 10); // Bad    
var points = [40, 100, 1, 5, 25, 10];          // Good

Yeni anahtar kelime sadece kod zorlaştırmaktadır. Ayrıca bazı beklenmedik sonuçlar da üretebilir:

var points = new Array(40, 100);  // Creates an array with two elements (40 and 100)

Öğelerden birini kaldırırsam ne olur?

var points = new Array(40);       // Creates an array with 40 undefined elements !!!!!

Yani temelde en iyi uygulama olarak kabul edilmez, ayrıca orada küçük bir fark vardır new Array(length), bunun gibi bir uzunluk geçirebilirsiniz , bu da önerilen bir yol değildir.

Kullanma farkı

var arr = new Array(size);

Veya

arr = [];
arr.length = size;

Bu soruda yeterince tartışıldığı gibi.

Hız sorununu eklemek istiyorum - şu anki en hızlı yol, google chromeikincisidir.

Ancak dikkat edin, bunlar güncellemelerle çok değişme eğilimindedir. Ayrıca çalışma süresi farklı tarayıcılar arasında farklılık gösterir.

Örneğin - bahsettiğim 2. seçenek, 2 milyon [ops / saniye] üzerinde çalışıyor chrome, ancak denersenizmozilla dev. şaşırtıcı derecede daha yüksek bir 23 milyon oranı elde edersiniz.

Her neyse, siteyi bu şekilde kullanarak farklı tarayıcılarda (ve makinelerde) ara sıra kontrol etmenizi öneririm.

Ben diference bildiği gibi u gibi dilim (veya Array diğer üstlendiği fonksiyonları) bulabilirsiniz code1 .ve code2 u göstermek Diziyi ve onun örneklerini :

code1:

[].slice; // find slice here
var arr = new Array();
arr.slice // find slice here
Array.prototype.slice // find slice here

code2:

[].__proto__ == Array.prototype; // true
var arr = new Array();
arr.__proto__ == Array.prototype; // true

Sonuç:

u yeni bir Array örneği görebilir []ve new Array()oluşturabilir ve hepsi de prototip işlevleriniArray.prototype

Onlar sadece Array'ın farklı bir örneğidir. [] != []

:)

[] Kullanarak garip bir davranışla karşılaştım.

Model "sınıfları" var ve alanları belirli bir değere başlattık. Örneğin:

require([
  "dojo/_base/declare",
  "dijit/_WidgetBase",
], function(declare, parser, ready, _WidgetBase){

   declare("MyWidget", [_WidgetBase], {
     field1: [],
     field2: "",
     function1: function(),
     function2: function()
   });    
});

Alanlar ile başlatıldığında []tüm Model nesneleri tarafından paylaşılacağını buldum . Birinde değişiklik yapmak diğerlerini etkiler.

Bu onları başlatmakla olmaz new Array(). Nesnelerin başlatılması için de aynı ( {}yeni vs Object())

TBH Kullanmakta olduğumuz çerçeveyle ilgili bir sorun olup olmadığından emin değilim ( Dojo )

Bunun gözle görülenden daha fazlası var. Diğer cevapların çoğu doğrudur AMA ..

new Array(n)

• Motorun nelemanlar için yer ayırmasına izin verir
• Dizi oluşturma için optimize edildi
• Oluşturulan dizi, en az performans gösteren dizi işlemlerine sahip seyrek olarak işaretlenir , çünkü her dizin erişiminin sınırları kontrol etmesi, değerin var olup olmadığını ve etmesi ve prototip zincirinde yürümesi gerekir
• Dizi seyrek olarak işaretlenmişse, geri dönüş yolu yoktur (en azından V8'de), 1ms veya 2 saat sonra içerikle doldurulmuş olsanız bile, ömrü boyunca her zaman daha yavaş olacaktır.

[1, 2, 3] || []

• Oluşturulan dizi paketlenmiş olarak işaretlenir (siz deleteveya [1,,3]sözdizimi kullanmadığınız sürece )
• Dizi için optimize edilmiş işlemler ( for .., forEach,map , vs.)
• Dizi büyüdükçe motorun alanı yeniden tahsis etmesi gerekir

Bu muhtemelen eski tarayıcı sürümleri / tarayıcıları için geçerli değildir.

Beni biraz zorlayan iki yapı arasında bir fark buldum.

Diyelim ki:

function MyClass(){
  this.property1=[];
  this.property2=new Array();
};
var MyObject1=new MyClass();
var MyObject2=new MyClass();

Gerçek hayatta, eğer bunu yaparsam:

MyObject1.property1.push('a');
MyObject1.property2.push('b');
MyObject2.property1.push('c');
MyObject2.property2.push('d');

Ne ile bitirmek budur:

MyObject1.property1=['a','c']
MyObject1.property2=['b']
MyObject2.property1=['a','c']
MyObject2.property2=['d']

Dil belirtiminin ne olacağını bilmiyorum, ancak iki nesnemin nesnelerimde benzersiz özellik dizileri olmasını istiyorsanız, kullanmalıyım new Array().

Array yapıcısını kullanarak istenen uzunlukta yeni bir dizi oluşturur ve her bir dizini tanımsız ile doldurur, bir değişkene bir dizi atanması, kendisine bilgi verdiğiniz dizinleri oluşturur.