Datatyper i TypeScript

Articles

Denne artikel forklarer datatyper i TypeScript.

YouTube Video

Datatyper i TypeScript

TypeScript tilbyder en række forskellige datatyper. Dette giver dig mulighed for at definere strenge typer for variabler, funktionens argumenter og returværdier. Nedenfor er de vigtigste datatyper og deres anvendelse.

Primære typer

number-type

1let age: number = 25;
2console.log(age);          // Outputs: 25
3console.log(typeof age);    // Outputs: number

number er en type, der bruges til at håndtere numeriske værdier, inklusive heltal og flydende punkt-tal (decimaler). Håndtering af værdier, der overskrider bestemte 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 TypeScript er tal repræsenteret som flydende punkt-tal. Dette kan resultere i små unøjagtigheder i beregningsresultater.
Når præcise beregninger kræves, fx for finansielle beløb, er det nødvendigt at undgå afrundingsfejl som denne. For eksempel kan du bruge BigInt eller toFixed() eller justere decimalpladserne ved hjælp af biblioteker som decimal.js.

string-type

string-typen håndterer tekstdata.

1let greeting: string = "Hello, TypeScript!";
2console.log(greeting);     // Outputs: Hello, TypeScript!
3console.log(typeof greeting);  // Outputs: string

boolean (logisk type)

boolean-typen har to værdier: true eller false.

1let isOpen: boolean = true;
2console.log(isOpen);       // Outputs: true
3console.log(typeof isOpen);    // Outputs: boolean

null og undefined

null repræsenterer en 'ikke-eksisterende værdi', og undefined repræsenterer en 'ikke-defineret værdi'.

1let emptyValue: null = null;
2let notDefined: undefined = undefined;
3
4console.log(emptyValue);       // Outputs: null
5console.log(typeof emptyValue);    // Outputs: object (JavaScript specification)
6
7console.log(notDefined);       // Outputs: undefined
8console.log(typeof notDefined);    // Outputs: undefined

Array

I TypeScript kan du angive typen af array-elementer. number[] er et array af tal, og string[] er et array af tekststrenge.

1let numbers: number[] = [1, 2, 3, 4];
2console.log(numbers);        // Outputs: [1, 2, 3, 4]
3console.log(typeof numbers); // Outputs: object
4
5let words: string[] = ["TypeScript", "JavaScript"];
6console.log(words);          // Outputs: ["TypeScript", "JavaScript"]
7console.log(typeof words);   // Outputs: object

Tuple

En tuple er et array med elementer af forskellige typer.

1let person: [string, number] = ["Alice", 30];
2console.log(person);         // Outputs: ["Alice", 30]
3console.log(typeof person);  // Outputs: object

Enum

enum definerer et sæt navngivne konstanter.

1enum Color {
2    Red,
3    Green,
4    Blue
5}
6
7let favoriteColor: Color = Color.Green;
8console.log(favoriteColor);  // Outputs: 1 (Defaults start from 0)
9console.log(typeof favoriteColor); // Outputs: number

any

any-typen kan indeholde enhver type værdi og bruges, når du vil deaktivere typekontrol.

1let anything: any = "Hello";
2console.log(anything);       // Outputs: Hello
3console.log(typeof anything);    // Outputs: string
4
5anything = 42;
6console.log(anything);       // Outputs: 42
7console.log(typeof anything);    // Outputs: number

Union-type

Ved at bruge unionstyper kan du definere variabler, der kan indeholde en af flere typer.

1let identifier: number | string = "ID_12345";
2console.log(identifier);     // Outputs: ID_12345
3console.log(typeof identifier);  // Outputs: string
4
5identifier = 12345;
6console.log(identifier);     // Outputs: 12345
7console.log(typeof identifier);  // Outputs: number

Sammendrag

number, string, boolean: Primitivtyper.
null, undefined: Specialværdier.
Array: En array med type-annotationer.
Tuple: Et array med elementer af forskellige typer.
enum: En enumereret type.
any: Enhver type.
Union: En variabel, der kan have en af flere typer.

Ved at bruge disse datatyper forbedrer TypeScript typesikkerheden, hvilket gør det lettere at forhindre fejl under udvikling.

Wrapper-objekter

Wrapper-objekter i TypeScript er objekter, der automatisk oprettes for at behandle primitive datatyper som objekter. Primitive typer muliggør lette og hurtige operationer, mens objekttyper har metoder og egenskaber, der muliggør mere avancerede operationer.

I JavaScript (og TypeScript) findes der wrapper-objekter, der svarer til primitive typer som string, number og boolean. De oprettes ved hjælp af konstruktørfunktioner kaldet String, Number og Boolean.

Nedenfor er eksempler på wrapper-objekter.

String-objektet

String-objektet leverer egenskaber og metoder til strenge.

1let strPrimitive: string = "Hello, World!";
2let strObject: String = new String("Hello, World!");
3
4console.log(strPrimitive);         // Outputs: Hello, World!
5console.log(typeof strPrimitive);  // Outputs: string
6
7console.log(strObject);            // Outputs: [String: 'Hello, World!']
8console.log(typeof strObject);     // Outputs: object

Funktioner:

I modsætning til primitive string behandles et String-objekt som object af typeof.
Wrapper-objekter er nyttige, når man manipulerer strenge eller kalder metoder på dem.

Number-objektet

Number-objektet leverer egenskaber og metoder for tal.

1let numPrimitive: number = 42;
2let numObject: Number = new Number(42);
3
4console.log(numPrimitive);         // Outputs: 42
5console.log(typeof numPrimitive);  // Outputs: number
6
7console.log(numObject);            // Outputs: [Number: 42]
8console.log(typeof numObject);     // Outputs: object

Funktioner:

Number-objektet, som en wrapper for tal, inkluderer metoder til numeriske operationer (f.eks. toFixed).

Boolean-objektet

Boolean-objektet leverer egenskaber og metoder for booleske værdier.

1let boolPrimitive: boolean = true;
2let boolObject: Boolean = new Boolean(true);
3
4console.log(boolPrimitive);        // Outputs: true
5console.log(typeof boolPrimitive); // Outputs: boolean
6
7console.log(boolObject);           // Outputs: [Boolean: true]
8console.log(typeof boolObject);    // Outputs: object

Funktioner:

Boolean-objektet er en wrapper for den primitive boolean type og behandles som object.

Forskelle mellem wrapper-objekter og primitive typer

Da wrapper-objekter behandles som objekter, er der en lille ydelsesnedgang, men flere funktionelle operationer er mulige på grund af de tilføjede egenskaber og metoder. Derudover er der forskelle i sammenligning ved brug af == og ===.

1let numPrimitive: number = 123;
2let numObject: Number = new Number(123);
3
4console.log('==  : ', numPrimitive == numObject);  // Outputs: true (Value comparison)
5console.log('=== : ', numPrimitive === numObject); // Outputs: false (Due to differing types)

Funktioner:

== sammenligner værdier, mens === strengt sammenligner inklusive typer. === returnerer false, når wrapper-objekter sammenlignes med primitive typer.

Typekonvertering

I TypeScript er det vigtigt at håndtere implicit og eksplicit typekonvertering korrekt.

Implicit Typekonvertering

I TypeScript bør implicit typekonvertering undgås så vidt muligt for at sikre typesikkerhed.

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

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

Eksplicit Typekonvertering

I TypeScript skal du bruge typeannotationer eller typekonverteringsfunktioner for sikkert at udføre typekonverteringer.

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

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

Typekontrol

I TypeScript kan du bruge operatoren typeof til at kontrollere datatypen af 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 () {});

I TypeScript kan du bruge typeof til at kontrollere typer, men for mere præcis typekontrol anbefales det også at bruge operatorerne instanceof eller is.

Sammendrag

Wrapper-objekter behandles som objekter, fordi de giver yderligere metoder og egenskaber for primitive typer.
String, Number og Boolean er repræsentative eksempler på wrapper-objekter.
I modsætning til primitive typer identificeres wrapper-objekter som object af typeof.

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

Grundlæggende om TypeScript Operatorer i TypeScript