Étant donné que TypeScript est fortement typé, il suffit de l'utiliser if () {}pour vérifier nullet undefinedne sonne pas correctement.

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

À l'aide d'un test de jonglage, vous pouvez tester les deux nullet undefineden un coup:

if (x == null) {

Si vous utilisez un contrôle strict, il ne sera vrai que pour les valeurs définies sur nullet ne sera pas évalué comme vrai pour les variables non définies:

if (x === null) {

Vous pouvez essayer cela 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');

Production

"a == null"

"a n'est pas défini"

"b == null"

"b === null"

if( value ) {
}

évaluera truesi ce valuen'est pas le cas:

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

tapuscrit inclut des règles javascript.

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

TypeScript comprend parfaitement la version JavaScript qui est something == null.

TypeScript exclura correctement à la fois nullet undefinedavec de telles vérifications.

Plus

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

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

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

donc:

• vérifier si (a == null) a raison de savoir si a est nul ou non défini
• vérifier si (a! = null) a raison de savoir si a est défini
• vérifier si (a) est erroné pour savoir si a est défini

Je pense que cette réponse a besoin d'une mise à jour, consultez l'historique des modifications pour l'ancienne réponse.

Fondamentalement, vous avez trois cas différés nuls, non définis et non déclarés, voir l'extrait ci-dessous.

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

Vous obtiendrez une erreur indiquant que la variable messagen'est pas définie (aka non déclarée), bien sûr, le compilateur Typescript ne devrait pas vous permettre de le faire, mais VRAIMENT rien ne peut vous empêcher.

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

Le compilateur se contentera de compiler le code ci-dessus. Donc, si vous êtes sûr que toutes les variables sont déclarées, vous pouvez simplement le faire

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

le code ci-dessus vérifiera nullet undefined, MAIS dans le cas où la messagevariable pourrait ne pas être déclarée (par sécurité), vous pouvez considérer le code suivant

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

Remarque: l'ordre ici typeof(message) !== 'undefined' && message !== nullest très important, vous devez d'abord vérifier l' undefinedétat, sinon ce sera le même que message != null, merci @Jaider.

Dans TypeScript 3.7, nous avons maintenant le chaînage facultatif et la coalescence nulle pour vérifier null et indéfini en même temps, par exemple:

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

ce code vérifiera si foo est défini sinon il retournera non défini

ancienne façon :

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

cette:

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

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

Avec le chaînage optionnel sera:

let x = foo?.bar();

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

une autre nouvelle fonctionnalité est Nullish Coalescing , par exemple:

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

ancienne façon:

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

Vous voudrez peut-être essayer

if(!!someValue)

avec !!.

Explication

Le premier !transformera votre expression en booleanvaleur.

Alors !someValuec'est truesi someValueest faux et falsesi someValuec'est vrai . Cela pourrait prêter à confusion.

En ajoutant un autre !, l'expression est maintenant truesi someValueest vraie et falsesi someValueest fausse , ce qui est beaucoup plus facile à gérer.

Discussion

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

Parce que !!someValuec'est précisément une expression booléenne, alors qu'elle someValuepourrait être absolument n'importe quoi. Ce type d'expression permettra désormais 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.

Car Typescript 2.x.xvous devez le faire de la manière suivante (en utilisant type guard ):

tl; dr

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

Pourquoi?

De cette façon isDefined(), respectera le type de variable et le code suivant saura tenir compte de cette vérification.

Exemple 1 - vérification 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 - les types respectent:

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

c'est méchant!

• nul
• indéfini
• faux
• ....

Si vous utilisez TypeScript, il est préférable de laisser le compilateur rechercher les valeurs nulles et indéfinies (ou la possibilité de celles-ci), 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 de nombreuses réponses l'indiquent, utilisez simplementvalue == null ).

Utilisez l'option de compilation strictNullCheckspour indiquer au compilateur d'étouffer les éventuelles valeurs nulles ou non définies. Si vous activez cette option, et puis il y a une situation où vous ne voulez autoriser nulle et non défini, vous pouvez définir le type que Type | null | undefined.

Si vous voulez passer tslintsans mettre strict-boolean-expressionsà allow-null-unionou allow-undefined-union, vous devez utiliser isNullOrUndefineddu node« s utilmodule ou rouler 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

Pas exactement du sucre syntaxique mais utile lorsque vos règles tslint sont strictes.

Une notation plus rapide et plus courte pour les nullchèques peut être:

value == null ? "UNDEFINED" : value

Cette ligne équivaut à:

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

Surtout quand vous avez beaucoup de nullcontrôle, c'est une belle notation courte.

J'ai eu ce problème et une partie de la réponse fonctionne très bien pour JSmais pas pour TSici est la raison.

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

C'est très 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 nulllorsque vous essayez de vérifier que nullle tslint| le compilateur se plaindra.

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

Tard pour rejoindre ce fil mais je trouve ce hack JavaScript très pratique pour vérifier si une valeur n'est pas définie

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

En général , je fais le contrôle de la jonglerie comme Fenton déjà discuté . Pour le rendre plus lisible, vous pouvez utiliser isNil de ramda.

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

totalAmount = isNil(totalAmount ) ? 0 : totalAmount ;

De manière détaillée, si vous souhaitez comparer les valeurs nulles et non définies UNIQUEMENT , utilisez l'exemple de code suivant pour référence:

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

Si incomingValuen'est pas déclaré, TypeScript doit renvoyer une exception. Si cela est déclaré mais non défini, leconsole.log() retourne "La valeur entrante est: non définie". Notez que nous n'utilisons pas l'opérateur strict strict.

La manière "correcte" (vérifiez les autres réponses pour plus de détails), si le incomingValuen'est pas un booleantype, évaluez simplement si sa valeur est vraie, cela sera évalué selon le type de constante / variable. Une truechaîne doit être définie explicitement en tant que chaîne à l'aide de l' = ''affectation. Sinon, il sera évalué comme false. Vérifions ce cas en utilisant le même contexte:

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

vous pouvez utiliser

if(x === undefined)

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, le chèque 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

Puisque TypeScript est un sur-ensemble typé de JavaScript ES6. Et lodash est une bibliothèque de javascript.

L'utilisation de lodash pour vérifier si la valeur est nulle ou non définie peut être effectuée à l'aide de _.isNil().

_.isNil(value)

Arguments

valeur (*): La valeur à vérifier.

Retour

(booléen) : retourne vrai si la valeur est nulle, sinon faux.

Exemple

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

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

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

Lien

Lodash Docs

attention si vous utilisez le stockage local, vous pouvez vous retrouver avec la chaîne non définie plutôt que la valeur non définie:

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

Les gens peuvent trouver cela utile: 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);
  });
});

Je l'écris toujours comme ceci:

var foo:string;

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

Cela fonctionnera bien et je pense que c'est très lisible.