Typescriptは現在（または予定されています）の安全なナビゲーション演算子をサポートしていますか？?.

つまり：

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

また、この演算子にはより一般的な名前があります（グーグルで検索するのは難しいためです）。

更新：TypeScript 3.7以降でサポートされ、オプションチェーンと呼ばれます：https : //www.typescriptlang.org/docs/handbook/release-notes/typescript-3-7.html#optional-chaining

TypeScript言語仕様では、それへの参照をまったく見つけることができません。

CoffeeScriptでこの演算子を何と呼ぶか​​については、存在演算子（具体的には、存在演算子の「アクセサーバリアント」）と呼ばれます。

オペレーターに関するCoffeeScriptのドキュメントから：

存在演算子のアクセサーバリアントを?.使用して、一連のプロパティでnull参照を吸収できます。.ベース値がnullまたは未定義の可能性がある場合は、ドットアクセサーの代わりに使用します。

したがって、存在演算子のアクセサーバリアントは、この演算子を参照する適切な方法のようです。TypeScriptは現在それをサポートしていないようです（ただし、他の人がこの機能への要望を表明しています）。

シングルほどではありませんが、機能します。

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

&&はいくつでも使用できます。

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

これはECMAScriptのオプションチェーン仕様で定義されているため、これについて説明するときには、オプションチェーンを参照する必要があります。ありそうな実装：

const result = a?.b?.c;

TypeScriptチームは、ECMAScript仕様が厳格化されるのをTypeScriptチームが待っているため、その実装は将来、非破壊的なものになる可能性があります。彼らが今何かを実装した場合、ECMAScriptが仕様を再定義すると、大きな変更が必要になります。

オプションの連鎖仕様を参照

TypeScriptチームは、標準のJavaScriptになることが決してない場合、適切と思われるように実装できますが、将来のECMAScriptの追加では、他の多くの機能と同様に、早期アクセスを許可してもセマンティクスを保持したいと考えています。

ショートカット

そのため、次のような型変換を含め、JavaScriptのすべてのファンキーな演算子を使用できます...

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

手動による解決策

しかし、質問に戻ります。私がJavaScript（したがってTypeScript）で同様のことを行う方法の鈍い例がありますが、あなたが本当に望んでいる機能であるため、それが優雅であるとは絶対に示唆していません。

(foo||{}).bar;

その場合は、fooあるundefined結果であるundefinedと場合fooに定義され、名前のプロパティがあるされbarた値を持っている、結果はその値です。

私は入れJSFiddleに例を。

これは、より長い例ではかなり大ざっぱに見えます。

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

チェーン機能

仕様がまだ空いている間に短いバージョンが必要な場合は、この方法を使用することがあります。これは式を評価し、チェーンが満たされなかったり、null / undefinedになったりした場合にデフォルトを返します（!=ここでは重要です。ここでは少し前向きなジャグリングをしたいので使用しません!==）。

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'));

更新：はい、現在サポートされています！

TypeScript 3.7でリリースされたばかりです：https : //devblogs.microsoft.com/typescript/announcing-typescript-3-7/

これはオプションのチェーンと呼ばれます：https : //devblogs.microsoft.com/typescript/announcing-typescript-3-7/#optional-chaining

これを使用すると、次のようになります。

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

以下と同等です。

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

古い答え

あなたはあなたの意見/欲望を表明することができるgithubにこれについてのオープン機能リクエストがあります：https：//github.com/Microsoft/TypeScript/issues/16

2019年11月13日を編集！

2019年11月5日の時点でTypeScript 3.7が出荷され、オプションの連鎖演算子🎉🎉🍾🍾🎉!!!がサポート されるようになりました。?.

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

歴史的目的のみ：

編集：私はfraczコメントのおかげで答えを更新しました。

TypeScript 2.0がリリースさ!.れました?.（C＃のセーフナビゲーター）と同じではありません

詳細については、この回答を参照してください：

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

これは、値がnullまたは未定義ではないことをコンパイラーに通知するだけです。これは、値がnullまたは未定義であるかどうかをチェックしません。

TypeScript非nullアサーション演算子

// 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
}

Elvis（？。）オプションの連鎖演算子はTypeScript 3.7でサポートされています。

これを使用してnull値を確認できますcats?.miows。catsがnullまたは未定義の場合はnullを返します。

オプションのメソッド呼び出しにも使用できcats.doMiow?.(5)ます。存在する場合はdoMiowを呼び出します。

プロパティへのアクセスも可能ですcats?.['miows']。

リファレンス：https : //devblogs.microsoft.com/typescript/announcing-typescript-3-7-beta/

?.TypeScript バージョン2.0では演算子はサポートされていません。

だから私は次の関数を使います：

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

使用法は次のようになります。

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

さらに、デフォルト値を設定できます。

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

Visual StudioのIntelliSenseで非常にうまく機能します。

ついに登場！

以下にいくつかの例を示します。

// 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?.()

しかし、それはあなたの仮定とまったく同じようには機能しません。

評価する代わりに

foo?.bar

この小さなコードスニペットに、私たちはすべて書くことに慣れています

foo ? foo.bar : null

実際に評価する

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

これは、空の文字列、0またはfalseなどのすべての偽の値に対して機能します。

彼らがなぜそれをコンパイルしないのかについての説明はありません foo == null

Typetraでディーププロパティへのタイプセーフなアクセスを提供できるPhonetradrの作業中に、このutilメソッドを作成しました。

/**
 * 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);

このアプローチはお勧めしません（パフォーマンスの問題に注意してください）が、spreadオペレーターを使用してオブジェクトのシャロークローンを作成し、そのプロパティにアクセスできます。

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

これは、「firstName」のタイプが「伝播」されるため機能します。

find(...)nullを返すことができる式があり、そこから単一のプロパティが必要な場合、これを最も頻繁に使用します。

 // 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;

typescriptが型を推論する方法にはいくつかのエッジケースがあり、これはコンパイルされませんが、これは通常は機能するはずです。

これはオプションのチェーンと呼ばれ、Typescript 3.7に含まれています

オプションのチェーンを使用すると、nullまたは未定義に遭遇した場合に一部の式の実行をすぐに停止できるコードを作成できます

以前に答えたように、それは現在検討中ですが、数年前から水中で死んでいます。

既存の回答に基づいて、私が考えることができる最も簡潔な手動バージョンは次のとおりです。

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'

プロパティが見つからないというエラーが発生した場合は、黙って失敗します。デフォルト値を決定するための標準構文にフォールバックしますが、これも完全に省略できます。

これは単純なケースで機能しますが、関数を呼び出して結果のプロパティにアクセスするなどのより複雑なものが必要な場合は、他のエラーも同様に飲み込まれます。悪いデザイン。

上記の場合、ここに投稿された他の回答の最適化されたバージョンがより良いオプションです。

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'

より複雑な例：

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

また、別の方法でLodashのようなものを使用することもでき_.get()ます。簡潔ですが、コンパイラは使用されたプロパティの有効性を判断できません。

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

まだ（2019年9月現在）ですが、「セーフナビゲーションオペレーター」は現在ステージ3にあるため、TypeScriptで実装されています。

この問題の更新を監視します。

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

いくつかのエンジンには初期の実装があります：

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

（https://github.com/tc39/proposal-optional-chaining/issues/115#issue-475422578から）

今すぐプラグインをインストールしてサポートすることができます：

npm install --save-dev ts-optchain

tsconfig.jsonで：

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

この回答は今後6か月ほどで古くなると思いますが、うまくいけば、その間誰かを助けるでしょう。

_.get(obj, 'address.street.name')タイプがないJavaScriptに最適です。ただし、TypeScript には、実際のElvis演算子が必要です。