typeof!== "undefined" et!= NULL

si la variable est déclarée (soit avec le mot-clé var , comme argument de fonction, ou comme variable globale), je pense que la meilleure façon de le faire est:

if (my_variable === undefined)

jQuery le fait, il est donc assez bon pour moi: -)

sinon, vous devrez utiliser typeof pour éviter un ReferenceError .

si vous vous attendez à ce que non défini soit redéfini, vous pouvez envelopper votre code comme ceci:

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

bon sens:

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

mais la meilleure façon de regarder est de vérifier via:

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

vous ne devriez pas vraiment vous soucier de l'indéfini étant renommé. Si quelqu'un renomme Non défini, vous serez dans beaucoup plus de problèmes que quelques-uns si les vérifications échouent. Si vous voulez vraiment protéger votre code, enveloppez - le dans une IFFE (expression de fonction immédiatement invoquée) comme ceci:

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

si vous travaillez avec des variables globales (ce qui est déjà erroné) dans un environnement de navigateur, je vérifierais pour non défini comme ceci:

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

depuis les variables globales font partie de l'objet window, vous pouvez simplement vérifier si elles ne sont pas définies au lieu de lancer une chaîne de caractères et de comparer les chaînes de caractères.

de plus, Pourquoi vos variables ne sont-elles pas définies? J'ai vu beaucoup de code où ils vérifient l'existence d'une variable et effectuent une action basée sur cela. Pas une seule fois je n'ai vu où cette approche a été correcte.

si vous êtes vraiment inquiet que non défini être redéfini, vous pouvez protéger contre cela avec une méthode d'aide comme ceci:

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

cela fonctionne parce que quand quelqu'un écrit undefined = "foo" il laisse seulement le nom undefined référence à une nouvelle valeur, mais il ne change pas la valeur réelle de undefined .

vous pouvez également utiliser l'opérateur void pour obtenir une valeur non définie:

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

(et oui, comme noté dans une autre réponse, cela va jeter une erreur si la variable n'a pas été déclarée, mais ce cas peut souvent être exclu soit par l'inspection du code, ou par le remaniement du code, par exemple en utilisant window.input !== void 0 pour tester les variables globales ou en ajoutant var input .)

j'ai réellement trouvé si (typeof input !== 'undefined') dans ce scénario où il est utilisé pour fournir des paramètres de fonction par défaut:

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 offre de nouvelles façons d'introduire par défaut les paramètres de la fonction de cette façon:

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

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

c'est moins verbeux et plus propre que la première option.

(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) { ... }

fonctionne très bien. Ce n'est bien sûr pas une comparaison null , mais je trouve généralement que si je dois distinguer entre undefined et null , je dois plutôt distinguer entre undefined et juste n'importe quelle fausse valeur, donc

else if (input) { ... }

le fait.

Si un programme redéfinit undefined c'est vraiment braindead de toute façon.

la seule raison à laquelle je pense était pour IE4 compatibilité, il n'a pas compris le mot-clé undefined (qui n'est pas en fait un mot-clé, malheureusement), mais des valeurs de cours pourrait être undefined , donc vous devez avoir ceci:

var undefined;

et la comparaison ci-dessus fonctionnerait très bien.

dans votre deuxième exemple, vous avez probablement besoin de doubles parenthèses pour rendre la peluche heureuse?