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

TypeScript полностью понимает версию JavaScript something == null.

TypeScript правильно исключит как null, так и undefined с помощью таких проверок.

Более

https://basarat.gitbook.io/typescript/recap/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

so:

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

Я думаю, что этот ответ нуждается в обновлении, проверьте историю изменений для старого ответа.

По сути, у вас есть три различных случая: null, undefined и undeclared, см. Фрагмент ниже.

// 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(!!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 2.x.x вы должны сделать это следующим образом (используя введите охранник):

tl; dr

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){}

это значит! данные

• нулевой
• неопределенный
• ложный
• ....

ОБНОВЛЕНИЕ (4 сентября 2020 г.)

Теперь вы можете использовать оператор ?? для проверки значений null и undefined и установки значения по умолчанию. Например:

const foo = null;
const bar = foo ?? 'exampleValue';
console.log(bar); // This will print 'exampleValue' due to the value condition of the foo constant, in this case, a null value

В качестве подробного способа, если вы хотите сравнить значения null и 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() вернет Входящее значение: undefined. Обратите внимание, что мы не используем оператор строгого равенства.

Правильный способ (подробности см. В других ответах), если 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"
}

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

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

Если вы хотите передать tslint без установки strict-boolean-expressions на allow-null-union или allow-undefined-union, вам нужно использовать isNullOrUndefined из модуля util node или свернуть свой собственный:

// 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 строгие.

Самый простой способ - использовать:

import { isNullOrUndefined } from 'util';

и тогда:

if (!isNullOrUndefined(foo))

Поздно присоединяться к этой теме, но я нахожу этот JavaScript-хакер очень удобным для проверки того, не определено ли значение.

 if(typeof(something) === 'undefined'){
   // Yes this is undefined
 }

Может быть, слишком поздно! но вы можете использовать оператор ?? в машинописном тексте. см. https://mariusschulz.com/blog/nullish-coalescing-the-operator-in-typescript

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

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 проверок может быть:

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'.

Обычно я провожу проверку, поскольку Фентон уже обсуждал. Чтобы сделать его более читабельным, вы можете использовать isNil от ramda.

import * as isNil from 'ramda/src/isNil';

totalAmount = isNil(totalAmount ) ? 0 : totalAmount ;

осторожно, если вы используете локальное хранилище, вы можете получить строку undefined, а не значение 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);
  });
});

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

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

_.isNil(value)

Аргументы

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

Возврат

(логическое): возвращает истину, если значение равно нулю, иначе - ложь.

Пример

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

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

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

Ссылка

Документы Lodash

Мы используем помощник hasValue, который проверяет значения NULL / undefined и гарантирует с помощью TypeScript, что ненужные проверки не выполняются. (Последнее похоже на то, как TS будет жаловаться на if ("a" === undefined), поскольку это всегда ложь).

Последовательное использование этого всегда безопасно, в отличие от !val, которое соответствует пустым строкам, нулю и т. Д. Оно также позволяет избежать использования нечеткого == сопоставления, что почти всегда является плохой практикой - нет необходимости вводить исключение.

type NullPart<T> = T & (null | undefined);

// Ensures unnecessary checks aren't performed - only a valid call if 
// value could be nullable *and* could be non-nullable
type MustBeAmbiguouslyNullable<T> = NullPart<T> extends never
  ? never
  : NonNullable<T> extends never
  ? never
  : T;

export function hasValue<T>(
  value: MustBeAmbiguouslyNullable<T>,
): value is NonNullable<MustBeAmbiguouslyNullable<T>> {
  return (value as unknown) !== undefined && (value as unknown) !== null;
}

export function hasValueFn<T, A>(
  value: MustBeAmbiguouslyNullable<T>,
  thenFn: (value: NonNullable<T>) => A,
): A | undefined {
  // Undefined matches .? syntax result
  return hasValue(value) ? thenFn(value) : undefined;
}

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

var foo:string;

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

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