Detaillierte Erklärung von as, Fragezeichen und Ausrufezeichen in Typescript

1. Das Schlüsselwort as gibt eine Behauptung an

In Typescript gibt es zwei Möglichkeiten, Behauptungen auszudrücken. Eine davon ist die Erweiterungsnotation:

let someValue: any = "Dies ist eine Zeichenfolge";
let strLength: Zahl = (einWert).Länge;

Eine andere Möglichkeit besteht darin, das Schlüsselwort as zu verwenden:

let someValue: any = "Dies ist eine Zeichenfolge";
let strLength: Zahl = (ein Wert als Zeichenfolge).Länge;

2. Fragezeichen (?) wird zur Attributdefinition verwendet

Fragezeichen kennzeichnen optionale Eigenschaften und werden im Allgemeinen in Eigenschaftsdefinitionen verwendet, beispielsweise bei der Verwendung in Schnittstellen:

Schnittstelle SquareConfig {
    Farbe?: Zeichenfolge;
    Breite?: Zahl;
}
Funktion erstelleQuadrat(Konfiguration: SquareConfig) {
    if (Konfigurationsfarbe) {
        konsole.log(konfiguration);
    }
}

Die Bedeutung eines optionalen Attributs ist: Bei Verwendung dieses Attributs existiert entweder der Attributname nicht oder er muss der Attributtypdefinition entsprechen.

Beispielsweise meldet die obige Funktion createSquare beim Kompilieren einen Fehler:

Fehler TS2551: Eigenschaft „clor“ existiert im Typ „SquareConfig“ nicht.

Was passiert, wenn Sie createSquare ändern und den Wert von config.color auf „undefined“ ändern?

Schnittstelle SquareConfig {
    Farbe?: Zeichenfolge;
    Breite?: Zahl;
}
Funktion erstelleQuadrat(Konfiguration: SquareConfig) {
    config.color = undefiniert;
    if (Konfigurationsfarbe) {
        konsole.log(konfiguration);
    }
}

Es liegt derzeit kein Kompilierungsfehler vor! config.color ist eindeutig als Zeichenfolgentyp definiert?

Auch wenn Sie zum Kompilieren –strictNullChecks hinzufügen, wird kein Fehler gemeldet. Es ist ersichtlich, dass der durch das optionale Attribut definierte Typ von TypeScript nicht streng behandelt wird und „undefined“ standardmäßig nicht aktiviert ist. Es ist zu beachten, dass, wenn das obige „undefined“ in „null“ geändert wird, bei der normalen Kompilierung kein Fehler gemeldet wird, bei der „–strictNullChecks“-Kompilierung jedoch der folgende Fehler gemeldet wird:

Fehler TS2322: Typ „null“ kann nicht dem Typ „String | undefiniert“ zugewiesen werden.

Aus diesem Fehler können wir folgende Schlussfolgerung ziehen: Ein optionales Attribut ist gleichbedeutend mit einem Union-Typ, der undefinierte Typen vereinigt; beim Kompilieren ohne –strictNullChecks kann dem undefinierten Typ null zugewiesen werden. Das heißt, die Definition von SquareConfig entspricht dem folgenden Code:

Schnittstelle SquareConfig {
    Farbe: Zeichenfolge|nicht definiert;
    Breite: Zahl|undefiniert;
}

Vergleichen wir optionale Attribute mit normalen Attributen. Ändern Sie createSquare erneut und ändern Sie das Farbattribut in ein normales Attribut.

Schnittstelle SquareConfig {
    Farbe: Zeichenfolge;
    Breite?: Zahl;
}
Funktion erstelleQuadrat(Konfiguration: SquareConfig) {
    config.color = undefiniert;
    if (Konfigurationsfarbe) {
        konsole.log(konfiguration);
    }
}

Das Kompilieren mit –strictNullChecks führt zu einem Fehler:

Fehler TS2322: Typ „undefined“ kann nicht dem Typ „String“ zugewiesen werden.

Auch dieser Vergleich bestätigt die obige Schlussfolgerung.

Das Fragezeichen (?) wird zum Lesen von Attributen verwendet

Das Fragezeichen wird zum Lesen von Attributen hauptsächlich in zwei Szenarien verwendet: eines zum Lesen von Array-Elementen (wie beispielsweise node[i] unten) und das andere zum Lesen unsicherer Typen wie any, union, optionale Typen (wie beispielsweise node[i].data) usw. Speichern Sie es, wie im folgenden Beispiel gezeigt, als index.ts:

Schnittstelle VNodeData {
    Klasse?: Zeichenfolge;
}
Schnittstelle VNode {
    sel?: Zeichenfolge;
    Daten?: VNodeData;
}
Funktionstest (Knoten: VNode []) {
    sei i = 0;
    var b = Knoten[i].data.class;
    wenn(b !== undefiniert) {
        konsole.log(1);
    }
}

Verwenden Sie tsc --strictNullChecks index.ts, Fehler:

Fehler TS2532: Objekt ist möglicherweise „undefiniert“

Im Folgenden werden die Auswirkungen der Änderung dieser Codezeile var b = node[i].data.class; nacheinander gezeigt.

1. Ändern Sie es in var b = node[i]?.data.class; und kompilieren Sie es dann. Fehler:

Objekt ist möglicherweise „undefiniert“

2. Ändern Sie es in var b = node[i]?.data?.class; und kompilieren Sie es dann. Die Kompilierung ist erfolgreich und der entsprechende Code nach der Kompilierung lautet:

Funktionstest (Knoten) {
    var _a, _b;
    var i = 0;
    var b = (_b = (_a = node[i]) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b["Klasse"];
    // var b = node[i].data.class; // Fehler wenn (b !== undefiniert) {
        konsole.log(1);
    }
}

var b = node[i]? bedeutet, dass wenn der Wert von node[i] null oder undefiniert ist, dann ist b gleich undefiniert, andernfalls ist b=node[i].

3. Ändern Sie es in var b = (node[i] as VNode).data?.class; und kompilieren Sie es dann. Die Kompilierung ist erfolgreich und der entsprechende Code nach der Kompilierung lautet:

Funktionstest (Knoten) {
    var_a;
    var i = 0;
    var b = (_a = node[i].data) === null || _a === void 0 ? void 0 : _a["Klasse"];
    // var b = Knoten[i]?.Daten?.Klasse;
    // var b = node[i].data.class; // Fehler wenn (b !== undefiniert) {
        konsole.log(1);
    }
}

Derzeit beurteilt der Typescript-Compiler bei Verwendung von node[i] nicht mehr, ob es null oder undefiniert ist. Das heißt, var b = node[i] als VNode wird direkt in var b = node[i] kompiliert.

4. Ändern Sie es in var b = node[i]!.data?.class und kompilieren Sie es dann. Die Kompilierung ist erfolgreich und der entsprechende Code nach der Kompilierung lautet:

Funktionstest (Knoten) {
    var_a;
    var i = 0;
    var b = (_a = node[i].data) === null || _a === void 0 ? void 0 : _a["Klasse"];
    // var b = (Knoten[i] als VNode).data?.class
    // var b = Knoten[i]?.Daten?.Klasse;
    // var b = node[i].data.class; // Fehler wenn (b !== undefiniert) {
        konsole.log(1);
    }
}

Es ist ersichtlich, dass die kompilierten Codes von 3 und 4 genau gleich sind und die Rolle von ! zu diesem Zeitpunkt gleichwertig ist. Allerdings wird ! nur verwendet, um Null und Undefiniert zu beurteilen; as kann verwendet werden, um den Typerkennungsbereich zu ändern (einzuengen oder zu vergrößern). Die beiden sind nur dann gleichwertig, wenn der von as gefolgte Typ ein nicht leerer Typ ist. Wie im folgenden Beispiel kann die Verwendung von as nicht in ! geändert werden.

Schnittstelle Cat {
    Aktion: Zeichenfolge;
}
Schnittstelle Hund {
    Aktion: Zeichenfolge;
}
Typ Tier = Katze | Hund;
let action:Tier = {} als Katze;

abschließend

1. Da und ! zum Lesen von Attributen verwendet werden, können beide den Umfang der Typprüfung einschränken und sind gleichwertig, wenn sie zur Nullerkennung verwendet werden. Es ist nur so, dass ! speziell verwendet wird, um dem Compiler mitzuteilen, dass dieser Wert kein Nullwert (null und undefiniert) sein kann, während as nicht darauf beschränkt ist.

2. ? kann zum Definieren und Lesen von Eigenschaften verwendet werden. Beim Lesen teilt es dem Compiler mit, dass dieser Wert null (null und undefiniert) sein kann und beurteilt werden muss.

Dies ist das Ende dieses Artikels mit der detaillierten Erklärung von as, Fragezeichen und Ausrufezeichen in Typescript. Weitere relevante Inhalte zu as, Fragezeichen und Ausrufezeichen in Typescript finden Sie in früheren Artikeln auf 123WORDPRESS.COM oder durchsuchen Sie die verwandten Artikel weiter unten. Ich hoffe, dass jeder 123WORDPRESS.COM in Zukunft unterstützen wird!