typeof! == "indefinido" vs.! = nulo

Muitas vezes vejo código JavaScript que verifica parâmetros indefinidos, etc., desta maneira:

if (typeof input !== "undefined") {
    // do stuff
}

Isso parece meio desperdício, pois envolve uma pesquisa de tipo e uma comparação de cadeias, sem mencionar sua verbosidade. É necessário porque undefinedpode ser renomeado, no entanto.

Minha pergunta é:
como esse código é melhor do que essa abordagem:

if (null != input) {
    // do stuff
}

Tanto quanto eu sei, você não pode redefinir null, então não vai quebrar inesperadamente. E, devido à coerção de tipo do !=operador, isso verifica os dois undefinede null... o que geralmente é exatamente o que você deseja (por exemplo, parâmetros de função opcionais).

No entanto, esse formulário não parece generalizado e até faz com que o JSLint grite com você por usar o !=operador incorreto .

Por que isso é considerado um estilo ruim?

typeof é mais seguro, pois permite que o identificador nunca tenha sido declarado antes:

if(typeof neverDeclared === "undefined") // no errors

if(neverDeclared === null) // throws ReferenceError: neverDeclared is not defined

Se a variável for declarada (com a varpalavra - chave, como argumento de função ou como variável global), acho que a melhor maneira de fazer isso é:

if (my_variable === undefined)

jQuery faz isso, então é bom o suficiente para mim :-)

Caso contrário, você precisará usar typeofpara evitar a ReferenceError.

Se você espera que o indefinido seja redefinido, você pode agrupar seu código assim:

(function(undefined){
    // undefined is now what it's supposed to be
})();

Ou obtenha-o através do voidoperador:

const undefined = void 0;
// also safe

bom caminho:

if(typeof neverDeclared == "undefined") //no errors

Mas a melhor maneira é verificar através de:

if(typeof neverDeclared === typeof undefined) //also no errors and no strings

Você realmente não deve se preocupar em renomear o indefinido. Se alguém renomear indefinido, você terá muito mais problemas do que apenas alguns se as verificações falharem. Se você realmente deseja proteger seu código, envolva-o em uma IFFE (expressão de função imediatamente chamada) assim:

(function($, Backbone, _, undefined) {
    //undefined is undefined here.
})(jQuery, Backbone, _);

Se você estiver trabalhando com variáveis ​​globais (que já estão erradas) em um ambiente de navegador, verifiquei indefinidamente assim:

if(window.neverDefined === undefined) {
    //Code works
}

Como as variáveis ​​globais fazem parte do objeto de janela, você pode simplesmente verificar o indefinido em vez de converter em uma string e comparar as strings.

Além disso, por que suas variáveis ​​não estão definidas? Eu já vi muitos códigos em que eles verificam a existência de variáveis ​​e executam alguma ação com base nisso. Nem uma vez vi onde essa abordagem estava correta.

Se você está realmente preocupado com a redefinição indefinida, pode se proteger contra isso com algum método auxiliar como este:

function is_undefined(value) {
   var undefined_check; // instantiate a new variable which gets initialized to the real undefined value
   return value === undefined_check;
}

Isso funciona porque quando alguém escreve, undefined = "foo"ele apenas permite que o nome undefined faça referência a um novo valor, mas ele não altera o valor real de undefined.

Você também pode usar o operador void para obter um valor indefinido:

if (input !== void 0) {
    // do stuff    
}

(E sim, como observado em outra resposta, isso gerará um erro se a variável não tiver sido declarada, mas esse caso pode ser descartado com freqüência por inspeção de código ou refatoração de código, por exemplo, usando window.input !== void 0para testar variáveis ​​globais ou adicionar var input.)

Na verdade, me deparei se (typeof input !== 'undefined')neste cenário em que ele está sendo usado para fornecer parâmetros de função padrão:

function greet(name, greeting) {
  name = (typeof name !== 'undefined') ?  name : 'Student';
  greeting = (typeof greeting !== 'undefined') ?  greeting : 'Welcome';

  return `${greeting} ${name}!`;
}

greet(); // Welcome Student!
greet('James'); // Welcome James!
greet('Richard', 'Howdy'); // Howdy Richard!

O ES6 fornece novas maneiras de introduzir parâmetros de função padrão desta maneira:

function greet(name = 'Student', greeting = 'Welcome') {
  return `${greeting} ${name}!`;
}

greet(); // Welcome Student!
greet('James'); // Welcome James!
greet('Richard', 'Howdy'); // Howdy Richard!

Isso é menos detalhado e mais limpo que a primeira opção.

if (input == undefined) { ... }

funciona muito bem. Obviamente, não é uma nullcomparação, mas geralmente acho que, se preciso distinguir entre undefinede null, na verdade, preciso distinguir entre undefinede qualquer valor falso, então

else if (input) { ... }

faz isso.

Se um programa redefine, undefinedele é realmente muito interessante.

A única razão pela qual consigo pensar foi na compatibilidade com o IE4, ela não entendeu a undefinedpalavra - chave (que não é realmente uma palavra-chave, infelizmente), mas é claro que os valores poderiam ser undefined , então você precisava disso:

var undefined;

e a comparação acima funcionaria bem.

No seu segundo exemplo, você provavelmente precisará de parênteses duplos para deixar o fiapo feliz?