Datatyper i TypeScript

Articles

Denne artikkelen forklarer datatyper i TypeScript.

YouTube Video

Datatyper i TypeScript

TypeScript tilbyr et utvalg av datatyper. Dette lar deg definere strenge typer for variabler, funksjonsargumenter og returverdier. Nedenfor er hoveddatatypene og deres bruk.

Primitive typer

nummer-type

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

number er en type som brukes for å håndtere numeriske verdier, inkludert heltall og flyttall (desimaltall). Håndtering av verdier som overstiger visse grenser 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 representeres tall som flyttall. Dette kan føre til små unøyaktigheter i beregningsresultater.
Når presise beregninger er nødvendige, som for eksempel økonomiske beløp, er det nødvendig å unngå avrundingsfeil som dette. For eksempel kan du bruke BigInt eller toFixed(), eller justere desimaler ved hjelp av biblioteker som decimal.js.

streng-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 verdier: true eller false.

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

null og undefined

null representerer en 'ikke-eksisterende verdi', og undefined representerer en 'udefinert verdi'.

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 spesifisere typen av elementer i arrays. number[] er en liste med tall, og string[] er en liste med strenger.

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

Tuples

En tuple er en liste med elementer av forskjellige typer.

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

Enum (oppramsing)

enum definerer et sett med navngitte 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 holde enhver type verdi og brukes når du vil deaktivere typekontroll.

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

Unionstype

Ved å bruke unionstyper kan du definere variabler som kan holde én av 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: Primitive typer.
null, undefined: Spesialverdier.
Array: En matrise med typeannotasjoner.
Tuple: En matrise med elementer av forskjellige typer.
enum: En enumerert type.
any: En hvilken som helst type.
Union: En variabel som kan ha én av flere typer.

Ved å bruke disse datatypene forbedrer TypeScript typesikkerheten, noe som gjør det lettere å forhindre feil under utviklingen.

Wrapper-objekter

Wrapper Objects i TypeScript er objekter som automatisk opprettes for å behandle primitivdatatyper som objekter. Primitive typer muliggjør lette og raske operasjoner, mens objekttyper har metoder og egenskaper, som gir mer avanserte operasjoner.

I JavaScript (og TypeScript) finnes det wrapper-objekter som tilsvarer primitive typer som string, number og boolean. De opprettes ved å bruke konstruktørfunksjoner kalt henholdsvis String, Number og Boolean.

Nedenfor er eksempler på wrapper-objekter.

String-objekt

String-objektet gir egenskaper og metoder for strenger.

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

Funksjoner:

I motsetning til primitive string behandles et String-objekt som en object av typeof.
Wrapper-objekter er nyttige når man manipulerer strenger eller kaller metoder på dem.

Number-objekt

Number-objektet gir egenskaper og metoder for tall.

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

Funksjoner:

Number-objektet, som en wrapper for tall, inneholder metoder for numeriske operasjoner (f.eks. toFixed).

Boolean-objekt

Boolean-objektet gir egenskaper og metoder for boolske verdier.

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

Funksjoner:

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

Forskjeller mellom wrapper-objekter og primitive typer

Siden wrapper-objekter behandles som objekter, er det en liten reduksjon i ytelse, men flere funksjonelle operasjoner er mulig på grunn av ekstra egenskaper og metoder. Videre er det forskjeller i sammenligning ved bruk av == 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)

Funksjoner:

== sammenligner verdier, mens === sammenligner strengt inkludert typer. === returnerer false når innpakningsobjekter sammenlignes med primitive typer.

Typekonvertering

I TypeScript er det viktig å håndtere implisitte og eksplisitte typekonverteringer på riktig måte.

Implisitt typekonvertering

I TypeScript bør implisitte typekonverteringer unngås så mye som mulig for å sikre typesikkerhet.

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

I dette eksempelet blir tallet 5 implisitt konvertert til en streng, som resulterer i strengen "55".

Eksplisitt typekonvertering

I TypeScript kan du bruke typeannotasjoner eller typekonverteringsfunksjoner for å trygt utfø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 eksempelet brukes Number()-funksjonen til eksplisitt å konvertere strengen "123" til tallet 123.

Typekontroll

I TypeScript kan du bruke typeof-operatoren for å sjekke datatypen til 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 bruke typeof til å kontrollere typer, men for mer presis typekontroll anbefales det også å bruke instanceof eller is-operatorene.

Sammendrag

Innpakningsobjekter behandles som objekter fordi de gir ekstra metoder og egenskaper for primitive typer.
String, Number og Boolean er representative eksempler på innpakningsobjekter.
I motsetning til primitive typer, identifiseres innpakningsobjekter som object av typeof.

Du kan følge med på artikkelen ovenfor ved å bruke Visual Studio Code på vår YouTube-kanal. Vennligst sjekk ut YouTube-kanalen.

YouTube Video

Grunnleggende om TypeScript Operatorer i TypeScript