Unterstützt TypeScript den ?. Operator? (Und, wie wird er genannt?)

Question

Unterstützt Typescript derzeit (oder gibt es Pläne dafür) den sicheren Navigations Operator von ?.?

d.h.:

var thing = foo?.bar
// das Gleiche wie:
var thing = (foo) ? foo.bar : null;

Gibt es auch einen gebräuchlicheren Namen für diesen Operator (es ist unglaublich schwer, danach zu googeln).

Answer 1

Der Elvis (?.) Optional Chaining Operator wird in TypeScript 3.7 unterstützt.

Sie können es verwenden, um nach Nullwerten zu überprüfen: cats?.miows gibt null zurück, wenn cats null oder undefined ist.

Sie können es auch für optionale Methodenaufrufe verwenden: cats.doMiow?.(5) ruft doMiow auf, wenn es existiert.

Eigenschaftszugriff ist ebenfalls möglich: cats?.['miows'].

Referenz: https://devblogs.microsoft.com/typescript/announcing-typescript-3-7-beta/

Answer 2

Es ist endlich da!

Hier sind ein paar Beispiele:

// Eigenschaften
foo?.bar
foo?.bar()
foo?.bar.baz()
foo?.bar?.baz()

// Indizierung
foo?.[0]
foo?.['bar']

// Überprüfen, ob eine Funktion definiert ist, bevor sie aufgerufen wird
foo?.()
foo.bar?.()
foo?.bar?.()

Aber es funktioniert nicht genau so wie angenommen.

Statt zu evaluieren

foo?.bar

zu diesem kleinen Code-Schnipsel, den wir alle gewohnt sind zu schreiben

foo ? foo.bar : null

evaluiert es tatsächlich zu

(foo === null || foo === undefined) ?
    undefined :
    foo.bar

was für alle falschen Werte wie einen leeren String, 0 oder false funktioniert.

Ich habe einfach keine Erklärung dafür, warum sie es nicht zu foo == null compilieren.

Answer 3

Der Operator ?. wird in TypeScript Version 2.0 nicht unterstützt.

Also benutze ich die folgende Funktion:

export function o(someObject: T, defaultValue: T = {} as T) : T {
    if (typeof someObject === 'undefined' || someObject === null)
        return defaultValue;
    else
        return someObject;
}

Die Verwendung sieht so aus:

o(o(o(test).prop1).prop2

außerdem kann ein Standardwert festgelegt werden:

o(o(o(o(test).prop1).prop2, "none")

Es funktioniert sehr gut mit IntelliSense in Visual Studio.

Answer 4

Während der Arbeit an Phonetradr haben wir diese Hilfsmethode erstellt, die Ihnen mit Typescript den typsicheren Zugriff auf tiefe Eigenschaften ermöglicht:

/**
 * Typsicherer Zugriff auf eine tiefe Eigenschaft eines Objekts
 *
 * @param obj                   Objekt, von dem die tiefe Eigenschaft abgerufen werden soll
 * @param unsafeDataOperation   Funktion, die die tiefe Eigenschaft zurückgibt
 * @param valueIfFail           Wert, der zurückgegeben werden soll, falls die Eigenschaft nicht vorhanden ist
 */
export function getInSafe(obj: O, unsafeDataOperation: (x: O) => T, valueIfFail?: any) : T {
    try {
        return unsafeDataOperation(obj)
    } catch (error) {
        return valueIfFail;
    }
}

//Beispiel-Nutzung:
getInSafe(sellTicket, x => x.phoneDetails.imeiNumber, '');

//Beispiel von oben
getInSafe(foo, x => x.bar.check, null);

Answer 5

Ich empfehle normalerweise nicht diesen Ansatz (achten Sie auf Leistungsprobleme), aber Sie können den Spread-Operator verwenden, um ein Objekt oberflächlich zu klonen, auf das Sie dann zugreifen können.

 const person = { personId: 123, firstName: 'Simon' };
 const firstName = { ...person }.firstName;

Dies funktioniert, weil der Typ 'firstName' 'propagiert' wird.

Ich werde dies am häufigsten verwenden, wenn ich einen find(...) Ausdruck habe, der null zurückgeben kann und ich ein einzelnes Attribut davon benötige:

 // dies würde einen Fehler verursachen (diese ID existiert nicht)
 const people = [person];
 const firstName2 = people.find(p => p.personId == 999).firstName;

 // dies funktioniert - kopiert jedoch alle Eigenschaften, was Leistungsprobleme hervorruft
 const firstName3 = { ...people.find(p => p.personId == 999) }.firstName;

Es kann einige Grenzfälle mit der Art und Weise geben, wie TypeScript Typen ableitet und das nicht kompiliert wird, aber das sollte normalerweise funktionieren.