TypeScript Generics med eksempler

Generiske TypeScript er en kraftfuld funktion, der giver dig mulighed for at skabe genbrugelige og typesikre komponenter. Generics giver en måde at skabe klasser, funktioner og grænseflader, der fungerer med en række forskellige typer, samtidig med at stærk typesikkerhed opretholdes. Denne artikel vil introducere dig til generiske lægemidler og demonstrere, hvordan du bruger dem med praktiske eksempler.

Forstå generiske lægemidler

Generisk giver dig mulighed for at definere en komponent med en pladsholder for den type, den opererer på. I stedet for at angive en konkret type, bruger du en generisk typeparameter, der kan erstattes med en hvilken som helst type, når komponenten bruges.

Grundlæggende syntaks

Den grundlæggende syntaks til at definere en generisk type er at bruge vinkelparenteser <> med et typeparameternavn. Her er et simpelt eksempel:

function identity(value: T): T {
  return value;
}

const stringIdentity = identity("Hello"); // string
const numberIdentity = identity(123); // number

I dette eksempel er identitet en generisk funktion, der tager en parameter værdi af typen T og returnerer en værdi af samme type. Typeparameteren T erstattes med den aktuelle type, når funktionen kaldes.

Generiske lægemidler med klasser

Generiske stoffer kan også bruges med klasser til at skabe fleksible og genanvendelige datastrukturer. Her er et eksempel på en generisk klasse:

class Box {
  private value: T;

  constructor(value: T) {
    this.value = value;
  }

  getValue(): T {
    return this.value;
  }
}

const stringBox = new Box("TypeScript");
console.log(stringBox.getValue()); // Output: TypeScript

const numberBox = new Box(42);
console.log(numberBox.getValue()); // Output: 42

I dette eksempel er Box-klassen defineret med en generisk typeparameter T. Klassen har en privat egenskab værdi af typen T og en metode getValue, der returnerer værdien af ​​typen T.

Generiske med grænseflader

Generisk kan bruges med grænseflader til at skabe fleksible og typesikre grænseflader. Her er et eksempel:

interface Pair<T, U> {
  first: T;
  second: U;
}

const pair: Pair<string, number> = {
  first: "Age",
  second: 30
};

console.log(pair.first); // Output: Age
console.log(pair.second); // Output: 30

I dette eksempel er Pair-grænsefladen defineret med to generiske typeparametre T og U. Interfacet repræsenterer et par værdier med henholdsvis typerne T og U.

Generiske i funktioner

Generisk kan bruges i funktioner til at håndtere flere typer, samtidig med at typesikkerheden opretholdes. Her er et eksempel på en generisk funktion, der fungerer med arrays:

function reverseArray(items: T[]): T[] {
  return items.reverse();
}

const reversedStringArray = reverseArray(["one", "two", "three"]);
console.log(reversedStringArray); // Output: ["three", "two", "one"]

const reversedNumberArray = reverseArray([1, 2, 3]);
console.log(reversedNumberArray); // Output: [3, 2, 1]

I dette eksempel tager funktionen reverseArray en matrix af typen T og returnerer en omvendt matrix af samme type. Typeparameteren T sikrer, at funktionen fungerer med arrays af enhver type, samtidig med at typesikkerheden opretholdes.

Begrænsninger på generiske lægemidler

Nogle gange kan det være nødvendigt at pålægge begrænsninger på den generiske typeparameter for at sikre, at den har visse egenskaber. Dette gøres ved hjælp af begrænsninger:

function logLength(item: T): void {
  console.log(item.length);
}

logLength("Hello, TypeScript"); // Output: 16
logLength([1, 2, 3]); // Output: 3
// logLength(123); // Error: number does not have a length property

I dette eksempel er logLength-funktionen begrænset til typer, der har en length egenskab. Dette tillader funktionen at acceptere strenge og arrays, men ikke tal eller andre typer uden en length egenskab.

Konklusion

Generics i TypeScript giver en effektiv måde at skabe fleksible og genanvendelige komponenter, samtidig med at stærk typesikkerhed opretholdes. Ved at forstå og bruge generiske artikler kan du skrive mere generisk og tilpasningsdygtig kode, hvilket forbedrer den overordnede kvalitet og vedligeholdelse af dine TypeScript-applikationer.

Eksperimenter med generiske stoffer i dine projekter for at se deres fordele i aktion og forbedre dine TypeScript-programmeringsfærdigheder.