Jaka jest różnica między" Array () " a "[] " podczas deklarowania tablicy JavaScript?

Różnica między utworzeniem tablicy z domyślną tablicą a konstruktorem tablicy jest subtelna, ale ważna.

Kiedy tworzysz tablicę używając

var a = [];

Nakazujesz interpreterowi utworzenie nowej tablicy uruchomieniowej. Nie jest konieczne żadne dodatkowe przetwarzanie. Załatwione.

Jeśli używasz:

var a = new Array();

Mówisz interpreterowi, że chcę wywołać konstruktor "Array " i wygenerować obiekt. Następnie przegląda kontekst wykonania, aby znaleźć konstruktora aby wywołać i wywołać, tworząc tablicę.

Możesz pomyśleć: "Cóż, to nie ma znaczenia. Są takie same!". Niestety nie możesz tego zagwarantować.

Weźmy następujący przykład:

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)

W powyższym przykładzie, pierwsze wywołanie będzie ostrzegać 'SPARTA' , jak można się spodziewać. Drugi nie. Skończysz widząc nieokreślone. Zauważ również, że b zawiera wszystkie natywne funkcje obiektu Array, takie jak push, gdzie inne nie.

Podczas gdy możesz się spodziewać tak się stanie, to tylko ilustruje fakt, że [] nie jest tym samym, co new Array().

Najlepiej jest użyć [], jeśli wiesz, że chcesz tylko tablicę. Nie sugeruję również, aby przejść i przedefiniować tablicę...

Istnieje istotna różnica, o której jeszcze nie wspomniano.

Od tego:

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

Można by pomyśleć, że new Array(2) jest odpowiednikiem [undefined, undefined], ale tak nie jest!

Spróbujmy map():

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

Zgodnie z ES6 Spec 22.1.1.2, zadaniem Array(len) jest po prostu tworzenie nowej tablicy, której właściwość length jest ustawiona na argument len i to wszystko, co oznacza, że nie ma żadnej tablicy element rzeczywisty wewnątrz nowo utworzonej tablicy.

Funkcja map(), zgodnie ze specyfikacją 22.1.3.15 najpierw sprawdzi HasProperty, a następnie wywoła callback, ale okazuje się, że:

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

I dlatego nie można oczekiwać, że jakiekolwiek funkcje iteracyjne będą działać jak zwykle na tablicach utworzonych z new Array(len).

BTW, Safari i Firefox mają dużo lepsze "drukowanie" do tej sytuacji:

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

Zgłosiłem już problem do Chromium i proszę ich o napraw to mylące drukowanie: https://bugs.chromium.org/p/chromium/issues/detail?id=732021

Aktualizacja: jest już naprawiony. Chrome teraz drukowane jako:

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

O dziwo, new Array(size) jest prawie 2x szybszy niż [] w Chrome, a mniej więcej tak samo w FF i IE (mierzone przez tworzenie i wypełnianie tablicy). Ma to znaczenie tylko wtedy, gdy znasz przybliżony rozmiar tablicy. Jeśli dodasz więcej przedmiotów niż podana długość, zwiększenie wydajności zostanie utracone.

Dokładniej: Array( jest szybką operacją czasu stałego, która nie przydziela żadnej pamięci, gdzie {[1] } jest operacją czasu liniowego, która ustawia typ i wartość.

Aby uzyskać więcej informacji, na następującej stronie opisano, dlaczego nigdy nie musisz używać new Array()

Nigdy nie musisz używać new Object() w JavaScript. Użyj obiektu literal {} zamiast tego. Podobnie, nie używaj new Array(), użyj tablicy literal [] zamiast tego. Tablice w pracy z JavaScript nie ma to jak tablice w Javie i użycie składni podobnej do Javy będzie zmylić Cię.

Nie stosować new Number, new String, lub new Boolean. Formy te wytwarzają niepotrzebne owijanie obiektów. Wystarczy użyć zamiast tego proste literały.

Zobacz też komentarze-formularz new Array(length) nie służy żadnemu użytecznemu celowi (przynajmniej w dzisiejszych implementacjach JavaScript).

W celu lepszego zrozumienia [] i 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

Powyższy wynik pochodzi z konsoli Google Chrome na Windows 7.

Pierwszym z nich jest domyślne wywołanie konstruktora obiektu. Możesz użyć jego parametrów, jeśli chcesz.

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

Drugi daje możliwość tworzenia nie pustej tablicy:

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

Mogę wyjaśnić w bardziej konkretny sposób, zaczynając od tego przykładu, który jest oparty na dobrym Fredriku.

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

Właśnie dodałem kolejną wartość do tablic i zrobiłem cztery alerty: Pierwszy i drugi mają dać nam wartość zapisaną w każdej tablicy, aby mieć pewność co do wartości. Zwrócą to samo! Teraz spróbuj trzeciego, zwraca false, ponieważ

Js traktuje test1 jako zmienną z typem danych array , a test2 jako obiekt o funkcjonalności tablicy , oraz jest tu kilka drobnych różnic.

Pierwsza różnica polega na tym, że gdy wywołamy test1, wywołujemy zmienną bez zastanowienia, po prostu zwraca wartości, które są zapisane w tej zmiennej bez względu na jej typ danych! Jednak, gdy wywołamy test2, wywoła ona funkcję Array () , a następnie przechowuje nasze wartości "Pushed" w swojej właściwości "Value" , i to samo dzieje się, gdy alarmujemy test2, Zwraca wartość "Value" właściwość obiektu array.

Więc kiedy Sprawdzimy, czy test1 jest równe test2 oczywiście nigdy nie zwrócą true, jedna jest funkcją, a druga zmienną (z typem tablicy), nawet jeśli mają taką samą wartość!

Aby mieć pewność, spróbuj 4. alert, z .wartość dodana do niego; zwróci true. W tym przypadku mówimy JS " pomijając typ kontenera, czy to była funkcja czy zmienna, Proszę porównać wartości, które są przechowywane w każdym pojemnik i powiedz nam, co widziałeś!"dokładnie tak się dzieje.

Mam nadzieję, że wyraziłem się jasno i przepraszam za mój zły angielski.

Nie ma różnicy kiedy inicjalizujesz tablicę bez żadnej długości. Więc var a = [] & var b = new Array() to samo.

Ale jeśli zainicjalizujesz tablicę o długości takiej jak var b = new Array(1);, ustawisz długość obiektu array na 1. Więc jego odpowiednik var b = []; b.length=1;.

Będzie to problematyczne, gdy wykonasz array_object.push, dodaje element po ostatnim elemencie i zwiększa długość.

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

Pierwszym z nich jest domyślne wywołanie konstruktora obiektu.najczęściej używane dla wartości dynamicznych.

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

Druga tablica jest używana przy tworzeniu wartości statycznych

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

Różnica w użyciu

var arr = new Array(size);

Lub

arr = [];
arr.length = size;

Jak już zostało omówione w tym pytaniu.

Chciałbym dodać problem prędkości - current najszybsza droga, na google chrome jest druga.

Ale zwróć uwagę, te rzeczy często zmieniają się wraz z aktualizacjami. Również czas uruchomienia będzie się różnić między różnymi przeglądarkami.

Na przykład-druga opcja, o której wspomniałem, działa z 2 milionami [ops / sekundę] na chrome, ale jeśli spróbujesz na mozilla dev., to zdobądź zaskakująco wyższą stawkę 23 milionów.

W każdym razie, proponuję sprawdzić to, co jakiś czas, na różnych przeglądarkach (i maszynach), używając strony jako takiej

Jak wiem, diferencja u może znaleźć slice (lub inne funkcje tablicy) jak code1 .i code2 show u Array and his instances :

Kod1:

[].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

Wniosek:

Jak widać [] i new Array() tworzą nową instancję tablicy.I wszystkie one otrzymują funkcje prototypowe z Array.prototype

Są po prostu innym przykładem Array.so to wyjaśnia dlaczego [] != []

:)

Nie ma dużej różnicy, w zasadzie robią to samo, ale robią je na różne sposoby, ale czytaj dalej, spójrz na to stwierdzenie na W3C:

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

I

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

Dwa powyższe przykłady robią dokładnie to samo. Nie ma potrzeby używania new Array ().
dla prostoty, czytelności i szybkości wykonania, użyj pierwszy (metoda array).

Ale jednocześnie tworzenie nowej tablicy przy użyciu składni new Array uważanej za złą praktyka:

Unikaj nowej tablicy()

Nie ma potrzeby używania wbudowanego konstruktora tablicy JavaScript new Array ().
Zamiast tego użyj [].
Te dwa różne instrukcje tworzą nową pustą tablicę o nazwie punkty:

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

Te dwa różne instrukcje tworzą nową tablicę zawierającą 6 liczby:

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

Słowo kluczowe new tylko komplikuje kod. Może również produkować niektóre nieoczekiwane wyniki:

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

Co jeśli usunę jeden z elementów?

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

Więc zasadniczo nie uważa się za najlepszą praktykę, również jest jedna niewielka różnica tam, można przekazać Długość do new Array(length) w ten sposób, który również nie jest zalecany sposób.

Przeżyłem dziwne zachowanie używając [].

Mamy modelowe "klasy" z polami zainicjalizowanymi do pewnej wartości. Np.:

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

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

Odkryłem, że gdy pola zostaną zainicjowane [], będą współdzielone przez wszystkie obiekty modelu. Wprowadzanie zmian w jednym wpływa na wszystkie inne.

Tak się nie dzieje inicjując je new Array(). To samo dotyczy inicjalizacji obiektów ({} vs new Object())

TBH nie jestem pewien, czy to problem z frameworkiem, którego używaliśmy (Dojo )

Jest w tym coś więcej niż na pierwszy rzut oka. Większość innych odpowiedzi jest poprawna , ale także ..

new Array(n)

• pozwala silnikowi na realokację przestrzeni dla n elementów
• Optymalizacja dla tablicy tworzenie
• utworzona tablica jest oznaczona sparse, która ma najmniej wykonywalne operacje tablicy, to dlatego, że każdy dostęp do indeksu musi sprawdzić granice, sprawdzić czy wartość istnieje i przejść przez łańcuch prototypów
• jeśli tablica jest oznaczona jako nie ma to jednak większego znaczenia, ponieważ w V8 zawsze będzie wolniejszy, nawet jeśli zapełnisz go zawartością (packed array) 1 ms lub 2 godziny później, nie ma znaczenia

[1, 2, 3] || []

• utworzona tablica jest oznaczona spakowana (chyba że używasz składni delete lub [1,,3])
• zoptymalizowane dla operacji array (for .., forEach, map, etc)
• silnik musi realokować przestrzeń w miarę wzrostu tablicy

To prawdopodobnie {[47] }Nie dotyczy starszych wersji/przeglądarek.

Cóż, {[0] } jest inny niż {[1] } jest inny w niektórych funkcjach wyjaśnię tylko najbardziej przydatne dwie (moim zdaniem) z nich.

Zanim przejdę do expaliningu różnic, najpierw ustawię bazę; kiedy użyjemy x = [] definiuje nową zmienną z typem danych Array, która dziedziczy wszystkie metody należące do prototypu tablicy, coś podobnego (ale nie do końca) do rozszerzania klasy. Jednakże, gdy użyjemy x = new Array() inicjalizuje klon prototypu tablicy przypisany do zmiennej x.

Teraz zobaczmy jaka jest różnica

Pierwsza różnica polega na tym, że używając new Array(x) Gdzie x jest liczbą całkowitą, inicjalizuje tablicę z x niezdefiniowanymi wartościami, na przykład new Array(16) zainicjalizuje tablicę z 16 pozycjami, wszystkie z nich są niezdefiniowane. Jest to bardzo przydatne, gdy asynchronicznie wypełniasz tablicę o predefiniowanej długości. Na przykład (jeszcze raz :)) Załóżmy, że otrzymujesz wyniki 100 konkurentów i otrzymujesz je asynchronicznie ze zdalnego systemu lub db, musisz przydzielić je do tablicy zgodnie z rangą po otrzymaniu każdego wyniku. W tym bardzo rzadkim przypadku zrobisz coś takiego jak myArray[result.rank - 1] = result.name, więc ranga 1 zostanie ustawiona na indeks 0 i tak dalej.

Druga răłĺźnica polega na tym, Ĺźe uĺźycie new Array() jak juĹź wiecie, tworzy caĹ ' kowicie nowy klon prototypu tablicy i przypisuje go do zmiennej, ktĂłra umoĹźliwia zrobienie czaru (niezaleĺźane btw). Ta magia jest że można nadpisać określoną metodę starszych metod tablicy. Na przykład można ustawić metodę Array.push, aby wypchnąć nową wartość na początek tablicy zamiast na koniec, a także dodać nowe metody (to jest lepsze) do tego konkretnego klona prototypu tablicy. To pozwoli Ci definiować bardziej złożone typy tablic w całym projekcie za pomocą własnych metod dodanych i używać go jako klasy.

Ostatnia rzecz, jeśli jesteś z bardzo niewielu ludzi (które naprawdę kocham) które dbają o przetwarzanie napowietrznych i zużycie pamięci aplikacji, nigdy nie będzie trudne new Array() bez desperacko go używać :).

Mam nadzieję, że to wystarczająco wyjaśniło o bestii new Array() :)

Znalazłem jedną różnicę między tymi dwoma konstrukcjami, które mocno mnie ugryzły.

Powiedzmy, że mam:

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

W prawdziwym życiu, jeśli to zrobię:

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

Kończy mi się to:

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

Nie wiem, co mówi specyfikacja języka, ale jeśli chcę, aby moje dwa obiekty miały unikalne tablice właściwości w moich obiektach, muszę użyć new Array().

Używając konstruktora Array tworzy nową tablicę o żądanej długości i zapełnia każdy z indeksów undefined, tablica przypisana do zmiennej tworzy indeksy, dla których podajesz informacje.