diferente - undefined javascript

typeof!== “undefined” vs.!=null

Question

A menudo veo el código JavaScript que comprueba los parámetros no definidos, etc.

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

Esto parece un poco inútil, ya que implica tanto una búsqueda de tipos como una comparación de cadenas, por no mencionar su verbosidad. Sin embargo, es necesario porque ''indefinido'' podría ser renombrado. Mi pregunta es: ¿Cómo es ese código mejor que este enfoque?

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

Que yo sepa, no se puede redefinir nulo, por lo que no se romperá inesperadamente. Y, debido a la coacción de tipo del operador! =, Esto comprueba tanto el valor indefinido como el nulo ... que a menudo es exactamente lo que desea (por ejemplo, para parámetros de función opcionales). Sin embargo, esta forma no parece generalizada, e incluso hace que JSLint te grite por usar el operador evil! =. ¿Por qué se considera este estilo malo?

Answer 1

Buen camino:

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

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

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

Answer 2

De hecho, me he topado con if (typeof input !== ''undefined'') en este escenario donde se usa 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.

Answer 3

Realmente no deberías preocuparte por el renombrado de undefined. Si alguien cambia el nombre de undefined, tendrá 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 de inmediato) como esta:

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

Si está trabajando con variables globales (lo cual ya es incorrecto) en un entorno de navegador, me gustaría verificar si no está definido de esta manera:

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

Dado que las variables globales son parte del objeto de la ventana, simplemente puede verificar contra indefinido en lugar de convertir a una cadena y comparar cadenas.

Además de eso, ¿por qué sus variables no están definidas? He visto muchos códigos en los que verifican la existencia de una variable y realizan alguna acción basada en eso. Ni una vez he visto donde este enfoque ha sido correcto.

Answer 4

Si está realmente preocupado por la redefinición indefinida, puede protegerse contra esto con un 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 que el nombre undefined refiera a un nuevo valor, pero no cambia el valor real de undefined .

Answer 5

Si se declara la variable (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á que usar typeof para evitar un typeof de ReferenceError .

Si espera que se redefina lo no definido, puede ajustar su código de esta manera:

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

Answer 6

También puede utilizar el operador void para obtener un valor no definido:

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

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

Answer 7

typeof permite que el identificador nunca haya sido declarado antes. Así que es más seguro en ese sentido:

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

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

Answer 8

(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

Answer 9

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!

Answer 10

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

Answer 11

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

funciona 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, así que

else if (input) { ... }

lo hace.

Si un programa redefine undefined , de todos modos es realmente un error mental.

La única razón por la que puedo pensar es en la compatibilidad con IE4, no entendía la palabra clave undefined (que en realidad no es una palabra clave, desafortunadamente), pero los valores del curso podrían undefined estar undefined , por lo que tenía que tener esto:

var undefined;

y la comparación anterior funcionaría bien.

En su segundo ejemplo, ¿probablemente necesita paréntesis dobles para hacer feliz a la pelusa?