Qual è la differenza tra “Array()” e “ []”, mentre la dichiarazione di un array JavaScript?

https://stackoverflow.com/questions/931872

06-09-2019
|

Domanda

Qual è la reale differenza tra la dichiarazione di un array in questo modo:

var myArray = new Array();

var myArray = [];

Soluzione

C'è una differenza, ma non v'è alcuna differenza in questo esempio.

Usando il metodo più prolisso: new Array() ha una possibilità in più nei parametri: se si passa un numero al costruttore, si otterrà un array di lunghezza:

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

Per illustrare i diversi modi per creare un array:

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

;

Un'altra differenza è che quando si utilizza new Array() sei in grado di impostare la dimensione della matrice, che colpisce la dimensione dello stack. Questo può essere utile se stai ricevendo overflow dello stack ( prestazioni di Array.push vs Array.unshift ), che è ciò che accade quando la dimensione della matrice supera la dimensione dello stack, e deve essere ricreato. Così ci può effettivamente, a seconda del caso d'uso, un aumento delle prestazioni quando si utilizza new Array() perché è possibile impedire l'overflow accada.

Come sottolineato nel questa risposta , new Array(5) sarà in realtà non aggiungere cinque elementi undefined alla matrice. Si aggiunge semplicemente spazio per cinque voci. Essere consapevoli del fatto che l'utilizzo di Array in questo modo rende difficile fare affidamento su array.length per i calcoli.

Altri suggerimenti

La differenza tra la creazione di una matrice con la matrice implicito e il costruttore matrice è sottile ma importante.

Quando si crea un array usando

var a = [];

Stai dicendo l'interprete per creare un nuovo array runtime. Nessuna elaborazione aggiuntivo necessario a tutti. Fatto.

Se si utilizza:

var a = new Array();

Stai dicendo l'interprete, voglio chiamare il costruttore "Array" e generare un oggetto. E poi alza lo sguardo attraverso il vostro contesto di esecuzione di trovare il costruttore di chiamare, e lo chiama, creando la matrice.

Si potrebbe pensare: "Beh, questo non importa affatto. Sono la stessa cosa!". Purtroppo non è possibile garantire che.

Prendiamo il seguente esempio:

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)

Nell'esempio precedente, la prima chiamata avvisa 'SPARTA' come ci si aspetterebbe. Il secondo non lo faranno. Si finirà per vedere indefinito. Potrai anche notare che il B contiene tutte le funzioni oggetto Array autoctone come push, dove l'altro non lo fa.

Mentre si può aspettare che questo accada, è solo illustra il fatto che [] non è lo stesso di new Array().

E 'probabilmente meglio usare solo [] se si sa che si desidera semplicemente un array. Anche io non suggerisco di andare in giro e ridefinendo Array ...

C'è una differenza enorme che nessuno ha menzionato.

Si potrebbe pensare che il new Array(2) è equivalente a [undefined, undefined] prima perché abbiamo

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

ma non è!

Proviamo map():

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

Vedi? È diverso! Ma perché è così?

Secondo ES6 Spec 22.1.1.2, Array(len) crea solo un nuovo array con length impostato len e niente di più. Quindi non v'è alcun elemento reale all'interno del nuovo array.

Mentre funzione map(), secondo spec 22.1.3.15 sarebbe dapprima controlla HasProperty quindi chiamare la richiamata, ma si scopre che:

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

Ecco perché non ci si può aspettare qualsiasi funzione di iterazione funzionano come al solito ad un array creato da new Array(len) .

A proposito, Safari e Firefox hanno una migliore espressione a questo:

// 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 ]

Ho già presentato un problema a Chrome per chiedere loro di risolvere questo registro di confusione: https://bugs.chromium.org/p/chromium/issues/detail ? id = 732021

UPDATE: E 'già fissato. Chrome ora accedere come

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

Stranamente, new Array(size) è quasi 2 volte più veloce rispetto [] in Chrome, e circa lo stesso in FF e IE (misurata mediante la creazione e la compilazione di un array). Importa solo se si conosce la dimensione approssimativa della matrice. Se si aggiungono altri elementi della lunghezza che hai dato, l'incremento delle prestazioni è perduto.

Più precisamente:. Array( è un'operazione costante di tempo veloce che alloca memoria, wheras [] è un'operazione tempo lineare che imposta il tipo e il valore

Per ulteriori informazioni, pagina seguente descrive il motivo per cui non è necessario utilizzare new Array()

Non hai mai bisogno di usare new Object() in   JavaScript. Utilizzare l'{} letterale oggetto   anziché. Allo stesso modo, non usare new Array(),   utilizzare il [] letterale dell'array   anziché. Array nel lavoro JavaScript   niente come gli array in Java, e   l'uso della sintassi simile a Java sarà   confondere.

Non utilizzare new Number, new String, o   new Boolean. Queste forme producono   wrapper di oggetti inutili. basta usare   semplici letterali invece.

Verificate anche i commenti - sotto forma new Array(length) non serve alcuno scopo utile (almeno nelle implementazioni di oggi di JavaScript)

Al fine di comprendere meglio [] e 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

Il risultato di cui sopra è da console di Google Chrome su Windows 7.

Il primo è la chiamata al costruttore oggetto predefinito. Si può usare i suoi parametri, se si desidera.

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

La seconda ti dà la possibilità di creare array non vuoto:

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

posso spiegare in modo più specifico a partire da questo esempio che si basa sul buon compromesso di Fredrik.

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

Ho appena aggiunto un altro valore per gli array, e ne fecero quattro avvisi: Il primo e secondo sono darci il valore memorizzato in ogni matrice, per essere sicuri sui valori. Torneranno lo stesso! Ora provate il terzo, restituisce false, è perché

JS tratta test1 come VARIABILE con un tipo di dati di matrice , e si tratta test2 come OBJECT con la funzionalità di un array , e ci sono poche piccole differenze qui.

La prima differenza è quando noi chiamiamo test1 che definisce una variabile senza pensare, solo restituisce i valori che sono memorizzati in questa variabile ignorando il tipo di dati! Ma, quando noi chiamiamo Test2 chiama il Array) funzione (e quindi memorizza il nostro "spinto" Valori nella sua "Valore" di proprietà, e lo stesso accade quando noi avvertiamo test2, restituisce il "Valore" proprietà dell'oggetto array.

Così, quando controlliamo se è uguale a test1 test2 ovviamente non potranno mai tornare vero, uno è una funzione e l'altra è una variabile (con un tipo di array), anche se hanno lo stesso valore!

Per essere sicuri di questo, provare il 4 ° avviso, con il .value aggiunto ad esso; tornerà vero. In questo caso diciamo JS "Trascurando il tipo di contenitore, se era funzione o variabile, si prega di confrontare i valori che sono memorizzati in ogni contenitore e dirci quello che hai visto!" questo è esattamente ciò che accade.

Spero che ho detto l'idea alla base che in modo chiaro, e mi dispiace per il mio cattivo inglese.

Non v'è alcuna differenza quando si inizializza array senza qualsiasi lunghezza. Così var a = [] & var b = new Array() è lo stesso.

Ma se inizializzare array con lunghezza come var b = new Array(1);, imposterà la lunghezza dell'oggetto array 1. Così la sua equivalente a var b = []; b.length=1;.

Questa sarà problematico ogni volta che si fa array_object.push, si aggiunga l'articolo dopo l'ultimo elemento e aumento di lunghezza.

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

Il primo è il costruttore di default oggetto call.mostly usato per i valori dinamici.

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

la seconda matrice viene utilizzata quando si creano valori statici

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

Non c'è grande differenza, si tratta fondamentalmente fanno la stessa cosa, ma loro che fanno in modi diversi, ma continuate a leggere, guardare a questo economico al W3C:

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

e

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


I due esempi sopra fanno esattamente la stessa. Non v'è alcuna necessità di utilizzare   new Array ().
Per semplicità, la leggibilità e la velocità di esecuzione, utilizzare il   prima (il metodo letterale array).

Ma, allo stesso tempo, la creazione di nuova matrice utilizzando la sintassi new Array considerato come una cattiva pratica:


Evita new Array ()

Non v'è alcuna necessità di utilizzare costruzione Array built-in del JavaScript   new Array ().
  Usare [] invece.
  Queste due istruzioni differenti entrambi creare un nuovo array vuoto denominato   Punti:

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


Queste due istruzioni differenti entrambi creare un nuovo array contenente 6   numeri:

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


Il nuovo parola chiave complica solo il codice. Si può anche produrre alcuni   risultati imprevisti:

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


Che cosa succede se rimuovo uno degli elementi?

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

Quindi, in pratica, non considerata come la migliore prassi, inoltre v'è una differenza minore lì, è possibile passare alla lunghezza new Array(length) come questo, non che anche un modo consigliato.

La differenza di utilizzo

var arr = new Array(size);

O

arr = []; arr.length = size;

Come è stato discusso abbastanza in questa domanda.

Vorrei aggiungere la velocità del problema - la corrente modo più veloce, su google chrome è la seconda.

Ma attenzione, queste cose tendono a cambiare molto con gli aggiornamenti.Anche il tempo di esecuzione variano tra i diversi browser.

Per esempio - l'opzione 2 che ho citato, funziona a 2 milioni di [ops/secondo] su chrome, ma se vuoi provare su di esso mozilla dev. devi avere un sorprendentemente più alto tasso di 23 milioni di euro.

Comunque, io suggerirei di controllare, ogni tanto, su diversi browser (e le macchine), usando il sito come tale

Per quanto ne so il diference u può trovare la fetta (o gli altri funcitons di Array) come code1 .e code2 show u Array e le sue istanze di :

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

conclusione:

come u può vedere [] e new Array() creare una nuova istanza di Array.And hanno trovato e troveranno le funzioni prototipo da Array.prototype

Sono solo diversi istanza di Array.so questo spiega perché [] != []

:)

Sono sostenute in un comportamento strano con [].

Abbiamo Girl "classi" con campi inizializzati a un valore. Es .:

require([ "dojo/_base/declare", "dijit/_WidgetBase", ], function(declare, parser, ready, _WidgetBase){ declare("MyWidget", [_WidgetBase], { field1: [], field2: "", function1: function(), function2: function() }); });

ho scoperto che quando i campi vengono inizializzati con [] allora sarebbe essere condivisa da tutti gli oggetti del modello. Apportare modifiche ad uno influisce su tutte le altre.

Questo non accade loro inizializzazione con new Array(). Lo stesso vale per l'inizializzazione di oggetti ({} vs nuova Object())

TBH Non sono sicuro se un problema con il quadro che stavamo usando ( Dojo )

Ho trovato una differenza tra le due costruzioni che mi ha morso piuttosto difficile.

Diciamo che ho:

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

Nella vita reale, se faccio questo:

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

Quello che io alla fine con questo:

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

Non so che cosa le specifiche del linguaggio dice dovrebbe succedere, ma se io voglio che i miei due oggetti abbiano matrici proprietà unica nei miei oggetti, devo usare new Array().

Uso della costruzione Array fa un nuovo array della lunghezza desiderata e popola ogni degli indici con definito, il assegnato un array ad una sola variabile crea gli indici che si danno che informazioni per.

Autorizzato sotto: CC-BY-SA insieme a attribuzione

Non affiliato a StackOverflow