有没有办法同时检查“null”和“undefined”？

使用杂耍检查，您可以一次测试 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”

---

if( value ) {
}

如果 value 不是：将评估为 true：

无效的

不明确的

钠

空字符串''

0

错误的

打字稿包括 javascript 规则。

---

在 TypeScript 3.7 中，我们现在有可选链接和 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();

https://i.stack.imgur.com/OPBH5.png

---

TypeScript 是否为此提供了专用的函数或语法糖

TypeScript 完全理解 something == null 的 JavaScript 版本。

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) 是否正确知道 a 是 null 还是 undefined

检查 (a != null) 是否正确知道是否定义了 a

检查 (a) 是否错误以了解是否定义了 a

---

你可能想试试

if(!!someValue)

与 !!。

解释

第一个 ! 会将您的表达式转换为 boolean 值。

如果 someValue 为 falsy，则 !someValue 为 true，如果 someValue 为 truthy，则 false。这可能会令人困惑。

通过添加另一个 !，如果 someValue 是 truthy，则表达式现在是 true，如果 someValue 是 falsy，则表达式现在是 false，这更容易管理。

讨论

现在，当像 if (someValue) 这样的东西会给我同样的结果时，我为什么还要用 if (!!someValue) 来打扰自己呢？

因为 !!someValue 恰好是一个布尔表达式，而 someValue 绝对可以是任何东西。这种表达式现在可以编写函数（我们需要这些函数），例如：

isSomeValueDefined(): boolean {
  return !!someValue
}

代替：

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

我希望它有所帮助。

---

我认为这个答案需要更新，检查旧答案的编辑历史。

基本上，您有三种不同的情况，即 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 2.x.x，您应该按以下方式进行（使用 type guard）：

tl;博士

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、undefined、0、false、""、NaN：

if ( value )
or
if ( !!value )

对于否定条件：

if ( !value )

仅测试 null 或 undefined：

if ( value == null )

更详细的答案

1- 如果值 不是，它将评估为 true：null、undefined、NaN、empty string ''、{ 5}、false
如果值为null、undefined、NaN、empty string、0或false，将转到else健康）状况。

if ( value ) {
  console.log('value is something different from 0, "", false, NaN, null, undefined');
} else {
  console.log('value is 0, "", false, NaN, null or undefined');
}
if ( !!value ) {
  console.log('value is something different from 0, "", false, NaN, null, undefined');
} else {
  console.log('value is 0, "", false, NaN, null or undefined');
}

2-如果你想要一个否定条件，那么你需要使用：

if ( !value ) {
  console.log('value is 0, "", false, NaN, null or undefined');
} else {
  console.log('value is something different from 0, "", false, NaN, null, undefined');
}

3- 它将评估 value 是 null 还是 undefined

if ( value == null ) {
  console.log('is null or undefined');
} else {
  console.log('it isnt null neither undefined');
}

4- 使用布尔条件不起作用。
它会 NOT 评估为 true 也不会评估为 false 如果值为 null、undefined、0、empty string、NaN
两个条件都将始终进入 else 条件。
除了 if value 是一个布尔变量。

if ( value==true ) {
} else { 
}
if ( value==false ) {
} else { 
}

---

更新（2020 年 9 月 4 日）

您现在可以使用 ?? 运算符来验证 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() 将返回“传入值是：未定义”。请注意，我们没有使用严格的等于运算符。

“正确”的方式（查看其他答案以了解详细信息），如果 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，那么让编译器检查空值和未定义（或其可能性）是一种更好的方法，而不是在运行时检查它们。 （如果您确实想在运行时检查，那么正如许多答案所示，只需使用 value == null）。

使用编译选项 strictNullChecks 告诉编译器阻塞可能的空值或未定义值。如果您设置了此选项，然后出现您确实想要允许 null 和 undefined 的情况，您可以将类型定义为 Type | null | undefined。

---

如果您想在不将 strict-boolean-expressions 设置为 allow-null-union 或 allow-undefined-union 的情况下通过 tslint，则需要使用 node 的 util 模块中的 isNullOrUndefined 或滚动您自己的：

// 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 hack 在检查值是否未定义时非常方便

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

---

我们使用一个帮助器 hasValue 来检查空值/未定义，并通过 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;
}

---

可能来晚了！但您可以在 typescript 中使用 ?? 运算符。见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'.

---

通常我会像 Fenton 那样做杂耍检查discussed。为了使其更具可读性，您可以使用 ramda 中的 isNil。

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

---

您可以使用三元运算符和新的空值合并运算符轻松完成此操作。

首先：使用三元检查是否为真。如果是，则返回 false，因此 if 语句不会运行。

第二：因为你现在知道这个值是假的，如果它是空的，你可以使用 nullish coalesce 运算符返回 true。因为它会为任何其他值返回自身，如果它不是空值，它将正确地使 if 语句失败。

让 x = 真； console.log("开始测试") if (x?false:x ?? true){ console.log(x,"is nullish") } x = false if (x?false:x ?? true){ log(x,"为空") } x = 0; if (x?false:x ?? true){ console.log(x,"is nullish") } x=1; if (x?false:x ?? true){ console.log(x,"is nullish") } x=""; if (x?false:x ?? true){ console.log(x,"is nullish") } x="hello world"; if (x?false:x ?? true){ console.log(x,"is nullish") } x=null; if (x?false:x ?? true){ console.log(x,"is nullish") } x=undefined; if (x?false:x ?? true){ console.log(x,"is nullish") }

---

因为 TypeScript 是 ES6 JavaScript 的类型化超集。 lodash 是一个 javascript 库。

使用 lodash 检查值是 null 还是 undefined 可以使用 _.isNil() 完成。

_.isNil(value)

论据

值 (*)：要检查的值。

退货

(boolean)：如果值为 null，则返回 true，否则返回 false。

例子

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

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

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

关联

Lodash Docs

---

试试这个，用！！运算符和变量。

let check;
if (!!check) {
  console.log('check is not null or not undefined');
} else {
  console.log('check is  null or  undefined');
}

这在 Angular 中将非常有用。
检查任何变量的 undefined 和 null。

---

我总是这样写：

var foo:string;

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

这会很好，我认为它非常易读。

---