टाइपोफ़! == "अपरिभाषित" बनाम! = शून्य

Question

मैं अक्सर जावास्क्रिप्ट कोड देखता हूं जो अपरिभाषित मापदंडों आदि की जांच करता है।

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

यह एक तरह से बेकार लगता है, क्योंकि इसमें एक प्रकार का लुकअप और एक स्ट्रिंग तुलना दोनों शामिल हैं, न कि इसकी वाचालता का उल्लेख करने के लिए। यह आवश्यक है क्योंकि undefinedइसका नाम बदला जा सकता है, हालांकि।

मेरा प्रश्न है:
यह कोड इस दृष्टिकोण से कैसे बेहतर है:

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

जहाँ तक मुझे पता है, आप फिर से परिभाषित नहीं कर सकते null, तो यह अप्रत्याशित रूप से टूटने वाला नहीं है। और, !=ऑपरेटर के प्रकार-ज़बरदस्ती के कारण , यह दोनों के लिए जाँच करता है undefinedऔर null... जो अक्सर वही होता है जो आप चाहते हैं (जैसे वैकल्पिक फ़ंक्शन मापदंडों के लिए)।

फिर भी यह रूप व्यापक नहीं लगता है, और यह JSLint को आपके द्वारा दुष्ट !=ऑपरेटर का उपयोग करने के लिए चिल्लाता है ।

क्यों इसे खराब शैली माना जाता है?

Comments

@ मार्सेल, वास्तविक अंतर नहीं है, लेकिन इसे करने के दो कारण हैं। एक, यह है कि कुछ के लिए यह पढ़ने के लिए स्पष्ट है। और दूसरा कारण, यह है कि यह एक चर के आकस्मिक ओवरराइटिंग को रोकता है। क्या आपने कभी ऐसा किया है: यदि (foo = "value") जब तुलना करने का इरादा हो। यदि आपको असाइनमेंट / तुलना ऑपरेटर में चर को उलटने की आदत है, तो आपको वह समस्या नहीं होगी।

— लेके

कुछ के लिए (मेरे सहित) यह वास्तव में पढ़ने के लिए अधिक कठिन है। इसके अलावा, अधिकांश IDE आपको आकस्मिक असाइनमेंट की चेतावनी देते हैं। लेकिन मैं अभी भी इस फॉर्म का उपयोग करता हूं यदि तुलनात्मक चर बहुत लंबा है। YMMV।

— जॉन्डोडो

@ मार्सेलकॉर्पेल इसे "योडा स्थिति" कहा जाता है: umumble.com/blogs/Programming/321

— kol

इसे पढ़ना ज्यादा मुश्किल है। एक नहीं कहता है "खाली बोतल नहीं है"।

— नोएल अब्राहम

if (null != input)अंग्रेजी बोलने वाले के लिए केवल "योडा स्पीक" (एक मैं .... उउउम्म्म्मम) है, इसलिए यदि वे एक ही चीज की बराबरी करते हैं तो यह वास्तव में सिर्फ शब्दार्थ है। IMHO।

— webLacky3rdClass

Answer 1

typeof सुरक्षित है क्योंकि यह पहचानकर्ता को पहले घोषित नहीं किया गया है:

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

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

Comments

अगर (टाइपऑफ डिक्लेयर नहीं किया गया! == "अपरिभाषित") && (neverDeclared! == null)) {वापसी सही है; } और {झूठे वापस; }

— एंथनी डिसेंटी

अशक्त / अपरिभाषित के साथ तुलना करते समय === का उपयोग करें।

— MyGGaN

@MyGaaN केवल अगर आप दोनों के बीच अंतर करना चाहते हैं। कई मामलों में, ==बेहतर हो सकता है, क्योंकि यह अशक्त और अपरिभाषित दोनों के लिए परीक्षण करता है।

— सीमोनस्टार

मुझे टाइपोफर somevar == 'अपरिभाषित' और टाइपोफ़ेयर somevar === 'अपरिभाषित' के बीच कोई अंतर नहीं मिल सकता है, क्योंकि टाइपोफ़ हमेशा स्ट्रिंग देता है। अशक्त के लिए यह 'ऑब्जेक्ट' लौटाएगा। या हो सकता है कि मैं गलत हूं?

— टॉमटॉम

मेरा मानना ​​है कि @ टॉमटॉम की टिप्पणी इस समस्या की जड़ है - मैं यह नहीं समझ सकता कि मूल्य का तुलना करने पर ऑपरेटर !==या ===संचालक का उपयोग क्यों करेंगे जिनके प्रकार को एक स्ट्रिंग के रूप में जाना जाता है।

— निकोलस रिनाडो

Answer 2

यदि चर घोषित किया जाता है (या तो varकीवर्ड के साथ , फ़ंक्शन तर्क के रूप में, या वैश्विक चर के रूप में), मुझे लगता है कि इसे करने का सबसे अच्छा तरीका है:

if (my_variable === undefined)

jQuery यह करता है, इसलिए यह मेरे लिए काफी अच्छा है :-)

अन्यथा, आपको typeofबचने के लिए उपयोग करना होगा ReferenceError।

यदि आप अनिर्धारित होने की अपेक्षा करते हैं, तो आप अपने कोड को इस तरह से लपेट सकते हैं:

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

या voidऑपरेटर के माध्यम से इसे प्राप्त करें :

const undefined = void 0;
// also safe

Comments

यदि अपरिभाषित पहले से ही परिभाषित किया गया है, तो क्या आप अपरिभाषित नाम के पैरामीटर के माध्यम से इसे अपने अनाम फ़ंक्शन में नहीं दे रहे हैं, कुछ भी पूरा नहीं कर रहे हैं?

— एंथनी डिसेंटी

@Anthony DiSanti: नहीं, undefinedफ़ंक्शन मान को दिया गया नाम है, न कि इसका मान। फ़ंक्शन को कुछ भी नहीं दिया गया है, जिसका अर्थ है कि पहले पैरामीटर का मान अपरिभाषित है।

— जॉय एडम्स

मेरी गलती है, निम्नलिखित के लिए धन्यवाद। मैंने अपना वोट हटा दिया है, इसके बारे में क्षमा करें।

— एंथनी डिसेंटी

जब आप इसे शुरू करने के लिए सही ढंग से कर सकते हैं, तो किसी अन्य डेवलपर द्वारा घोषित अपरिभाषित को संभालने के लिए अपवाद क्यों लिखें? jQuery आरंभिक अनाम फ़ंक्शन को लपेटता है जैसा कि आप अपने फ़ंक्शन में दिखाते हैं कि यह सुनिश्चित करने के लिए अपरिभाषित को परिभाषित नहीं किया गया था और न्यूनतम आकार को कम करने के लिए। सीधे शब्दों में कहें तो अगर यह इस तरह से अप्रत्याशित परिणाम दे सकता है, तो इसे टाइप करने से बचने के लिए आलसी प्रोग्रामिंग के लिए जोखिम क्यों है (टाइपऑफ चर === 'अपरिभाषित')। यदि हम चाहते थे (टाइपो वैरिएबल === 'ऑब्जेक्ट') तो क्या हमें एक डिफॉल्ट वैरिएबल प्रदान करना चाहिए जो एक ऑब्जेक्ट है और साथ ही साथ हम कर सकते हैं (वेरिएबल === ऑब्जेक्ट)?

— fyrye

Answer 3

अच्छा रास्ता:

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

लेकिन सबसे अच्छा दिखने वाला तरीका है:

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

Comments

var अपरिभाषित = कार्य () {}; if (टाइपऑफ़ नेवरडेल्ड === टाइपो अपरिभाषित); neverDecalred! = 'function'; jsfiddle.net/hbPZ5 वापसी टाइपो var; एक स्ट्रिंग देता है। कोई त्रुटि या तार नहीं लेकिन हमेशा अपेक्षित परिणाम नहीं देंगे। दी गई डेवलपर्स को अपरिभाषित घोषित नहीं करना चाहिए, लेकिन कुछ ढांचे और पुस्तकालय हैं जो करते हैं।

— fyrye

मैं मुख्य रूप से उपयोग करता हूं, if (typeof neverDeclared === typeof undefined) { लेकिन लिंट एक त्रुटि फेंकता है। "एक स्ट्रिंग की उम्मीद है और इसके बजाय 'टाइपोफ़' देखा है।" आप इस त्रुटि के आसपास कैसे पहुंचेंगे? क्या हमें लिंट की मांगों को प्रस्तुत करना चाहिए और इसके बदले 'अच्छे तरीके' का उपयोग करना चाहिए?

— अयेलिस

@fyrye क्या आप किसी भी जावास्क्रिप्ट लाइब्रेरी / चौखटे के बारे में जानते हैं जो वास्तव में अपरिभाषित है? मुझे पता है कि यह संभव है; लेकिन मैं जंगली उदाहरण में एक खोज करना चाहूंगा, "यहां वह जगह है जहां आप इस जंगली वाइल्डबेस्ट का सामना कर सकते हैं!"

— Bigtunacan

typeof neverDeclared === typeof void 0; --ड

— एलेक्स यारोशेविच

यह त्रुटिपूर्ण है, क्योंकि वास्तव में आप केवल एक निश्चित चर ("अपरिभाषित") पर निर्भर हैं, जिसे परिभाषित नहीं किया जा रहा है। जो कि अन्य पोस्ट के अनुसार गलत हो सकता है। आप हमेशा कर सकते हैं if(typeof neverDeclared === typeof undefined_variable_with_a_name_assumed_to_be_never_defined) {लेकिन यह लंबे समय तक है।

— पियरे-ओलिवियर वेर्स

Answer 4

आपको वास्तव में नाम नहीं होने के बारे में चिंता नहीं करनी चाहिए। अगर कोई अपरिभाषित का नाम नहीं लेता है, तो आप चेक फेल होने पर कुछ ही की तुलना में बहुत अधिक परेशानी में होंगे। यदि आप वास्तव में अपने कोड को सुरक्षित रखना चाहते हैं, तो इसे IFFE में लपेटें (तुरंत फ़ंक्शन एक्सप्रेशन)

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

यदि आप एक वैश्विक वातावरण में वैश्विक चर (जो पहले से ही गलत है) के साथ काम कर रहे हैं, तो मैं इस तरह अपरिभाषित की जाँच करूँगा:

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

चूँकि ग्लोबल वैरिएबल विंडो ऑब्जेक्ट का एक हिस्सा है, आप बस एक स्ट्रिंग के लिए अपरिहार्य और स्ट्रिंग की तुलना करने के बजाय अपरिभाषित के खिलाफ जांच कर सकते हैं।

उसके ऊपर, आपके चर क्यों परिभाषित नहीं किए गए हैं? मैंने बहुत से कोड देखे हैं जहाँ वे एक चर अस्तित्व की जाँच करते हैं और उसके आधार पर कुछ क्रिया करते हैं। एक बार मैंने यह नहीं देखा कि यह दृष्टिकोण कहाँ तक सही है।

Comments

इनपुट सत्यापन और निर्भरता जाँच दोनों इसका उपयोग करने के लिए अच्छे कारण हैं। यदि मेरे पास जावास्क्रिप्ट फाइलें हैं जो लोड की गई या init ऑब्जेक्ट्स घोषित की गई अन्य फ़ाइलों पर निर्भर हैं, तो यह उन वस्तुओं या गुणों का परीक्षण करने के लिए उपयोगी है जो एक फाइल अपरिभाषित के खिलाफ निर्भर हैं और आपकी स्क्रिप्ट को अप्रत्याशित रूप से विफल होने देने के बजाय एक अच्छा अपवाद फेंकती हैं।

— अमेरिकन

ऐसा लगता है कि आपको एएमडी (आवश्यकताएं) में कुछ की आवश्यकता हो सकती है (आवश्यकता है)

— Peeter

या मैं अपनी परियोजना में एक और पुस्तकालय को शामिल करने के बजाय बस एक बहुत ही सरल तुलना करना चाह सकता हूं :)

— AmericanUmlaut

संपादित करने में बहुत देर हो चुकी है :( जोड़ना चाहते थे - आवश्यकता.जेएस इनपुट सत्यापन के लिए भी सही समाधान नहीं है (मेरे प्रारंभिक टिप्पणी में उल्लेखित init ऑब्जेक्ट)। यदि आपको कोई ऐसी वस्तु मिल गई है जिसकी आपको कुछ के साथ आबादी होने की उम्मीद है। मान लोड होने से पहले, तब यह एक अपवाद फेंकने के लिए उपयोगी है यदि वे परिभाषित नहीं हैं।

— AmericanUmlaut

नहीं, क्योंकि टाइपोफ़ एक स्ट्रिंग लौटाता है। तो टाइपऑफ अपरिभाषित रिटर्न "अपरिभाषित"। window.input! == अपरिभाषित (यदि आपका वैरिएबल वैश्विक ख़राब है)

— Peeter

Answer 5

यदि आप वास्तव में अपरिभाषित पुनर्परिभाषित होने के बारे में चिंतित हैं, तो आप इस तरह से कुछ सहायक विधि से रक्षा कर सकते हैं:

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

यह काम करता है क्योंकि जब कोई लिखता है undefined = "foo"तो वह केवल नाम undefined को एक नए मूल्य पर जाने देता है, लेकिन वह वास्तविक मूल्य को नहीं बदलता है undefined।

Comments

हालाँकि, आपने अब एक फ़ंक्शन कॉल शुरू किया है, जो प्रदर्शन को नुकसान पहुंचाएगा।

— टिम डाउन

मुझे नहीं लगता कि यह फ़ंक्शन कॉल प्रदर्शन को मार देगा, यह बहुत अधिक संभावना है कि DOM अड़चन होगा। लेकिन वैसे भी, यदि आपके पास अपना सामान्य बड़ा अनाम फ़ंक्शन है जिसमें आपकी लाइब्रेरी शामिल है, तो आप undefined_checkशीर्ष पर भी परिभाषित कर सकते हैं और फिर इसे अपने कोड में हर जगह उपयोग कर सकते हैं।

— इवो ​​वेटजेल

सहमत हुए, और मैं यह नहीं कह रहा कि यह एक बुरा विचार है। यह केवल यह इंगित करने के लायक है कि इस फ़ंक्शन को कॉल करना typeofचेक करने की तुलना में धीमी गति से प्रदर्शन करेगा ।

— टिम डाउन

मुझे लगता है कि यह कार्य इतना सरल है कि यह इनलेट होगा, इसलिए प्रदर्शन प्रभावित नहीं होगा।

— ह्यूज

@TimDown: पहला कोड लिखें, जो पठनीय हो। दूसरा लिखने का कोड, अगर यह कायम है, और फिर, अगर यह वास्तव में धीमा है। फिर प्रदर्शन के बारे में सोचें।

— andreas

Answer 6

आप अपरिभाषित मान प्राप्त करने के लिए शून्य ऑपरेटर का भी उपयोग कर सकते हैं:

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

(और हाँ, जैसा कि एक अन्य उत्तर में उल्लेख किया गया है, यह एक त्रुटि को फेंक देगा यदि चर घोषित नहीं किया गया था, लेकिन इस मामले को अक्सर कोड निरीक्षण, या कोड रीफैक्टरिंग, जैसे कि window.input !== void 0वैश्विक चर का परीक्षण करने या जोड़ने के लिए उपयोग करके खारिज किया जा सकता है var input।)

Answer 7

अगर वास्तव (typeof input !== 'undefined')में इस परिदृश्य में डिफ़ॉल्ट फ़ंक्शन पैरामीटर प्रदान करने के लिए इसका उपयोग किया जा रहा है, तो मैं वास्तव में आया हूं :

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 डिफ़ॉल्ट फ़ंक्शन मापदंडों को इस तरह से पेश करने के नए तरीके प्रदान करता है:

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

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

यह पहले विकल्प की तुलना में कम वर्बोज़ और क्लीनर है।

Answer 8

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 9

(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

Comments

क्या आप एक स्पष्टीकरण प्रदान कर सकते हैं?

— झपट्टा गोफुन्डे रिलेक्सेंसिंग

छह संभावित मूल्य हैं जो टाइपोफ़ रिटर्न करते हैं: ऑब्जेक्ट, बूलियन, फ़ंक्शन, संख्या, स्ट्रिंग और अपरिभाषित। टाइपऑफ़ ऑपरेटर का उपयोग उसके ऑपरेटर के डेटा प्रकार (एक स्ट्रिंग वापस करने) के लिए किया जाता है। ऑपरेंड या तो एक शाब्दिक या डेटा संरचना हो सकता है जैसे कि एक चर, एक फ़ंक्शन, या एक ऑब्जेक्ट। ऑपरेटर डेटा प्रकार लौटाता है। सिंटेक्स टाइपऑफ़ ऑपरेंड या टाइपोफ़ (ऑपरेंड)

— अविनाश मौर्य

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

ठीक काम करता है। यह बिल्कुल नहीं एक की है nullतुलना, लेकिन मैं आम तौर पर लगता है कि अगर मैं के बीच अंतर करने की जरूरत है undefinedऔर null, मैं वास्तव में नहीं बल्कि के बीच अंतर करने की जरूरत है undefinedऔर बस किसी भी झूठी मूल्य, इसलिए

else if (input) { ... }

क्या यह।

यदि कोई प्रोग्राम फिर से परिभाषित करता है undefined करता है तो यह वास्तव में वैसे भी बहुत अच्छा है।

एकमात्र कारण जिसके बारे में मैं सोच सकता था वह IE4 संगतता के लिए था, यह undefinedकीवर्ड को नहीं समझता था (जो वास्तव में एक कीवर्ड नहीं है, दुर्भाग्य से), लेकिन निश्चित रूप से मूल्य हो सकते हैं undefined , इसलिए आपको यह करना होगा:

var undefined;

और ऊपर की तुलना ठीक काम करेगी।

अपने दूसरे उदाहरण में, आपको लिंट को खुश करने के लिए संभवतः डबल कोष्ठक की आवश्यकता है?

Comments

आपका इनपुट पर input == undefinedवापस आ जाएगा । truenull

— एमजील जूल