Verificação nula de JavaScript

Encontrei o seguinte código:

function test(data) {
    if (data != null && data !== undefined) {
        // some code here
    }
}

Sou um pouco novo em JavaScript, mas, a partir de outras perguntas que tenho lido aqui, tenho a impressão de que esse código não faz muito sentido.

Você receberá um erro se acessar uma variável indefinida em qualquer contexto que não seja typeof.

Atualização: a (citação da) resposta acima pode ser enganosa. Deve dizer «uma variável não declarada» , em vez de «uma variável não definida» .

Como descobri, nas respostas de Ryan ♦ , maerics e nwellnhof , mesmo quando nenhum argumento é fornecido para uma função, suas variáveis ​​para os argumentos sempre são declaradas. Esse fato também prova errado o primeiro item da lista abaixo.

Pelo meu entendimento, os seguintes cenários podem ser observados:

• A função foi chamada sem argumentos, criando assim datauma variável indefinida e gerando um erro data != null.

• A função foi chamada especificamente com null(ou undefined), como argumento, caso em que data != nulljá protege o código interno, tornando-o && data !== undefinedinútil.

• A função foi chamada com um argumento não nulo; nesse caso, passará trivialmente ambos data != null e data !== undefined .

P: Meu entendimento está correto?

Eu tentei o seguinte, no console do Firefox:

--
[15:31:31.057] false != null
[15:31:31.061] true
--
[15:31:37.985] false !== undefined
[15:31:37.989] true
--
[15:32:59.934] null != null
[15:32:59.937] false
--
[15:33:05.221] undefined != null
[15:33:05.225] false
--
[15:35:12.231] "" != null
[15:35:12.235] true
--
[15:35:19.214] "" !== undefined
[15:35:19.218] true

Não consigo descobrir um caso em que o data !== undefined depois data != null possa ser útil.

Uma "variável indefinida" é diferente do valor undefined.

Uma variável indefinida:

var a;
alert(b); // ReferenceError: b is not defined

Uma variável com o valor undefined:

var a;
alert(a); // Alerts “undefined”

Quando uma função usa um argumento, esse argumento é sempre declarado, mesmo que seu valor seja undefinede, portanto, não haverá nenhum erro. Você está certo sobre != nullseguido de !== undefinedser inútil, no entanto.

Em JavaScript, nullé um objeto singleton especial que é útil para sinalizar "sem valor". Você pode testá-lo por comparação e, como de costume no JavaScript, é uma boa prática usar o ===operador para evitar confusão de tipo de coerção:

var a = null;
alert(a === null); // true

Como @rynah menciona, "indefinido" é um pouco confuso em JavaScript. No entanto, é sempre seguro testar se a typeof(x)string é "indefinida", mesmo que "x" não seja uma variável declarada:

alert(typeof(x) === 'undefined'); // true

Além disso, as variáveis ​​podem ter o "valor indefinido" se não forem inicializadas:

var y;
alert(typeof(y) === 'undefined'); // true

Juntando tudo, seu cheque deve ficar assim:

if ((typeof(data) !== 'undefined') && (data !== null)) {
  // ...

No entanto, como a variável "data" é sempre definida, pois é um parâmetro de função formal, o uso do operador "typeof" é desnecessário e você pode comparar com segurança diretamente com o "valor indefinido".

function(data) {
  if ((data !== undefined) && (data !== null)) {
    // ...

Este trecho equivale a dizer "se a função foi chamada com um argumento definido e não é nulo ..."

No seu caso, use data==null(que é verdadeiro APENAS para nulo e indefinido - na segunda imagem, concentre-se em linhas / colunas nulo indefinido)

function test(data) {
    if (data != null) {
        console.log('Data: ', data);
    }
}

test();          // the data=undefined
test(null);      // the data=null
test(undefined); // the data=undefined

test(0); 
test(false); 
test('something');

Aqui você tem todos ( src ):

E se

== (sua negação ! = )

=== (sua negação ! == )

P: A função foi chamada sem argumentos, tornando os dados uma variável indefinida e gerando um erro nos dados! = Null.

R: Sim, dataserá definido como indefinido. Consulte a seção 10.5 Instanciação de encadernação da declaração das especificações. Mas acessar um valor indefinido não gera um erro. Você provavelmente está confundindo isso com o acesso a uma variável não declarada no modo estrito, o que gera um erro.

P: A função foi chamada especificamente com null (ou indefinido), como argumento. Nesse caso, data! = Null já protege o código interno, tornando inútil && data! == indefinido.

P: A função foi chamada com um argumento não nulo; nesse caso, passará trivialmente os dados! = Null e data! == indefinidos.

A: correto. Observe que os seguintes testes são equivalentes:

data != null
data != undefined
data !== null && data !== undefined

Consulte a seção 11.9.3 O algoritmo de comparação de igualdade de igualdade e a seção 11.9.6 O algoritmo de comparação de igualdade estrita da especificação.

Eu acho que testar variáveis ​​para valores que você não espera não é uma boa ideia em geral. Porque o teste como você pode considerar como escrever uma lista negra de valores proibidos. Mas e se você esquecer de listar todos os valores proibidos? Alguém, até você, pode decifrar seu código transmitindo um valor inesperado. Portanto, uma abordagem mais apropriada é semelhante à lista de permissões - testando variáveis ​​apenas para os valores esperados, não inesperados. Por exemplo, se você espera que o valor dos dados seja uma sequência, em vez disso:

function (data) {
  if (data != null && data !== undefined) {
    // some code here
    // but what if data === false?
    // or data === '' - empty string?
  }
}

faça algo assim:

function (data) {
  if (typeof data === 'string' && data.length) {
    // consume string here, it is here for sure
    // cleaner, it is obvious what type you expect
    // safer, less error prone due to implicit coercion
  } 
}

typeof foo === "undefined"é diferente de foo === undefined, nunca os confunda. typeof foo === "undefined"é o que você realmente precisa. Além disso, use !==no lugar de!=

Portanto, a declaração pode ser escrita como

function (data) {
  if (typeof data !== "undefined" && data !== null) {
    // some code here
  }
}

Editar:

Você não pode usar foo === undefinedpara variáveis ​​não declaradas.

var t1;

if(typeof t1 === "undefined")
{
  alert("cp1");
}

if(t1 === undefined)
{
  alert("cp2");
}

if(typeof t2 === "undefined")
{
  alert("cp3");
}

if(t2 === undefined) // fails as t2 is never declared
{
  alert("cp4");
}

A maneira simples de fazer seu teste é:

function (data) {
    if (data) { // check if null, undefined, empty ...
        // some code here
    }
}

var a;
alert(a); //Value is undefined

var b = "Volvo"; 
alert(b); //Value is Volvo

var c = null;
alert(c); //Value is null