Hur man definierar och använder TypeScript-klasser
TypeScript-klasser erbjuder ett tydligt och strukturerat sätt att organisera data och beteenden i ett objekt. Detta gör det enklare för dig att modellera enheter och begrepp i din kod.
Vad är TypeScript-klasser?
Klasser är ett nyckelbegrepp i TypeScript, som är ett programmeringsspråk baserat på JavaScript. Klasser representerar en strukturerad metod för att definiera objekt och för att tillämpa objektorienterad programmering (OOP). TypeScript-klasser är som ritningar för att skapa objekt som samlar logiskt relaterade data och metoder.
TypeScript innehåller alla funktioner i JavaScript och inkluderar även statisk typning. Detta gör att du kan ange datatyper för TypeScript-funktioner, variabler och klasser så att du kan upptäcka kompileringsfel. Förutom typsäkerhet stöder TypeScript-klasser även begrepp som arv och abstraktion, vilket underlättar utvecklingen av komplexa applikationer.
Med TypeScript-klasser kan du skapa en tydlig hierarki av klasser som ärver egenskaper och metoder. Detta främjar återanvändning och strukturering av kod. Klasskonstruktorer gör det möjligt att initialisera instanser och säkerställer konsekvent objektskapande.
Vad är syntaxen för TypeScript-klasser?
Notationen för TypeScript-klasser liknar den i ECMAScript 6 (ES6) och är en utökad version av JavaScript-klasssyntaxen. En TypeScript-klass kan innehålla olika element för att definiera objektens struktur och beteende. De viktigaste komponenterna är:
- Egenskaper
- Konstruktörer
- Metoder
Egenskaper
Egenskaper bestämmer ett objekts tillstånd. De lagrar datavärden och kan förses med datatyper så att de endast har giltiga värden.
class ClassName {
propertyName: propertyType;
}- ClassName: namnet på klassen
- propertyName: namnet på den egenskap som du vill definiera
- propertyType: egenskapens datatyp
Här är ett konkret exempel:
class Person {
name: string;
}Först definieras en klass Person med en egenskap name av typ string. Detta innebär att instanser av klassen Person har en egenskap name som lagrar strängar.
Konstruktör
Konstruktorn i TypeScript är en speciell metod som anropas när en klassinstans (objekt) skapas. Du behöver den för att initialisera egenskaperna hos ett objekt. Konstruktorn definierar i huvudsak instansens initiala tillstånd. Du kan ange parametrar i konstruktorn för att överföra värden när du instansierar TypeScript-klasser.
Den grundläggande syntaxen för en konstruktör i TypeScript är:
class ClassName {
constructor(parameter1: Type1, parameter2: Type2, ...) {
}
}- konstruktör: varje klass kan ha en enda konstruktör. Om ingen konstruktör definieras skapas en tom konstruktör som standard.
- parameter: Typ: parametrar är valfria, beroende på klassen och dess krav. Parametrar bör märkas med sina datatyper.
Ett exempel på en konstruktör:
class Person {
firstName: string;
lastName: string;
constructor(firstName: string, lastName: string) {
this.firstName = firstName;
this.lastName = lastName;
}
}I exemplet ovan har klassen Person en konstruktor som accepterar två parametrar, firstName och lastName. När en instans av denna klass skapas överförs dessa parametrar, och konstruktorn initialiserar instansens egenskaper firstName och lastName med motsvarande värden. this refererar till den aktuella instansen av klassen som koden exekveras på.
Metoder
I TypeScript är metoder funktioner som kan definieras i klasser och tillämpas på deras instanser. Metoder gör det möjligt att utföra vissa åtgärder eller operationer i en klass.
class ClassName {
// ...
methodName(parameter1: Type1, parameter2: Type2, ...): ReturnType {
}
// ...
}- methodName: metodens namn
- parameter: Typ: valfria parametrar som metoden accepterar
- ReturnType: detta är datatypen som bestämmer värdet som metoden returnerar. Om metoden inte returnerar något kan du ange
void.
För att komma åt en egenskap eller anropa en metod på en klassinstans använder du punktoperatorn . följt av metodnamnet och de nödvändiga argumenten om metoden förväntar sig parametrar.
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 används för att skapa och returnera personens fullständiga namn. Den hämtar värdena för egenskaperna firstName och lastName som definieras i klassen och initialiseras i konstruktorn. Objektet person skapas med nyckelordet new följt av klassnamnet och respektive parametrar. Metoden sammanfogar de två strängarna när den anropas och returnerar det fullständiga namnet som en sträng. Utmatningen för objektet person blir därför ”John Doe”.
Exempel på TypeScript-klasser
TypeScript-klasser har olika mekanismer för att organisera och styra objektens struktur och beteende. Nedan presenterar vi några begrepp för användning av TypeScript-klasser.
Tillgång
TypeScript erbjuder tre åtkomstmodifierare: public, private och protected för att kontrollera åtkomsten till egenskaper och metoder inom och utanför klassen.
- public (standard): egenskaper och metoder markerade med
publickan anropas från var som helst, både inom och utanför klassen. - privat:
privateavser egenskaper och metoder som endast kan anropas inom själva klassen. De är otillgängliga för externa koddelar. - skyddad: egenskaper och metoder markerade med
protectedkan anropas av klassen själv och av härledda klasser (i arv), men inte av extern kod.
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 det här exemplet är socialSecurityNumber en privat egenskap som endast kan nås inom klassen Person. Du kan dock anropa metoden greet utanför klassen.
Arv
Arv är ett grundläggande begrepp inom objektorienterad programmering (OOP) som används i TypeScript och många andra programmeringsspråk för internet. Det gör det möjligt att skapa en ny klass utifrån en befintlig basklass eller superklass. Den härledda klassen (underklassen) ärver basklassens egenskaper och metoder och kan utöka eller anpassa dem.
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();Med hjälp av nyckelordet extends ärver underklassen Dog egenskaperna och metoderna från överklassen Animal. Klassen Dog överskriver metoden makeSound för att lägga till ett specifikt beteende samtidigt som den ärver egenskapen name från Animal.
Skrivskyddad
Du kan använda readonly för att deklarera egenskaper hos TypeScript-klasser eller objekt som skrivskyddade. Detta innebär att när en skrivskyddad egenskap har initialiserats kan dess värde inte längre ändras.
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,54I vårt exempel är egenskapen pi skrivskyddad och initialiseras i konstruktorn. Efter initialiseringen kan pi inte längre ändras. Om du försöker ändra värdet på pi efter initialiseringen genererar TypeScript ett kompileringsfel.