JavaScript => Deklaracje i zadania

Składnia

var foo [= wartość [, foo2 [, foo3 ... [, fooN]]]];
niech bar [= wartość [, bar2 [, foo3 ... [, barN]]]];
const baz = wartość [, baz2 = wartość2 [, ... [, bazN = wartośćN]]];

Uwagi

Zobacz też:

Ponowne przypisywanie stałych

Nie można ponownie przypisać stałych.

const foo = "bar";
foo = "hello";

Wydruki:

Uncaught TypeError: Assignment to constant.

Modyfikowanie stałych

Zadeklarowanie zmiennej const tylko zapobiega zastąpieniu jej wartości nową wartością. const nie nakłada żadnych ograniczeń na wewnętrzny stan obiektu. Poniższy przykład pokazuje, że wartość właściwości const obiektu można zmienić, a nawet nowe właściwości można dodać, ponieważ obiekt przypisany do person jest modyfikowany, ale nie zastępowany .

const person = { 
    name: "John" 
};
console.log('The name of the person is', person.name);

person.name = "Steve";
console.log('The name of the person is', person.name);

person.surname = "Fox";
console.log('The name of the person is', person.name, 'and the surname is', person.surname);

Wynik:

The name of the person is John
The name of the person is Steve
The name of the person is Steve and the surname is Fox

W tym przykładzie stworzyliśmy stały obiekt o nazwie person i ponownie przypisaliśmy właściwość person.name i stworzyliśmy nową właściwość person.surname .

Deklarowanie i inicjowanie stałych

Możesz zainicjalizować stałą za pomocą słowa kluczowego const .

const foo = 100;
const bar = false;
const person = { name: "John" };
const fun = function () = { /* ... */ };
const arrowFun = () => /* ... */ ;

Ważny
Musisz zadeklarować i zainicjować stałą w tej samej instrukcji.

Deklaracja

Istnieją cztery podstawowe sposoby deklarowania zmiennej w JavaScript: użycie słów kluczowych var , let lub const , lub w ogóle bez słowa kluczowego (deklaracja „goła”). Zastosowana metoda określa wynikowy zakres zmiennej lub możliwość ponownego przypisania w przypadku const .

var kluczowe var tworzy zmienną o zasięgu funkcji.
let kluczowe let tworzy zmienną o zasięgu blokowym.
const kluczowe const tworzy zmienną o zasięgu blokowym, której nie można ponownie przypisać.
Naga deklaracja tworzy zmienną globalną.

var a = 'foo';    // Function-scope
let b = 'foo';    // Block-scope
const c = 'foo';  // Block-scope & immutable reference

Pamiętaj, że nie można deklarować stałych bez ich inicjalizacji w tym samym czasie.

const foo; // "Uncaught SyntaxError: Missing initializer in const declaration"

(Przykład deklaracji zmiennej bez słów kluczowych nie został uwzględniony powyżej z przyczyn technicznych. Kontynuuj czytanie, aby zobaczyć przykład.)

Typy danych

Zmienne JavaScript mogą zawierać wiele typów danych: liczby, ciągi znaków, tablice, obiekty i więcej:

// Number
var length = 16;

// String
var message = "Hello, World!"; 

// Array
var carNames = ['Chevrolet', 'Nissan', 'BMW']; 

// Object
var person = {
    firstName: "John",
    lastName: "Doe"
};

JavaScript ma typy dynamiczne. Oznacza to, że ta sama zmienna może być używana jako różne typy:

var a;              // a is undefined
var a = 5;          // a is a Number
var a = "John";     // a is a String

Nieokreślony

Zadeklarowana zmienna bez wartości będzie miała wartość undefined

var a;

console.log(a); // logs: undefined

Próba pobrania wartości niezadeklarowanych zmiennych powoduje błąd ReferenceError. Jednak zarówno rodzaj niezadeklarowanych, jak i zunifikowanych zmiennych jest „niezdefiniowany”:

var a;
console.log(typeof a === "undefined"); // logs: true
console.log(typeof variableDoesNotExist === "undefined"); // logs: true

Zadanie

Aby przypisać wartość do poprzednio zadeklarowanej zmiennej, użyj operatora przypisania, = :

a = 6;
b = "Foo";

Jako alternatywę dla niezależnej deklaracji i przydziału można wykonać oba kroki w jednej instrukcji:

var a = 6;
let b = "Foo";

W tej składni zmienne globalne mogą być deklarowane bez słowa kluczowego; gdyby ktoś zadeklarował zmienną bez przypisania bezpośrednio po słowie, interpreter nie byłby w stanie rozróżnić globalnych deklaracji a; z odniesień do zmiennych a; .

c = 5;
c = "Now the value is a String.";
myNewGlobal;    // ReferenceError

Należy jednak pamiętać, że powyższa składnia jest ogólnie odradzana i nie jest zgodna z trybem ścisłym. Ma to na celu uniknięcie scenariusza, w którym programista nieumyślnie upuszcza słowo kluczowe let lub var ze swojej instrukcji, przypadkowo tworząc zmienną w globalnej przestrzeni nazw, nie zdając sobie z tego sprawy. Może to spowodować zanieczyszczenie globalnej przestrzeni nazw i konflikt z bibliotekami oraz prawidłowe działanie skryptu. Dlatego zmienne globalne powinny być zadeklarowane i zainicjowane przy użyciu słowa kluczowego var w kontekście obiektu okna, tak aby intencja była wyraźnie określona.

Dodatkowo zmienne można zadeklarować kilka naraz, oddzielając każdą deklarację (i opcjonalne przypisanie wartości) przecinkiem. Korzystając z tej składni, słowa kluczowe var i let muszą być użyte tylko raz na początku każdej instrukcji.

globalA = "1", globalB = "2";
let x, y = 5;
var person = 'John Doe',
    foo,
    age = 14,
    date = new Date();

Zwróć uwagę w poprzednim fragmencie kodu, że kolejność występowania deklaracji i wyrażeń przypisania ( var a, b, c = 2, d; ) nie ma znaczenia. Możesz dowolnie wymieszać oba.

Deklaracja funkcji również skutecznie tworzy zmienne.