# Hvordan definere og bruke TypeScript-klasser

TypeScript-klasser gir en klar og strukturert måte å organisere data og atferd i et **objekt** på. Dette gjør det enklere for deg å modellere enheter og konsepter i koden din.

## Hva er TypeScript-klasser?

Klasser er et sentralt begrep i TypeScript, som er et programmeringsspråk basert på JavaScript. Klasser representerer en **strukturert metode for å definere objekter** og for å anvende objektorientert programmering (OOP). TypeScript-klasser er som blåkopier for å lage objekter som samler logisk relaterte data og metoder.

[TypeScript](https://www.ionos.com/nb-no/digitalguide/nettsteder/webutvikling/hva-er-typescript/) inneholder alle funksjonene i JavaScript og inkluderer også **statisk typing**. Dette gjør det mulig å spesifisere datatyper for [TypeScript-funksjoner](https://www.ionos.com/nb-no/digitalguide/nettsteder/webutvikling/typescript-funksjoner/), variabler og klasser, slik at du kan oppdage feil under kompilering. I tillegg til typesikkerhet støtter TypeScript-klasser også konsepter som arv og abstraksjon, noe som letter utviklingen av komplekse applikasjoner.

Med TypeScript-klasser kan du opprette en klar **hierarki av klasser** som arver egenskaper og metoder. Dette fremmer gjenbruk og strukturering av kode. Klassekonstruktører gjør det mulig å initialisere instanser og sikrer konsistent objektskaping.

## Hva er syntaksen for TypeScript-klasser?

Notasjonen for TypeScript-klasser ligner på den i **ECMAScript 6 (ES6)** og er en utvidet versjon av JavaScript-klassesyntaksen. En TypeScript-klasse kan inneholde ulike elementer for å definere strukturen og oppførselen til objekter. Hovedkomponentene er:

- **Egenskaper**
- **Konstruktører**
- **Metoder**

### Egenskaper

Egenskaper bestemmer **tilstanden til et objekt**. De lagrer dataverdier og kan merkes med datatyper slik at de bare har gyldige verdier.

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

- **ClassName**: navnet på klassen
- **propertyName**: navnet på egenskapen du vil definere
- **propertyType**: datatypen til egenskapen

Her er et konkret eksempel:

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

Først defineres en klasse `Person` med en egenskap `name` av typen `string`. Dette betyr at instanser av klassen `Person` har en egenskap `name` som lagrer **strenger**.

### Konstruktør

Konstruktøren i TypeScript er en spesiell metode som kalles når en klasseinstans (objekt) opprettes. Du trenger den for **å initialisere egenskapene til et objekt**. Konstruktøren definerer i hovedsak den opprinnelige tilstanden til en instans. Du kan spesifisere parametere i konstruktøren for å overføre verdier når du instansierer TypeScript-klasser.

Den grunnleggende syntaksen for en konstruktør i TypeScript er:

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

- **konstruktør**: hver klasse kan ha én enkelt konstruktør. Hvis ingen konstruktør er definert, opprettes en tom konstruktør som standard.
- **parameter: Type**: parametere er valgfrie, avhengig av klassen og dens krav. Parametere bør merkes med datatypene sine.

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 som aksepterer to parametere, `firstName` og `lastName`. Når **du oppretter en instans** av denne klassen, overføres disse parametrene, og konstruktøren initialiserer egenskapene `firstName` og `lastName` til instansen med de tilsvarende verdiene. `this` refererer til den aktuelle instansen av klassen som koden kjøres på.

### Metoder

I TypeScript er metoder funksjoner som kan defineres i klasser og brukes på deres instanser. Metoder lar deg utføre **visse handlinger eller operasjoner** i sammenheng med en klasse.

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

- **methodName**: navnet på metoden
- **parameter: Type**: valgfrie parametere som metoden aksepterer
- **ReturnType**: dette er datatypen som bestemmer verdien som metoden returnerer. Hvis metoden ikke returnerer noe, kan du angi `void`.

For å få tilgang til en egenskap eller kalle en metode på en klasseinstans, bruk punktoperatøren `.` etterfulgt av metodens navn og de nødvendige argumentene hvis metoden forventer parametere.

```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` brukes til å opprette og returnere personens fulle navn. Den får tilgang til verdiene for egenskapene `firstName` og `lastName` som er definert i klassen og initialisert i konstruktøren. Objektet `person` opprettes av nøkkelordet `new` etterfulgt av klassens navn og de respektive parametrene. Metoden **sammenføyer de to strengene** når den kalles, og returnerer det fulle navnet som en streng. Utdataene for objektet `person` er derfor «John Doe».

## TypeScript-klasseeksempler

TypeScript-klasser har ulike mekanismer for å organisere og kontrollere **strukturen og oppførselen til objekter**. Nedenfor presenterer vi noen konsepter for bruk av TypeScript-klasser.

### Tilgang

TypeScript tilbyr tre tilgangsmodifikatorer: `public`, `private` og `protected` for å kontrollere tilgangen til egenskaper og metoder innenfor og utenfor klassen.

- **offentlig (standard)**: egenskaper og metoder merket med `public` kan kalles fra hvor som helst, både innenfor og utenfor klassen.
- **privat**: `private` refererer til egenskaper og metoder som kun kan kalles innenfor selve klassen. De er utilgjengelige for eksterne kodepartier.
- **beskyttet**: egenskaper og metoder merket med `protected` kan kalles av klassen selv og av avledede klasser (i arv), men ikke av 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 eksemplet er `socialSecurityNumber` en privat egenskap som kun er tilgjengelig innenfor klassen `Person`. Du kan imidlertid kalle opp metoden `greet` utenfor klassen.

### Arv

Arv er et grunnleggende konsept i objektorientert programmering (OOP) som brukes i TypeScript og mange andre programmeringsspråk på internett. Det gjør det mulig å opprette en ny klasse på grunnlag av en eksisterende **baseklasse eller superklasse**. Den avledede klassen (underklassen) arver egenskapene og metodene til baseklassen og kan utvide 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 å bruke nøkkelordet `extends` arver underklassen `Dog` egenskapene og metodene fra overklassen `Animal`. Klassen `Dog` overstyrer metoden `makeSound` for å legge til en spesifikk atferd, samtidig som den arver egenskapen `name` fra `Animal`.

### Skrivebeskyttet

Du kan bruke `readonly` til å erklære egenskaper i TypeScript-klasser eller -objekter som **skrivebeskyttede**. Dette betyr at når en skrivebeskyttet egenskap er initialisert, kan verdien ikke lenger endres.

```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 vårt eksempel er egenskapen `pi` skrivebeskyttet og initialiseres i konstruktøren. Etter initialisering kan `pi` ikke lenger endres. Hvis du prøver å endre verdien av `pi` etter initialisering, vil TypeScript generere en kompileringsfeil.


This is a markdown version of: [https://www.ionos.com/nb-no/digitalguide/nettsteder/webutvikling/typescript-klasser/](https://www.ionos.com/nb-no/digitalguide/nettsteder/webutvikling/typescript-klasser/) for AI/LLM consumption.