Ponieważ TypeScript jest silnie napisany, po prostu używa się go if () {}do sprawdzenia nulli undefinednie brzmi dobrze.

Czy TypeScript ma do tego celu jakąś dedykowaną funkcję lub cukier składniowy?

Za pomocą testu żonglowania możesz przetestować jedno nulli undefinedjedno trafienie:

if (x == null) {

Jeśli zastosujesz ścisłe sprawdzenie, będzie to prawdą tylko dla wartości ustawionych na nulli nie będzie oceniane jako prawda dla niezdefiniowanych zmiennych:

if (x === null) {

Możesz spróbować z różnymi wartościami, korzystając z tego przykładu:

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

Wynik

„a == null”

„a jest niezdefiniowany”

„b == null”

„b === null”

if( value ) {
}

oceni, trueczy valuenie jest:

• null
• undefined
• NaN
• pusta struna ''
• 0
• false

maszynopis zawiera reguły javascript.

Czy TypeScript ma do tego dedykowaną funkcję lub cukier składniowy

TypeScript w pełni rozumie aktualną wersję JavaScript something == null.

TypeScript poprawnie wykluczy oba nulli undefinedprzy takich kontrolach.

Więcej

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

Zrobiłem różne testy na placu zabaw maszynopisu:

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

daje:

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

więc:

• sprawdzanie, czy (a == null) ma prawo wiedzieć, czy a jest zerowe czy niezdefiniowane
• sprawdzanie, czy (a! = null) ma prawo wiedzieć, czy a jest zdefiniowane
• sprawdzanie, czy (a) jest błędne, aby wiedzieć, czy a jest zdefiniowane

Myślę, że ta odpowiedź wymaga aktualizacji, sprawdź historię edycji starej odpowiedzi.

Zasadniczo masz trzy różne przypadki: zerowy, niezdefiniowany i niezadeklarowany, zobacz poniższy fragment.

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

Pojawi się błąd mówiący, że zmienna messagejest niezdefiniowana (inaczej niezadeklarowana), oczywiście, kompilator Typescript nie powinien na to pozwolić, ale NAPRAWDĘ nic nie może temu zapobiec.

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

Kompilator chętnie po prostu skompiluje powyższy kod. Jeśli więc masz pewność, że wszystkie zmienne są zadeklarowane, możesz to po prostu zrobić

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

powyższy kod sprawdzi, nullczy undefined, ALE jeśli messagezmienna może być niezadeklarowana (dla bezpieczeństwa), możesz rozważyć następujący kod

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

Uwaga: kolejność tutaj typeof(message) !== 'undefined' && message !== nulljest bardzo ważna, musisz najpierw sprawdzić undefinedstan, w przeciwnym razie będzie ona taka sama, jak message != nulldzięki, @Jaider.

W TypeScript 3.7 mamy teraz Opcjonalne łączenie w łańcuchy i Nullish Coalescing, aby sprawdzać null i niezdefiniowane w tym samym czasie, przykład:

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

kod ten sprawdzi, czy zdefiniowano foo, w przeciwnym razie zwróci niezdefiniowany

stary sposób :

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

to:

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

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

Z opcjonalnym łańcuchem będzie:

let x = foo?.bar();

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

kolejną nową funkcją jest Nullish Coalescing , przykład:

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

stara droga:

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

Możesz spróbować

if(!!someValue)

z !!.

Wyjaśnienie

Pierwszy !zamieni twoje wyrażenie w booleanwartość.

To !someValuejest, truejeśli someValuejest fałszem i falsejeśli someValuejest prawdą . To może być mylące.

Dodając kolejne !, wyrażenie brzmi teraz, truejeśli someValuejest prawdą, a falsejeśli someValuejest fałszem , co jest o wiele łatwiejsze do opanowania.

Dyskusja

Dlaczego mam się tym przejmować, if (!!someValue)gdy coś takiego if (someValue)dałoby mi taki sam wynik?

Ponieważ !!someValuejest to właśnie wyrażenie logiczne, podczas gdy someValuemoże być absolutnie wszystkim. Ten rodzaj wyrażenia pozwoli teraz na pisanie funkcji (i Boże, potrzebujemy ich), takich jak:

isSomeValueDefined(): boolean {
  return !!someValue
}

zamiast:

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

Mam nadzieję, że to pomoże.

Bo Typescript 2.x.xpowinieneś to zrobić w następujący sposób (używając ochrony typu ):

tl; dr

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

Dlaczego?

W ten sposób isDefined()uszanuje typ zmiennej i poniższy kod będzie wiedział, że weźmie to pod uwagę.

Przykład 1 - kontrola podstawowa:

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

Przykład 2 - typy uwzględniają:

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

to wredne! dane

• zero
• nieokreślony
• fałszywe
• …

Jeśli używasz TypeScript, lepiej jest pozwolić kompilatorowi sprawdzać null i niezdefiniowane (lub ich możliwości), zamiast sprawdzać je w czasie wykonywania. (Jeśli chcesz sprawdzić w czasie wykonywania, to jak wiele odpowiedzi wskazuje, po prostu użyj value == null).

Użyj opcji kompilacji, strictNullChecksaby poinformować kompilator o zadławieniu możliwych wartości zerowych lub niezdefiniowanych. Jeśli ustawisz tę opcję, a to nie jest sytuacja, w której ty nie chcesz, aby wartości null i undefined, można zdefiniować typem Type | null | undefined.

Jeśli chcesz przekazać tslintbez ustawiania strict-boolean-expressionsna allow-null-unionlub allow-undefined-union, trzeba użyć isNullOrUndefinedz node„s utilmodułu lub toczyć własną rękę:

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

Niezupełnie cukier składniowy, ale przydatny, gdy twoje reguły tslint są surowe.

Szybszym i krótszym oznaczeniem nullczeków może być:

value == null ? "UNDEFINED" : value

Ta linia odpowiada:

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

Zwłaszcza, gdy masz dużo nullczeków, jest to miły krótki zapis.

Miałem ten problem i niektóre odpowiedzi działają w porządku, JSale nie TSdlatego, że to jest powód.

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

To wszystko dobrze, ponieważ JS nie ma typów

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

W TS, jeśli zmienna nie została zdefiniowana nullprzy próbie sprawdzenia, nullczy tslint| kompilator będzie narzekał.

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

Późno dołączyłem do tego wątku, ale uważam, że ten JavaScript jest bardzo przydatny w sprawdzaniu, czy wartość jest niezdefiniowana

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

Zwykle sprawdzam żonglerkę, jak to już omówił Fenton . Aby uczynić go bardziej czytelnym, możesz użyć isNil z ramdy.

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

totalAmount = isNil(totalAmount ) ? 0 : totalAmount ;

Mówiąc wprost, jeśli chcesz porównać TYLKO wartości puste i niezdefiniowane , użyj do tego następującego przykładowego kodu:

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

Jeśli incomingValuenie zostanie zadeklarowane, TypeScript powinien zwrócić wyjątek. Jeśli zostanie to zadeklarowane, ale nie zdefiniowane, console.log()zwróci „Wartość przychodząca: niezdefiniowana”. Uwaga: nie używamy operatora ścisłego równości.

„Prawidłowy” sposób (sprawdź pozostałe odpowiedzi w celu uzyskania szczegółowych informacji), jeśli incomingValuenie jest booleantypem, po prostu oceń, czy jego wartość jest prawdziwa, zostanie to ocenione zgodnie z typem stałej / zmiennej. trueCiąg muszą być zdefiniowane jawnie jako ciąg pomocą = ''przyznawanie. Jeśli nie, zostanie to ocenione jako false. Sprawdźmy ten przypadek, używając tego samego kontekstu:

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

możesz użyć

if(x === undefined)

Wszystko,

Odpowiedź z największą liczbą głosów, tak naprawdę nie działa, jeśli pracujesz z obiektem. W takim przypadku, jeśli właściwość nie jest obecna, sprawdzenie nie zadziała. I to był problem w naszym przypadku: zobacz tę próbkę:

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

Wynik:

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

link plunkr: https://plnkr.co/edit/BJpVHD95FhKlpHp1skUE

Ponieważ TypeScript jest typowanym nadzbiorem JavaScript ES6. A lodash to biblioteka javascript.

Za pomocą lodash można sprawdzić, czy wartość jest pusta czy niezdefiniowana, można to zrobić za pomocą _.isNil().

_.isNil(value)

Argumenty

wartość (*): wartość do sprawdzenia.

Zwroty

(boolean) : Zwraca true, jeśli wartość jest nullish, w przeciwnym razie false.

Przykład

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

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

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

Połączyć

Lodash Docs

ostrożnie, jeśli używasz pamięci lokalnej, możesz skończyć z ciągiem niezdefiniowanym zamiast z niezdefiniowaną wartością:

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

Ludzie mogą uznać to za przydatne: 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);
  });
});

Zawsze piszę tak:

var foo:string;

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

To zadziała dobrze i myślę, że jest bardzo czytelne.