JavaScript => Aangiften en opdrachten

Syntaxis

var foo [= waarde [, foo2 [, foo3 ... [, fooN]]]];
let bar [= waarde [, bar2 [, foo3 ... [, barN]]]];
const baz = waarde [, baz2 = waarde2 [, ... [, bazN = waardeN]]];

Opmerkingen

Zie ook:

Constanten opnieuw toewijzen

Je kunt constanten niet opnieuw toewijzen.

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

prints:

Uncaught TypeError: Assignment to constant.

Constanten wijzigen

Het declareren van een variabele const voorkomt alleen dat zijn waarde wordt vervangen door een nieuwe waarde. const stelt geen beperkingen aan de interne status van een object. Het volgende voorbeeld laat zien dat een waarde van een eigenschap van een const object kan worden gewijzigd en zelfs nieuwe eigenschappen kunnen worden toegevoegd, omdat het object dat is toegewezen aan person is gewijzigd, maar niet is vervangen .

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

Resultaat:

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

In dit voorbeeld hebben we een constant object met de naam person en hebben we de eigenschap person.name opnieuw toegewezen en de nieuwe eigenschap person.surname .

Constanten declareren en initialiseren

U kunt een constante initialiseren met het sleutelwoord const .

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

Belangrijk
U moet een constante in dezelfde verklaring declareren en initialiseren.

Verklaring

Er zijn vier principe manieren om een variabele in JavaScript verklaren: met behulp van de var , let of const trefwoorden of zonder zoekterm helemaal ( "kale" verklaring). De gebruikte methode bepaalt het resulterende bereik van de variabele, of de toewijsbaarheid in het geval van const .

Het var trefwoord maakt een functiebereikvariabele.
Het let trefwoord maakt een block-scope-variabele.
Het sleutelwoord const maakt een block-scope variabele die niet opnieuw kan worden toegewezen.
Een kale verklaring creëert een globale variabele.

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

Houd er rekening mee dat u constanten niet kunt declareren zonder ze tegelijkertijd te initialiseren.

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

(Om technische redenen is hierboven geen voorbeeld opgenomen van een verklaring zonder sleutelwoordvariabele. Lees verder om een voorbeeld te bekijken.)

Gegevenstypen

JavaScript-variabelen kunnen veel gegevenstypen bevatten: getallen, tekenreeksen, arrays, objecten en meer:

// Number
var length = 16;

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

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

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

JavaScript heeft dynamische typen. Dit betekent dat dezelfde variabele als verschillende typen kan worden gebruikt:

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

onbepaald

Opgegeven variabele zonder waarde heeft de waarde undefined

var a;

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

Als u de waarde van niet-aangegeven variabelen probeert op te halen, krijgt u een ReferenceError. Zowel het type niet-aangegeven als geunialiseerde variabelen is echter "niet-gedefinieerd":

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

toewijzing

Gebruik de toewijzingsoperator om een waarde toe te kennen aan een eerder gedeclareerde variabele, = :

a = 6;
b = "Foo";

Als alternatief voor onafhankelijke aangifte en toewijzing is het mogelijk om beide stappen in één verklaring uit te voeren:

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

Het is in deze syntaxis dat globale variabelen zonder een sleutelwoord kunnen worden gedeclareerd; als men onmiddellijk na het woord een kale variabele zonder een opdracht zou declareren, zou de tolk geen onderscheid kunnen maken tussen globale verklaringen a; van verwijzingen naar variabelen a; .

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

Merk echter op dat de bovenstaande syntaxis over het algemeen wordt afgeraden en niet voldoet aan de strikte modus. Dit is om het scenario te vermijden waarin een programmeur per ongeluk een let of var sleutelwoord uit zijn instructie laat vallen en per ongeluk een variabele in de globale naamruimte maakt zonder het te beseffen. Dit kan de globale naamruimte en het conflict met bibliotheken en de goede werking van een script vervuilen. Daarom moeten globale variabelen worden gedeclareerd en geïnitialiseerd met het sleutelwoord var in de context van het vensterobject, zodat de intentie expliciet wordt vermeld.

Bovendien kunnen variabelen meerdere tegelijk worden gedeclareerd door elke verklaring (en optionele waardetoekenning) te scheiden met een komma. Met deze syntaxis hoeven de vari- en let-sleutelwoorden slechts eenmaal aan het begin van elke instructie te worden gebruikt.

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

Merk in het vorige codefragment op dat de volgorde waarin expressies en toewijzingsuitdrukkingen voorkomen ( var a, b, c = 2, d; ) er niet toe doet. Je mag de twee vrijelijk mengen.

Functiedeclaratie maakt ook effectief variabelen.