Использует ли Typescript (или планирует ли он) поддерживать безопасную навигацию оператора ?.
т
var thing = foo?.bar
// same as:
var thing = (foo) ? foo.bar : null;
Кроме того, существует ли более распространенное имя для этого оператора (для него не всегда сложно использовать Google).
Я не могу найти никакой ссылки на него в TypeScript спецификация языка.
Что касается вызова этого оператора в CoffeeScript, он называется экзистенциальным оператором (в частности, "вариантом доступа" экзистенциального оператора).
Из Документация CoffeeScript для операторов:
Вариант доступа экзистенциального оператора
?.может использоваться для вставки нулевых ссылок в цепочке свойств. Используйте его вместо точки доступа.в тех случаях, когда базовое значение может быть null или undefined.
Таким образом, вариант варианта доступа экзистенциального оператора представляется правильным способом обращения к этому оператору; и 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, поэтому их реализация в будущем может быть непоколебимой. Если бы они внедрили что-то сейчас, в конечном итоге потребовались бы серьезные изменения, если бы ECMAScript переопределил их спецификацию.
См. Дополнительную спецификацию цепочки
Там, где что-то никогда не будет стандартным JavaScript, команда TypeScript может реализовать по своему усмотрению, но для будущих добавлений ECMAScript они хотят сохранить семантику, даже если они предоставляют ранний доступ, как и для многих других функций.
Таким образом, доступны все классные операторы JavaScripts, включая преобразования типов, такие как...
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'));
На github есть открытый запрос функции, где вы можете озвучить свое мнение/желание: https://github.com/Microsoft/TypeScript/issues/16
Изменить: Я обновил ответ благодаря комментарию fracz.
TypeScript 2.0 выпущен !. Это не то же самое, что ?. (безопасный навигатор на С#)
См. этот ответ для получения более подробной информации:
fooobar.com/questions/63500/...
Это говорит только компилятору, что значение не равно null или undefined. Это будет не, если значение равно null или undefined.
TypeScript Оператор ненулевого утверждения
// 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
}
Оператор ?. не поддерживается в 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")
Это работает очень хорошо с IntelliSense в Visual Studio.
Мы создали этот метод util при работе над Phonetradr, который может предоставить вам безопасный доступ к глубоким свойствам с помощью Typescript:
/**
* 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);Обычно я не рекомендую этот подход (следите за проблемами производительности), но вы можете использовать оператор распространения для поверхностного клонирования объекта, к которому затем можно получить доступ к свойству.
const person = { personId: 123, firstName: 'Simon' };
const firstName = { ...person }.firstName;
Это работает, потому что тип 'firstName' распространяется через.
Я буду использовать это чаще всего, когда у меня есть выражение find(...) которое может возвратить ноль, и мне нужно одно свойство из него:
// 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 3.7.
Вы можете использовать его для проверки на нулевые значения: cats?.miows возвращает ноль, если кошки нулевые или неопределенные.
Вы также можете использовать его для необязательного вызова метода: cats.doMiow?(5) вызовет doMiow, если он существует.
Ссылка: https://devblogs.microsoft.com/typescript/announcing-typescript-3-7-beta/
Как уже было сказано ранее, в настоящее время он все еще рассматривается, но уже несколько лет находится в воде.
Основываясь на существующих ответах, вот самая краткая версия руководства, которую я могу придумать:
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'
Это просто молча терпит неудачу при пропущенных ошибках свойства. Он использует стандартный синтаксис для определения значения по умолчанию, который также может быть полностью опущен.
Хотя это работает для простых случаев, если вам нужны более сложные вещи, такие как вызов функции и последующий доступ к свойству результата, то все другие ошибки также проглатываются. Плохой дизайн.
В вышеприведенном случае оптимизированная версия другого ответа, размещенного здесь, является лучшим вариантом:
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 г.), но поскольку "оператор безопасной навигации" теперь находится на этапе 3, он реализован в TypeScript.
Следите за обновлениями:
https://github.com/microsoft/TypeScript/issues/16
Несколько движков имеют ранние реализации:
ОАО: 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 нам нужен настоящий оператор Элвиса!
В версии 2.9 поддерживается! https://github.com/Microsoft/TypeScript/wiki/What%27s-new-in-TypeScript#non-null-assertion-operator
const a = {}
console.log(a!.b!.c)
Никаких дополнительных опций в .tsconfig не требуется