ECMAScript Primitive Types

ECMAScript heeft vijf primitive types, namelijk Undefined, Null, Boolean, Number en String.

Operator typeof

De operator typeof heeft één parameter, namelijk de variabele of waarde die moet worden gecontroleerd. Bijvoorbeeld:

var sTemp = "test string";
alert (typeof sTemp);    // Uitvoer "string"
alert (typeof 86);    // Uitvoer "number"

Bij het aanroepen van de operator typeof op een variabele of waarde, wordt een van de volgende waarden teruggegeven:

  • undefined - als de variabele een Undefined-type is
  • boolean - als de variabele een Boolean-type is
  • number - als de variabele een Number-type is
  • string - als de variabele een String-type is
  • object - als de variabele een referentietype of een Null-type is

Opmerking:Je zou kunnen vragen, waarom de operator typeof voor de waarde null "Object" teruggeeft. Dit is een fout in de oorspronkelijke implementatie van JavaScript die door ECMAScript is overgenomen. Nu wordt null beschouwd als een placeholder voor objecten, wat deze矛盾 verklaart, maar technisch gezien blijft het een primitive waarde.

Type Undefined

Zoals eerder vermeld, heeft het type Undefined slechts één waarde, namelijk undefined. De standaardwaarde van een variabele die niet is geïnitialiseerd, is undefined.

var oTemp;

Deze regel declareert de variabele oTemp zonder een initiële waarde. Deze variabele wordt de waarde undefined toegewezen, dus de litteraal van het type undefined. Je kunt de waarde van deze variabele testen met behulp van het volgende codefragment: }}

var oTemp;
alert(oTemp == undefined);

Dit codeblok toont "true", wat betekent dat deze waarden echt gelijk zijn. Het is ook mogelijk om de waarde van een variabele met behulp van de typeof-bewerking weer te geven als undefined:

var oTemp;
alert(typeof oTemp); // Uitvoer "undefined"

Tip:De waarde undefined is verschillend van de niet-gedefinieerde waarde. Echter, de typeof-bewerking onderscheidt deze twee waarden niet echt. Overweeg onderstaande code:

var oTemp;
alert(typeof oTemp);  // Uitvoer "undefined"
alert(typeof oTemp2);  // Uitvoer "undefined"

Deze code geeft voor beide variabelen "undefined" uit, zelfs als alleen de variabele oTemp2 niet is verklaard. Als je een andere operator dan typeof gebruikt voor oTemp2, kan dit een fout veroorzaken, omdat andere operatoren alleen kunnen worden gebruikt voor variabelen die zijn verklaard.

Bijvoorbeeld, onderstaande code zal een fout veroorzaken:

var oTemp;
alert(oTemp2 == undefined);

Als een functie geen expliciete return-waarde heeft, wordt ook de waarde "undefined" geretourneerd, zoals hieronder weergegeven:

function testFunc() {
{}
alert(testFunc() == undefined);  // Uitvoer "true"

Null-typ

Een ander type met slechts één waarde is Null, het heeft slechts één speciale waarde null, dus zijn litteraal. De waarde undefined is eigenlijk afgeleid van de waarde null, dus ECMAScript definieert ze als gelijk.

alert(null == undefined);  // Uitvoer "true"

Hoewel deze twee waarden gelijk zijn, hebben ze een verschillende betekenis. undefined is de waarde die aan een variabele wordt toegewezen wanneer deze is verklaard maar niet is geïnitialiseerd, null wordt gebruikt om een nog niet bestaand object aan te geven (dit is kort besproken toen we het over de typeof-bewerking hebben gehad). Als een functie of methode een object moet retourneren, wordt meestal null geretourneerd wanneer het object niet gevonden wordt.

Boolean-typ

Boolean-typ is een van de meest gebruikte typen in ECMAScript. Het heeft twee waarden true en false (dus twee Boolean-literaalwaarden).

Hoewel false niet gelijk is aan 0, kan 0 in noodzaak worden omgezet naar false, zodat beide in Boolean-uitingen veilig kunnen worden gebruikt.

var bFound = true;
var bLost = false;

Number-type

De meest speciale type gedefinieerd in ECMA-262 is het Number-type. Dit type kan zowel 32-bits gehele getallen als 64-bits floating-point-getallen representeren.

Iedere direct ingevoerde (in plaats van via een andere variabele opgehaalde) getal wordt gezien als een litteraal van het Number-type. Bijvoorbeeld, de onderstaande code declareert een variabele die een geheel getal opslaat, zijn waarde wordt gedefinieerd door het litteraal 86:

var iNum = 86;

Octale en hexadecimale getallen

Gehele getallen kunnen ook worden weergegeven als octale (met 8 als basis) of hexadecimale (met 16 als basis) litteraallen. Een octaal litteraal moet beginnen met een 0, gevolgd door willekeurige octale cijfers (0 tot 7), zoals in onderstaande code:

var iNum = 070;  //070 is gelijk aan het decimale 56

Om een hexadecimaal litteraal te maken, moet het eerste cijfer 0 zijn, gevolgd door het letter x, gevolgd door willekeurige hexadecimale cijfers (0 tot 9 en A tot F). Deze letters kunnen zowel hoofdletters als kleine letters zijn. Bijvoorbeeld:

var iNum = 0x1f;  //0x1f is gelijk aan het decimale 31
var iNum = 0xAB;  //0xAB is gelijk aan het decimale 171

Tip:Hoewel alle gehele getallen kunnen worden weergegeven als octale of hexadecimale litteraallen, zijn alle wiskundige operaties ten gevolge van de resultaten in decimaal.

Floating-point-getal

Om een floating-point-waarde te definiëren, moet er een komma en ten minste één cijfer achter de komma worden opgenomen (bijvoorbeeld, gebruik 1.0 in plaats van 1). Dit wordt gezien als een floating-point-literal. Bijvoorbeeld:

var fNum = 5.0;

Een interessante kenmerkende eigenschap van floating-point-literaal is dat er voor de berekening werkelijk een string wordt opgeslagen.

Wetenschappelijke notatie

Voor zeer grote of zeer kleine getallen kan de wetenschappelijke notatie worden gebruikt om floating-point-getallen te representeren, een getal kan worden weergegeven als een getal (inclusief decimale cijfers) gevolgd door e (of E), gevolgd door een vermenigvuldigingsfactor van 10. Bijvoorbeeld:

var fNum = 5.618e7

Deze symbool vertegenwoordigt het getal 56180000. Door de wetenschappelijke notatie om te zetten naar een berekening, kan deze waarde worden verkregen: 5.618 x 107。

Ook kan een zeer klein getal met wetenschappelijke notatie worden weergegeven, bijvoorbeeld 0.00000000000000008 kan worden weergegeven als 8-e17(Hier wordt 10 opgetild tot de -17e macht, wat betekent dat het moet worden gedeeld door 10 negentien keer). ECMAScript converteert standaard floating-point-getallen met zes of meer voorlopige nullen in wetenschappelijke notatie.

Tip:Float-waarden kunnen ook worden opgeslagen in de vorm van 64-bit IEEE 754, wat betekent dat decimale waarden maximaal 17 decimale plaatsen kunnen hebben. Waarden na de 17e decimale plaats worden afgesneden, wat enige kleine wiskundige fouten kan veroorzaken.

Speciale Number-waarden

Een paar speciale waarden zijn ook gedefinieerd als Number-type. De eerste twee zijn Number.MAX_VALUE en Number.MIN_VALUE, die de buitenste grenzen van de verzameling van Number-waarden definiëren. Alle ECMAScript-getallen moeten tussen deze twee waarden vallen. Hoewel de berekende resultaten van de berekening echter niet tussen deze twee waarden hoeven te vallen.

Wanneer de berekende waarde groter is dan Number.MAX_VALUE, wordt deze toegewezen aan Number.POSITIVE_INFINITY, wat betekent dat er geen numerieke waarde meer is. Evenzo wordt een berekende waarde die kleiner is dan Number.MIN_VALUE toegewezen aan Number.NEGATIVE_INFINITY, wat ook betekent dat er geen numerieke waarde meer is. Als de berekening een oneindige waarde teruggeeft, kan het resultaat niet meer worden gebruikt in andere berekeningen.

Feitelijk zijn er speciale waarden die oneindig representeren, zoals je zou verwachten, namelijk Infinity. De waarde van Number.POSITIVE_INFINITY is Infinity. De waarde van Number.NEGATIVE_INFINITY is -Infinity.

Omdat oneindige getallen zowel positief als negatief kunnen zijn, kan een methode worden gebruikt om te bepalen of een getal beperkt is (in plaats van elk oneindig getal afzonderlijk te testen). De isFinite() methode kan worden aangeroepen voor elk getal om ervoor te zorgen dat het geen oneindig getal is. Bijvoorbeeld:

var iResult = iNum * some_really_large_number;
if (isFinite(iResult)) {
    alert("finite");
{}
else {
    alert("infinite");
{}

De laatste speciale waarde is NaN, wat staat voor 'Not a Number'. NaN is een merkwaardige speciale waarde. Over het algemeen treedt dit op wanneer een conversie naar een type (String, Boolean, etc.) mislukt. Bijvoorbeeld, het omzetten van het woord 'blue' naar een getal mislukt omdat er geen equivalente getal is. Net als oneindig, kan NaN niet worden gebruikt in wiskundige berekeningen. Een ander merkwaardig kenmerk van NaN is dat het niet gelijk is aan zichzelf, wat betekent dat de volgende code false teruggeeft:

alert(NaN == NaN);  //Output: "false"

For this reason, it is not recommended to use the NaN value itself. The isNaN() function does quite well:

alert(isNaN("blue"));  //Output: "true"
alert(isNaN("666"));  //Output: "false"

String type

The unique feature of the String type is that it is the only primitive type without a fixed size. You can store 0 or more Unicode characters in a string, represented by 16-bit integers (Unicode is an international character set, which will be discussed later in this tutorial).

Each character in a string has a specific position, starting with the first character at position 0, the second character at position 1, and so on. This means that the position of the last character in the string is always one less than the length of the string:

De lengte van een string en de positie van de karakters

String literals are declared by double quotes ("), or single quotes ('), while Java declares strings with double quotes and characters with single quotes. However, since ECMAScript does not have a character type, either of these notations can be used. For example, the following two lines of code are both valid:

var sColor1 = "red";
var sColor2 = 'red';

The String type also includes several character literals, which Java, C, and Perl developers should be very familiar with.

The following lists the character literals of ECMAScript:

Literals Meaning
\n New line
\t Tab
\b Space
\r Carriage return
\f Form feed
\\\ Backslash
\' Single quotes
\" Double quotes
\0nnn Octal code nnn Represents the character (n Is one of the octal numbers from 0 to 7)
\xnn Hexadecimal code nn Represents the character (n Is one of the hexadecimal numbers from 0 to F)
\unnnn Hexadecimal code nnnn Represents the Unicode character (n Is one of the hexadecimal numbers from 0 to F)