Dado que TypeScript está fuertemente tipado, simplemente se usa if () {}para verificar nully undefinedno suena bien.

¿TypeScript tiene alguna función dedicada o sintaxis de azúcar para esto?

Usando un chequeo de malabarismo, puede probar ambos nully undefinedde una sola vez:

if (x == null) {

Si usa una verificación estricta, solo será cierto para los valores establecidos en nully no se evaluará como verdadero para las variables indefinidas:

if (x === null) {

Puedes probar esto con varios valores usando este ejemplo:

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

Salida

"a == nulo"

"a no está definido"

"b == nulo"

"b === nulo"

if( value ) {
}

evaluará truesi valueno es:

• null
• undefined
• NaN
• cuerda vacía ''
• 0
• false

El mecanografiado incluye reglas de JavaScript.

¿TypeScript tiene una función dedicada o sintaxis de azúcar para esto?

TypeScript comprende completamente la versión de JavaScript que es something == null.

TypeScript descartará correctamente ambos nully undefinedcon tales comprobaciones.

Más

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

Hice diferentes pruebas en el patio de juegos mecanografiado:

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

da:

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

entonces:

• comprobar si (a == nulo) es correcto para saber si a es nulo o indefinido
• comprobar si (a! = null) es correcto para saber si se define a
• comprobar si (a) es incorrecto para saber si se define a

Creo que esta respuesta necesita una actualización, consulte el historial de edición de la respuesta anterior.

Básicamente, tiene tres casos deferentes nulos, indefinidos y no declarados, vea el fragmento a continuación.

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

Obtendrá un error que dice que la variable messageno está definida (también conocida como no declarada), por supuesto, el compilador de Script no debería permitirle hacer eso, pero REALMENTE nada puede impedirlo.

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

El compilador estará encantado de compilar el código anterior. Entonces, si está seguro de que todas las variables están declaradas, simplemente puede hacerlo

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

el código anterior verificará nully undefined, PERO en caso de que la messagevariable no esté declarada (por seguridad), puede considerar el siguiente código

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

Nota: el pedido aquí typeof(message) !== 'undefined' && message !== nulles muy importante, undefinedprimero debe verificar el estado, de lo contrario será el mismo que message != null, gracias @Jaider.

En TypeScript 3.7 ahora tenemos encadenamiento opcional y fusión nula para verificar nulos e indefinidos al mismo tiempo, por ejemplo:

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

este código verificará si foo está definido; de lo contrario, volverá indefinido

antigua manera :

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

esta:

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

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

Con encadenamiento opcional será:

let x = foo?.bar();

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

Otra característica nueva es Nullish Coalescing , por ejemplo:

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

vieja forma:

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

Es posible que desee probar

if(!!someValue)

con !!.

Explicación

El primero !convertirá tu expresión en un booleanvalor.

Entonces !someValuees truesi someValuees falso y falsesi someValuees verdadero . Esto puede ser confuso.

Al agregar otro !, la expresión ahora es truesi someValuees verdadero y falsesi someValuees falso , lo cual es mucho más fácil de administrar.

Discusión

Ahora, ¿por qué me molesto if (!!someValue)cuando algo así if (someValue)me hubiera dado el mismo resultado?

Porque !!someValuees precisamente una expresión booleana, mientras que someValuepodría ser absolutamente cualquier cosa. Este tipo de expresión ahora permitirá escribir funciones (y Dios las necesitamos) como:

isSomeValueDefined(): boolean {
  return !!someValue
}

en vez de:

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

Espero que ayude.

Para ello Typescript 2.x.x, debe hacerlo de la siguiente manera (usando type guard ):

tl; dr

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

¿Por qué?

De esta forma isDefined()se respetará el tipo de variable y el siguiente código sabría tener en cuenta este cheque.

Ejemplo 1 - verificación básica:

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

Ejemplo 2 - respeto de tipos:

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 malo! datos

• nulo
• indefinido
• falso
• ....

Si está utilizando TypeScript, es un mejor enfoque dejar que el compilador verifique si hay valores nulos e indefinidos (o la posibilidad de que existan), en lugar de verificarlos en tiempo de ejecución. (Si desea verificar en tiempo de ejecución, entonces, como indican muchas respuestas, simplemente use value == null).

Use la opción de compilación strictNullCheckspara indicarle al compilador que se asfixie ante posibles valores nulos o indefinidos. Si se establece esta opción, y luego hay una situación en la que no desea permitir nula y sin definir, se puede definir el tipo Type | null | undefined.

Si desea pasar tslintsin fijar strict-boolean-expressionsa allow-null-uniono allow-undefined-union, es necesario el uso isNullOrUndefinedde node's utilmódulo o hágalo usted mismo:

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

No es exactamente el azúcar sintáctico, pero es útil cuando las reglas de tslint son estrictas.

Una notación más rápida y más corta para los nullcontroles puede ser:

value == null ? "UNDEFINED" : value

Esta línea es equivalente a:

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

Especialmente cuando tienes mucho nullcheque, es una buena notación corta.

Tuve este problema y algunas de las respuestas funcionan bien, JSpero esta TSes la razón.

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

Eso es todo bueno ya que JS no tiene tipos

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

En TS si la variable no se definió con nullcuando intenta comprobar que nullel tslint| El compilador se quejará.

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

Tarde para unirse a este hilo, pero encuentro este truco de JavaScript muy útil para verificar si un valor no está definido

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

Por lo general, hago el control de malabarismo como Fenton ya discutió . Para que sea más fácil de leer, puede utilizar isNil de Ramda.

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

totalAmount = isNil(totalAmount ) ? 0 : totalAmount ;

Como forma detallada, si desea comparar valores nulos e indefinidos SOLAMENTE , use el siguiente código de ejemplo como referencia:

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 incomingValue no se declara, TypeScript debería devolver una excepción. Si esto se declara pero no se define, console.log()devolverá "El valor entrante es: indefinido". Tenga en cuenta que no estamos utilizando el operador estricto igual.

La forma "correcta" (verifique las otras respuestas para más detalles), si el incomingValueno es un booleantipo, simplemente evalúe si su valor es verdadero, esto se evaluará de acuerdo con el tipo constante / variable. Una truecadena debe definirse explícitamente como una cadena que utiliza la = ''asignación. Si no, se evaluará como false. Verifiquemos este caso usando el mismo contexto:

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

puedes usar

if(x === undefined)

Todas,

La respuesta con más votos no funciona realmente si está trabajando con un objeto. En ese caso, si una propiedad no está presente, el cheque no funcionará. Y ese fue el problema en nuestro caso: vea esta muestra:

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

Salir:

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

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

Dado que TypeScript es un superconjunto mecanografiado de ES6 JavaScript. Y lodash son una biblioteca de javascript.

El uso de lodash para verificar si el valor es nulo o indefinido se puede hacer usando _.isNil().

_.isNil(value)

Argumentos

valor (*): El valor a verificar.

Devoluciones

(booleano) : devuelve verdadero si el valor es nulo, de lo contrario falso.

Ejemplo

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

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

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

Enlace

Docs Lodash

Tenga cuidado si está usando almacenamiento local, puede terminar con la cadena indefinida en lugar del valor indefinido:

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

La gente puede encontrar esto útil: 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);
  });
});

Siempre lo escribo así:

var foo:string;

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

Esto funcionará bien y creo que es muy legible.