Website-Suche

typescript - Gibt es eine Möglichkeit, sowohl `null` als auch `undefined` zu überprüfen?

Da TypeScript stark typisiert ist, klingt es nicht richtig, einfach if() {} zu verwenden, um auf null und undefined zu prüfen.

Hat TypeScript dafür eine spezielle Funktion oder syntaktischen Zucker?

Antwort #1

Mit einem Juggling-Check können Sie sowohl null als auch undefined auf einmal testen:

if (x == null) {

Wenn Sie eine strenge Überprüfung verwenden, ist sie nur für Werte, die auf null gesetzt sind, wahr und wird für undefinierte Variablen nicht als wahr ausgewertet:

if (x === null) {

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

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"

Antwort #2

if( value ) {
}

wird zu true ausgewertet, wenn value nicht ist:

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

TypeScript beinhaltet JavaScript-Regeln.

Antwort #3

In TypeScript 3.7 haben wir jetzt Optionales Verkettung und Nullish Coalescing, um null und undefined gleichzeitig zu prüfen, Beispiel:

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

Dieser Code überprüft, ob foo definiert ist, andernfalls wird undefined zurückgegeben.

alte Art :

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

dies :

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

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

Mit optionalem Verkettung wird sein:

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

alte Art:

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

BONUS

Antwort #4

Hat TypeScript dafür eine spezielle Funktion oder Syntax-Zucker?

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

TypeScript wird mit solchen Prüfungen sowohl null als auch undefined korrekt ausschließen.

Mehr

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

Antwort #5

EINFACHE ANTWORT

Obwohl TypeScript eine stark typisierte Sprache ist, hat es die gleichen Probleme mit Zeigern und Variableninitialisierung, die es von JavaScript geerbt hat.
JavaScript prüft nicht, ob eine Variable im Kontext existiert, den so häufigen undefined-Status.

um zu bewerten, ob der Wert NICHT null,undefined,0,false,"" oder NaN ist:

if ( value )
or
if ( !!value )

Für eine negative Bedingung prüfen Sie, ob der Wert null, undefined, 0, false, "" oder NaN ist:

if ( !value )

um zu testen, ob es null oder undefined ist:

if ( value == null )

nur null testen:

if ( value === null )

nur undefined testen:

if ( value === undefined )

MEHR DETAILLIERTE ANTWORT

1- Es wird zu true ausgewertet, wenn der Wert nicht ist: null, undefined, NaN, leerer String '', 0, false
Wenn der Wert null, undefined, NaN, leerer String, 0 oder false ist, wird zur else-Bedingung gegangen.

if ( value ) {
  console.log('value is something different from 0, "", false, NaN, null, undefined');
} else {
  console.log('value is 0, "", false, NaN, null or undefined');
}
if ( !!value ) {
  console.log('value is something different from 0, "", false, NaN, null, undefined');
} else {
  console.log('value is 0, "", false, NaN, null or undefined');
}

2- Wenn Sie eine negative Bedingung wollen, dann müssen Sie Folgendes verwenden:

if ( !value ) {
  console.log('value is 0, "", false, NaN, null or undefined');
} else {
  console.log('value is something different from 0, "", false, NaN, null, undefined');
}

3- Es wird bewertet, ob der Wert null oder undefined ist

if ( value == null ) {
  console.log('is null or undefined');
} else {
  console.log('it isnt null neither undefined');
}

4- Die Verwendung eines Tests mit Booleschen Werten funktioniert nicht.
Es wird NICHT zu true noch zu false ausgewertet, wenn der Wert null, undefined, 0, leerer String, NaN ist.
Beide Bedingungen gehen immer zur else-Bedingung.
Mit der Ausnahme, wenn der Wert eine boolesche Variable ist.

if ( value==true ) {
} else { 
}
if ( value==false ) {
} else { 
}

Antwort #6

Ich habe verschiedene Tests auf dem TypeScript-Playground 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

also :

  • Überprüfen, ob (a == null) korrekt ist, um zu wissen, 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

Antwort #7

Du könntest versuchen

if(!!someValue)

mit !!.

Erklärung

Das erste ! wird Ihren Ausdruck in einen boolean-Wert umwandeln.

Dann ist !someValue true, wenn someValue falsy ist, und false, wenn someValue truthy ist. Das könnte verwirrend sein.

Durch das Hinzufügen eines weiteren ! ist der Ausdruck jetzt true, wenn someValue wahrheitsgemäß ist, und false, wenn someValue falschheitsgemäß ist, was viel einfacher zu handhaben ist.

Diskussion

Warum beschäftige ich mich jetzt mit if (!!someValue), wenn so etwas wie if (someValue) mir dasselbe Ergebnis geliefert hätte?

Weil !!someValue genau ein boolescher Ausdruck ist, während someValue absolut irgendetwas sein könnte. Dieser Art von Ausdruck wird es nun ermöglichen, Funktionen zu schreiben (und Gott, wir brauchen diese) wie:

isSomeValueDefined(): boolean {
  return !!someValue
}

statt:

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

Ich hoffe, es hilft.

Antwort #8

Für Typescript 2.x.x sollten Sie es auf folgende Weise tun (unter Verwendung eines Typ-Guards):

tl;dr

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

Warum?

Auf diese Weise wird isDefined() den Typ der Variablen beachten, und der folgende Code würde diese Überprüfung nun berücksichtigen.

Beispiel 1 - grundlegende Überprü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 - Arten Respekt:

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

Antwort #9

Ich denke, diese Antwort benötigt ein Update, prüfe den Bearbeitungsverlauf für die alte Antwort.

Im Grunde haben Sie drei verschiedene Fälle: null, undefined und undeclared, siehe den untenstehenden Ausschnitt.

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

Du wirst einen Fehler erhalten, der besagt, dass die Variable message undefiniert ist (also nicht deklariert), natürlich sollte der Typescript-Compiler das nicht zulassen, aber WIRKLICH nichts kann dich daran hindern.

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

Der Compiler wird einfach glücklich sein, den obigen Code zu kompilieren. Wenn Sie sich also sicher sind, dass alle Variablen deklariert sind, können Sie das einfach tun.

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

Der obige Code prüft auf null und undefined, ABER falls die Variable message nicht deklariert ist (zur Sicherheit), können Sie den folgenden Code in Betracht ziehen

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

Hinweis: Die Reihenfolge hier typeof(message) !== 'undefined' && message !== null ist sehr wichtig. Du musst zuerst den undefined-Zustand überprüfen, andernfalls wäre es genau dasselbe wie message != null. Danke @Jaider.

Antwort #10

if(data){}

es bedeutet !data

  • null
  • undefiniert
  • falsch
  • ....

Antwort #11

AKTUALISIERUNG (4. Sept. 2020)

Sie können nun den ??-Operator verwenden, um null und undefined "Werte" zu überprüfen und einen Standardwert festzulegen. Zum Beispiel:

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

Auf eine ausführliche Weise, wenn Sie nur null und undefined Werte VERGLEICHEN möchten, verwenden Sie den folgenden 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 incomingValue nicht deklariert ist, sollte TypeScript eine Ausnahme zurückgeben. Wenn es deklariert, aber nicht definiert ist, wird console.log() "Eingehender Wert ist: undefined" zurückgeben. Beachten Sie, dass wir den strikten Gleichheitsoperator nicht verwenden.

Die „korrekte“ Methode (siehe die anderen Antworten für Details), falls der incomingValue kein boolean-Typ ist, besteht einfach darin zu prüfen, ob sein Wert wahr ist; dies wird entsprechend dem Konstanten-/Variablentyp ausgewertet. Ein true-String muss explizit als String mit der Zuweisung = '' definiert werden. Andernfalls wird er als false ausgewertet. 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"
}

Verwandte Artikel