Есть ли выделенная функция для проверки нулевого и неопределенного в TypeScript?

Используя проверку жонглирования, вы можете проверить как null, так и undefined одним нажатием:

if (x == null) {

Если вы используете строгую проверку, это будет верно только для значений, установленных в null и не будет оцениваться как истина для переменных undefined:

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 undefined"

"b == null"

"b === null"

if( value ) {
}

будет оцениваться как true если value не указано:

• null
• undefined
• NaN
• пустая строка ''
• 0
• false

машинописный текст включает в себя правила javascript.

Я провел различные тесты на игровой площадке typescript:

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

так:

• проверка, если (a == null) правильно знать, является ли a null или undefined
• проверка, если (a!= null) правильно знать, определено ли a
• проверка того, что (а) неправильно знать, определено ли значение

Есть ли у TypeScript выделенная функция или синтаксический сахар для этого

Нет. Я просто делаю something == null так же, как JavaScript.

if(data){}

это значение! data​​p >

• NULL
• undefined
• ложь
• ....

Поскольку я использую угловые и угловые на основе машинописных текстов, я перечислю возможные сценарии для проверки типа, нулевого, пустого и неопределенного.

Это то, что я знаю

1. if(!something)//to check null, undefined, false or empty
2. if(something == null)//to check null or undefined
3. if(something === null)//to check only if null

Кроме того, есть официальная документация, которую вы можете использовать для получения более подробной информации.

TL; DR

В JavaScript null не является фактически null object, typeof undefined не undefined но typeof null является object.

Вам также может понадобиться знать, что == в JavaScript сравнивает значение, а не тип, но === сравнивает как тип, так и значение, например 1 == '1'//return true но 1 === '1'//return false, то же самое для null и undefined например null == undefined//return true но null === undefined//return false

Надеюсь, это поможет кому-то.

Вы можете попробовать

if(!!someValue)

с !! ,

объяснение

Первый ! превратит ваше выражение в boolean значение.

Тогда !someValue true если someValue является ложным и false если someValue является правдивым. Это может показаться странным.

Добавив еще один ! , выражение теперь true если someValue является правдивым и false если someValue является ложным, что намного проще в управлении.

обсуждение

Теперь, зачем мне беспокоиться, if (!!someValue) когда что-то вроде if (someValue) даст мне тот же результат?

Потому что !!someValue - это точно логическое выражение, тогда как someValue может быть абсолютно любым. В таком выражении теперь будут записаны функции (и Бог нам нужен), например:

isSomeValueDefined(): boolean {
  return !!someValue
}

вместо:

isSomeValueDefined(): boolean {
  if(someValue) {
    return true
  }
  return false
}

Я надеюсь, что это помогает.

Если вы используете TypeScript, это лучший подход, позволяющий компилятору проверять значения null и undefineds (или их возможности), а не проверять их во время выполнения. (Если вы хотите проверить во время выполнения, то, как указано в большинстве ответов, просто используйте value == null).

Используйте параметр компиляции strictNullChecks, чтобы сообщить компилятору, чтобы он подавил возможные значения null или undefined. Если вы установите этот параметр, а затем появится ситуация, когда вы do хотите разрешить null и undefined, вы можете определить тип как Type | null | undefined.

Если вы хотите передать tslint без установки strict-boolean-expressions в allow-null-union или allow-undefined-union, вам нужно использовать модуль isNullOrUndefined от node 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 строги.

Для Typescript 2.xx вы должны сделать это следующим образом:

ТЛ; др

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 ok - we know it number
  }
}

Более быстрая и короткая запись для null проверок может быть:

value == null ? "UNDEFINED" : value

Эта строка эквивалентна:

if(value == null) {
       console.log("UNDEFINED")
} else {
    console.log(value)
}

Особенно, когда у вас много null проверки, это хорошая короткая нотация.

Поскольку TypeScript является типизированным надмножеством JavaScript ES6. И lodash - это библиотека javascript.

Использование lodash для проверки, если значение равно null или undefined, может быть выполнено с помощью _.isNil().

_.isNil(value)

аргументы

value (*): значение для проверки.

Возвращает

(boolean): Возвращает true, если значение nullish, else false.

пример

_.isNil(null);
// => true

_.isNil(void 0);
// => true

_.isNil(NaN);
// => false

Ссылка на сайт

Документы Lodash

Все,

Ответ с большинством голосов, на самом деле не работает, если вы работаете с объектом. В этом случае, если свойство отсутствует, проверка не будет работать. И это было проблемой в нашем случае: см. Этот пример:

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

вы можете использовать

if(x === undefined)

Я всегда пишу это так:

var foo:string;

if(!foo){
   foo="something";    
}

Это будет хорошо работать, и я думаю, что это очень читаемо.