Da TypeScript stark typisiert ist, wird einfach if () {}nach gesucht nullund es undefinedklingt nicht richtig.

Hat TypeScript dafür eine spezielle Funktion oder Syntax?

Mit einem Jonglier-Check können Sie beide nullund undefinedmit einem Schlag testen :

if (x == null) {

Wenn Sie eine strenge Prüfung verwenden, gilt diese nur für Werte, die auf nullundefinierte Variablen festgelegt sind, und wird nicht als wahr ausgewertet:

if (x === null) {

Sie können dies mit verschiedenen Werten anhand dieses Beispiels versuchen:

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

Ausgabe

"a == null"

"a ist undefiniert"

"b == null"

"b === null"

if( value ) {
}

wird bewerten, truewenn valuenicht:

• null
• undefined
• NaN
• leerer String ''
• 0
• false

Typoskript enthält Javascript-Regeln.

Hat TypeScript dafür eine spezielle Funktion oder Syntax?

TypeScript versteht die JavaScript-Version vollständig something == null .

TypeScript schließt sowohl nullund als auch korrekt ausundefined solche Überprüfungen .

Mehr

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

Ich habe verschiedene Tests auf dem Typoskript-Spielplatz durchgeführt:

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

gibt:

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

damit:

• Überprüfen Sie, ob (a == null) richtig ist, um festzustellen, ob a null oder undefiniert ist
• Überprüfen, ob (a! = null) richtig ist, um zu wissen, ob a definiert ist
• Überprüfen, ob (a) falsch ist, um zu wissen, ob a definiert ist

Ich denke, diese Antwort muss aktualisiert werden. Überprüfen Sie den Bearbeitungsverlauf auf die alte Antwort.

Grundsätzlich haben Sie drei aufgeschobene Fälle null, undefiniert und nicht deklariert (siehe den folgenden Ausschnitt).

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

Sie erhalten eine Fehlermeldung, dass die Variable messageundefiniert (auch als nicht deklariert bezeichnet) ist. Der Typescript-Compiler sollte dies natürlich nicht zulassen, aber WIRKLICH kann Sie nichts davon abhalten.

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

Der Compiler kompiliert gerne den obigen Code. Wenn Sie also sicher sind, dass alle Variablen deklariert sind, können Sie dies einfach tun

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

Der obige Code prüft auf nullund undefined, ABER falls die messageVariable (aus Sicherheitsgründen) nicht deklariert ist, können Sie den folgenden Code berücksichtigen

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

Hinweis: Die Reihenfolge hier typeof(message) !== 'undefined' && message !== nullist sehr wichtig. Sie müssen undefinedzuerst den Status überprüfen, da er genau so ist wie message != null, danke @Jaider.

In TypeScript 3.7 haben wir jetzt optionales Verketten und Nullish Coalescing , um gleichzeitig null und undefiniert zu prüfen. Beispiel:

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

Dieser Code prüft, ob foo definiert ist, andernfalls wird undefiniert zurückgegeben

alter Weg :

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

diese:

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

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

Mit optionaler Verkettung wird:

let x = foo?.bar();

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

Eine weitere neue Funktion ist Nullish Coalescing , Beispiel:

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

Alter Weg:

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

Vielleicht möchten Sie es versuchen

if(!!someValue)

mit !!.

Erläuterung

Der erste !verwandelt Ihren Ausdruck in einen booleanWert.

Dann !someValueist, trueob someValuees falsch ist und falseob someValuees wahr ist . Dies könnte verwirrend sein.

Durch Hinzufügen eines weiteren !, jetzt ist der Ausdruck , truewenn someValueist truthy und falsewenn someValueist falsy , die viel einfacher zu verwalten ist.

Diskussion

Warum beschäftige ich mich jetzt mit so if (!!someValue)etwas?if (someValue) mir das gleiche Ergebnis gebracht hätte?

Denn !!someValueist genau ein boolescher Ausdruck, während someValueabsolut alles sein könnte. Diese Art des Ausdrucks ermöglicht es nun, Funktionen (und Gott, die wir brauchen) wie folgt zu schreiben:

isSomeValueDefined(): boolean {
  return !!someValue
}

anstatt:

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

Ich hoffe, es hilft.

Denn Typescript 2.x.xSie sollten es folgendermaßen tun (mit Type Guard ):

tl; dr

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

Warum?

Auf diese Weise isDefined()wird der Variablentyp berücksichtigt und der folgende Code würde wissen, dass diese Prüfung berücksichtigt wird.

Beispiel 1 - Grundprüfung:

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

Beispiel 2 - Typen respektieren:

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

Es ist gemein! Daten

• Null
• nicht definiert
• falsch
• ....

Wenn Sie TypeScript verwenden, ist es besser, den Compiler nach Nullen und Undefinierten (oder deren Möglichkeit) suchen zu lassen, als zur Laufzeit nach ihnen zu suchen. (Wenn Sie zur Laufzeit überprüfen möchten, verwenden Sie einfach, wie viele Antworten anzeigen value == null.)

Verwenden Sie die Kompilierungsoption strictNullChecks, um den Compiler anzuweisen, mögliche Null- oder undefinierte Werte zu drosseln. Wenn Sie diese Option gesetzt, und dann gibt es eine Situation , wo Sie es möchten null ermöglichen und nicht definiert, können Sie die Art , wie definieren Type | null | undefined.

Wenn Sie übergeben möchten , tslintohne Einstellung strict-boolean-expressionszu allow-null-unionoder allow-undefined-unionmüssen Sie die Verwendung isNullOrUndefinedvon node‚s - utilModul oder rollen Sie Ihre eigenen:

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

Nicht gerade syntaktischer Zucker, aber nützlich, wenn Ihre tslint-Regeln streng sind.

Eine schnellere und kürzere Notation für nullSchecks kann sein:

value == null ? "UNDEFINED" : value

Diese Zeile entspricht:

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

Besonders wenn Sie viel nullScheck haben, ist es eine schöne kurze Notation.

Ich hatte dieses Problem und einige der Antworten funktionieren gut, JSaber nicht für TShier ist der Grund.

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

Das ist alles gut, da JS keine Typen hat

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

In TS , wenn die Variable nicht definiert wurde , mit , nullwenn Sie versuchen, das zu überprüfen , nulldie tslint| Compiler wird sich beschweren.

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

Spät, um diesem Thread beizutreten, aber ich finde diesen JavaScript-Hack sehr praktisch, um zu überprüfen, ob ein Wert undefiniert ist

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

Normalerweise mache ich den Jonglier-Check, wie Fenton bereits besprochen hat . Um die Lesbarkeit zu verbessern , können Sie isNil von ramda verwenden.

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

totalAmount = isNil(totalAmount ) ? 0 : totalAmount ;

Wenn Sie NUR null und undefinierte Werte vergleichen möchten , verwenden Sie den ausführlichen Beispielcode als Referenz:

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

Wenn dies incomingValuenicht deklariert ist, sollte TypeScript eine Ausnahme zurückgeben. Wenn dies deklariert, aber nicht definiert ist, wird dieconsole.log() wird "Eingehender Wert ist: undefiniert" zurückgegeben. Beachten Sie, dass wir nicht den strengen Gleichheitsoperator verwenden.

Der "richtige" Weg (überprüfen Sie die anderen Antworten auf Details), wenn der incomingValuekein booleanTyp ist, bewerten Sie einfach, ob sein Wert wahr ist, dies wird gemäß dem Typ der Konstanten / Variablen ausgewertet. Eine trueZeichenfolge muss mithilfe der = ''Zuweisung explizit als Zeichenfolge definiert werden . Wenn nicht, wird es als bewertet false. Lassen Sie uns diesen Fall im selben Kontext überprüfen:

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

Sie können verwenden

if(x === undefined)

Alle,

Die Antwort mit den meisten Stimmen funktioniert nicht wirklich, wenn Sie mit einem Objekt arbeiten. In diesem Fall funktioniert die Prüfung nicht, wenn eine Eigenschaft nicht vorhanden ist. Und das war das Problem in unserem Fall: siehe dieses Beispiel:

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

Ergebnis:

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

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

Da TypeScript eine typisierte Obermenge von ES6-JavaScript ist. Und lodash sind eine Bibliothek von Javascript.

Mit lodash können Sie überprüfen, ob der Wert null oder undefiniert ist _.isNil().

_.isNil(value)

Argumente

Wert (*): Der zu überprüfende Wert.

Kehrt zurück

(boolean) : Gibt true zurück, wenn der Wert nullish ist, andernfalls false.

Beispiel

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

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

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

Verknüpfung

Lodash Docs

Vorsicht, wenn Sie lokalen Speicher verwenden, kann die Zeichenfolge undefiniert und nicht der Wert undefiniert sein:

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

Personen finden dies möglicherweise hilfreich: 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);
  });
});

Ich schreibe es immer so:

var foo:string;

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

Dies wird gut funktionieren und ich denke, es ist sehr gut lesbar.