Data-typen

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

var length = 16;                               // Number
var lastName = "Johnson";                      // String
var x = {firstName:"John", lastName:"Doe"};    // Object

Het concept van gegevenstypen

Bij het programmeren zijn datatypes een belangrijk concept. Om met variabelen te kunnen werken, is het belangrijk iets over het type te weten. Zonder datatypes kan een computer dit niet oplossen oplossen:

var x = 16 + "Volvo";

Heeft het zin om "Volvo" toe te voegen aan zestien? Zal het een fout opleveren van het resultaat? JavaScript behandelt het bovenstaande voorbeeld als:

var x = "16" + "Volvo";

Bij het toevoegen van een getal en een string, behandelt JavaScript het getal als een string.

JavaScript evalueert uitdrukkingen van links naar rechts. Verschillende sequenties kunnen verschillende resultaten opleveren:

JavaScript:
var x = 16 + 4 + "Volvo";
Resultaat:
20Volvo

JavaScript:
var x = "Volvo" + 16 + 4;
Resultaat:
Volvo164

JavaScript:
var x = "Volvo" + (16 + 4);
Resultaat:
Volvo20

In het eerste voorbeeld behandelt JavaScript 16 en 4 als getallen, totdat het "Volvo" bereikt is.
In het tweede voorbeeld, de eerste operand is een string, worden alle operanden behandeld als strings. In het laatste voorbeeld worden eerst de haakjes opgelost en het restultaat als string toegevoegd.

JavaScript-typen zijn dynamisch

JavaScript heeft dynamische typen. Dit betekent dat dezelfde variabele kan worden gebruikt om verschillende gegevenstypen vast te houden.

Voorbeeld:
var x;           // Now x is undefined
x = 5;           // Now x is a Number
x = "John";      // Now x is a String

JavaScript-strings

Een string (of een tekenreeks) is een reeks karakters zoals "John Doe".

Tekenreeksen worden tussen aanhalingstekens geschreven. U kunt enkele of dubbele aanhalingstekens gebruiken.
Voorbeeld:
var carName1 = "Volvo XC60";   // Using double quotes
var carName2 = 'Volvo XC60';   // Using single quotes

U kunt aanhalingstekens binnen een tekenreeks gebruiken, zolang ze niet overeenkomen met de aanhalingstekens rond de tekenreeks.

Voorbeeld:
var answer1 = "It's alright";             // Single quote inside double quotes
var answer2 = "He is called 'Johnny'";    // Single quotes inside double quotes
var answer3 = 'He is called "Johnny"';    // Double quotes inside single quotes

JavaScript-nummers

JavaScript heeft slechts één type getallen. Getallen kunnen met of zonder decimalen worden geschreven.

Voorbeeld:
var x1 = 34.00;     // Written with decimals
var x2 = 34;        // Written without decimals

Extra grote of extra kleine getallen kunnen met wetenschappelijke (exponentiële) notatie worden geschreven.

Voorbeeld:
var y = 123e5;      // 12300000
var z = 123e-5;     // 0.00123

JavaScript Booleans

Booleans kunnen slechts twee waarden hebben: true of false.

Voorbeeld:
var x = 5;
var y = 5;
var z = 6;
(x == y)       // Returns true
(x == z)       // Returns false

Booleans worden vaak gebruikt bij voorwaardelijk testen.

JavaScript-arrays

Een array is een verzameling waarden. JavaScript-arrays worden tussen vierkante haken geschreven. Array-items worden gescheiden door komma's. De volgende code declareert (maakt) een array genaamd cars, met drie items (autonamen).

Voorbeeld:
var cars = ["Saab", "Volvo", "BMW"];
window.alert(cars[0]); // Outputs Saab
window.alert(cars[2]); // Outputs BMW

Array-indexen zijn op nul gebaseerd, wat betekent dat het het eerste item [0] is, het tweede [1], enzovoort.

JavaScript-objecten

JavaScript-objecten worden met accolades geschreven {}. Objecteigenschappen worden geschreven als naam: waardeparen, gescheiden door komma's.

Voorbeeld:
var person = {firstName:"John", lastName:"Doe", age:50, eyeColor:"blue"};
Het object (persoon) in het bovenstaande voorbeeld heeft 4 eigenschappen: firstName, lastName, age en eyeColor.

Het type operator

U kunt de JavaScript- typeofoperator gebruiken om het type JavaScript-variabele te vinden.
De typeofoperator retourneert het type van een variabele of een uitdrukking.

Voorbeeld:
typeof ""             // Returns "string"
typeof "John"         // Returns "string"
typeof "John Doe"     // Returns "string"

Voorbeeld:
typeof 0              // Returns "number"
typeof 314            // Returns "number"
typeof 3.14           // Returns "number"
typeof (3)            // Returns "number"
typeof (3 + 4)        // Returns "number"

Ongedefinieerd

In JavaScript heeft een variabele zonder waarde de waarde undefined. Het type is ook undefined.

Voorbeeld:
var car;    // Value is undefined, type is undefined

Elke variabele kan worden geleegd door de waarde in te stellen op undefined. Het type zal ook zijn undefined.

Voorbeeld:
car = undefined;    // Value is undefined, type is undefined


Lege waarden

Een lege waarde heeft niets te maken met undefined. Een lege string heeft zowel een legale waarde als een type.

Voorbeeld:
var car = "";    // The value is "", the typeof is "string"

Null

In JavaScript null is "niets". Het wordt verondersteld iets te zijn dat niet bestaat. Helaas is in JavaScript het gegevenstype null een object. Je kunt het beschouwen als een bug in JavaScript die typeof null een object is. Het zou moeten zijn null. U kunt een object leegmaken door het in te stellen op null.

Voorbeeld:
var person = {firstName:"John", lastName:"Doe", age:50, eyeColor:"blue"};
person = null;    // Now value is null, but type is still an object

U kunt een object ook leegmaken door het in te stellen op undefined.

Voorbeeld:
var person = {firstName:"John", lastName:"Doe", age:50, eyeColor:"blue"};
person = undefined;   // Now both value and type is undefined

Verschil tussen ongedefinieerd en null

undefined en null zijn gelijk in waarde maar verschillend van type:
typeof undefined           // undefined
typeof null                // object
null === undefined         // false, inhoud en type vergelijken
null == undefined          // true, alleen inhoud vergelijken

Primitieve gegevens

Een primitieve gegevenswaarde is een enkele eenvoudige gegevenswaarde zonder aanvullende eigenschappen en methoden. De typeof operator kan één van deze primitieve typen retourneren:

Voorbeeld:
typeof "John"              // Returns "string"
typeof 3.14                // Returns "number"
typeof true                // Returns "boolean"
typeof false               // Returns "boolean"
typeof x                   // Returns "undefined" (if x has no value)

Complexe gegevens

De typeof operator kan een van twee complexe typen retourneren:

De typeof operator retourneert "object" voor objecten, arrays en null. De typeof operator retourneert geen "object" voor functies.

Voorbeeld:
typeof {name:'John', age:34} // Returns "object"
typeof [1,2,3,4]             // Returns "object" (not "array", see note below)
typeof null                  // Returns "object"
typeof function myFunc(){}   // Returns "function"

De typeofoperator retourneert "object" voor arrays, omdat in JavaScript arrays objecten zijn.