typeof!== "undefined" frente!= nulo

Si la variable se declara (ya sea con la palabra clave var, como un argumento de función, o como una variable global), creo que la mejor manera de hacerlo es:

if (my_variable === undefined)

JQuery lo hace, así que es lo suficientemente bueno para mí: -)

De lo contrario, tendrás que usar typeof para evitar un ReferenceError.

Si espera que undefined sea redefinido, podría envolver su código de la siguiente manera:

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

Buen camino:

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

Pero la mejor manera es comprobar a través de:

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

Realmente no debería preocuparse por el cambio de nombre de undefined. Si alguien cambia el nombre de undefined, estará en muchos más problemas que solo unos pocos si los cheques fallan. Si realmente desea proteger su código, envuélvalo en una IFFE (expresión de función invocada inmediatamente) como esta:

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

Si está trabajando con variables globales (lo cual ya está mal) en un entorno de navegador, revisaría indefinido de la siguiente manera:

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

Dado que las variables globales son parte del objeto window, puede simplemente comprobar contra indefinido en lugar de casting a una cadena y comparar cadenas.

Además de eso, ¿por qué no están definidas sus variables? He visto un montón de código donde comprobar una existencia de variables y realizar alguna acción basada en eso. Ni una sola vez he visto dónde ha sido correcto este enfoque.

Si realmente le preocupa que undefined sea redefinido, puede protegerse contra esto con algún 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;
}

Esto funciona porque cuando alguien escribe undefined = "foo" solo deja el nombre undefined referencia a un nuevo valor, pero no cambia el valor real de undefined.

También puede usar el operador void para obtener un valor indefinido:

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

(Y sí, como se señaló en otra respuesta, esto lanzará un error si la variable no fue declarada, pero este caso a menudo se puede descartar ya sea por inspección de código, o por refactorización de código, por ejemplo, usando window.input !== void 0 para probar variables globales o agregando var input.)

En realidad me he encontrado con if (typeof input !== 'undefined') en este escenario donde se está utilizando para proporcionar parámetros de función predeterminados:

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!

ES6 proporciona nuevas formas de introducir parámetros de función predeterminados de esta manera:

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

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

Esto es menos detallado y más limpio que la primera opción.

(function(){

  var a= b = 3;
  var ed = 103;
  
})();



//console.log(ed); //ed is not defined

console.log("a defined? " + (typeof a !== 'undefined')); //no define
console.log("b defined? " + (typeof b !== 'undefined')); //yes define
console.log(typeof(b)); //number
console.log(typeof(4+7));   //number
console.log(b); //3
console.log(typeof("4"+"7")); //string
var e= "ggg";
console.log(typeof(e)); //string
 var ty=typeof(b);
console.log(ty); //number
console.log(typeof false); //boolean
console.log(typeof 1); //number
console.log(typeof 0); //number
console.log(typeof true); //boolean


console.log(typeof Math.tan);  //function
console.log(typeof function(){}); //function 

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

//if(neverDeclared == null) //showing error 


console.log(typeof {a:1}); //object
console.log(typeof null); //object
console.log(typeof JSON); //object
console.log(typeof Math); //object
console.log(typeof /a-z/); //object
console.log(typeof new Date()); //object

console.log(typeof afbc); //undefined
//console.log(typeof new);//error

document.write("<br> * oprator as math ");
var r=14*"4";
document.write(r);

document.write("<br> + oprator as string ");
var r=14+"44";
document.write(r);

document.write("<br> Minus Operator work as mathematic ");
var r=64-"44";
document.write(r);


document.write("<br>");
console.log(typeof(4*"7")); //returns number
console.log(typeof(4+"7")); //returns string




 

Interview Question in JavaScript

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

  console.log(greeting,name);
}

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

//ES6 provides new ways of introducing default function parameters this way:

function greet2(name = 'Student', greeting = 'Welcome') {
//  return '${greeting} ${name}!';
console.log(greeting,name);
}

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

var bar = null;
console.log(typeof bar === "object"); //true yes 
//because null a datatype of object

var barf = "dff";
console.log(typeof barf.constructor);//function


console.log(Array.isArray(bar));//falsss


console.log((bar !== null) && (bar.constructor === Object)); //false

console.log((bar !== null) && (typeof bar === "object"));  // logs false
//because bar!==null, bar is a object


console.log((bar !== null) && ((typeof bar === "object") || (typeof bar === "function"))); //false

console.log(typeof bar === typeof object); //false
console.log(typeof bar2 === typeof undefined); //true
console.log(typeof bar3 === typeof undefinedff); //true
console.log(typeof bar2 == typeof undefined); //true

console.log((bar !== null) && (typeof bar === "object") && (toString.call(bar) !== "[object Array]")); //false

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

Funciona muy bien. Por supuesto, no es una comparación null, pero generalmente encuentro que si necesito distinguir entre undefined y null, en realidad necesito distinguir entre undefined y cualquier valor falso, por lo que

else if (input) { ... }

Lo hace.

Si un programa redefine undefined es realmente braindead de todos modos.

La única razón que se me ocurre fue para la compatibilidad con IE4, no entendía la palabra clave undefined (que en realidad no es una palabra clave, desafortunadamente), sino de los valores del curso podrían ser undefined, así que tenías que tener esto:

var undefined;

Y la comparación anterior funcionaría bien.

En tu segundo ejemplo, probablemente necesites paréntesis dobles para hacer feliz a la pelusa?