Datatyper i JavaScript

Denne artikel forklarer datatyper i JavaScript.

YouTube Video

Datatyper i JavaScript

JavaScript har datatyper til at klassificere værdier, som groft sagt kan opdeles i primitiver og objekttyper. Datatyper bestemmer, hvilken type data der gemmes i en variabel, og påvirker, hvordan den kan manipuleres.

Primære typer

Primitiver er simple datatyper, der repræsenterer en enkelt værdi. JavaScript har følgende 7 primitivtyper.

number

1let num = 42;
2let pi = 3.14;
3
4console.log("Value of num:", num);
5console.log("Value of pi:", pi);

• number er en type, der bruges til at håndtere numeriske værdier, herunder heltal og decimaltal. Håndtering af værdier, der overstiger visse grænser, resulterer i Infinity eller NaN (Not-a-Number).

1// Decimal calculations
2console.log(0.1 + 0.2 === 0.3); // false
3console.log(0.1 + 0.2); // 0.30000000000000004
4
5// Calculations with large numbers
6console.log(9007199254740991 + 1); // correct value
7console.log(9007199254740991 + 2); // incorrect value

• I JavaScript repræsenteres tal som flydende komma-tal. Som følge heraf kan visse decimaler (især dem, der ikke kan repræsenteres præcist i binær form) muligvis ikke udtrykkes korrekt.
• Når der kræves præcise beregninger, såsom for monetære værdier, er det nødvendigt at undgå sådanne afrundingsfejl. For eksempel kan du bruge BigInt eller justere antallet af decimaler med toFixed().

string

1let greeting = "Hello, world!";
2let char = 'A';
3const message = `"${greeting}" in JavaScript`;
4
5console.log("Value of greeting:", greeting);
6console.log("Value of char:", char);
7console.log("Value of message:", message);

• string er en datatype, der bruges til at håndtere tekst og repræsenterer en sekvens af tegn. Den repræsenteres ved at omslutte tekst med enkelt- (') eller dobbeltanførselstegn ("). Fra ES6 og frem tillader skabelonstrenge nem indlejring af variabler ved brug af backticks (``). For at indsætte en variabel, brug syntaksen ${}`.

boolean

1let isAvailable = true;
2let hasError = false;
3
4console.log("Value of isAvailable:", isAvailable);
5console.log("Value of hasError:", hasError);

• boolean repræsenterer en logisk værdi og kan kun have to værdier: true eller false. Det bruges som resultat af betingede udtryk eller som en indikator.

null

1let result = null;
2
3console.log("Value of result:", result);

• null er en datatype, der eksplicit angiver 'ingen værdi'. null sættes af udviklere for at angive en tilsigtet tomhed.

undefined

1let score;
2let subject = undefined;
3
4console.log("Value of score:", score);     // undefined
5console.log("Value of subject:", subject);

• undefined er en datatype, der betyder 'ikke defineret'. undefined tildeles automatisk, når en variabel erklæres, men ikke får tildelt en værdi.

bigint

1let bigIntValue = 9007199254740991n;
2let anotherBigInt = 123456789012345678901234567890n;
3
4console.log("Value of bigIntValue:", bigIntValue);
5console.log("Value of anotherBigInt:", anotherBigInt);

• bigint er en datatypes til håndtering af store heltal. bigint tillader nøjagtig repræsentation af store heltal, der ikke kan repræsenteres af datatypen number. bigint-litteraler repræsenteres ved at tilføje n til slutningen af et tal.
• bigint er en datatype til at håndtere heltal af vilkårlig størrelse uden grænser for rækkevidde. Dog kan bigint og number ikke bruges direkte sammen, så der kræves forsigtighed.

Symbol

1let sym1 = Symbol('id');
2let sym2 = Symbol('id');
3
4console.log("sym1 === sym2:", sym1 === sym2); // false

• Symbol er en datatyp, der bruges til at skabe unikke identifikatorer. Den oprettes ved hjælp af Symbol() og kan bruges som en egenskab for et objekt. I modsætning til andre primitive typer har Symbol unikke værdier, så selv med det samme indhold behandles det som et andet Symbol.

Objekttyper

Objekttyper er datastrukturer, der kan gemme flere værdier. Et objekt er en samling af nøgle-værdi-par og kan have egenskaber og metoder.

Object

1let person = {
2    name: "John",
3    age: 30,
4    isEmployee: true
5};
6console.log(person.name); // John

• Object er en samling af egenskaber (nøgle-værdi par), der kan gemme forskellige typer data. Objekter repræsenteres med krøllede parenteser {}, og hver egenskab forbindes med : mellem nøgle og værdi.

Array

1let numbers = [10, 20, 30];
2console.log(numbers[0]); // 10
3console.log(numbers[1]); // 20
4console.log(numbers[2]); // 30
5console.log(numbers[3]); // undefined

• Array er en liste, der rummer flere værdier i en ordnet rækkefølge. Arrays repræsenteres med firkantede parenteser [], og værdier adskilles med kommaer ,. Hvert element tilgås ved hjælp af en indeks, der starter ved 0.

Function

1function greet(name) {
2    return "Hello, " + name;
3}
4console.log(greet("Alice")); // Hello, Alice

• Funktioner er en type objekt og genanvendelige kodeblokke. Funktioner kan defineres ved hjælp af nøgleordet function.

Andre objekttyper

• JavaScript har også indbyggede objekttyper som Date, RegExp, Map og Set. Disse håndterer data i henhold til specifikke anvendelsestilfælde.

Typekonvertering

Implicitte og eksplícitte typekonverteringer udføres ofte i JavaScript.

Implicit typekonvertering

• JavaScript kan automatisk konvertere typer, når der udføres operationer mellem forskellige typer.

1let result = 5 + "5"; // "55" (the number is converted to a string)
2
3console.log(result);

• I dette eksempel bliver tallet 5 implicit konverteret til en streng, hvilket resulterer i strengen "55".

Eksplícit typekonvertering

• Udviklere kan også udføre typekonverteringer eksplicit.

1let num = "123";
2let convertedNum = Number(num); // Converts "123" to the number 123
3
4console.log(typeof num);
5console.log(typeof convertedNum);

• I dette eksempel bruges funktionen Number() til eksplicit at konvertere strengen "123" til tallet 123.

Typekontrol

I JavaScript kan du bruge typeof-operatoren til at kontrollere datatypen på en variabel.

 1// Output: The type of 42 is: number
 2console.log('The type of 42             is:', typeof 42);
 3
 4// Output: The type of 42 is: bigint
 5console.log('The type of 42n            is:', typeof 42n);
 6
 7// Output: The type of "hello" is: string
 8console.log('The type of "hello"        is:', typeof "hello");
 9
10// Output: The type of true is: boolean
11console.log('The type of true           is:', typeof true);
12
13// Output: The type of undefined is: undefined
14console.log('The type of undefined      is:', typeof undefined);
15
16// Output: The type of null is: object
17console.log('The type of null           is:', typeof null);
18
19// Output: The type of Symbol() is: symbol
20console.log('The type of Symbol()       is:', typeof Symbol());
21
22// Output: The type of {} is: object
23console.log('The type of {}             is:', typeof {});
24
25// Output: The type of function () {} is: function
26console.log('The type of function () {} is:', typeof function () {});

Konklusion

• Primitive typer inkluderer number, string, boolean, null, undefined og symbol.
• Objekttyper inkluderer Object, Array, Function blandt andre.
• Da både automatiske og eksplícitte typekonverteringer forekommer, er det vigtigt at forstå den korrekte brug af datatyper.

Du kan følge med i ovenstående artikel ved hjælp af Visual Studio Code på vores YouTube-kanal. Husk også at tjekke YouTube-kanalen.

YouTube Video