Wat is TypeScript-interface versus type?

TypeScript ondersteunt aangepaste typen, die kunnen worden gedefinieerd met ' koppel ' of ' type ”. Een interface kan worden geïmplementeerd door een klasse of een object, terwijl een type-alias alleen kan worden gebruikt voor het maken van een nieuwe naam voor een bestaand type of om een combinatie van typen te definiëren. Hoewel typen en interfaces vaak uitwisselbaar zijn, zijn er bepaalde verschillen in hun functionaliteit en syntaxis waardoor ze geschikter zijn voor bepaalde scenario's.

Deze blog beschrijft de TypeScript-interface en het type en hun verschil.

Wat is TypeScript-interface versus type?

“ Koppel ' En ' type 'worden gebruikt voor het definiëren van aangepaste typen in TypeScript. Maar er zijn enkele verschillen in hun functionaliteit en syntaxis. Het belangrijkste verschil tussen een interface en een type is dat een interface een nieuw type definieert, terwijl een type-alias dat niet doet.

Een interface kan worden geïmplementeerd door een klasse of een object, terwijl typen complexere typen kunnen definiëren met behulp van functies zoals vakbonden en kruispunten. Over het algemeen worden interfaces vaker gebruikt voor het definiëren van objectvormen en API's, terwijl typen vaker worden gebruikt voor het definiëren van complexe gegevenstypen en typen hulpprogramma's. Laten we beide afzonderlijk begrijpen.

Wat is een TypeScript-interface?

Een TypeScript-interface is een techniek om de vorm van een TypeScript-object te definiëren. Het is gemaakt met het trefwoord ' koppel ” en het specificeert een set attributen en methoden die een object nodig heeft om te worden geclassificeerd als van dat type. Het is gelijk aan een klasse in objectgeoriënteerd programmeren; het definieert echter geen implementatie. Interfaces worden voornamelijk gebruikt voor typecontrole en om ervoor te zorgen dat een object voldoet aan een specifieke structuur.

Voordat u doorgaat, moet u er rekening mee houden dat om een TypeScript-bestand uit te voeren, het moet worden omgezet in een JavaScript-bestand en vervolgens de JavaScript-code op de terminal moet uitvoeren met behulp van de gegeven opdrachten:

tsc bestandsnaam.ts
knooppunt bestandsnaam.js

Voorbeeld

Maak een interface met de naam 'User' die drie attributen en een methode definieert informatie verkrijgen() ”:

interface Gebruiker {
voornaam: string;
achternaam: string;
leeftijd: aantal;
informatie verkrijgen ( ) : leegte;
}

Maak een klas ' Student ” dat wordt geërfd met een interface. De klasse definieert zijn attributen, een constructor die de waarden aan de attributen zal toewijzen, en een methode 'getInfo()' die de waarden ten opzichte van de attributen zal weergeven:

class Student implementeert Gebruiker {
voornaam: string;
achternaam: string;
leeftijd: aantal;

constructeur ( voornaam: string, achternaam: string, leeftijd: nummer ) {
deze.voornaam = voornaam;
deze.achternaam = achternaam;
deze.leeftijd = leeftijd;
}
informatie verkrijgen ( ) : leegte {
console.log ( 'Studenteninformatie:' )
console.log ( '- Naam: ' + deze.voornaam + '' + deze.achternaam ) ;
console.log ( '- Leeftijd: ' + deze.leeftijd ) ;
}
}

Maak een object van ' Student ' genaamd ' soa ' van ' Gebruiker ' typ door de constructor aan te roepen met het sleutelwoord 'new' en roep vervolgens de methode getInfo() aan om de gegevens op de console af te drukken:

const std: Gebruiker = nieuwe leerling ( 'Knuppel' , 'Steve' , 17 ) ;
standaard.getInfo ( ) ;

Uitgang

Wat is een TypeScript-type?

TypeScript-typen worden meestal gebruikt voor het maken van aliassen voor bestaande typen en voor het maken van meer gecompliceerde typen. Het vertegenwoordigt een specifieke vorm of structuur van gegevens. Het kan worden gedefinieerd/gedeclareerd met de ' type ' sleutelwoord. De typen van TypeScript kunnen worden gebruikt om code begrijpelijker te maken en herhaling/duplicatie te verminderen.

Voorbeeld

Definieer eerst een type ' Gebruiker ' de ... gebruiken ' type ” trefwoord gespecificeerd met vijf eigenschappen waarvan er één een optioneel kenmerk is dat “ telefoon ”:

type Gebruiker = {
voornaam: string;
achternaam: string;
leeftijd: aantal;
e-mail: tekenreeks;
telefoon?: tekenreeks;
} ;

Definieer een functie met de naam ' getFullName ”, waaraan een parameter van het type “ Gebruiker ' en drukt de gegevens af die bestaan uit de informatie van de persoon, waaronder ' naam ”, “ leeftijd ”, “ e-mailen ' En ' telefoonnummer ”:

functie informatie verkrijgen ( persoon: Gebruiker ) : leegte {
console.log ( 'Gebruikers informatie:' )
console.log ( '- Naam: ' + persoon.voornaam + '' + persoon.achternaam ) ;
console.log ( '- Leeftijd: ' + persoon.leeftijd ) ;
console.log ( '- E-mail: ' + persoon.e-mail ) ;
console.log ( '-Telefoonnummer: ' + persoon.telefoon ) ;
}

Maak nu een object ' persoon ' van type ' Gebruiker ” met sleutel-waardeparen:

const persoon: Gebruiker = {
Voornaam: 'Mily' ,
achternaam: 'Michel' ,
leeftijd: 28 ,
e-mail: 'mili124@yahoo.com' ,
telefoon: '086-34581734'
} ;

Druk ten slotte de gebruikersinformatie af door de functie getInfo() aan te roepen:

console.log ( informatie verkrijgen ( persoon ) ) ;

Uitgang

Dat ging allemaal over de TypeScript-interface en het type.

Conclusie

In TypScript, ' koppel ' En ' type ” worden gebruikt voor het definiëren van aangepaste typen. Een interface kan worden geïmplementeerd door een klasse of een object, terwijl typen complexere typen kunnen definiëren met behulp van functies zoals vakbonden en kruispunten. Dit zijn de krachtige functies die kunnen helpen om meer georganiseerde en schaalbare code te schrijven. Deze blog beschreef de TypeScript-interface en het type en hun verschil.

Wat is TypeScript-interface versus type?