Есть ли способ проверить как "нулевой", так и "undefined"?

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

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

Ответ 1

Используя проверку жонглирования, вы можете проверить как 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"

Ответ 2

if( value ) {
}

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

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

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

Ответ 3

Я провел различные тесты на игровой площадке 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
проверка того, что (а) неправильно знать, определено ли значение

Ответ 4

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

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

Ответ 5

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

По сути, у вас есть три разных случая: 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 Null, спасибо @Jaider.

Ответ 6

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

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
}

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

Ответ 7

if(data){}

это значение! datap >

NULL
undefined
ложь
....

Ответ 8

Для Typescript 2.x.x вы должны сделать это следующим образом (используя type guard):

ТЛ; др

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

Ответ 9

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

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

Ответ 10

Если вы хотите передать 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 строги.

Ответ 11

Все,

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

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

Ответ 12

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

value == null ? "UNDEFINED" : value

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

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

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

Ответ 13

У меня была эта проблема, и некоторые из ответов прекрасно работают для 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 при попытке проверить, что 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'.

Ответ 14

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

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

Ответ 15

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

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

totalAmount = isNil(totalAmount ) ? 0 : totalAmount ;

Ответ 16

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

Ответ 17

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

if(x === undefined)

Ответ 18

Поскольку 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

Ответ 19

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

var foo:string;

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

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