是否有专门的函数来检查TypeScript中的null和undefined？

Question

由于TypeScript是强类型的，只需使用if () {}来检查null和undefined听起来不对。

TypeScript是否具有专用功能或语法糖？

Answer 1

使用杂耍检查，您可以在一次点击中同时测试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');

输出

  

＆＃34; a == null＆＃34;

     

＆＃34; a未定义＆＃34;

     

＆＃34; b == null＆＃34;

     

＆＃34; b === null＆＃34;

Answer 2

if( value ) {
}

如果true不是，则

将评估为value：

• null
• undefined
• NaN
• 空字符串''
• 0
• false

typescript包含javascript规则。

Answer 3

我在打字稿操场上做了不同的测试：

http://www.typescriptlang.org/play/

public function addEmail(Email $email)
{
    $predictate = function($key, $element) use ($email) {
        /** @var  Email $element If the two email compared as strings are equals, return true. */
        return $element->getEmail()->getEmail() === $email->getEmail();
    };

    // Create a new Email object and add it to the collection
    if (false === $this->emails->exists($predictate)) {
        $this->emails->add($email);
    }

    // Anyway set the email for this store
    $email->setForStore($this);

    return $this;
}

给出：

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 == null）是否正确知道a是空还是未定义
• 检查是否（a！= null）知道a是否已定义
• 检查（a）是否错误以确定a是否已定义

Answer 4

  

TypeScript是否具有此

的专用函数或语法糖

没有。我只是something == null和JavaScript一样。

Answer 5

当我使用基于打字稿的angular和angular时，我将列出可能的情况以检查类型，null，empty和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

此外，您还可以使用an official documentation了解更多详细信息。

TL; DR

在JavaScript中，null实际上不是null，而是object，typeof undefined是undefined，而typeof null是{{1} }。

您可能还需要知道JavaScript中的object会比较值而不是类型，但是==会同时比较类型和值，例如===而是1 == '1' // return true 1 === '1' // return false和null（例如undefined）相同，但null == undefined // return true

更新时间：2019年1月15日

深入研究Typescript一段时间后，我发现以下是检查null和undefined的最佳，最稳定的方法。

null === undefined // return false

希望这对某人有帮助。

Answer 6

if(data){}

这是意思！数据

• 空
• 未定义
• 假
• ....

Answer 7

您可能想尝试

if(!!someValue)

!!。

<强>解释

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

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

通过添加其他true，如果someValue truthy ，则表达式现在为false;如果someValue为<{1}}，则表达式为if (!!someValue) em> falsy ，这更容易管理。

<强>讨论

现在，为什么在if (someValue)之类的内容会给我相同的结果时，我会为!!someValue打扰自己？

因为someValue恰好是一个布尔表达式，而isSomeValueDefined(): boolean { return !!someValue } 可能绝对是任何东西。这种表达现在将会写出函数（而上帝我们需要那些），如：

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

而不是：

-keepparameternames
-renamesourcefileattribute SourceFile
-keepattributes Exceptions,InnerClasses,Signature,Deprecated,SourceFile,LineNumberTable,EnclosingMethod,MethodParameters,LocalVariableTable,LocalVariableTypeTable

//Preserve all annotations.

-keepattributes *Annotation*

// Preserve all .class method names.

-keepclassmembernames class * {
    java.lang.Class class$(java.lang.String);
    java.lang.Class class$(java.lang.String, boolean);
}

// Preserve all native method names and the names of their classes.

-keepclasseswithmembernames class * {
    native <methods>;
}

// Preserve the special static methods that are required in all enumeration classes.

-keepclassmembers class * extends java.lang.Enum {
    public static **[] values();
    public static ** valueOf(java.lang.String);
}

// Explicitly preserve all serialization members. The Serializable interface
// is only a marker interface, so it wouldn't save them.
// You can comment this out if your library doesn't use serialization.
// If your code contains serializable classes that have to be backward
// compatible, please refer to the manual.

-keepclassmembers class * implements java.io.Serializable {
    static final long serialVersionUID;
    static final java.io.ObjectStreamField[] serialPersistentFields;
    private void writeObject(java.io.ObjectOutputStream);
    private void readObject(java.io.ObjectInputStream);
    java.lang.Object writeReplace();
    java.lang.Object readResolve();
}

我希望它有所帮助。

Answer 8

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

Answer 9

如果您使用的是TypeScript，那么让编译器检查空值和未定义（或其可能性）是一种更好的方法，而不是在运行时检查它们。 （如果你想在运行时检查，那么尽可能多的答案表明，只需使用value == null）。

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

Answer 10

最简单的方法是使用：

import { isNullOrUndefined } from 'util';

和：

if (!isNullOrUndefined(foo))

Answer 11

更新（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 值 ONLY ，请使用以下示例代码作为参考：

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，即可根据常量进行评估/变量类型。必须使用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"
}

Answer 12

如果您希望在未tslint设置为strict-boolean-expressions或allow-null-union的情况下传递allow-undefined-union，则需要使用isNullOrUndefined中的node＆＃ 39; 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规则严格时很有用。

Answer 13

在 TypeScript 3.7 中，我们现在具有可选链接，可同时检查空和未定义，例如：

bodyToMono

此代码将检查是否定义了foo，否则将返回undefined

旧方式：

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

Answer 14

所有

如果你正在处理一个对象，那么得票最多的答案就不会有效。在这种情况下，如果没有财产，检查将无效。这就是我们案例中的问题：请参阅此示例：

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

Answer 15

null检查的更快和更短的表示法可以是：

value == null ? "UNDEFINED" : value

此行等效于：

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

尤其是当您有很多null时，请用一个简短的缩写来表示。

Answer 16

我遇到了这个问题，其中一些答案对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'.

Answer 17

后来加入了这个线程，但是我发现这个JavaScript hack在检查值是否未定义时非常方便

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

Answer 18

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

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

totalAmount = isNil(totalAmount ) ? 0 : totalAmount ;

Answer 19

请注意，如果您使用的是本地存储，则可以以未定义的字符串而不是未定义的值结尾：

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

Answer 20

可能来晚了！但您可以在 typescript 中使用 ?? 运算符。 见https://mariusschulz.com/blog/nullish-coalescing-the-operator-in-typescript

Answer 21

我们使用一个帮助程序 hasValue 来检查 nulls/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;
}

Answer 22

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

可以使用_.isNil()使用lodash检查值是否为null或未定义。

_.isNil(value)

参数

值（*）：要检查的值。

返回

（布尔值）：如果值为空，则返回true，否则返回false。

示例

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

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

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

链接

Lodash Docs

Answer 23

你可以使用

if(x === undefined)

Answer 24

我总是这样写：

var foo:string;

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

这样可以正常工作，我认为它非常易读。