Поскольку TypeScript строго типизирован, просто используется if () {}для проверки nullи undefinedзвучит неправильно.

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

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

if (x == null) {

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

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

Вывод

"== ноль"

"а не определено"

"b == ноль"

"b === ноль"

if( value ) {
}

оценим, trueесли valueнет:

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

машинопись включает в себя правила JavaScript.

Есть ли в 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

так:

• проверка правильности (a == null), чтобы узнать, является ли значение null или неопределенным
• проверка правильности (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.

В TypeScript 3.7 у нас теперь есть Optional Chaining и Nullish Coalescing, чтобы проверять null и undefined одновременно, например:

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

этот код проверит, определен ли foo, иначе вернет undefined

старый способ :

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это ложь, и falseесли someValueэто правда . Это может сбивать с толку.

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

обсуждение

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

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

isSomeValueDefined(): boolean {
  return !!someValue
}

вместо:

isSomeValueDefined(): boolean {
  if(someValue) {
    return true
  }
  return 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){}

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

• значение NULL
• не определено
• ложный
• ....

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

Используйте опцию compile, 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);
}

В ТС , если переменная не была определена с , nullкогда вы пытаетесь проверить , что | Компилятор будет жаловаться.nulltslint

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

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

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

totalAmount = isNil(totalAmount ) ? 0 : totalAmount ;

Как многословным образом, если вы хотите сравнить нулевые и неопределенные значения ТОЛЬКО , используйте следующий пример кода для справки:

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

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

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

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

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

_.isNil(value)

аргументы

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

Возвращает

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

пример

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

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

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

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

Lodash Docs

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

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

var foo:string;

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

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