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




validar null en typescript (13)

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?


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

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


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.


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.


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

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 ;

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.


Siempre lo escribo así:

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

Esto funcionará bien y creo que es muy legible.


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
 }

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


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

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"


puedes usar

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

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

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

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

es malo! datos

  • nulo
  • indefinido
  • falso
  • ....




typescript