JavaScript => तुलना संचालन

टिप्पणियों

बूलियन जबरदस्ती का उपयोग करते समय, निम्नलिखित मूल्यों को "झूठा" माना जाता है:

false
0
"" (खाली स्ट्रिंग)
null
undefined
NaN (संख्या नहीं, उदाहरण के लिए 0/0 )
document.all ¹ (ब्राउज़र संदर्भ)

बाकी सब कुछ "सत्य" माना जाता है।

_{ECMAScript विनिर्देश का} ¹ _{विलफुल उल्लंघन}

तर्क ऑपरेटर बूलियन के साथ

var x = true,
    y = false;

तथा

यदि दोनों भाव सत्य का मूल्यांकन करते हैं तो यह संचालक सही लौटेगा। यह बूलियन ऑपरेटर शॉर्ट-सर्किट को रोजगार होगा और मूल्यांकन नहीं होगा y अगर x मूल्यांकन करने के लिए false ।

x && y;

यह असत्य है, क्योंकि y असत्य है।

या

यदि दो में से एक भाव सत्य का मूल्यांकन करता है, तो यह ऑपरेटर सही लौटेगा। यह बूलियन ऑपरेटर शॉर्ट-सर्कुलेटिंग को रोजगार देगा और यदि x true मूल्यांकन करता है तो y का मूल्यांकन नहीं किया जाएगा।

x || y;

यह सच लौटेगा, क्योंकि x सत्य है।

नहीं

यदि सही पर अभिव्यक्ति सही है, और सही पर अभिव्यक्ति का सही मूल्यांकन करता है, तो यह ऑपरेटर गलत लौटेगा।

!x;

यह असत्य लौटेगा, क्योंकि x सत्य है।

सार समानता (==)

अमूर्त समानता ऑपरेटर के संचालन की तुलना एक सामान्य प्रकार में बदलने के बाद की जाती है। यह रूपांतरण कैसे होता है यह ऑपरेटर के विनिर्देश पर आधारित है:

== ऑपरेटर के लिए विशिष्टता:

7.2.13 सार समानता तुलना
तुलना x == y , जहाँ x और y मान हैं, true या false निर्माण करता true । इस तरह की तुलना निम्न प्रकार से की जाती है:
यदि Type(x) Type(y) , तो:
ए। सख्त समानता तुलना x === y प्रदर्शन करने का परिणाम लौटाएं।
यदि x null और y undefined , तो true लौटें।
यदि x undefined और y null , तो true लौटें।
यदि Type(x) Number और Type(y) String , तो तुलना x == ToNumber(y) का परिणाम x == ToNumber(y) ।
यदि Type(x) String और Type(y) Number , तो तुलना का परिणाम ToNumber(x) == y ।
यदि Type(x) Boolean , तो तुलना का परिणाम ToNumber(x) == y ।
यदि Type(y) Boolean , तो comparison x == ToNumber(y) का परिणाम comparison x == ToNumber(y) ।
यदि Type(x) या तो String , Number , या Symbol और Type(y) Object , तो तुलना का परिणाम x == ToPrimitive(y) ।
यदि Type(x) ऑब्जेक्ट है और Type(y) या तो String , Number , या Symbol , तो तुलनात्मक परिणाम के परिणाम को वापस ToPrimitive(x) == y ।
false ।

उदाहरण:

1 == 1;                     // true
1 == true;                  // true  (operand converted to number: true => 1)
1 == '1';                   // true  (operand converted to number: '1' => 1 )
1 == '1.00';                // true
1 == '1.00000000001';       // false
1 == '1.00000000000000001'; // true  (true due to precision loss)
null == undefined;          // true  (spec #2)
1 == 2;                     // false
0 == false;                 // true
0 == undefined;             // false
0 == "";                    // true

संबंधपरक ऑपरेटर (<, <=>,> =)

जब दोनों ऑपरेंड संख्यात्मक होते हैं, तो उनकी तुलना सामान्य रूप से की जाती है:

1 < 2        // true
2 <= 2       // true
3 >= 5       // false
true < false // false (implicitly converted to numbers, 1 > 0)

जब दोनों ऑपरेंड स्ट्रिंग्स होते हैं, तो उनकी तुलना लेक्सिकोग्राफिक (वर्णमाला क्रम के अनुसार) से की जाती है:

'a' < 'b'    // true
'1' < '2'    // true
'100' > '12' // false ('100' is less than '12' lexicographically!)

जब एक ऑपरेंड एक स्ट्रिंग होता है और दूसरा एक नंबर होता है, तो स्ट्रिंग तुलना से पहले नंबर में बदल जाती है:

'1' < 2      // true
'3' > 2      // true
true > '2'   // false (true implicitly converted to number, 1 < 2)

जब स्ट्रिंग गैर-संख्यात्मक होती है, तो संख्यात्मक रूपांतरण NaN ( NaN -ए-नंबर) देता है। NaN तुलना हमेशा false :

1 < 'abc'    // false
1 > 'abc'    // false

लेकिन null , undefined या खाली तारों के साथ संख्यात्मक मान की तुलना करते समय सावधान रहें:

1 > ''        // true
1 < ''        // false
1 > null      // true
1 < null      // false
1 > undefined // false
1 < undefined // false

जब एक ऑपरेंड एक ऑब्जेक्ट होता है और दूसरा नंबर होता है, तो ऑब्जेक्ट तुलना से पहले नंबर में बदल जाता है। विशेष रूप से null होने के कारण Number(null);//0

new Date(2015)< 1479480185280            // true
null > -1                                //true
({toString:function(){return 123}}) > 122  //true

असमानता

ऑपरेटर != का उल्टा होता है == ऑपरेटर।
वापस आ जाएगी true है, तो ऑपरेंड बराबर नहीं हैं।
यदि वे एक ही प्रकार के नहीं हैं तो जावास्क्रिप्ट इंजन दोनों ऑपरेंड को मिलान प्रकारों में बदलने की कोशिश करेगा। नोट: यदि दो ऑपरेंड में मेमोरी में अलग-अलग आंतरिक संदर्भ हैं, तो false वापस कर दिया जाएगा।

नमूना:

1 != '1'     // false
1 != 2       // true

ऊपर के नमूने में, 1 != '1' false , क्योंकि एक आदिम संख्या प्रकार की तुलना एक char मूल्य से की जा रही है। इसलिए, जावास्क्रिप्ट इंजन RHS मान के डेटाटाइप के बारे में परवाह नहीं करता है।

ऑपरेटर !== === ऑपरेटर का व्युत्क्रम है। यदि ऑपरेशंस समान नहीं हैं या यदि उनके प्रकार मेल नहीं खाते हैं, तो सही वापस आएगा।

उदाहरण:

1 !== '1'    // true
1 !== 2      // true
1 !== 1      // false

लॉजिक ऑपरेटर्स नॉन-बूलियन वैल्यूज़ (बूलियन कॉर्शन)

तार्किक या ( || सही करने के लिए), ओर पढ़ते हुए, पहले truthy मूल्य के लिए मूल्यांकन करेंगे। यदि कोई सत्य मान नहीं मिला है, तो अंतिम मान लौटाया जाता है।

var a = 'hello' || '';             // a = 'hello'
var b = '' || [];                  // b = []
var c = '' || undefined;           // c = undefined
var d = 1 || 5;                    // d = 1
var e = 0 || {};                   // e = {}
var f = 0 || '' || 5;              // f = 5
var g = '' || 'yay' || 'boo';      // g = 'yay'

तार्किक और ( && ), बाएं से दाएं पढ़ना, पहले गलत मूल्य का मूल्यांकन करेगा। यदि कोई गलत मान नहीं पाया जाता है, तो अंतिम मान लौटाया जाता है।

var a = 'hello' && '';                  // a = ''
var b = '' && [];                       // b = ''
var c = undefined && 0;                 // c = undefined
var d = 1 && 5;                         // d = 5
var e = 0 && {};                        // e = 0
var f = 'hi' && [] && 'done';           // f = 'done'
var g = 'bye' && undefined && 'adios';  // g = undefined

उदाहरण के लिए, फ़ंक्शन तर्क के लिए डिफ़ॉल्ट मान सेट करने के लिए (ES6 से पहले) इस ट्रिक का उपयोग किया जा सकता है।

var foo = function(val) {
    // if val evaluates to falsey, 'default' will be returned instead.
    return val || 'default';
}

console.log( foo('burger') );  // burger
console.log( foo(100) );       // 100
console.log( foo([]) );        // []
console.log( foo(0) );         // default
console.log( foo(undefined) ); // default

बस ध्यान रखें कि तर्कों के लिए, 0 और (कुछ हद तक) खाली स्ट्रिंग भी अक्सर मान्य मान होते हैं जो स्पष्ट रूप से पारित होने में सक्षम होना चाहिए और एक डिफ़ॉल्ट को ओवरराइड करना चाहिए, जो इस पैटर्न के साथ, वे (क्योंकि वे नहीं करेंगे) झूठा है )।

अशक्त और अपरिभाषित

`null` और `undefined` बीच अंतर

null और undefined शेयर सार समानता == लेकिन सख्त समानता === ,

null == undefined   // true
null === undefined  // false

वे कुछ अलग चीजों का प्रतिनिधित्व करते हैं:

undefined मूल्य की अनुपस्थिति का प्रतिनिधित्व करता है, जैसे कि एक पहचानकर्ता / वस्तु संपत्ति के निर्माण से पहले या पहचानकर्ता / फ़ंक्शन पैरामीटर निर्माण के बीच की अवधि में और यह पहले सेट है, यदि कोई हो।
null एक पहचानकर्ता या संपत्ति के लिए एक मूल्य की जानबूझकर अनुपस्थिति का प्रतिनिधित्व करता है जो पहले ही बनाई जा चुकी है।

वे विभिन्न प्रकार के वाक्यविन्यास हैं:

undefined वैश्विक वस्तु की एक संपत्ति है , जो आमतौर पर वैश्विक दायरे में अपरिवर्तनीय है। इसका मतलब यह है कि कहीं भी आप एक पहचानकर्ता को परिभाषित कर सकते हैं, इसके अलावा वैश्विक नाम स्थान उस क्षेत्र से undefined छिपा सकता है (हालांकि चीजें अभी भी undefined हो सकती हैं )
null एक शब्द शाब्दिक है , इसलिए इसका अर्थ कभी नहीं बदला जा सकता है और ऐसा करने का प्रयास एक एरर फेंक देगा।

`null` और `undefined` बीच समानताएं

null और undefined दोनों मिथ्या हैं।

if (null) console.log("won't be logged");
if (undefined) console.log("won't be logged");

न तो null या undefined समान false ( इस प्रश्न को देखें)।

false == undefined   // false
false == null        // false
false === undefined  // false
false === null       // false

`undefined` का उपयोग करना

यदि वर्तमान गुंजाइश पर भरोसा नहीं किया जा सकता है, तो कुछ का उपयोग करें जो अपरिभाषित का मूल्यांकन करता है, उदाहरण के लिए void 0; ।
यदि undefined दूसरे मूल्य से छाया हुआ है, तो यह Array या Number को छायांकित करने जितना ही बुरा है।
undefined रूप में कुछ स्थापित करने से बचें। यदि आप किसी ऑब्जेक्ट foo से प्रॉपर्टी बार delete foo.bar; बजाय।
undefined खिलाफ अस्तित्व परीक्षण पहचानकर्ता foo एक संदर्भ त्रुटि फेंक सकता है , इसके बजाय "undefined" खिलाफ typeof foo उपयोग करें।

ग्लोबल ऑब्जेक्ट की NaN संपत्ति

NaN (" N ot a N umber") एक विशेष मान है जो IEEE Standard द्वारा फ़्लोटिंग-पॉइंट अंकगणित के लिए परिभाषित किया गया है, जिसका उपयोग तब किया जाता है जब एक गैर-संख्यात्मक मान प्रदान किया जाता है, लेकिन एक संख्या अपेक्षित है ( 1 * "two" ), या जब किसी गणना में मान्य number परिणाम नहीं होता है ( Math.sqrt(-1) )।

NaN साथ कोई भी समानता या संबंधपरक तुलना false , यहाँ तक कि खुद से भी इसकी तुलना की जाती है। क्योंकि, NaN एक निरर्थक संगणना के परिणाम को निरूपित करने वाला है, और इस तरह, यह किसी अन्य निरर्थक संगणना के परिणाम के बराबर नहीं है।

(1 * "two") === NaN  //false

NaN === 0;          // false
NaN === NaN;        // false
Number.NaN === NaN; // false

NaN < 0;            // false
NaN > 0;            // false
NaN > 0;            // false
NaN >= NaN;         // false
NaN >= 'two';       // false

गैर-बराबरी की तुलना हमेशा true होगी:

NaN !== 0;          // true
NaN !== NaN;        // true

यदि मान NaN है तो जाँच करना

आप फ़ंक्शन नंबर.isNaN () का उपयोग करके NaN लिए एक मान या अभिव्यक्ति का परीक्षण कर सकते हैं:

Number.isNaN(NaN);         // true
Number.isNaN(0 / 0);       // true
Number.isNaN('str' - 12);  // true

Number.isNaN(24);          // false
Number.isNaN('24');        // false
Number.isNaN(1 / 0);       // false
Number.isNaN(Infinity);    // false

Number.isNaN('str');       // false
Number.isNaN(undefined);   // false
Number.isNaN({});          // false

आप यह मान सकते हैं कि मान स्वयं के साथ तुलना करके NaN है:

value !== value;    // true for NaN, false for any other value

आप निम्न Number.isNaN() उपयोग Number.isNaN() लिए कर सकते हैं:

Number.isNaN = Number.isNaN || function(value) {     
    return value !== value;
}

इसके विपरीत, वैश्विक समारोह isNaN() न केवल NaN , बल्कि किसी भी मूल्य या अभिव्यक्ति के लिए भी true , जो किसी संख्या में isNaN() नहीं किया जा सकता है:

isNaN(NaN);         // true
isNaN(0 / 0);       // true
isNaN('str' - 12);  // true

isNaN(24);          // false
isNaN('24');        // false
isNaN(Infinity);    // false

isNaN('str');       // true
isNaN(undefined);   // true
isNaN({});          // true

ECMAScript SameValue नामक एक " SameValue " एल्गोरिथ्म को परिभाषित करता है, जिसे ECMAScript 6 के बाद से Object.is साथ लागू किया जा सकता है। विपरीत == और === तुलना, का उपयोग कर Object.is() व्यवहार करेगा NaN खुद के साथ समान रूप से (और -0 के समान नहीं के रूप में +0 ):

Object.is(NaN, NaN)      // true
Object.is(+0, 0)         // false

NaN === NaN              // false
+0 === 0                 // true

आप Object.is() ( MDN से Object.is() लिए निम्नलिखित Object.is() उपयोग कर सकते हैं:

if (!Object.is) {
  Object.is = function(x, y) {
    // SameValue algorithm
    if (x === y) { // Steps 1-5, 7-10
      // Steps 6.b-6.e: +0 != -0
      return x !== 0 || 1 / x === 1 / y;
    } else {
      // Step 6.a: NaN == NaN
      return x !== x && y !== y;
    }
  };
}

नोट करने के लिए अंक

NaN अपने आप में एक संख्या है, जिसका अर्थ है कि यह स्ट्रिंग "NaN" के बराबर नहीं है, और सबसे महत्वपूर्ण बात (हालांकि शायद अनजाने में):

typeof(NaN) === "number"; //true

बूलियन ऑपरेटरों में शॉर्ट-सर्कुलेटिंग

और-ऑपरेटर ( && ) और या-ऑपरेटर ( || ) काम शॉर्ट-सर्किट अनावश्यक कार्य को रोकने के लिए यदि आपरेशन के परिणाम अतिरिक्त कार्य किए नहीं बदलता है।

x && y , y का मूल्यांकन नहीं किया जाएगा यदि x false मूल्यांकन करता false , क्योंकि पूरी अभिव्यक्ति false होने की गारंटी है।

x || y , y का मूल्यांकन नहीं किया जाएगा यदि x मूल्यांकन true , क्योंकि पूरी अभिव्यक्ति true होने की गारंटी true ।

कार्यों के साथ उदाहरण

निम्नलिखित दो कार्य करें:

function T() { // True
  console.log("T");
  return true;
}

function F() { // False
  console.log("F");
  return false;
}

उदाहरण 1

T() && F(); // false

आउटपुट:

'टी'
'एफ'

उदाहरण 2

F() && T(); // false

आउटपुट:

'एफ'

उदाहरण 3

T() || F(); // true

आउटपुट:

'टी'

उदाहरण 4

F() || T(); // true

आउटपुट:

'एफ'
'टी'

त्रुटियों को रोकने के लिए शॉर्ट-सर्किटिंग

var obj; // object has value of undefined
if(obj.property){ }// TypeError: Cannot read property 'property' of undefined
if(obj.property && obj !== undefined){}// Line A TypeError: Cannot read property 'property' of undefined

पंक्ति A: यदि आप आदेश को उलटते हैं तो पहला सशर्त विवरण दूसरे पर त्रुटि को रोक देगा, इसे निष्पादित नहीं करेगा यदि वह त्रुटि को फेंक देगा।

if(obj !== undefined && obj.property){}; // no error thrown

लेकिन केवल तभी उपयोग किया जाना चाहिए जब आप undefined उम्मीद करते हैं

if(typeof obj === "object" && obj.property){}; // safe option but slower

डिफ़ॉल्ट मान प्रदान करने के लिए लघु-परिचालित करना

|| ऑपरेटर का उपयोग "सत्य" मान या डिफ़ॉल्ट मान का चयन करने के लिए किया जा सकता है।

उदाहरण के लिए, इसका उपयोग यह सुनिश्चित करने के लिए किया जा सकता है कि एक अशक्त मान गैर-अशक्त मान में परिवर्तित हो गया है:

var nullableObj = null;
var obj = nullableObj || {};  // this selects {}

var nullableObj2 = {x: 5};
var obj2 = nullableObj2 || {} // this selects {x: 5}

या पहले सत्य मूल्य वापस करने के लिए

var truthyValue = {x: 10};
return truthyValue || {}; // will return {x: 10}

उसी का उपयोग कई बार वापस करने के लिए किया जा सकता है:

envVariable || configValue || defaultConstValue // select the first "truthy" of these

एक वैकल्पिक फ़ंक्शन को कॉल करने के लिए लघु-सर्किटिंग

कॉलबैक का मूल्यांकन करने के लिए && ऑपरेटर का उपयोग किया जा सकता है, केवल अगर यह पारित हो जाए:

function myMethod(cb) {
    // This can be simplified
    if (cb) {
       cb();
    }

    // To this
    cb && cb();
}

बेशक, ऊपर परीक्षण यह मान्य नहीं करता है कि cb वास्तव में एक function और न केवल एक Object / Array / String / Number ।

सार समानता / असमानता और प्रकार रूपांतरण

समस्या

अमूर्त समानता और असमानता ऑपरेटर ( == और != ) अपने ऑपरेंड को परिवर्तित करते हैं यदि ऑपरेंड प्रकार मेल नहीं खाते हैं। इस प्रकार का ज़बरदस्ती इन ऑपरेटरों के परिणामों के बारे में भ्रम का एक आम स्रोत है, विशेष रूप से, ये ऑपरेटर हमेशा संक्रमणशील नहीं होते हैं क्योंकि कोई भी उम्मीद नहीं करेगा।

"" ==  0;     // true A
 0 == "0";    // true A
"" == "0";    // false B
false == 0;   // true
false == "0"; // true

"" !=  0;     // false A
 0 != "0";    // false A
"" != "0";    // true B
false != 0;   // false
false != "0"; // false

परिणाम यह समझने के लिए शुरू करते हैं कि क्या आप समझते हैं कि जावास्क्रिप्ट संख्याओं के रिक्त तारों को कैसे परिवर्तित करता है।

Number("");    // 0
Number("0");   // 0
Number(false); // 0

समाधान

false B , दोनों ऑपरेंड स्ट्रिंग्स ( "" और "0" ) हैं, इसलिए कोई प्रकार का रूपांतरण नहीं होगा और चूंकि "" और "0" समान मूल्य नहीं हैं, "" == "0" false जैसा सोचा था।

यहां अप्रत्याशित व्यवहार को खत्म करने का एक तरीका यह सुनिश्चित करना है कि आप हमेशा एक ही प्रकार के ऑपरेंड की तुलना करें। उदाहरण के लिए, यदि आप चाहते हैं कि संख्यात्मक तुलना के परिणाम स्पष्ट रूपांतरण का उपयोग करें:

var test = (a,b) => Number(a) == Number(b); 
test("", 0);        // true;
test("0", 0);       // true
test("", "0");      // true;
test("abc", "abc"); // false as operands are not numbers

या, यदि आप स्ट्रिंग तुलना चाहते हैं:

var test = (a,b) => String(a) == String(b);
test("", 0);   // false;
test("0", 0);  // true
test("", "0"); // false;

साइड-नोट : Number("0") और new Number("0") एक ही बात नहीं है! जबकि पूर्व एक प्रकार का रूपांतरण करता है, बाद वाला एक नई वस्तु बनाएगा। वस्तुओं की तुलना संदर्भ से की जाती है न कि मूल्य से जो नीचे दिए गए परिणामों की व्याख्या करती है।

Number("0") == Number("0");         // true;
new Number("0") == new Number("0"); // false

अंत में, आपके पास सख्त समानता और असमानता ऑपरेटरों का उपयोग करने का विकल्प है जो किसी भी प्रकार के निहितार्थ का प्रदर्शन नहीं करेंगे।

"" ===  0;  // false
 0 === "0"; // false
"" === "0"; // false

इस विषय का और संदर्भ यहां पाया जा सकता है:

जावास्क्रिप्ट तुलना में ऑपरेटर (== बनाम ===) का उपयोग किया जाना चाहिए? ।

सार समानता (==)

खाली ऐरे

/* ToNumber(ToPrimitive([])) == ToNumber(false) */
[] == false; // true

जब [].toString() निष्पादित होता है तो यह कॉल करता है [].join() यदि यह मौजूद है, या Object.prototype.toString() अन्यथा। यह तुलना true क्योंकि [].join() रिटर्न '' जो 0 में coerced है, झूठी ToNumber के बराबर है।

हालांकि सावधान रहें, सभी वस्तुएं सत्य हैं और Array Object का एक उदाहरण है:

// Internally this is evaluated as ToBoolean([]) === true ? 'truthy' : 'falsy'
[] ? 'truthy' : 'falsy'; // 'truthy'

समानता तुलना संचालन

जावास्क्रिप्ट में चार अलग-अलग समानता तुलनात्मक संचालन हैं।

SameValue

यह true अगर दोनों ऑपरेंड एक ही प्रकार के हैं और एक ही मूल्य के हैं।

नोट: एक वस्तु का मूल्य एक संदर्भ है।

आप इस तुलना एल्गोरिथ्म का उपयोग Object.is (ECMAScript 6) के माध्यम से कर सकते हैं।

उदाहरण:

Object.is(1, 1);            // true
Object.is(+0, -0);          // false
Object.is(NaN, NaN);        // true
Object.is(true, "true");    // false
Object.is(false, 0);        // false
Object.is(null, undefined); // false
Object.is(1, "1");          // false
Object.is([], []);          // false

इस एल्गोरिथ्म में एक समतुल्य संबंध के गुण हैं:

Reflexivity : Object.is(x, x) किसी भी वैल्यू x लिए true
समरूपता : Object.is(x, y) true यदि, और केवल यदि, Object.is(y, x) किसी भी मान x और y लिए true ।
संक्रामिता : अगर Object.is(x, y) और Object.is(y, z) कर रहे हैं true है, तो Object.is(x, z) भी है true किसी भी मूल्यों के लिए, x , y और z ।

SameValueZero

यह सेमवैल्यू की तरह व्यवहार करता है, लेकिन +0 और -0 को समान मानता है।

आप इस तुलना एल्गोरिथ्म का उपयोग Array.prototype.includes (ECMAScript 7) के माध्यम से कर सकते हैं।

उदाहरण:

[1].includes(1);            // true
[+0].includes(-0);          // true
[NaN].includes(NaN);        // true
[true].includes("true");    // false
[false].includes(0);        // false
[1].includes("1");          // false
[null].includes(undefined); // false
[[]].includes([]);          // false

इस एल्गोरिथ्म में अभी भी एक समानता संबंध के गुण हैं:

Reflexivity : [x].includes(x) किसी भी मान x लिए true
समरूपता : [x].includes(y) यदि true है, और केवल तभी, [y].includes(x) true , किसी भी मान के लिए x और y ।
संक्रामिता : यदि [x].includes(y) और [y].includes(z) कर रहे हैं true है, तो [x].includes(z) भी है true , किसी भी मूल्यों के लिए x , y और z ।

सख्त समानता की तुलना

यह सेमवैल्यू की तरह व्यवहार करता है, लेकिन

+0 और -0 बराबर हो।
किसी भी मूल्य से भिन्न NaN ही शामिल करता है

आप इस तुलना एल्गोरिथ्म का उपयोग === ऑपरेटर (ECMAScript 3) के माध्यम से कर सकते हैं।

वहाँ भी है !== ऑपरेटर (ECMAScript 3), जो === के परिणाम को नकारता है।

उदाहरण:

1 === 1;            // true
+0 === -0;          // true
NaN === NaN;        // false
true === "true";    // false
false === 0;        // false
1 === "1";          // false
null === undefined; // false
[] === [];          // false

इस एल्गोरिथ्म में निम्नलिखित गुण हैं:

समरूपता : x === y है true है, और वह भी तब, वाई === एक्स is सच , for any values एक्स and y`।
सक्रांति : यदि x === y और y === z true , तो x === z भी true , किसी भी मान के लिए x , y और z ।

लेकिन एक तुलनीय संबंध नहीं है क्योंकि

NaN रिफ्लेक्टिव नहीं है : NaN !== NaN

सार समानता

यदि दोनों ऑपरेंड एक ही प्रकार के हैं, तो यह स्ट्रिक्ट इक्वेलिटी कम्पेरिजन की तरह व्यवहार करता है।

अन्यथा, यह उन्हें निम्नानुसार करता है:

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

यदि कोई ज़बरदस्ती थी, तो ज़बरदस्त मूल्यों की पुनरावृत्ति की तुलना की जाती है। अन्यथा एल्गोरिथ्म false ।

आप इस तुलना एल्गोरिथ्म का उपयोग == ऑपरेटर (ECMAScript 1) के माध्यम से कर सकते हैं।

वहाँ भी है != ऑपरेटर (ECMAScript 1), जो == के परिणाम को नकारता है।

उदाहरण:

1 == 1;            // true
+0 == -0;          // true
NaN == NaN;        // false
true == "true";    // false
false == 0;        // true
1 == "1";          // true
null == undefined; // true
[] == [];          // false

इस एल्गोरिथ्म में निम्नलिखित गुण हैं:

समरूपता : x == y true यदि, और केवल यदि, y == x true , किसी भी मान के लिए x और y ।

लेकिन एक तुलनीय संबंध नहीं है क्योंकि

NaN रिफ्लेक्टिव नहीं है : NaN != NaN
परिवर्तनशीलता पकड़ में नहीं आती है, जैसे 0 == '' और 0 == '0' , लेकिन '' != '0'

कई तर्क बयानों को समूहीकृत करना

आप अधिक जटिल लॉजिक मूल्यांकन बनाने के लिए कई बूलियन लॉजिक स्टेटमेंट्स को समूहीकृत कर सकते हैं, खासकर यदि स्टेटमेंट्स में अधिक उपयोगी।

if ((age >= 18 && height >= 5.11) || (status === 'royalty' && hasInvitation)) {
  console.log('You can enter our club');
}

हम कथन को थोड़ा छोटा और वर्णनात्मक बनाने के लिए समूहित तर्क को चर में स्थानांतरित कर सकते हैं:

var isLegal = age >= 18;
var tall = height >= 5.11;
var suitable = isLegal && tall;
var isRoyalty = status === 'royalty';
var specialCase = isRoyalty && hasInvitation;
var canEnterOurBar = suitable || specialCase;

if (canEnterOurBar) console.log('You can enter our club');

ध्यान दें कि इस विशेष उदाहरण (और कई अन्य) में, कोष्ठक के साथ कथनों को समूहीकृत करना उसी तरह काम करता है जैसे कि हमने उन्हें हटा दिया, बस एक रैखिक तर्क मूल्यांकन का पालन करें और आप स्वयं को उसी परिणाम के साथ पाएंगे। मैं लघुकोष्ठक का उपयोग करना पसंद करता हूं क्योंकि यह मुझे स्पष्ट समझने की अनुमति देता है कि मैंने क्या इरादा किया था और तर्क गलतियों के लिए रोक सकता है।

स्वचालित प्रकार के वार्तालाप

खबरदार कि संख्या गलती से तार या NaN (संख्या नहीं) में परिवर्तित हो सकती है।

जावास्क्रिप्ट शिथिल टाइप है। एक चर में विभिन्न प्रकार के डेटा हो सकते हैं और एक चर अपने डेटा प्रकार को बदल सकता है:

var x = "Hello";     // typeof x is a string
x = 5;               // changes typeof x to a number

गणितीय कार्य करते समय, जावास्क्रिप्ट संख्याओं को तारों में बदल सकता है:

var x = 5 + 7;       // x.valueOf() is 12,  typeof x is a number
var x = 5 + "7";     // x.valueOf() is 57,  typeof x is a string
var x = "5" + 7;     // x.valueOf() is 57,  typeof x is a string
var x = 5 - 7;       // x.valueOf() is -2,  typeof x is a number
var x = 5 - "7";     // x.valueOf() is -2,  typeof x is a number
var x = "5" - 7;     // x.valueOf() is -2,  typeof x is a number
var x = 5 - "x";     // x.valueOf() is NaN, typeof x is a number

स्ट्रिंग से स्ट्रिंग घटाना, एक त्रुटि उत्पन्न नहीं करता है लेकिन NaN (संख्या नहीं) लौटाता है:

"Hello" - "Dolly"    // returns NaN

तुलना संचालकों की सूची

ऑपरेटर	तुलना	उदाहरण
`==`	बराबरी का	`i == 0`
`===`	समान मूल्य और प्रकार	`i === "5"`
`!=`	बराबर नहीं	`i != 5`
`!==`	समान मूल्य या प्रकार नहीं	`i !== 5`
`>`	से अधिक	`i > 5`
`<`	से कम	`i < 5`
`>=`	से बड़ा या बराबर	`i >= 5`
`<=`	इससे कम या इसके बराबर	`i <= 5`

बहु राज्य डेटा की तुलना का अनुकूलन करने के लिए बिट फ़ील्ड

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

उदाहरण के लिए उपयोगकर्ता इनपुट। कीबोर्ड की दिशा कीज़ से इनपुट प्राप्त करते समय, नीचे, बाएं, दाएं आप विभिन्न कुंजियों को एक ही चर में निर्दिष्ट कर सकते हैं, जिसमें प्रत्येक दिशा थोड़ी सी निर्दिष्ट होती है।

उदाहरण रीडिंग कीबोर्ड बिटफील्ड के माध्यम से

var bitField = 0;  // the value to hold the bits
const KEY_BITS = [4,1,8,2]; // left up right down
const KEY_MASKS = [0b1011,0b1110,0b0111,0b1101]; // left up right down
window.onkeydown = window.onkeyup = function (e) {
    if(e.keyCode >= 37 && e.keyCode <41){
        if(e.type === "keydown"){
            bitField |= KEY_BITS[e.keyCode - 37];
        }else{
            bitField &= KEY_MASKS[e.keyCode - 37];
        }
    }    
}

एक सरणी के रूप में पढ़ने का उदाहरण

var directionState = [false,false,false,false];
window.onkeydown = window.onkeyup = function (e) {
    if(e.keyCode >= 37 && e.keyCode <41){
        directionState[e.keyCode - 37] = e.type === "keydown";
    }    
}

बिटवाइस का उपयोग करने के लिए बिटवाइज़ या | और बिट के अनुरूप मूल्य। इसलिए यदि आप 2 बिट बिट सेट करना चाहते हैं bitField |= 0b10 इसे चालू करेंगे। आप थोड़ा उपयोग बंद बिटवाइज़ और चालू करने के लिए चाहते हैं & पर आवश्यक थोड़ा करके सब है कि एक मूल्य के साथ। 4 बिट्स का उपयोग करना और 2 बिट बिट ऑफ bitfield &= 0b1101;

आप कह सकते हैं कि उपरोक्त उदाहरण विभिन्न प्रमुख राज्यों को एक सरणी में निर्दिष्ट करने की तुलना में बहुत अधिक जटिल है। हां यह निर्धारित करने के लिए थोड़ा अधिक जटिल है, लेकिन इसका फायदा राज्य से पूछताछ करते समय आता है।

यदि आप परीक्षण करना चाहते हैं यदि सभी कुंजियाँ हैं।

// as bit field
if(!bitfield) // no keys are on

// as array test each item in array
if(!(directionState[0] && directionState[1] && directionState[2] && directionState[3])){

आप चीजों को आसान बनाने के लिए कुछ स्थिरांक निर्धारित कर सकते हैं

// postfix U,D,L,R for Up down left right
const KEY_U = 1;
const KEY_D = 2;
const KEY_L = 4;
const KEY_R = 8;
const KEY_UL = KEY_U + KEY_L; // up left
const KEY_UR = KEY_U + KEY_R; // up Right
const KEY_DL = KEY_D + KEY_L; // down left
const KEY_DR = KEY_D + KEY_R; // down right

फिर आप कई विभिन्न कीबोर्ड राज्यों के लिए जल्दी से परीक्षण कर सकते हैं

if ((bitfield & KEY_UL) === KEY_UL) { // is UP and LEFT only down
if (bitfield  & KEY_UL) {             // is Up left down 
if ((bitfield & KEY_U) === KEY_U) {   // is Up only down
if (bitfield & KEY_U) {               // is Up down (any other key may be down)
if (!(bitfield & KEY_U)) {            // is Up up (any other key may be down)
if (!bitfield ) {                     // no keys are down
if (bitfield ) {                      // any one or more keys are down

कीबोर्ड इनपुट सिर्फ एक उदाहरण है। बिटफ़िल्ड तब उपयोगी होते हैं जब आपके पास विभिन्न राज्य होते हैं जिन्हें संयोजन में होना चाहिए। जावास्क्रिप्ट एक बिट क्षेत्र के लिए 32 बिट्स तक का उपयोग कर सकता है। इनके प्रयोग से महत्वपूर्ण प्रदर्शन बढ़ सकते हैं। वे परिचित होने के लायक हैं।

Modified text is an extract of the original Stack Overflow Documentation

के तहत लाइसेंस प्राप्त है CC BY-SA 3.0

से संबद्ध नहीं है Stack Overflow

JavaScript
तुलना संचालन

खोज…

टिप्पणियों

तर्क ऑपरेटर बूलियन के साथ

तथा

या

नहीं

सार समानता (==)

7.2.13 सार समानता तुलना

उदाहरण:

संबंधपरक ऑपरेटर (<, <=>,> =)

असमानता

लॉजिक ऑपरेटर्स नॉन-बूलियन वैल्यूज़ (बूलियन कॉर्शन)

अशक्त और अपरिभाषित

`null` और `undefined` बीच अंतर

`null` और `undefined` बीच समानताएं

`undefined` का उपयोग करना

ग्लोबल ऑब्जेक्ट की NaN संपत्ति

यदि मान NaN है तो जाँच करना

नोट करने के लिए अंक

बूलियन ऑपरेटरों में शॉर्ट-सर्कुलेटिंग

सार समानता / असमानता और प्रकार रूपांतरण

समस्या

समाधान

खाली ऐरे

समानता तुलना संचालन

SameValue

SameValueZero

सख्त समानता की तुलना

सार समानता

कई तर्क बयानों को समूहीकृत करना

स्वचालित प्रकार के वार्तालाप

तुलना संचालकों की सूची

बहु राज्य डेटा की तुलना का अनुकूलन करने के लिए बिट फ़ील्ड

टिप्पणियों

तर्क ऑपरेटर बूलियन के साथ

तथा

या

नहीं

सार समानता (==)

7.2.13 सार समानता तुलना

उदाहरण:

संबंधपरक ऑपरेटर (<, <=>,> =)

असमानता

लॉजिक ऑपरेटर्स नॉन-बूलियन वैल्यूज़ (बूलियन कॉर्शन)

अशक्त और अपरिभाषित

null और undefined बीच अंतर

null और undefined बीच समानताएं

undefined का उपयोग करना

ग्लोबल ऑब्जेक्ट की NaN संपत्ति

यदि मान NaN है तो जाँच करना

नोट करने के लिए अंक

बूलियन ऑपरेटरों में शॉर्ट-सर्कुलेटिंग

सार समानता / असमानता और प्रकार रूपांतरण

समस्या

समाधान

खाली ऐरे

समानता तुलना संचालन

SameValue

SameValueZero

सख्त समानता की तुलना

सार समानता

कई तर्क बयानों को समूहीकृत करना

स्वचालित प्रकार के वार्तालाप

तुलना संचालकों की सूची

बहु राज्य डेटा की तुलना का अनुकूलन करने के लिए बिट फ़ील्ड

`null` और `undefined` बीच अंतर

`null` और `undefined` बीच समानताएं

`undefined` का उपयोग करना