Verificação nula do JavaScript

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

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

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

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

Também, as variáveis podem ter o "valor indefinido" se não forem inicializados:

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

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

No entanto, uma vez que a variável "data" é sempre definida, uma vez que é um parâmetro de função formal, usar o operador "Typ of" É desnecessário e você pode comparar 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 que é definido e não é nulo..."

Q: a função foi chamada sem argumentos, tornando os dados uma variável indefinida, e levantando um erro nos dados != nulo.

A: SIM, data será definido como indefinido. Ver secção 10.5 Declaração de instanciamento da especificação. Mas aceder a um valor indefinido não cria um erro. Você provavelmente está confundindo isso com acessar uma variável não declarada em modo estrito, o que gera um erro.

P: a função foi chamado especificamente com null (ou indefinido), como seu argumento, em que caso Dados != null já protege o código interno, renderização & dados != = indefinido inútil.

Q: a função foi chamada com um argumento não nulo, caso em que passará trivialmente ambos os dados != null and data !== indefinido.

A: Correcto. Note - se que os seguintes ensaios são equivalentes:

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

Ver secção 11.9.3 o algoritmo de comparação abstracta da igualdade e secção 11.9.6 o algoritmo de comparação da igualdade estrita da especificação.

Eu acho que testar variáveis para valores que você não espera não é uma boa idéia em geral. Porque o teste como seu você pode considerar como escrever uma lista negra de valores proibidos. Mas e se te esqueceres de listar todos os valores proibidos? Alguém, até tu, pode decifrar o teu código com um valor inesperado. Então uma abordagem mais apropriada é algo como variáveis de teste de listas brancas apenas para os valores esperados, não inesperados. Por exemplo, se você espera que o valor dos dados seja um string, em vez disto:

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

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. É o que realmente precisas. Além disso, use !== em substituição de !=

Para que a declaração possa ser escrita como

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

Editar:

Não pode utilizar foo === undefined para 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 forma simples de fazer o 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