对于Typescript 2.x。X你应该用以下方式(使用类型保护):

博士tl;

function isDefined<T>(value: T | undefined | null): value is T {
  return <T>value !== undefined && <T>value !== null;
}

Why?

这样，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
  }
}

All,

得票最多的答案，如果你在研究一个对象，就不适用了。在这种情况下，如果属性不存在，检查将不起作用。这就是我们案例中的问题:请看这个例子:

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有专门的函数或语法糖吗

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

通过这样的检查，TypeScript会正确地排除null和undefined。

More

https://basarat.gitbook.io/typescript/recap/null-undefined

在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();

奖金

我们使用一个helper 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;
}

你可能想试试

if(!!someValue)

! !

解释

第一个!将表达式转换为布尔值。

如果someValue为假则为真，如果someValue为真则为假。这可能会让人困惑。

通过添加另一个!，表达式现在如果someValue为真则为真，如果someValue为假则为假，这更容易管理。

讨论

现在，为什么我要用if (!!someValue)来麻烦自己，而像if (someValue)这样的东西会给我相同的结果?

因为! !someValue恰好是一个布尔表达式，而someValue可以是任何东西。这种表达式现在可以编写如下函数(上帝，我们需要这样的函数):

isSomeValueDefined(): boolean {
  return !!someValue
}

而不是:

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

我希望这能有所帮助。