# Sådan defineres og bruges TypeScript-klasser

TypeScript-klasser giver en klar og struktureret måde at organisere data og adfærd i et **objekt** på. Dette gør det lettere for dig at modellere enheder og koncepter i din kode.

## Hvad er TypeScript-klasser?

Klaser er et centralt begreb i TypeScript, som er et programmeringssprog baseret på JavaScript. Klasser repræsenterer en **struktureret metode til at definere objekter** og anvende objektorienteret programmering (OOP). TypeScript-klasser er som blueprints til at oprette objekter, der samler logisk relaterede data og metoder.

[TypeScript](https://www.ionos.com/da-dk/digitalguide/websteder/webudvikling/hvad-er-typescript/) indeholder alle JavaScript-funktionerne og omfatter også **statisk typning**. Dette giver dig mulighed for at angive datatyper for [TypeScript-funktioner](https://www.ionos.com/da-dk/digitalguide/websteder/webudvikling/typescript-funktioner/), variabler og klasser, så du kan opdage kompileringsfejl. Ud over typesikkerhed understøtter TypeScript-klasser også begreber som arv og abstraktion, hvilket letter udviklingen af komplekse applikationer.

Med TypeScript-klasser kan du oprette en klar **hierarki af klasser**, der arver egenskaber og metoder. Dette fremmer genbrug og strukturering af kode. Klassekonstruktorer gør det muligt at initialisere instanser og sikrer konsistent objektoprettelse.

## Hvad er syntaksen for TypeScript-klasser?

Notationen for TypeScript-klasser ligner den i **ECMAScript 6 (ES6)** og er en udvidet version af JavaScript-klassesyntaksen. En TypeScript-klasse kan indeholde forskellige elementer til at definere objekters struktur og adfærd. De vigtigste komponenter er:

- **Egenskaber**
- **Konstruktører**
- **Metoder**

### Egenskaber

Egenskaber bestemmer **et objekts tilstand**. De gemmer dataværdier og kan forsynes med datatyper, så de kun har gyldige værdier.

```typescript
class ClassName {
    propertyName: propertyType;
}
```

- **ClassName**: navnet på klassen
- **propertyName**: navnet på den egenskab, du vil definere
- **propertyType**: datatypen for egenskaben

Her er et konkret eksempel:

```typescript
class Person {
    name: string;
}
```

Først defineres en klasse `Person` med en egenskab `name` af typen `string`. Det betyder, at instanser af klassen `Person` har en egenskab `name`, der gemmer **strenge**.

### Konstruktør

Konstruktoren i TypeScript er en speciel metode, der kaldes, når en klasseinstans (objekt) oprettes. Du har brug for den til **at initialisere et objekts egenskaber**. Konstruktoren definerer i det væsentlige en instans’ indledende tilstand. Du kan angive parametre i konstruktoren for at overføre værdier, når du instansierer TypeScript-klasser.

Den grundlæggende syntaks for en konstruktør i TypeScript er:

```typescript
class ClassName {
    constructor(parameter1: Type1, parameter2: Type2, ...) {
    }
}
```

- **konstruktør**: hver klasse kan have en enkelt konstruktør. Hvis der ikke er defineret nogen konstruktør, oprettes der som standard en tom konstruktør.
- **parameter: Type**: parametre er valgfri, afhængigt af klassen og dens krav. Parametre skal mærkes med deres datatyper.

Et eksempel på en konstruktør:

```typescript
class Person {
    firstName: string;
    lastName: string;
    constructor(firstName: string, lastName: string) {
        this.firstName = firstName;
        this.lastName = lastName;
    }
}
```

I eksemplet ovenfor har klassen `Person` en konstruktør, der accepterer to parametre `firstName` og `lastName`. Når **der oprettes en instans** af denne klasse, overføres disse parametre, og konstruktøren initialiserer instansens egenskaber `firstName` og `lastName` med de tilsvarende værdier. `this` henviser til den aktuelle instans af klassen, som koden udføres på.

### Metoder

I TypeScript er metoder funktioner, der kan defineres i klasser og anvendes på deres instanser. Metoder giver dig mulighed for at udføre **bestemte handlinger eller operationer** i forbindelse med en klasse.

```typescript
class ClassName {
    // ...
    methodName(parameter1: Type1, parameter2: Type2, ...): ReturnType {
    }
    // ...
}
```

- **methodName**: navnet på metoden
- **parameter: Type**: valgfri parametre, som metoden accepterer
- **ReturnType**: dette er den datatype, der bestemmer den værdi, som metoden returnerer. Hvis metoden ikke returnerer noget, kan du angive `void`.

For at få adgang til en egenskab eller kalde en metode på en klasseinstans skal du bruge prikoperatoren `.` efterfulgt af metodens navn og de nødvendige argumenter, hvis metoden forventer parametre.

```typescript
class Person {
    firstName: string;
    lastName: string;
    constructor(firstName: string, lastName: string) {
        this.firstName = firstName;
        this.lastName = lastName;
    }
    getFullName(): string {
        return this.firstName + " " + this.lastName;
    }
}
const person = new Person("John", "Doe");
const fullName = person.getFullName();
```

Metoden `getFullName` bruges til at oprette og returnere personens fulde navn. Den får adgang til værdierne for egenskaberne `firstName` og `lastName`, der er defineret i klassen og initialiseret i konstruktøren. Objektet `person` oprettes ved hjælp af nøgleordet `new` efterfulgt af klassens navn og de respektive parametre. Metoden **sammenkæder de to strenge**, når den kaldes, og returnerer det fulde navn som en streng. Outputtet for objektet `person` er derfor “John Doe”.

## TypeScript-klasseeksempler

TypeScript-klasser har forskellige mekanismer til at organisere og kontrollere **objekters struktur og adfærd**. Nedenfor præsenterer vi nogle koncepter til brug af TypeScript-klasser.

### Adgang

TypeScript tilbyder tre adgangsmodifikatorer: `public`, `private` og `protected` til at kontrollere adgangen til egenskaber og metoder inden for og uden for klassen.

- **offentlig (standard)**: egenskaber og metoder markeret med `public` kan kaldes fra hvor som helst, både inden for og uden for klassen.
- **privat**: `private` henviser til egenskaber og metoder, der kun kan kaldes inden for selve klassen. De er utilgængelige for eksterne kodestykker.
- **beskyttet**: egenskaber og metoder markeret med `protected` kan kaldes af selve klassen og af afledte klasser (i arv), men ikke af ekstern kode.

```typescript
class Person {
    private socialSecurityNumber: string;
    constructor(ssn: string) {
        this.socialSecurityNumber = ssn;
    }
    greet() {
        console.log("Hello, I am a person with SSN: " + this.socialSecurityNumber);
    }
}
const person = new Person("123-45-6789");
person.greet();
```

I dette eksempel er `socialSecurityNumber` en privat egenskab, som kun kan tilgås inden for klassen `Person`. Du kan dog kalde metoden `greet` uden for klassen.

### Arv

Arv er et grundlæggende begreb i objektorienteret programmering (OOP), der bruges i TypeScript og mange andre internetprogrammeringssprog. Det gør det muligt at oprette en ny klasse på basis af en eksisterende **basisklasse eller superklasse**. Den afledte klasse (underklasse) arver basisklassens egenskaber og metoder og kan udvide eller tilpasse dem.

```typescript
class Animal {
    name: string;
    constructor(name: string) {
        this.name = name;
    }
    makeSound() {
        console.log("Some generic sound");
    }
}
class Dog extends Animal {
    makeSound() {
        console.log(this.name + " barks");
    }
}
const myDog = new Dog("Buddy");
myDog.makeSound();
```

Ved hjælp af nøgleordet `extends` arver underklassen `Dog` egenskaberne og metoderne fra overklassen `Animal`. Klassen `Dog` tilsidesætter metoden `makeSound` for at tilføje en specifik adfærd, samtidig med at den arver egenskaben `name` fra `Animal`.

### Skrivebeskyttet

Du kan bruge `readonly` til at erklære egenskaber for TypeScript-klasser eller -objekter som **skrivebeskyttede**. Det betyder, at når en skrivebeskyttet egenskab er blevet initialiseret, kan dens værdi ikke længere ændres.

```typescript
class Circle {
    readonly pi: number = 3.14159;
    radius: number;
    constructor(radius: number) {
        this.radius = radius;
    }
    getArea() {
        return this.pi    *this.radius*    this.radius;
    }
}
const myCircle = new Circle(5);
console.log(myCircle.getArea()); // Output: ≈ 78,54
```

I vores eksempel er egenskaben `pi` skrivebeskyttet og initialiseres i konstruktøren. Efter initialiseringen kan `pi` ikke længere ændres. Hvis du forsøger at ændre værdien af `pi` efter initialiseringen, genererer TypeScript en kompileringsfejl.


This is a markdown version of: [https://www.ionos.com/da-dk/digitalguide/websteder/webudvikling/typescript-klasser/](https://www.ionos.com/da-dk/digitalguide/websteder/webudvikling/typescript-klasser/) for AI/LLM consumption.