Datatyper

En værdi i JavaScript er altid af en bestemt type – f.eks. en tekststreng eller et tal.

Der er otte grundlæggende typer i JavScript. Her vil jeg beskrive dem overordnet og på de næste sider vil jeg tale om hver enkelt mere uddybende.

Du kan putte alle typer data i en variabel. F.eks. kan en variabel på et tidspunkt indeholde en tekststreng og kort efter et tal:

          // no error
let message = "hallo";
message = 123456;
        

Sprog der tillader den slags ting kaldes “dynamically typed”, hvilket betyder, at der findes datatyper, men variable er ikke bundet af dem.

Number

          let n = 123;
n = 12.345;
        

Datatypen number repræsenterer både heltal og kommatal.

Der er mange operatorer vor numre, som f.eks. multiplikation *, division /, addition +, subtraktion - og flere andre.

Udover regulære tal findes der også såkaldte “specielle numeriske værdier” der høre med under denne datatype: Infinity, -Infinity og NaN.

Infinity repræsenterer et matematisk Uendeligt ∞. Det er en speciel værdi, der er højere end hvilket som helst andet tal.

Du kan få det som et resultat af at dividere med nul:
```
alert( 1 / 0 ); // Infinity
```
Eller referere til det direkte:
```
alert( Infinity ); // Infinity
```
NaN repræsenterer en fejl i en beregning. Det er et resultat af en forkert eller ikke klart defineret matematisk operation:
```
alert( "not a number" / 2 ); // NaN, sådan en division resulterer ikke i et tal
```
NaN hænger fast. Alle fremtidige oprerationer på NaN vil resultere i NaN:
```
alert( NaN + 1 ); // NaN
alert( 3 * NaN ); // NaN
alert( "not a number" / 2 - 1 ); // NaN
```
Så, hvis der er et NaN et eller andet sted i udtrykket, så vil det påvirke hele beregningen (der er kun én undtagelse for dette: NaN ** 0 giver 1).

Matematik er “sikkert” i JavaScript. Du kan gøre alt: dividere med nul, behandle ikke-nummeriske tekststrenge som tal, etc.

Dit script vil aldrig stoppe med en fatal fejl (“die”). Det værste der kan ske er, at du får et NaNsom resultat.

Specielle nummeriske værdier tilfører formelt datatypen “number”, selv om de ikke i ordets forstand er tal.

Du lærer mere om at arbejde med tal i kapitlet Tal (Numbers).

I JavaScript kan datatypen “Number” ikke repræsentere heltal større end (2⁵³-1) (det svarer til 9007199254740991), eller mindre end -(2⁵³-1) for negative tal. Dette skyldes en intern begrænsning.

For at være helt præcis kan “number”-typen gemme større heltal (op til <308>1.7976931348623157 * 10³⁰⁸), men uden for det sikre heltalsområde ±(2⁵³-1) vil der være en præcisionsfejl, fordi ikke alle cifre kan passe ind i den faste 64-bit lagring. Så en “omtrentlig” værdi kan blive gemt.

For eksempel er disse to tal (lige over det sikre område) de samme:

          console.log(9007199254740991 + 1); // 9007199254740992
console.log(9007199254740991 + 2); // 9007199254740992
        

Så at sige, kan alle ulige heltal større end (253-1) slet ikke gemmes i “number”-typen.

Til de fleste formål er området ±(2⁵³-1) mere end tilstrækkeligt, men nogle gange har vi brug for hele området af virkelig store heltal, f.eks. til kryptografi eller tidsstempler med mikrosekund-præcision.

BigInt datatypen er tilføjet sproget for nyligt til at repræsentere heltal af en vilkårlig længde.

En BigInt værdi oprettes ved at tilføje et n i slutningen af tallet:

          // Et "n" i slutningen betyder at det er et BigInt
const bigInt = 1234567890123456789012345678901234567890n;
        

Fordi BigInt bruges meget sjældent vil jeg ikke dække det yderligere her, men du kan læse mere om dem i et seperat kapitel BigInt. Læs det, hvis du skal arbejde med virkelig store tal.

<<<<<<< HEAD

Som det er nu, understøttesBigInt i Firefox/Chrome/Edge/Safari, men ikke i IE.

Du kan tjekke MDN BigInt kompatabilitetstabel for et overblik over, hvilke browsere der understøtter.

=======

d78b01e9833009fab534462e05c03cffc51bf0e3

String

En string (tekststreng) i JavaScript skal omkranses af anførselstegn (citationstegn).

          let str = "Hallo";
let str2 = 'enkelt anførselstegn er også ok';
let phrase = `backtick kan indlejre variable ${str}`;
        

I JavaScript er der tre typer af anførselstegn.

Dobbelt anførselstegn: "Hallo".
Enkelt anførselstegn: 'Hallo'.
Grave (Backticks): `Hallo`.

Dobbelt og enkelt anførselstegn er “simple” anførselstegn. Der er stort set ingen forskel på dem i JavaScript.

Backticks har “udvidet funktionalitet”. De tillader dig at indlejre variable og udtryk i tekststrengen ved at skrive ${…}, for eksempel: