web-dev-qa-db-fra.com

Existe-t-il une fonction dédiée pour vérifier null et undefined dans TypeScript?

Comme TypeScript est fortement typé, utiliser simplement if () {} pour vérifier les valeurs null et indéfini ne semble pas correct. 

TypeScript a-t-il un sucre de fonction ou de syntaxe dédié à cela?

typescript
225
David Liu

En utilisant un test de jonglerie, vous pouvez tester null et undefined en un coup:

if (x == null) {

Si vous utilisez une vérification stricte, elle ne sera vraie que pour les valeurs définies à null et ne sera pas évaluée comme vraie pour les variables non définies:

if (x === null) {

Vous pouvez essayer ceci avec différentes valeurs en utilisant cet exemple:

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

Sortie

"a == null" 

"a n'est pas défini"

"b == null"

"b === null"

251
Fenton
if( value ) {
}

sera évalué à true si value n'est pas:

  • null
  • undefined
  • NaN
  • chaîne vide ''
  • 0
  • false

TypeScript inclut des règles javascript.

157
Ramazan Sağır

J'ai fait différents tests sur le terrain de jeu TypeScript:

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

donne:

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

alors:

  • vérifier si (a == null) a le droit de savoir si a est null ou non défini
  • vérifier si (a! = null) a raison de savoir si a est défini
  • vérifier si (a) a tort de savoir si a est défini
34
Juangui Jordán

Est-ce que TypeScript a le sucre de fonction ou de syntaxe dédié pour ceci

Non, je ne fais que something == null comme JavaScript.

26
basarat
if(data){}

c'est méchant! data

  • nul
  • undefined
  • false
  • ....
13
artemitSoft

Vous voudrez peut-être essayer

if(!!someValue)

avec !!.

Explication

Le premier ! transformera votre expression en une valeur boolean.

Alors !someValue est true si someValue est falsy et false si someValue est truthy. Cela pourrait être déroutant.

En ajoutant un autre !, l'expression est maintenant true si someValue est truthy et false si someValue est falsy, ce qui est beaucoup plus facile à gérer.

Discussion

Maintenant, pourquoi est-ce que je me dérange avec if (!!someValue) alors que quelque chose comme if (someValue) m'aurait donné le même résultat?

Parce que !!someValue est précisément une expression booléenne, alors que someValue pourrait être absolument n'importe quoi. Ce type d’expression va maintenant permettre d’écrire des fonctions (et Dieu nous en avons besoin) comme:

isSomeValueDefined(): boolean {
  return !!someValue
}

au lieu de:

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

J'espère que ça aide.

9
avi.elkharrat

Si vous utilisez TypeScript, il est préférable de laisser le compilateur vérifier les valeurs nulles et non définies (ou leur possibilité) plutôt que de les vérifier au moment de l'exécution. (Si vous voulez vérifier au moment de l'exécution, alors comme beaucoup de réponses l'indiquent, utilisez simplement value == null).

Utilisez l’option de compilation strictNullChecks pour indiquer au compilateur d’étouffer les éventuelles valeurs NULL ou indéfinies. Si vous définissez cette option et qu'il y a une situation dans laquelle vous do souhaitez autoriser les valeurs null et indéfinie, vous pouvez définir le type en tant que Type | null | undefined.

5
user663031

Pour TypeScript 2.x.x, vous devriez le faire de la manière suivante:

tl; dr 

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

Pourquoi?

De cette manière, isDefined() respectera le type de variable et le code suivant saura prendre en compte cette vérification.

Exemple 1 - Contrôle de base:

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

Exemple 2 - respect des types:

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
  }
}
4
Sergei Panfilov

Si vous voulez passer tslint sans définir strict-boolean-expressions en allow-null-union ou allow-undefined-union, vous devez utiliser le module isNullOrUndefined du node's util ou créer votre propre

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

Sucre pas exactement syntaxique mais utile quand vos règles de tslint sont strictes.

2
Graeme Wicksted

J'ai eu ce problème et une partie de la réponse fonctionne très bien pour JS mais pas pour TS voici la raison.

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

Tout cela est bien, car JS n'a pas de types

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

Dans TS si la variable n'a pas été définie avec null lorsque vous essayez de vérifier que null est tslint | le compilateur va se plaindre.

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

Tout,

La réponse avec le plus de votes ne fonctionne pas vraiment si vous travaillez avec un objet. Dans ce cas, si une propriété n'est pas présente, la vérification ne fonctionnera pas. Et c’était le problème dans notre cas: voir cet exemple:

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

Résultat:

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

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

0
Ben Croughs

Une notation plus rapide et plus courte pour les vérifications null peut être: 

value == null ? "UNDEFINED" : value

Cette ligne est équivalente à: 

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

Surtout quand vous avez beaucoup de null, vérifiez que c'est une notation courte de Nice. 

0
Harry Stylesheet

Habituellement, je fais déjà le contrôle de jonglage en tant que Fenton discuté . Pour le rendre plus lisible, vous pouvez utiliser isNil de ramda.

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

totalAmount = isNil(totalAmount ) ? 0 : totalAmount ;
0
Neo

Je suis en retard pour rejoindre ce fil, mais je trouve ce piratage JavaScript très utile pour vérifier si une valeur est indéfinie

 if(typeof(something) === 'undefined'){
   // Yes this is undefined
 }
0
Shahid Manzoor Bhat