Unterstützt Typescript derzeit (oder gibt es Pläne) den sicheren Navigationsoperator von ??.

dh:

var thing = foo?.bar
// same as:
var thing = (foo) ? foo.bar : null;

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

Update : Es wird ab TypeScript 3.7 unterstützt und als optionale Verkettung bezeichnet : https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-7.html#optional-chaining

Ich kann in der TypeScript-Sprachspezifikation keinerlei Verweis darauf finden .

Was diesen Operator in CoffeeScript betrifft, wird er als existenzieller Operator bezeichnet (insbesondere als "Accessor-Variante" des existenziellen Operators).

Aus der CoffeeScript-Dokumentation zu Operatoren :

Die Accessor-Variante des existenziellen Operators ?.kann verwendet werden, um Nullreferenzen in einer Eigenschaftskette aufzunehmen. Verwenden Sie es anstelle des Punktzugriffs .in Fällen, in denen der Basiswert null oder undefiniert sein kann .

Die Accessor-Variante des existenziellen Operators scheint also der richtige Weg zu sein, um auf diesen Operator zu verweisen. und TypeScript scheint dies derzeit nicht zu unterstützen (obwohl andere den Wunsch nach dieser Funktionalität geäußert haben ).

Nicht so schön wie eine Single?, Aber es funktioniert:

var thing = foo && foo.bar || null;

Sie können so viele && verwenden, wie Sie möchten:

var thing = foo && foo.bar && foo.bar.check && foo.bar.check.x || null;

Dies ist in der Spezifikation für die optionale Verkettung von ECMAScript definiert. Daher sollten wir uns bei der Erörterung wahrscheinlich auf die optionale Verkettung beziehen . Voraussichtliche Umsetzung:

const result = a?.b?.c;

Das lange und kurze daran ist, dass das TypeScript-Team darauf wartet, dass die ECMAScript-Spezifikation verschärft wird, damit ihre Implementierung in Zukunft nicht mehr unterbrochen werden kann. Wenn sie jetzt etwas implementieren würden, müssten größere Änderungen vorgenommen werden, wenn ECMAScript ihre Spezifikation neu definiert.

Siehe Optionale Verkettungsspezifikation

Wenn etwas niemals Standard-JavaScript sein wird, kann das TypeScript-Team es nach eigenem Ermessen implementieren. Für zukünftige ECMAScript-Ergänzungen möchten sie jedoch die Semantik beibehalten, auch wenn sie wie bei so vielen anderen Funktionen frühzeitig darauf zugreifen.

Abkürzungen

So sind alle funky JavaScripts-Operatoren verfügbar, einschließlich der Typkonvertierungen wie ...

var n: number = +myString; // convert to number
var b: bool = !!myString; // convert to bool

Manuelle Lösung

Aber zurück zur Frage. Ich habe ein stumpfes Beispiel dafür, wie Sie in JavaScript (und damit in TypeScript) etwas Ähnliches tun können, obwohl ich definitiv nicht vorschlage, dass es eine anmutige Funktion ist, nach der Sie wirklich suchen.

(foo||{}).bar;

Wenn fooalso undefineddas Ergebnis ist undefinedund wenn foodefiniert ist und eine Eigenschaft barmit einem Wert hat, ist das Ergebnis dieser Wert.

Ich habe ein Beispiel für JSFiddle gegeben .

Dies sieht für längere Beispiele recht lückenhaft aus.

var postCode = ((person||{}).address||{}).postcode;

Kettenfunktion

Wenn Sie verzweifelt nach einer kürzeren Version suchen, während die Spezifikation noch in der Luft ist, verwende ich diese Methode in einigen Fällen. Es wertet den Ausdruck aus und gibt einen Standardwert zurück, wenn die Kette nicht erfüllt werden kann oder null / undefiniert endet (beachten Sie !=, dass dies hier wichtig ist, wir möchten es nicht verwenden, !==da wir hier ein bisschen positives Jonglieren wollen).

function chain<T>(exp: () => T, d: T) {
    try {
        let val = exp();
        if (val != null) {
            return val;
        }
    } catch { }
    return d;
}

let obj1: { a?: { b?: string }} = {
    a: {
        b: 'c'
    }
};

// 'c'
console.log(chain(() => obj1.a.b, 'Nothing'));

obj1 = {
    a: {}
};

// 'Nothing'
console.log(chain(() => obj1.a.b, 'Nothing'));

obj1 = {};

// 'Nothing'
console.log(chain(() => obj1.a.b, 'Nothing'));

obj1 = null;

// 'Nothing'
console.log(chain(() => obj1.a.b, 'Nothing'));

Update: Ja, es wird jetzt unterstützt!

Es wurde gerade mit TypeScript 3.7 veröffentlicht: https://devblogs.microsoft.com/typescript/announcing-typescript-3-7/

Es wird als optionale Verkettung bezeichnet : https://devblogs.microsoft.com/typescript/announcing-typescript-3-7/#optional-chaining

Damit folgendes:

let x = foo?.bar.baz(); 

ist äquivalent zu:

let x = (foo === null || foo === undefined) ?
    undefined :
    foo.bar.baz();

Alte Antwort

Auf github gibt es hierfür eine offene Funktionsanforderung, in der Sie Ihre Meinung / Ihren Wunsch äußern können: https://github.com/Microsoft/TypeScript/issues/16

Bearbeiten 13. November 2019!

Ab dem 5. November 2019 wurde TypeScript 3.7 ausgeliefert und unterstützt jetzt ?. den optionalen Verkettungsoperator 🎉🎉🍾🍾🎉 !!!

https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-7.html#optional-chaining

Nur für historische Zwecke:

Bearbeiten: Ich habe die Antwort dank fracz Kommentar aktualisiert.

TypeScript 2.0 veröffentlicht !.Es ist nicht dasselbe wie ?.(Safe Navigator in C #)

Siehe diese Antwort für weitere Details:

https://stackoverflow.com/a/38875179/1057052

Dies teilt dem Compiler nur mit, dass der Wert nicht null oder undefiniert ist. Das wird nicht überprüft, ob der Wert null oder undefiniert ist.

TypeScript Nicht-Null-Assertionsoperator

// Compiled with --strictNullChecks
function validateEntity(e?: Entity) {
    // Throw exception if e is null or invalid entity
}

function processEntity(e?: Entity) {
    validateEntity(e);
    let s = e!.name;  // Assert that e is non-null and access name
}

Der optionale Verkettungsoperator Elvis (?.) Wird in TypeScript 3.7 unterstützt.

Sie können damit nach Nullwerten suchen: cats?.miows Gibt null zurück, wenn Katzen null oder undefiniert sind.

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

Der Zugang zu Immobilien ist ebenfalls möglich : cats?.['miows'].

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

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

Also benutze ich folgende Funktion:

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

Die Verwendung sieht folgendermaßen aus:

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

Außerdem können Sie einen Standardwert festlegen:

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

Es funktioniert sehr gut mit IntelliSense in Visual Studio.

Es ist endlich da!

Hier einige Beispiele:

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

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

// check if a function is defined before invoking
foo?.()
foo.bar?.()
foo?.bar?.()

Aber es funktioniert nicht genau so wie Ihre Annahme.

Anstatt zu bewerten

foo?.bar

An dieses kleine Code-Snippet sind wir alle gewöhnt zu schreiben

foo ? foo.bar : null

es wertet tatsächlich aus

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

Dies funktioniert für alle Falsey-Werte wie eine leere Zeichenfolge, 0 oder false.

Ich habe nur keine Erklärung dafür, warum sie es nicht kompilieren foo == null

Wir haben diese util-Methode während der Arbeit an Phonetradr erstellt, mit der Sie mit Typescript typsicher auf tiefe Eigenschaften zugreifen können:

/**
 * Type-safe access of deep property of an object
 *
 * @param obj                   Object to get deep property
 * @param unsafeDataOperation   Function that returns the deep property
 * @param valueIfFail           Value to return in case if there is no such property
 */
export function getInSafe<O,T>(obj: O, unsafeDataOperation: (x: O) => T, valueIfFail?: any) : T {
    try {
        return unsafeDataOperation(obj)
    } catch (error) {
        return valueIfFail;
    }
}

//Example usage:
getInSafe(sellTicket, x => x.phoneDetails.imeiNumber, '');

//Example from above
getInSafe(foo, x => x.bar.check, null);

Ich empfehle diesen Ansatz im Allgemeinen nicht (achten Sie auf Leistungsprobleme), aber Sie können den Spread-Operator verwenden, um ein Objekt flach zu klonen, auf das Sie dann auf die Eigenschaft zugreifen können.

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

Dies funktioniert, weil der Typ von 'Vorname' durch 'weitergegeben' wird.

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

 // this would cause an error (this ID doesn't exist)
 const people = [person];
 const firstName2 = people.find(p => p.personId == 999).firstName;

 // this works - but copies every property over so raises performance concerns
 const firstName3 = { ...people.find(p => p.personId == 999) }.firstName;

Es kann einige Randfälle mit der Art und Weise geben, wie Typoskript Typen ableitet, und dies wird nicht kompiliert, aber dies sollte im Allgemeinen funktionieren.

Es heißt optionale Verkettung und ist in Typescript 3.7

Durch die optionale Verkettung können wir Code schreiben, mit dem wir die Ausführung einiger Ausdrücke sofort beenden können, wenn wir auf null oder undefiniert stoßen

Wie bereits erwähnt, wird derzeit noch darüber nachgedacht, aber es ist bereits seit einigen Jahren tot im Wasser .

Aufbauend auf den vorhandenen Antworten ist hier die prägnanteste manuelle Version, die ich mir vorstellen kann:

jsfiddle

function val<T>(valueSupplier: () => T): T {
  try { return valueSupplier(); } catch (err) { return undefined; }
}

let obj1: { a?: { b?: string }} = { a: { b: 'c' } };
console.log(val(() => obj1.a.b)); // 'c'

obj1 = { a: {} };
console.log(val(() => obj1.a.b)); // undefined
console.log(val(() => obj1.a.b) || 'Nothing'); // 'Nothing'

obj1 = {};
console.log(val(() => obj1.a.b) || 'Nothing'); // 'Nothing'

obj1 = null;
console.log(val(() => obj1.a.b) || 'Nothing'); // 'Nothing'

Bei fehlenden Eigenschaftsfehlern schlägt dies einfach stillschweigend fehl. Es wird auf die Standardsyntax zur Bestimmung des Standardwerts zurückgegriffen, die ebenfalls vollständig weggelassen werden kann.

Obwohl dies in einfachen Fällen funktioniert, werden auch andere Fehler verschluckt, wenn Sie komplexere Dinge wie das Aufrufen einer Funktion und den Zugriff auf eine Eigenschaft für das Ergebnis benötigen. Schlechtes Design.

Im obigen Fall ist eine optimierte Version der anderen hier veröffentlichten Antwort die bessere Option:

jsfiddle

function o<T>(obj?: T, def: T = {} as T): T {
    return obj || def;
}

let obj1: { a?: { b?: string }} = { a: { b: 'c' } };
console.log(o(o(o(obj1).a)).b); // 'c'

obj1 = { a: {} };
console.log(o(o(o(obj1).a)).b); // undefined
console.log(o(o(o(obj1).a)).b || 'Nothing'); // 'Nothing'

obj1 = {};
console.log(o(o(o(obj1).a)).b || 'Nothing'); // 'Nothing'

obj1 = null;
console.log(o(o(o(obj1).a)).b || 'Nothing'); // 'Nothing'

Ein komplexeres Beispiel:

o(foo(), []).map((n) => n.id)

Sie können auch in die andere Richtung gehen und so etwas wie Lodash 'verwenden _.get(). Es ist kurz, aber der Compiler kann die Gültigkeit der verwendeten Eigenschaften nicht beurteilen:

console.log(_.get(obj1, 'a.b.c'));

Noch nicht (Stand September 2019), aber da sich der "Operator für sichere Navigation" jetzt in Phase 3 befindet , wird er in TypeScript implementiert.

In dieser Ausgabe finden Sie Updates:

https://github.com/microsoft/TypeScript/issues/16

Einige Motoren haben frühe Implementierungen:

JSC: https://bugs.webkit.org/show_bug.cgi?id=200199

V8: https://bugs.chromium.org/p/v8/issues/detail?id=9553

SM: https://bugzilla.mozilla.org/show_bug.cgi?id=1566143

(über https://github.com/tc39/proposal-optional-chaining/issues/115#issue-475422578 )

Sie können jetzt ein Plugin installieren, um es zu unterstützen:

npm install --save-dev ts-optchain

In Ihrer tsconfig.json:

// tsconfig.json
{
    "compilerOptions": {
        "plugins": [
            { "transform": "ts-optchain/transform" },
        ]
    },
}

Ich gehe davon aus, dass diese Antwort in den nächsten 6 Monaten veraltet sein wird, aber hoffentlich hilft sie in der Zwischenzeit jemandem.

_.get(obj, 'address.street.name')funktioniert hervorragend für JavaScript, wo Sie keine Typen haben. Aber für TypeScript brauchen wir den echten Elvis-Operator!