TypeScript Flashcards

Categorie sponsor

TypeScript is een statisch getypeerde superset van JavaScript, gecreëerd door Anders Hejlsberg bij Microsoft. Het is een taal ontworpen om de productiviteit te verhogen en de codekwaliteit in grote applicaties te verbeteren. TypeScript wordt gekenmerkt door een rijk typesysteem en geavanceerde taalfuncties, waardoor foutdetectie tijdens compilatie en betere ondersteuning voor ontwikkelingstools mogelijk zijn. Deze taal biedt functies zoals interfaces, generics en decorators, die ontwikkelaars tools bieden om meer leesbare en onderhoudbare code te schrijven. TypeScript ondersteunt ook volledige compatibiliteit met JavaScript en geleidelijke adoptie in bestaande projecten, met behoud van prestaties en eenvoudig gebruik van het JavaScript-ecosysteem.

Onze flashcard-app bevat zorgvuldig geselecteerde TypeScript-interviewvragen met uitgebreide antwoorden die u effectief voorbereiden op elk interview dat TypeScript-kennis vereist. IT Flashcards is niet alleen een hulpmiddel voor werkzoekenden - het is een geweldige manier om uw kennis te versterken en te testen, ongeacht uw huidige carrièreplannen. Regelmatig gebruik van de app helpt u up-to-date te blijven met de nieuwste TypeScript-trends en uw vaardigheden op een hoog niveau te houden.

Voorbeelden van TypeScript-flashcards uit onze app

Download onze app uit de App Store of Google Play om meer gratis flitskaarten te krijgen of abonneer u voor toegang tot alle flitskaarten.

Wat is het 'any' type in TypeScript en wanneer wordt het gebruik ervan aanbevolen?

Het type any in TypeScript is een dynamisch type dat elke datatype kan vertegenwoordigen. Het gebruik van het any-type stelt ons in staat om typecontrole te vermijden tijdens compilatie, en het kan op een vergelijkbare manier worden behandeld als het dynamische type in andere programmeertalen, zoals JavaScript.

Hier is een voorbeeld van het gebruik van het any-type in TypeScript:

let dynamicValue: any = 100;
dynamicValue = "hallo";
dynamicValue = false;

Hoewel het gebruik van het any-type handig is, wordt het niet aanbevolen als we de datastructuur kennen. Het belangrijkste voordeel van TypeScript ten opzichte van JavaScript is dat TypeScript statische typen introduceert, wat helpt bij het opsporen van fouten tijdens de compilatie.

Het gebruik van het any-type moet daarom beperkt blijven tot situaties waarin we geen specifiek type kunnen bepalen. Bijvoorbeeld, het kan noodzakelijk zijn wanneer we te maken hebben met dynamische gegevens, zoals API-gegevens, die van structuur kunnen veranderen. Let op - overmatig gebruik van het any-type kan leiden tot het verlies van de voordelen die TypeScript biedt door typecontrole en verificatie.

Leg uit wat het 'void' type is in de context van functies in TypeScript.

Het void type in TypeScript is een speciaal type dat wordt geretourneerd door functies die geen waarde retourneren. In JavaScript / TypeScript terminologie, functies die geen gedeclareerd retourtype hebben of geen retourinstructie hebben, retourneren undefined. Een dergelijk functietype kan worden gedeclareerd met behulp van het void type.

Het void type is nuttig wanneer we een functie willen maken die een specifieke actie moet uitvoeren, maar geen waarde teruggeeft. Dit wordt vaak gebruikt voor functies gericht op het veranderen van de staat van de applicatie of het weergeven van effecten op het scherm, zoals reacties op klikgebeurtenissen.

Voorbeeld:

function logMessage(message: string): void {
  console.log(message);
}

De logMessage functie neemt een string als argument en geeft deze weer op de console. Het geeft geen waarde terug. Het void type definieert precies dat het geen waarde mag teruggeven. Als we proberen een waarde te retourneren uit een dergelijke functie, zal TypeScript een compilatiefout melden.

Wat zijn de verschillen tussen een interface en een type in TypeScript?

In TypeScript dienen zowel interfaces als types vergelijkbare doeleinden, maar er zijn verschillen tussen hen. Hieronder zal ik er een paar schetsen.

1. Vermogen om types op meerdere manieren te verklaren: Types toelaten complexere verklaringen, bijvoorbeeld, we kunnen een type verklaren als een unie, intersectie, tuple type, literal types, index types, mapped types, conditionele types, enz. Interfaces bezitten deze flexibiliteit niet.

2. Uitbreiden en implementeren: Interfaces kunnen worden uitgebreid en geïmplementeerd voor klassen, wat het schrijven van code gemakkelijker kan maken. Types, daarentegen, bieden deze functionaliteit niet.

3. Declaration merging: Interfaces kunnen meerdere verklaringen hebben in één scope. Al deze verklaringen worden samengevoegd tot één interface. Types kunnen niet meer dan één keer worden verklaard.

Voorbeeld van het samenvoegen van interfaces:

interface Gebruiker {
  naam: string;
}

interface Gebruiker {
  leeftijd: number;
}

// Nu bevat de Gebruiker-interface velden naam en leeftijd

Voorbeeld van een verschil bij het verklaren van een type:

type Gebruiker = {
  naam: string;
};

// De compiler zal een fout genereren omdat types niet meer dan eens kunnen worden verklaard
type Gebruiker = {
  leeftijd: number;
};

4. Structurele type compatibiliteit: Interfaces kunnen worden gebruikt voor het bepalen van structurele type compatibiliteit, terwijl types zijn ontworpen om samengestelde types te behandelen.

Voorbeelden van het gebruik van interfaces en types:

interface VoorbeeldInterface {
    eigenschap1: string;
}

type VoorbeeldType = {
    eigenschap1: string;
    eigenschap2: number;
} | string | number;

Maar hou in je achterhoofd dat de keuze tussen interface en type voornamelijk afhangt van de as of de situatie. Elk heeft zijn voor- en nadelen.

Hoe kun je een object definiëren met specifieke eigenschappen en typen in TypeScript?

In TypeScript kunnen we een object definiëren met gespecificeerde eigenschappen en typen met behulp van de zogenaamde interface of type alias. Beide mechanismen richten zich op het controleren van de vorm die een gegeven object presenteert. Ze dienen om de vorm van objecten te beschrijven. Hier is hoe het te doen:

1. Met behulp van Interface:

interface Persoon {
    voornaam: string;
    achternaam: string;
    leeftijd: number;
    isInDienst: boolean;
}

let john: Persoon = {
    voornaam: 'John',
    achternaam: 'Doe',
    leeftijd: 25,
    isInDienst: true
};

2. Met behulp van Type Alias:

type Auto = {
    merk: string;
    model: string;
    jaar: number;
}

let mijnAuto: Auto = {
    merk: 'Toyota',
    model: 'Corolla',
    jaar: 2020
};

In beide gevallen, als we een object willen toewijzen aan een variabele die niet overeenkomt met de gedeclareerde vorm (bijvoorbeeld ontbreekt een veld of is er een extra veld), krijgen we een compilatiefout.