Como o TypeScript é fortemente digitado, basta usar if () {}
para verificar null
e undefined
não parece certo.
O TypeScript tem alguma função dedicada ou açúcar de sintaxe para isso?
Como o TypeScript é fortemente digitado, basta usar if () {}
para verificar null
e undefined
não parece certo.
O TypeScript tem alguma função dedicada ou açúcar de sintaxe para isso?
Respostas:
Usando uma verificação de malabarismo, você pode testar ambos null
e undefined
em um hit:
if (x == null) {
Se você usar uma verificação estrita, isso só será verdadeiro para valores definidos como null
e não será avaliado como verdadeiro para variáveis indefinidas:
if (x === null) {
Você pode tentar isso com vários valores usando este exemplo:
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');
Resultado
"a == null"
"a é indefinido"
"b == null"
"b === null"
"false" == false
uma string não vazia como "false" é avaliada como true
.
if(x)
verificações de estilo truthy / falsey , mas não if(x == null)
, que apenas capturam null
e undefined
. Verifique se var c: number = 0; check(c, 'b');
não está "nulo" null
, ou undefined
.
if( value ) {
}
avaliará true
se value
não é:
null
undefined
NaN
''
0
false
O texto datilografado inclui regras javascript.
O TypeScript possui função dedicada ou açúcar de sintaxe para este
O TypeScript entende completamente a versão do JavaScript que é something == null
.
O TypeScript descartará corretamente ambos null
e undefined
com essas verificações.
myVar == null
. Apenas outra opção.
== null
é a maneira correta de testar nulos e indefinidos. !!something
é uma coerção inútil em um condicional em JS (apenas use something
). !!something
também coagirá 0 e '' a falso, o que não é o que você deseja fazer se estiver procurando por nulo / indefinido.
Eu fiz testes diferentes no playground tipográfico:
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);
dá:
a is null or undefined
b is null or undefined
c is defined
tão:
Acho que esta resposta precisa de uma atualização, verifique o histórico de edições para obter a resposta antiga.
Basicamente, você tem três casos diferidos nulos, indefinidos e não declarados, consulte o trecho abaixo.
// bad-file.ts
console.log(message)
Você receberá um erro dizendo que a variável message
é indefinida (também não declarada); é claro, o compilador Typescript não deve permitir que você faça isso, mas REALMENTE nada pode impedi-lo.
// evil-file.ts
// @ts-gnore
console.log(message)
O compilador terá prazer em compilar apenas o código acima. Portanto, se você tiver certeza de que todas as variáveis são declaradas, basta fazer isso
if ( message != null ) {
// do something with the message
}
o código acima procurará null
e undefined
, MAS, caso a message
variável não seja declarada (por segurança), considere o código a seguir
if ( typeof(message) !== 'undefined' && message !== null ) {
// message variable is more than safe to be used.
}
Nota: a ordem aqui typeof(message) !== 'undefined' && message !== null
é muito importante, você deve verificar undefined
primeiro o estado; caso contrário, será o mesmo que message != null
, graças a @Jaider.
if(typeof something !== 'undefined' && something !== null){...}
No TypeScript 3.7 , agora temos encadeamento opcional e coalescência nula para verificar nulo e indefinido ao mesmo tempo, por exemplo:
let x = foo?.bar.baz();
este código irá verificar se foo está definido, caso contrário ele retornará indefinido
maneira antiga :
if(foo != null && foo != undefined) {
x = foo.bar.baz();
}
isto:
let x = (foo === null || foo === undefined) ? undefined : foo.bar();
if (foo && foo.bar && foo.bar.baz) { // ... }
Com encadeamento opcional será:
let x = foo?.bar();
if (foo?.bar?.baz) { // ... }
outro novo recurso é o Nullish Coalescing , por exemplo:
let x = foo ?? bar(); // return foo if it's not null or undefined otherwise calculate bar
à moda antiga:
let x = (foo !== null && foo !== undefined) ?
foo :
bar();
Você pode tentar
if(!!someValue)
com !!
.
Explicação
O primeiro !
transformará sua expressão em um boolean
valor.
Então !someValue
é true
se someValue
é falso e false
se someValue
é verdade . Isso pode ser confuso.
Ao adicionar uma outra !
, a expressão agora é true
se someValue
é truthy e false
se someValue
é Falsas , que é muito mais fácil de gerir.
Discussão
Agora, por que me incomodo if (!!someValue)
quando algo assim if (someValue)
me daria o mesmo resultado?
Porque !!someValue
é precisamente uma expressão booleana, enquanto que someValue
pode ser absolutamente qualquer coisa. Esse tipo de expressão agora permitirá escrever funções (e Deus precisamos delas) como:
isSomeValueDefined(): boolean {
return !!someValue
}
ao invés de:
isSomeValueDefined(): boolean {
if(someValue) {
return true
}
return false
}
Espero que ajude.
!!'false'
está em ação true
porque 'false'
é uma sequência válida
Para Typescript 2.x.x
você deve fazê-lo da seguinte maneira (usando tipo guarda ):
tl; dr
function isDefined<T>(value: T | undefined | null): value is T {
return <T>value !== undefined && <T>value !== null;
}
Por quê?
Dessa forma isDefined()
, respeitará o tipo de variável e o código a seguir saberá levar essa conta em consideração.
Exemplo 1 - verificação 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
}
}
Exemplo 2 - os tipos respeitam:
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){}
é mau! dados
true
ou false
apenas. Se você tiver um booleano com uma null
atribuição ou um undefined
valor, em ambos os casos, o valor será avaliado como false
.
Se você estiver usando o TypeScript, é uma abordagem melhor permitir que o compilador verifique nulos e indefinidos (ou a possibilidade deles), em vez de procurá-los em tempo de execução. (Se você deseja verificar em tempo de execução, o número de respostas indicado, basta usar value == null
).
Use a opção de compilação strictNullChecks
para dizer ao compilador para engasgar com possíveis valores nulos ou indefinidos. Se você definir essa opção, e depois há uma situação onde você não deseja permitir nulos e indefinidos, você pode definir o tipo Type | null | undefined
.
Se você quer passar tslint
sem definir strict-boolean-expressions
a allow-null-union
ou allow-undefined-union
, você precisa usar isNullOrUndefined
a partir node
do util
módulo ou rolar o seu próprio:
// 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
Não é exatamente um açúcar sintático, mas útil quando suas regras de tslint são rigorosas.
Uma notação mais rápida e mais curta para null
verificações pode ser:
value == null ? "UNDEFINED" : value
Esta linha é equivalente a:
if(value == null) {
console.log("UNDEFINED")
} else {
console.log(value)
}
Especialmente quando você tem muito null
cheque, é uma notação curta e agradável.
Eu tive esse problema e algumas das respostas funcionam muito bem, JS
mas não por TS
aqui é o motivo.
//JS
let couldBeNullOrUndefined;
if(couldBeNullOrUndefined == null) {
console.log('null OR undefined', couldBeNullOrUndefined);
} else {
console.log('Has some value', couldBeNullOrUndefined);
}
Tudo isso é bom, já que JS não tem 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);
}
Em TS, se a variável não foi definida null
quando você tenta verificar se null
o tslint
| compilador irá reclamar.
//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 ingressar neste segmento, mas acho esse hack JavaScript muito útil para verificar se um valor é indefinido
if(typeof(something) === 'undefined'){
// Yes this is undefined
}
Como uma maneira detalhada, se você deseja comparar SOMENTE valores nulos e indefinidos , use o seguinte código de exemplo para referência:
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}`);
}
Se incomingValue
não for declarado, o TypeScript deve retornar uma exceção. Se isso for declarado, mas não definido, console.log()
retornará "O valor recebido é: indefinido". Observe que não estamos usando o operador estrito igual.
A maneira "correta" (verifique as outras respostas para obter detalhes), se incomingValue
não for um boolean
tipo, basta avaliar se seu valor é verdadeiro, isso será avaliado de acordo com o tipo de constante / variável. Uma true
string deve ser definida explicitamente como string usando a = ''
atribuição. Caso contrário, será avaliado como false
. Vamos verificar este caso usando o mesmo 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"
}
você pode usar
if(x === undefined)
Todos,
A resposta com mais votos não funciona realmente se você estiver trabalhando com um objeto. Nesse caso, se uma propriedade não estiver presente, a verificação não funcionará. E esse foi o problema no nosso caso: veja este exemplo:
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);
Resultado:
true , false, false , true (in case of !=)
true , true, true, true (in case of !==) => so in this sample not the correct answer
Link do plunkr: https://plnkr.co/edit/BJpVHD95FhKlpHp1skUE
null
. Tente isso: plnkr.co/edit/NfiVnQNes1p8PvXd1fCG?p=preview
Como o TypeScript é um superconjunto digitado do JavaScript ES6. E o lodash é uma biblioteca de javascript.
O uso do lodash para verificar se o valor é nulo ou indefinido pode ser feito usando _.isNil()
.
_.isNil(value)
valor (*): o valor a ser verificado.
(booleano) : retorna true se o valor for nulo, caso contrário, false.
_.isNil(null);
// => true
_.isNil(void 0);
// => true
_.isNil(NaN);
// => false
cuidado se estiver usando armazenamento local, você pode acabar com a sequência indefinida em vez do valor indefinido:
localStorage.setItem('mykey',JSON.stringify(undefined));
localStorage.getItem('mykey') === "undefined"
true
As pessoas podem achar isso ú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);
});
});
Eu sempre escrevo assim:
var foo:string;
if(!foo){
foo="something";
}
Isso vai funcionar bem e eu acho que é muito legível.
0
também passa no !foo
teste.
undefined
é diferente de false
. Isso é muito comum nos parâmetros opcionais da função booleana, nos quais você deve usar a abordagem comum do JavaScript:function fn(flag?: boolean) { if (typeof flag === "undefined") flag = true; /* set default value */ }
var isTrue; if(isTrue)//skips, if(!isTrue)// enters if(isTrue === undefined)//enters
. Também tentei em texto datilografado com o var isTrue:boolean
qual era indefinido, e o mesmo se verifica. @ Gingi, há algo diferente sobre o que você tentou e o que eu tentei?
Since TypeScript is strongly-typed
Eu não poderia encontrar este em sua docs e não tenho dúvidas sobre isso ...