typescript - operator - undefined or null

¿Hay alguna manera de verificar tanto `null` como` undefined`?

Question

Dado que TypeScript está fuertemente tipado, simplemente usar if () {} para verificar nulo e indefinido no suena bien.

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

Answer 1

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

No. Acabo de hacer something == null igual que JavaScript.

Answer 2

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 el message variable no está definido (también conocido como no declarado), 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á si es null e undefined , PERO en caso de que la variable del message 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 orden aquí typeof(message) !== ''undefined'' && message !== null es muy importante, primero debe verificar el estado undefined contrario será igual que message != null Null, gracias @Jaider.

Answer 3

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() .

var foo:string;

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

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

Enlazar

Docs Lodash

Answer 4

Es posible que desee probar

if(data){}

con !! .

Explicación

El primero ! convertirá su expresión en un valor boolean .

Entonces !someValue es true si someValue es falso y false si someValue es verdadero . Esto puede ser confuso.

Al agregar otro ! , la expresión ahora es true si someValue es verdadero y false si someValue es falso , lo cual es mucho más fácil de administrar.

Discusión

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

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

if(!!someValue)

en lugar de:

isSomeValueDefined(): boolean {
  return !!someValue
}

Espero que ayude.

Answer 5

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

Answer 6

Para Typescript 2.xx 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 manera, isDefined() respetará el tipo de variable y el siguiente código sabría tener en cuenta esta verificación.

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

Answer 7

Por lo general, hago el control de malabarismo como Fenton ya discussed . Para hacerlo más legible, puede usar isNil de ramda.

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

totalAmount = isNil(totalAmount ) ? 0 : totalAmount ;

Answer 8

Si desea pasar tslint sin establecer strict-boolean-expressions en allow-null-union o allow-undefined-union , debe usar isNullOrUndefined del isNullOrUndefined de isNullOrUndefined del node o rodar el suyo propio:

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

Answer 9

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 strictNullChecks para indicarle al compilador que se strictNullChecks con posibles valores nulos o indefinidos. Si configura esta opción, y luego hay una situación en la que desea permitir valores nulos e indefinidos, puede definir el tipo como Type | null | undefined Type | null | undefined Type | null | undefined

Answer 10

Siempre lo escribo así:

var foo:string; if(!foo){ foo="something"; }

Esto funcionará bien y creo que es muy legible.

Answer 11

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
 }

Answer 12

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

if(x === undefined)

Las personas pueden encontrar esto útil: https://github.com/angular/components/blob/master/src/cdk/coercion/boolean-property.spec.ts

_.isNil(value)

Answer 13

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

Answer 14

Tuve este problema y algunas de las respuestas funcionan bien para JS pero no para TS , esta es 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 null cuando intenta verificar ese null 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''.

Answer 15

Una notación más rápida y más corta para null comprobaciones null 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 muchos cheques null , es una buena notación corta.

Answer 16

Usando un chequeo de malabarismo, puede probar tanto null como undefined en un solo golpe:

if (x == null) {

Si usa una verificación estricta, solo será verdadero para los valores establecidos en null y 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"

Answer 17

puedes usar

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

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

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

Answer 18

if( value ) {
}

se evaluará como true si el value no es:

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

El mecanografiado incluye reglas de JavaScript.

Answer 19

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

es malo! datos

• nulo
• indefinido
• falso
• ....