Так машинопис сильно типізованих, просто використовуючи if () {}
для перевірки null
і undefined
не звучить.
Чи має TypeScript для цього якусь виділену функцію або синтаксичний цукор?
Так машинопис сильно типізованих, просто використовуючи if () {}
для перевірки null
і undefined
не звучить.
Чи має TypeScript для цього якусь виділену функцію або синтаксичний цукор?
Відповіді:
Використовуючи перевірку жонглювання, ви можете протестувати як null
і undefined
одним ударом:
if (x == null) {
Якщо ви використовуєте строгу перевірку, вона буде істинною лише для встановлених значень null
і не буде оцінюватися як істинна для невизначених змінних:
if (x === null) {
Ви можете спробувати це з різними значеннями, використовуючи цей приклад:
var a: number;
var b: number = null;
function check(x, name) {
if (x == null) {
console.log(name + ' == null');
}
if (x === null) {
console.log(name + ' === null');
}
if (typeof x === 'undefined') {
console.log(name + ' is undefined');
}
}
check(a, 'a');
check(b, 'b');
Вихідні дані
"a == null"
"a не визначено"
"b == null"
"b === null"
"false" == false
не порожня рядок типу "false" оцінюється до true
.
if(x)
стилю truthy / falsey , але ні if(x == null)
, що тільки ловить null
і undefined
. Перевірте, використовуючи var c: number = 0; check(c, 'b');
його не "нульовим" null
, або undefined
.
if( value ) {
}
оцінюємо, true
якщо value
ні:
null
undefined
NaN
''
0
false
машинопис включає правила javascript.
Чи має TypeScript для цього виділений функцію або синтаксичний цукор
TypeScript повністю розуміє версію JavaScript, яка є something == null
.
TypeScript правильно виключає і null
та, іundefined
такі перевірки.
myVar == null
. Просто ще один варіант.
== null
це правильний спосіб тестування на null & undefined. !!something
є марною примусовою умовою в JS (просто використання something
). !!something
буде також примушувати 0 та "" до false, що не є тим, що ви хочете робити, якщо шукаєте null / undefined.
Я робив різні тести на майданчику машинопису:
http://www.typescriptlang.org/play/
let a;
let b = null;
let c = "";
var output = "";
if (a == null) output += "a is null or undefined\n";
if (b == null) output += "b is null or undefined\n";
if (c == null) output += "c is null or undefined\n";
if (a != null) output += "a is defined\n";
if (b != null) output += "b is defined\n";
if (c != null) output += "c is defined\n";
if (a) output += "a is defined (2nd method)\n";
if (b) output += "b is defined (2nd method)\n";
if (c) output += "c is defined (2nd method)\n";
console.log(output);
дає:
a is null or undefined
b is null or undefined
c is defined
тому:
Я думаю, що ця відповідь потребує оновлення, перевірте історію редагування на стару відповідь.
В основному, у вас є три випадкові випадки: нульові, невизначені та незадекларовані, див. Фрагмент нижче.
// bad-file.ts
console.log(message)
Ви отримаєте помилку, говорить про те, що змінна message
не визначена (вона також недекларована), звичайно, компілятор Typescript не повинен дозволяти вам це робити, але НАДАЛЬНО нічого не може вам завадити.
// evil-file.ts
// @ts-gnore
console.log(message)
Компілятор буде радий просто скласти код вище. Отже, якщо ви впевнені, що всі змінні оголошені, ви можете просто зробити це
if ( message != null ) {
// do something with the message
}
Наведений вище код перевірятиме null
і undefined
, АЛЕ в разі message
змінні може бути неоголошеним (для безпеки), ви можете розглянути наступний код
if ( typeof(message) !== 'undefined' && message !== null ) {
// message variable is more than safe to be used.
}
Примітка: порядок тут typeof(message) !== 'undefined' && message !== null
дуже важливий, ви повинні спочатку перевірити його undefined
стан, він буде точно таким же, як message != null
, дякую @Jaider.
if(typeof something !== 'undefined' && something !== null){...}
Зараз у TypeScript 3.7 у нас є необов'язкове ланцюжок і Nullish Coalescing, щоб перевірити нульові та невизначені одночасно, наприклад:
let x = foo?.bar.baz();
цей код перевірить, чи визначено foo, інакше він повернеться невизначеним
старий спосіб :
if(foo != null && foo != undefined) {
x = foo.bar.baz();
}
це:
let x = (foo === null || foo === undefined) ? undefined : foo.bar();
if (foo && foo.bar && foo.bar.baz) { // ... }
З необов'язковим ланцюжком буде:
let x = foo?.bar();
if (foo?.bar?.baz) { // ... }
Ще одна нова особливість - Nullish Coalescing , наприклад:
let x = foo ?? bar(); // return foo if it's not null or undefined otherwise calculate bar
старий спосіб:
let x = (foo !== null && foo !== undefined) ?
foo :
bar();
Ви можете спробувати
if(!!someValue)
з !!
.
Пояснення
Перший !
перетворить ваше вираження в аboolean
значення.
Тоді !someValue
як , true
якщо someValue
це falsy і false
якщо someValue
це truthy . Це може заплутати.
Додавши ще одне !
, вираз тепер є, true
якщо someValue
є неправдоподібним, а false
якщо someValue
- хибним , що керувати набагато простіше.
Обговорення
Тепер, чому я морочу себе, if (!!someValue)
коли щось подібнеif (someValue)
дало б мені такий же результат?
Тому що !!someValue
саме булевий вираз, тоді як someValue
може бути абсолютно все. Цей вираз тепер дозволить записати функції (а Бог нам це потрібен), наприклад:
isSomeValueDefined(): boolean {
return !!someValue
}
замість:
isSomeValueDefined(): boolean {
if(someValue) {
return true
}
return false
}
Я сподіваюся, що це допомагає.
!!'false'
є у справі, true
тому що 'false'
це дійсна рядок
Для цього Typescript 2.x.x
слід це зробити наступним чином (використовуючи типові гвардії ):
тл; д-р
function isDefined<T>(value: T | undefined | null): value is T {
return <T>value !== undefined && <T>value !== null;
}
Чому?
Таким чином isDefined()
буде враховано тип змінної, і наступний код міг би врахувати цю перевірку.
Приклад 1 - основна перевірка:
function getFoo(foo: string): void {
//
}
function getBar(bar: string| undefined) {
getFoo(bar); //ERROR: "bar" can be undefined
if (isDefined(bar)) {
getFoo(bar); // Ok now, typescript knows that "bar' is defined
}
}
Приклад 2 - відношення типів:
function getFoo(foo: string): void {
//
}
function getBar(bar: number | undefined) {
getFoo(bar); // ERROR: "number | undefined" is not assignable to "string"
if (isDefined(bar)) {
getFoo(bar); // ERROR: "number" is not assignable to "string", but it's ok - we know it's number
}
}
if(data){}
це означає! дані
true
абоfalse
тільки. Якщо у вас є булева з null
присвоєнням або undefined
значенням, в обох випадках значення буде оцінено як false
.
Якщо ви використовуєте TypeScript, то краще підходити дозволити компілятору перевірити наявність нулів та невизначених значень (або можливості цього), а не перевіряти їх під час виконання. (Якщо ви хочете перевірити під час виконання, то скільки відповідей вказує, просто використовуйте value == null
).
Використовуйте параметр компіляції, strictNullChecks
щоб сказати компілятору задушитись можливими нульовими або невизначеними значеннями. Якщо ви встановите цей параметр, а потім виникає ситуація , коли ви дійсно хочете , щоб нуль і невизначеним, ви можете визначити тип , як Type | null | undefined
.
Якщо ви хочете пройти tslint
без встановлення strict-boolean-expressions
на allow-null-union
абоallow-undefined-union
, вам потрібно використовувати isNullOrUndefined
від node
«s util
модуля або згорнути свій власний:
// tslint:disable:no-null-keyword
export const isNullOrUndefined =
<T>(obj: T | null | undefined): obj is null | undefined => {
return typeof obj === "undefined" || obj === null;
};
// tslint:enable:no-null-keyword
Не зовсім синтаксичний цукор, але корисний, коли ваші правила tslint суворі.
Швидше і коротше позначення null
чеків може бути:
value == null ? "UNDEFINED" : value
Цей рядок еквівалентний:
if(value == null) {
console.log("UNDEFINED")
} else {
console.log(value)
}
Особливо, коли ви багато null
перевіряєте, це приємна коротка нотатка.
У мене було це питання, і деякі відповіді працюють просто чудово, JS
але не для TS
цього є причина.
//JS
let couldBeNullOrUndefined;
if(couldBeNullOrUndefined == null) {
console.log('null OR undefined', couldBeNullOrUndefined);
} else {
console.log('Has some value', couldBeNullOrUndefined);
}
Це все добре, оскільки JS не має типів
//TS
let couldBeNullOrUndefined?: string | null; // THIS NEEDS TO BE TYPED AS undefined || null || Type(string)
if(couldBeNullOrUndefined === null) { // TS should always use strict-check
console.log('null OR undefined', couldBeNullOrUndefined);
} else {
console.log('Has some value', couldBeNullOrUndefined);
}
У TS, якщо змінна не була визначена з, null
коли ви намагаєтеся перевірити, чи null
є tslint
| компілятор поскаржиться.
//tslint.json
...
"triple-equals":[true],
...
let couldBeNullOrUndefined?: string; // to fix it add | null
Types of property 'couldBeNullOrUndefined' are incompatible.
Type 'string | null' is not assignable to type 'string | undefined'.
Type 'null' is not assignable to type 'string | undefined'.
Пізно приєднуватися до цього потоку, але я вважаю цей злом JavaScript дуже зручним для перевірки, чи значення не визначене
if(typeof(something) === 'undefined'){
// Yes this is undefined
}
Як багатослівним чином, якщо ви хочете порівняти нульові і невизначені значення ТІЛЬКИ , використовуйте наступний приклад коду для довідки:
const incomingValue : string = undefined;
const somethingToCompare : string = incomingValue; // If the line above is not declared, TypeScript will return an excepion
if (somethingToCompare == (undefined || null)) {
console.log(`Incoming value is: ${somethingToCompare}`);
}
Якщо incomingValue
це не оголошено, TypeScript повинен повернути виняток. Якщо це оголошено, але не визначено, тоconsole.log()
то повернеться "Вхідне значення: невизначене". Зверніть увагу, що ми не використовуємо оператор строгої рівності.
"Правильний" спосіб (перевірте інші відповіді на деталі), якщо incomingValue
це не boolean
тип, просто оцініть, чи є його значенням правдивим, це буде оцінено відповідно до типу "постійний / змінний". true
Рядок повинен бути визначена в явному вигляді рядка з використанням = ''
асигнування. Якщо ні, це буде оцінено як false
. Давайте перевіримо цей випадок, використовуючи той самий контекст:
const incomingValue : string = undefined;
const somethingToCompare0 : string = 'Trumpet';
const somethingToCompare1 : string = incomingValue;
if (somethingToCompare0) {
console.log(`somethingToCompare0 is: ${somethingToCompare0}`); // Will return "somethingToCompare0 is: Trumpet"
}
// Now, we will evaluate the second constant
if (somethingToCompare1) {
console.log(`somethingToCompare1 is: ${somethingToCompare1}`); // Launched if incomingValue is defined
} else {
console.log(`somethingToCompare1 is: ${somethingToCompare1}`); // Launched if incomingValue is undefined. Will return "somethingToCompare1 is: undefined"
}
ви можете використовувати
if(x === undefined)
Усі,
Відповідь з найбільшою кількістю голосів, насправді не працює, якщо ви працюєте з об’єктом. У такому випадку, якщо властивості немає, перевірка не працюватиме. І це було проблемою в нашому випадку: дивіться цей зразок:
var x =
{ name: "Homer", LastName: "Simpson" };
var y =
{ name: "Marge"} ;
var z =
{ name: "Bart" , LastName: undefined} ;
var a =
{ name: "Lisa" , LastName: ""} ;
var hasLastNameX = x.LastName != null;
var hasLastNameY = y.LastName != null;
var hasLastNameZ = z.LastName != null;
var hasLastNameA = a.LastName != null;
alert (hasLastNameX + ' ' + hasLastNameY + ' ' + hasLastNameZ + ' ' + hasLastNameA);
var hasLastNameXX = x.LastName !== null;
var hasLastNameYY = y.LastName !== null;
var hasLastNameZZ = z.LastName !== null;
var hasLastNameAA = a.LastName !== null;
alert (hasLastNameXX + ' ' + hasLastNameYY + ' ' + hasLastNameZZ + ' ' + hasLastNameAA);
Результат:
true , false, false , true (in case of !=)
true , true, true, true (in case of !==) => so in this sample not the correct answer
посилання на plunkr: https://plnkr.co/edit/BJpVHD95FhKlpHp1skUE
null
. Спробуйте це: plnkr.co/edit/NfiVnQNes1p8PvXd1fCG?p=preview
Оскільки TypeScript - це набір суперсети JavaScript ES6. І lodash - це бібліотека javascript.
Використання lodash для перевірки того, що значення є нульовим або невизначеним, можна зробити за допомогою _.isNil()
.
_.isNil(value)
значення (*): значення для перевірки.
(boolean) : Повертає true, якщо значення є нульовим, else false.
_.isNil(null);
// => true
_.isNil(void 0);
// => true
_.isNil(NaN);
// => false
будьте обережні, якщо ви використовуєте локальне сховище, ви можете вказувати рядок не визначений, а не значення undefined:
localStorage.setItem('mykey',JSON.stringify(undefined));
localStorage.getItem('mykey') === "undefined"
true
Люди можуть вважати це корисним: https://github.com/angular/components/blob/master/src/cdk/coercion/boolean-property.spec.ts
/**
* @license
* Copyright Google LLC All Rights Reserved.
*
* Use of this source code is governed by an MIT-style license that can be
* found in the LICENSE file at https://angular.io/license
*/
/** Coerces a data-bound value (typically a string) to a boolean. */
export function coerceBooleanProperty(value: any): boolean {
return value != null && `${value}` !== 'false';
}
import {coerceBooleanProperty} from './boolean-property';
describe('coerceBooleanProperty', () => {
it('should coerce undefined to false', () => {
expect(coerceBooleanProperty(undefined)).toBe(false);
});
it('should coerce null to false', () => {
expect(coerceBooleanProperty(null)).toBe(false);
});
it('should coerce the empty string to true', () => {
expect(coerceBooleanProperty('')).toBe(true);
});
it('should coerce zero to true', () => {
expect(coerceBooleanProperty(0)).toBe(true);
});
it('should coerce the string "false" to false', () => {
expect(coerceBooleanProperty('false')).toBe(false);
});
it('should coerce the boolean false to false', () => {
expect(coerceBooleanProperty(false)).toBe(false);
});
it('should coerce the boolean true to true', () => {
expect(coerceBooleanProperty(true)).toBe(true);
});
it('should coerce the string "true" to true', () => {
expect(coerceBooleanProperty('true')).toBe(true);
});
it('should coerce an arbitrary string to true', () => {
expect(coerceBooleanProperty('pink')).toBe(true);
});
it('should coerce an object to true', () => {
expect(coerceBooleanProperty({})).toBe(true);
});
it('should coerce an array to true', () => {
expect(coerceBooleanProperty([])).toBe(true);
});
});
Я завжди пишу це так:
var foo:string;
if(!foo){
foo="something";
}
Це буде добре працювати, і я думаю, це дуже читабельно.
0
також проходить !foo
тест.
undefined
інакше, ніж false
. Це дуже часто зустрічається з додатковими булевими параметрами функції, де слід використовувати загальний підхід JavaScript:function fn(flag?: boolean) { if (typeof flag === "undefined") flag = true; /* set default value */ }
var isTrue; if(isTrue)//skips, if(!isTrue)// enters if(isTrue === undefined)//enters
. Також спробував це в машинописному тексті, з var isTrue:boolean
яким не було визначено, і те саме, якщо перевіряється. @Gingi, чи є щось інше в тому, що ти спробував і що я спробував?
Since TypeScript is strongly-typed
Я не міг знайти це у своїх документах, і я маю сумніви з цього приводу ...