Vì TypeScript được gõ mạnh, chỉ cần sử dụng if () {}để kiểm tra nullvà undefinednghe không đúng.

TypeScript có bất kỳ chức năng chuyên dụng hoặc cú pháp đường cho việc này không?

Sử dụng kiểm tra tung hứng, bạn có thể kiểm tra cả hai nullvà undefinedtrong một lần nhấn:

if (x == null) {

Nếu bạn sử dụng kiểm tra nghiêm ngặt, nó sẽ chỉ đúng với các giá trị được đặt thành nullvà sẽ không đánh giá là đúng với các biến không xác định:

if (x === null) {

Bạn có thể thử điều này với các giá trị khác nhau bằng cách sử dụng ví dụ này:

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

Đầu ra

"a == null"

"a là không xác định"

"b == null"

"b === null"

if( value ) {
}

sẽ đánh giá truenếu valuekhông:

• null
• undefined
• NaN
• chuỗi rỗng ''
• 0
• false

bản thảo bao gồm các quy tắc javascript.

TypeScript có chức năng chuyên dụng hoặc cú pháp đường cho việc này không

TypeScript hoàn toàn hiểu phiên bản JavaScript something == null.

TypeScript sẽ loại trừ chính xác cả hai nullvà undefinedvới các kiểm tra như vậy.

Hơn

https://basarat.gitbook.io/typescript/recap/null-und xác định

Tôi đã làm các bài kiểm tra khác nhau trên sân chơi bản thảo:

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

cho:

a is null or undefined
b is null or undefined
c is defined

vì thế:

• kiểm tra xem (a == null) có đúng không khi biết a là null hoặc không xác định
• kiểm tra xem (a! = null) có đúng không nếu biết a được xác định
• kiểm tra nếu (a) sai để biết nếu a được xác định

Tôi nghĩ rằng câu trả lời này cần một bản cập nhật, kiểm tra lịch sử chỉnh sửa cho câu trả lời cũ.

Về cơ bản, bạn có ba trường hợp trì hoãn null, không xác định và không khai báo, xem đoạn trích dưới đây.

// bad-file.ts
console.log(message)

Bạn sẽ gặp một lỗi nói rằng biến đó messagekhông được xác định (còn gọi là không khai báo), tất nhiên, trình biên dịch Typecript không nên cho phép bạn làm điều đó nhưng THỰC SỰ không có gì có thể ngăn cản bạn.

// evil-file.ts
// @ts-gnore
console.log(message)

Trình biên dịch sẽ rất vui khi chỉ biên dịch mã ở trên. Vì vậy, nếu bạn chắc chắn rằng tất cả các biến được khai báo, bạn chỉ cần làm điều đó

if ( message != null ) {
    // do something with the message
}

mã ở trên sẽ kiểm tra nullvà undefined, NHƯNG trong trường hợp messagebiến có thể không được khai báo (để đảm bảo an toàn), bạn có thể xem xét mã sau

if ( typeof(message) !== 'undefined' && message !== null ) {
    // message variable is more than safe to be used.
}

Lưu ý: thứ tự ở đây typeof(message) !== 'undefined' && message !== nullrất quan trọng bạn phải kiểm tra undefinedtrạng thái trước tiên, nó sẽ giống như message != null, cảm ơn @Jaider.

Trong TypeScript 3.7, giờ đây chúng ta có Chuỗi kết hợp và Nullish Coalescing tùy chọn để kiểm tra null và không xác định cùng một lúc, ví dụ:

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

mã này sẽ kiểm tra nếu foo được xác định nếu không nó sẽ trả về không xác định

cách cũ :

if(foo != null && foo != undefined) {
   x = foo.bar.baz();
} 

điều này:

let x = (foo === null || foo === undefined) ? undefined : foo.bar();

if (foo && foo.bar && foo.bar.baz) { // ... }

Với chuỗi tùy chọn sẽ là:

let x = foo?.bar();

if (foo?.bar?.baz) { // ... }

một tính năng mới khác là Nullish Coalescing , ví dụ:

let x = foo ?? bar(); // return foo if it's not null or undefined otherwise calculate bar

cách cũ:

let x = (foo !== null && foo !== undefined) ?
foo :
bar();

Bạn có thể muốn thử

if(!!someValue)

với !!.

Giải trình

Đầu tiên !sẽ biến biểu thức của bạn thành một booleangiá trị.

Sau đó !someValuelà truenếu someValuelà falsy và falsenếu someValuelà truthy . Điều này có thể gây nhầm lẫn.

Bằng cách thêm khác !, khái niệm tại là truenếu someValuelà truthy và falsenếu someValuelà falsy , đó là dễ dàng hơn để quản lý.

Thảo luận

Bây giờ, tại sao tôi lại bận tâm đến bản thân if (!!someValue)khi một thứ như thế if (someValue)sẽ cho tôi kết quả tương tự?

Bởi vì !!someValuechính xác là một biểu thức boolean, trong khi someValuecó thể hoàn toàn là bất cứ điều gì. Kiểu biểu thức này bây giờ sẽ cho phép viết các hàm (và Chúa chúng ta cần chúng) như:

isSomeValueDefined(): boolean {
  return !!someValue
}

thay vì:

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

Tôi hy vọng nó sẽ giúp.

Đối với Typescript 2.x.xbạn nên làm theo cách sau (sử dụng loại bảo vệ ):

tl; dr

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

Tại sao?

Theo cách isDefined()này sẽ tôn trọng loại biến và mã sau đây sẽ biết kiểm tra tài khoản này.

Ví dụ 1 - kiểm tra cơ bản:

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

Ví dụ 2 - loại tôn trọng:

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

nó có nghĩa là dữ liệu

• vô giá trị
• chưa xác định
• sai
• ....

Nếu bạn đang sử dụng TypeScript, cách tốt hơn là để trình biên dịch kiểm tra null và không xác định (hoặc khả năng của chúng), thay vì kiểm tra chúng vào thời gian chạy. (Nếu bạn muốn kiểm tra vào thời gian chạy, thì càng nhiều câu trả lời chỉ ra, chỉ cần sử dụng value == null).

Sử dụng tùy chọn biên dịch strictNullChecksđể báo cho trình biên dịch bóp nghẹt các giá trị null hoặc không xác định có thể. Nếu bạn đặt tùy chọn này, và sau đó là một tình huống mà bạn làm muốn cho phép null và undefined, bạn có thể xác định loại như Type | null | undefined.

Nếu bạn muốn vượt qua tslintmà không cần thiết strict-boolean-expressionsphải allow-null-unionhay allow-undefined-union, bạn cần phải sử dụng isNullOrUndefinedtừ node's utilmô-đun hoặc cuộn của riêng bạn:

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

Không chính xác đường cú pháp nhưng hữu ích khi quy tắc tslint của bạn nghiêm ngặt.

Một ký hiệu nhanh hơn và ngắn hơn để nullkiểm tra có thể là:

value == null ? "UNDEFINED" : value

Dòng này tương đương với:

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

Đặc biệt khi bạn có nhiều nullkiểm tra thì đó là một ký hiệu ngắn đẹp.

Tôi đã có vấn đề này và một số câu trả lời hoạt động tốt JSnhưng không phải vì TSlý do ở đây.

//JS
let couldBeNullOrUndefined;
if(couldBeNullOrUndefined == null) {
  console.log('null OR undefined', couldBeNullOrUndefined);
} else {
  console.log('Has some value', couldBeNullOrUndefined);
}

Đó là tất cả tốt vì JS không có loại

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

Trong TS nếu biến không được định nghĩa với nullkhi bạn cố gắng để kiểm tra rằng nullcác tslint| trình biên dịch sẽ khiếu nại.

//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'.

Việc tham gia chuỗi này muộn nhưng tôi thấy việc hack JavaScript này rất tiện lợi trong việc kiểm tra xem giá trị có được xác định không

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

Thông thường tôi làm kiểm tra tung hứng như Fenton đã thảo luận . Để dễ đọc hơn, bạn có thể sử dụng isNil từ ramda.

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

totalAmount = isNil(totalAmount ) ? 0 : totalAmount ;

Như một cách tiết, nếu bạn muốn so sánh rỗng và không xác định giá trị CHỈ , sử dụng mã ví dụ sau đây để tham khảo:

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

Nếu incomingValuekhông được khai báo, TypeScript sẽ trả về một ngoại lệ. Nếu điều này được khai báo nhưng không được xác định,console.log() sẽ trả về "Giá trị đến là: không xác định". Lưu ý chúng tôi không sử dụng toán tử bằng nghiêm ngặt.

Cách "chính xác" (kiểm tra các câu trả lời khác để biết chi tiết), nếu đó incomingValuekhông phải là một booleanloại, chỉ cần đánh giá nếu giá trị của nó là đúng, điều này sẽ được đánh giá theo loại hằng / biến. Một truechuỗi phải được xác định rõ ràng là chuỗi bằng cách sử dụng phép = ''gán. Nếu không, nó sẽ được đánh giá là false. Hãy kiểm tra trường hợp này bằng cách sử dụng cùng một bối cảnh:

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

bạn có thể dùng

if(x === undefined)

Tất cả,

Câu trả lời có nhiều phiếu nhất, không thực sự hiệu quả nếu bạn đang làm việc với một đối tượng. Trong trường hợp đó, nếu một tài sản không có mặt, kiểm tra sẽ không hoạt động. Và đó là vấn đề trong trường hợp của chúng tôi: xem mẫu này:

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

Kết quả:

true , false, false , true (in case of !=)
true , true, true, true (in case of !==) => so in this sample not the correct answer

liên kết plunkr: https://plnkr.co/edit/BJpVHD95FhKlpHp1skUE

Vì TypeScript là một siêu ký tự gõ của ES6 JavaScript. Và lodash là một thư viện của javascript.

Sử dụng lodash để kiểm tra nếu giá trị là null hoặc không xác định có thể được thực hiện bằng cách sử dụng _.isNil().

_.isNil(value)

Tranh luận

giá trị (*): Giá trị cần kiểm tra.

Trả về

(boolean) : Trả về true nếu giá trị là nullish, khác false.

Thí dụ

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

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

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

Liên kết

Tài liệu tạm thời

cẩn thận nếu bạn đang sử dụng bộ nhớ cục bộ, bạn có thể kết thúc bằng chuỗi không xác định thay vì giá trị không xác định:

localStorage.setItem('mykey',JSON.stringify(undefined));
localStorage.getItem('mykey') === "undefined"
true

Mọi người có thể thấy điều này hữu ích: 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);
  });
});

Tôi luôn viết nó như thế này:

var foo:string;

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

Điều này sẽ hoạt động tốt và tôi nghĩ rằng nó rất dễ đọc.