𝗩𝗮𝗿𝗶𝗮𝗯𝗹𝗲 𝗩𝗮𝗿𝗶𝗮𝗯𝗹𝗲 𝗣𝗹𝗮𝗶𝗻 𝗩𝗮𝗿𝗶𝗮𝗯𝗹𝗲
हमें सीधे समस्या में कटौती करते हैं: फ़ाइल का आकार। यहां सूचीबद्ध हर दूसरा उत्तर आपके कोड को चरम पर ले जाता है। मैं आपके सामने प्रस्तुत करता हूं कि सर्वोत्तम संभव प्रदर्शन के लिए, कोड की पठनीयता, बड़े पैमाने पर परियोजना प्रबंधन, कई कोड संपादकों में वाक्यविन्यास में बाधा, और कोड आकार में कमी, यह गणना करने का सही तरीका है: अंडरस्कोर-नोटेशन चर।
wvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwv
जैसा कि ऊपर दिए गए चार्ट में दिखाया गया है और नीचे दिए गए उदाहरण हैं, शुरू करने के लिए यहां पांच आसान चरण दिए गए हैं:
- गणना समूह के लिए एक नाम निर्धारित करें। एक संज्ञा के बारे में सोचें जो गणना के उद्देश्य या कम से कम प्रविष्टियों में वर्णन कर सकती है। उदाहरण के लिए, उपयोगकर्ता द्वारा चयन किए जाने वाले रंगों का प्रतिनिधित्व करने वाले गणन का एक समूह रंग से बेहतर रंग के नाम हो सकता है।
- तय करें कि क्या समूह में गणना परस्पर-अनन्य या स्वतंत्र है। यदि पारस्परिक रूप से अनन्य है, तो प्रत्येक नामांकित चर नाम के साथ शुरू करें
ENUM_। यदि स्वतंत्र या साइड-बाय-साइड, उपयोग करें INDEX_।
- प्रत्येक प्रविष्टि के लिए, एक नया स्थानीय वैरिएबल बनाएं, जिसका नाम शुरू होता है
ENUM_या INDEX_फिर समूह का नाम, फिर एक अंडरस्कोर, फिर संपत्ति के लिए एक अद्वितीय अनुकूल नाम
- एक जोड़े
ENUMLENGTH_, ENUMLEN_, INDEXLENGTH_, या INDEXLEN_(चाहे LEN_या LENGTH_बहुत अंत में है व्यक्तिगत पसंद) प्रगणित चर। आपको अपने कोड में जहां भी संभव हो, इस चर का उपयोग यह सुनिश्चित करने के लिए करना चाहिए कि गणन में एक अतिरिक्त प्रविष्टि जोड़ने और इस मूल्य को बढ़ाने से आपका कोड नहीं टूटेगा।
- लगातार प्रत्येक enumerated चर एक मूल्य के एक आखिरी की तुलना में अधिक दो, 0. पर शुरू इस पेज पर टिप्पणी है कि कहते हैं कर रहे हैं
0एक प्रगणित मूल्य क्योंकि के रूप में नहीं किया जाना चाहिए 0 == null, 0 == false, 0 == "", और अन्य जे एस पागलपन। मैं आपको इस समस्या से बचने और एक ही समय में प्रदर्शन को बढ़ावा देने के लिए प्रस्तुत करता हूं, हमेशा उपयोग करें ===और कभी भी ==अपने कोड में प्रकट न करें typeof(पूर्व typeof X == "string") को छोड़कर । उपयोग करने के अपने सभी वर्षों में ===, मुझे कभी भी 0 का गणना मूल्य के रूप में उपयोग करने में कोई समस्या नहीं हुई। यदि आप अभी भी बग़ल में हैं, तो कई मामलों में प्रदर्शन जुर्माना के बिना गणना 1में ENUM_गणना मूल्य (लेकिन INDEX_गणना में नहीं ) के रूप में इस्तेमाल किया जा सकता है ।
const ENUM_COLORENUM_RED = 0;
const ENUM_COLORENUM_GREEN = 1;
const ENUM_COLORENUM_BLUE = 2;
const ENUMLEN_COLORENUM = 3;
// later on
if(currentColor === ENUM_COLORENUM_RED) {
// whatever
}
यहाँ बताया गया है कि मुझे याद है कि कब उपयोग करना है INDEX_और कब उपयोग करना है ENUM_:
// Precondition: var arr = []; //
arr[INDEX_] = ENUM_;
हालांकि, ENUM_कुछ परिस्थितियों में, सूचकांक के रूप में उपयुक्त हो सकता है जैसे कि प्रत्येक आइटम की घटनाओं को गिनते समय।
const ENUM_PET_CAT = 0,
ENUM_PET_DOG = 1,
ENUM_PET_RAT = 2,
ENUMLEN_PET = 3;
var favoritePets = [ENUM_PET_CAT, ENUM_PET_DOG, ENUM_PET_RAT,
ENUM_PET_DOG, ENUM_PET_DOG, ENUM_PET_CAT,
ENUM_PET_RAT, ENUM_PET_CAT, ENUM_PET_DOG];
var petsFrequency = [];
for (var i=0; i<ENUMLEN_PET; i=i+1|0)
petsFrequency[i] = 0;
for (var i=0, len=favoritePets.length|0, petId=0; i<len; i=i+1|0)
petsFrequency[petId = favoritePets[i]|0] = (petsFrequency[petId]|0) + 1|0;
console.log({
"cat": petsFrequency[ENUM_PET_CAT],
"dog": petsFrequency[ENUM_PET_DOG],
"rat": petsFrequency[ENUM_PET_RAT]
});
गौर करें कि, ऊपर दिए गए कोड में, नए प्रकार के पालतू जानवरों को जोड़ना वास्तव में आसान है: आपको बस एक नई प्रविष्टि संलग्न करनी होगी ENUM_PET_RATऔर उसके ENUMLEN_PETअनुसार अपडेट करना होगा । गणना की अन्य प्रणालियों में एक नई प्रविष्टि जोड़ने के लिए यह अधिक कठिन और छोटी बात हो सकती है।
wvwwvw wvwwww wvwxvw wvwvwv vwvwvw wvwvvw wvwwvw wvwvww wvwvw wvwvwv vwvxwv wvwvw wvwvw wvwvwwvvwwwvw
𝗩𝗮𝗿𝗶𝗮𝗯𝗹𝗲𝘀 𝗩𝗮𝗿𝗶𝗮𝗯𝗹𝗲𝘀 𝗘𝘅𝘁𝗲𝗻𝗱 𝗩𝗮𝗿𝗶𝗮𝗯𝗹𝗲𝘀 𝗩𝗮𝗿𝗶𝗮𝗯𝗹𝗲𝘀
इसके अतिरिक्त, गणना के इस सिंटैक्स को स्पष्ट और संक्षिप्त वर्ग के लिए अनुमति देता है जो नीचे देखा गया है। एक वर्ग का विस्तार करने के लिए, LEN_मूल कक्षा के प्रवेश के लिए एक वृद्धि संख्या जोड़ें । फिर, अपनी LEN_प्रविष्टि के साथ उपवर्ग को समाप्त करें ताकि भविष्य में उपवर्ग को और आगे बढ़ाया जा सके।
(function(window){
"use strict";
var parseInt = window.parseInt;
// use INDEX_ when representing the index in an array instance
const INDEX_PIXELCOLOR_TYPE = 0, // is a ENUM_PIXELTYPE
INDEXLEN_PIXELCOLOR = 1,
INDEX_SOLIDCOLOR_R = INDEXLEN_PIXELCOLOR+0,
INDEX_SOLIDCOLOR_G = INDEXLEN_PIXELCOLOR+1,
INDEX_SOLIDCOLOR_B = INDEXLEN_PIXELCOLOR+2,
INDEXLEN_SOLIDCOLOR = INDEXLEN_PIXELCOLOR+3,
INDEX_ALPHACOLOR_R = INDEXLEN_PIXELCOLOR+0,
INDEX_ALPHACOLOR_G = INDEXLEN_PIXELCOLOR+1,
INDEX_ALPHACOLOR_B = INDEXLEN_PIXELCOLOR+2,
INDEX_ALPHACOLOR_A = INDEXLEN_PIXELCOLOR+3,
INDEXLEN_ALPHACOLOR = INDEXLEN_PIXELCOLOR+4,
// use ENUM_ when representing a mutually-exclusive species or type
ENUM_PIXELTYPE_SOLID = 0,
ENUM_PIXELTYPE_ALPHA = 1,
ENUM_PIXELTYPE_UNKNOWN = 2,
ENUMLEN_PIXELTYPE = 2;
function parseHexColor(inputString) {
var rawstr = inputString.trim().substring(1);
var result = [];
if (rawstr.length === 8) {
result[INDEX_PIXELCOLOR_TYPE] = ENUM_PIXELTYPE_ALPHA;
result[INDEX_ALPHACOLOR_R] = parseInt(rawstr.substring(0,2), 16);
result[INDEX_ALPHACOLOR_G] = parseInt(rawstr.substring(2,4), 16);
result[INDEX_ALPHACOLOR_B] = parseInt(rawstr.substring(4,6), 16);
result[INDEX_ALPHACOLOR_A] = parseInt(rawstr.substring(4,6), 16);
} else if (rawstr.length === 4) {
result[INDEX_PIXELCOLOR_TYPE] = ENUM_PIXELTYPE_ALPHA;
result[INDEX_ALPHACOLOR_R] = parseInt(rawstr[0], 16) * 0x11;
result[INDEX_ALPHACOLOR_G] = parseInt(rawstr[1], 16) * 0x11;
result[INDEX_ALPHACOLOR_B] = parseInt(rawstr[2], 16) * 0x11;
result[INDEX_ALPHACOLOR_A] = parseInt(rawstr[3], 16) * 0x11;
} else if (rawstr.length === 6) {
result[INDEX_PIXELCOLOR_TYPE] = ENUM_PIXELTYPE_SOLID;
result[INDEX_SOLIDCOLOR_R] = parseInt(rawstr.substring(0,2), 16);
result[INDEX_SOLIDCOLOR_G] = parseInt(rawstr.substring(2,4), 16);
result[INDEX_SOLIDCOLOR_B] = parseInt(rawstr.substring(4,6), 16);
} else if (rawstr.length === 3) {
result[INDEX_PIXELCOLOR_TYPE] = ENUM_PIXELTYPE_SOLID;
result[INDEX_SOLIDCOLOR_R] = parseInt(rawstr[0], 16) * 0x11;
result[INDEX_SOLIDCOLOR_G] = parseInt(rawstr[1], 16) * 0x11;
result[INDEX_SOLIDCOLOR_B] = parseInt(rawstr[2], 16) * 0x11;
} else {
result[INDEX_PIXELCOLOR_TYPE] = ENUM_PIXELTYPE_UNKNOWN;
}
return result;
}
// the red component of green
console.log(parseHexColor("#0f0")[INDEX_SOLIDCOLOR_R]);
// the alpha of transparent purple
console.log(parseHexColor("#f0f7")[INDEX_ALPHACOLOR_A]);
// the enumerated array for turquoise
console.log(parseHexColor("#40E0D0"));
})(self);
(लंबाई: 2,450 बाइट्स)
कुछ लोग कह सकते हैं कि यह अन्य समाधानों की तुलना में कम व्यावहारिक है: यह टन अंतरिक्ष की प्रतीक्षा करता है, इसे लिखने में लंबा समय लगता है, और यह चीनी सिंटैक्स के साथ लेपित नहीं है। यदि वे अपने कोड को छोटा नहीं करते हैं तो वे लोग सही होंगे। हालांकि, कोई भी उचित व्यक्ति अंतिम उत्पाद में अनधिकृत कोड नहीं छोड़ेगा। इस लघुकरण के लिए, क्लोजर कंपाइलर सबसे अच्छा है जो मुझे अभी तक ढूंढना है। ऑनलाइन एक्सेस यहां पाया जा सकता है । क्लोजर कंपाइलर इस एन्यूमरेशन डेटा के सभी को लेने और इसे इनलाइन करने में सक्षम है, जिससे आपका जावास्क्रिप्ट सुपर डुपर छोटा और सुपर डुपर फास्ट रन करेगा। इस प्रकार, क्लोजर कंपाइलर के साथ न्यूनतम करें। ध्यान से देखें।
wvwwvw wvwwww wvwxvw wvwvwv vwvwvw wvwvvw wvwwvw wvwvww wvwvw wvwvwv vwvxwv wvwvw wvwvw wvwvwwvvwwwvw
क्लोजर कंपाइलर कुछ अविश्वसनीय अविश्वसनीय अनुकूलन प्रदर्शनों के माध्यम से करने में सक्षम है जो किसी अन्य जावास्क्रिप्ट मिनिफ़ायर की क्षमताओं से परे हैं। क्लोजर कंपाइलर एक निश्चित मान पर सेट आदिम वैरिएबल को इनलाइन करने में सक्षम है। क्लोजर कंपाइलर इन-इन वैल्यू के आधार पर इनफेक्शन बनाने में सक्षम है और अगर-स्टेटमेंट और लूप में अप्रयुक्त ब्लॉक को खत्म करता है।
'use strict';(function(e){function d(a){a=a.trim().substring(1);var b=[];8===a.length?(b[0]=1,b[1]=c(a.substring(0,2),16),b[2]=c(a.substring(2,4),16),b[3]=c(a.substring(4,6),16),b[4]=c(a.substring(4,6),16)):4===a.length?(b[1]=17*c(a[0],16),b[2]=17*c(a[1],16),b[3]=17*c(a[2],16),b[4]=17*c(a[3],16)):6===a.length?(b[0]=0,b[1]=c(a.substring(0,2),16),b[2]=c(a.substring(2,4),16),b[3]=c(a.substring(4,6),16)):3===a.length?(b[0]=0,b[1]=17*c(a[0],16),b[2]=17*c(a[1],16),b[3]=17*c(a[2],16)):b[0]=2;return b}var c=
e.parseInt;console.log(d("#0f0")[1]);console.log(d("#f0f7")[4]);console.log(d("#40E0D0"))})(self);
(लंबाई: 605 बाइट्स)
क्लोजर कंपाइलर आपको बेहतर कोडिंग के लिए पुरस्कृत करता है और आपके कोड को अच्छी तरह से व्यवस्थित करता है, क्योंकि कई मिनिफ़ाइर एक बड़े आकार की फ़ाइल आकार के साथ संगठित कोड को सज़ा देते हैं, क्लोजर कंपाइलर आपके सभी स्वच्छता और विवेक के माध्यम से झारना करने में सक्षम है, यदि आप ट्रिक्स का उपयोग करते हैं चर नाम गणना की तरह। यह, इस एक दिमाग में, कोडिंग की पवित्र कब्र है: एक उपकरण जो दोनों आपके कोड को छोटे आकार के आकार के साथ सहायता करता है और बेहतर प्रोग्रामिंग आदतों को प्रशिक्षित करके आपके दिमाग को सहायता प्रदान करता है।
wvwwvw wvwwww wvwxvw wvwvwv vwvwvw wvwvvw wvwwvw wvwvww wvwvw wvwvwv vwvxwv wvwvw wvwvw wvwvwwvvwwwvw
𝗦𝗶𝘇𝗲 𝗦𝗶𝘇𝗲 𝗦𝗶𝘇𝗲
अब, देखते हैं कि इनमें से किसी भी गणना के बिना समतुल्य फ़ाइल कितनी बड़ी होगी।
Enumerations का उपयोग किए बिना स्रोत (लंबाई: 1,973 बाइट्स (477 बाइट्स enumerated कोड से छोटा है!))
Enumerations (लंबाई: 843 बाइट्स ( enumerated कोड से अधिक लंबे बाइट्स ) का उपयोग किए बिना छोटा किया गया )
जैसा कि देखा गया है, गणना के बिना, स्रोत कोड एक बड़े कीम कोड की कीमत पर छोटा होता है। मुझे आपके बारे में कुछ पता नही है; लेकिन मुझे पता है कि मैं अंत उत्पाद में स्रोत कोड को शामिल नहीं करता हूं। इस प्रकार, गणना का यह रूप बहुत बेहतर है कि छोटे फ़ाइल आकार में परिणाम हो।
wvwwvw wvwwww wvwxvw wvwvwv vwvwvw wvwvvw wvwwvw wvwvww wvwvw wvwvwv vwvxwv wvwvw wvwvw wvwvwwvvwwwvw
𝗕𝘂𝗴 𝗕𝘂𝗴 𝗖𝗼𝗼𝗽𝗲𝗿𝗮𝘁𝗶𝘃𝗲 𝗕𝘂𝗴
गणन के इस रूप के बारे में एक और लाभ यह है कि इसका उपयोग आसानी से बड़े आकार की परियोजनाओं को प्रबंधित करने के लिए किया जा सकता है, जो बिना किसी आकार के कोड आकार का त्याग किए। जब कई अन्य लोगों के साथ एक बड़ी परियोजना पर काम कर रहे हैं, तो यह स्पष्ट रूप से लाभदायक हो सकता है कि कोड बनाने वाले चर नामों को स्पष्ट रूप से चिह्नित करें और लेबल करें ताकि कोड के मूल निर्माता को जल्दी से सहयोगी बग फिक्सिंग के लिए पहचाना जा सके।
// JG = Jack Giffin
const ENUM_JG_COLORENUM_RED = 0,
ENUM_JG_COLORENUM_GREEN = 1,
ENUM_JG_COLORENUM_BLUE = 2,
ENUMLEN_JG_COLORENUM = 3;
// later on
if(currentColor === ENUM_JG_COLORENUM_RED) {
// whatever
}
// PL = Pepper Loftus
// BK = Bob Knight
const ENUM_PL_ARRAYTYPE_UNSORTED = 0,
ENUM_PL_ARRAYTYPE_ISSORTED = 1,
ENUM_BK_ARRAYTYPE_CHUNKED = 2, // added by Bob Knight
ENUM_JG_ARRAYTYPE_INCOMPLETE = 3, // added by jack giffin
ENUMLEN_PL_COLORENUM = 4;
// later on
if(
randomArray === ENUM_PL_ARRAYTYPE_UNSORTED ||
randomArray === ENUM_BK_ARRAYTYPE_CHUNKED
) {
// whatever
}
𝗦𝘂𝗽𝗲𝗿𝗶𝗼𝗿 𝗦𝘂𝗽𝗲𝗿𝗶𝗼𝗿 
इसके अलावा, गणना के बाद इस तरह की गणना भी तेजी से होती है। सामान्य नाम वाली संपत्तियों में, ब्राउज़र को यह देखने के लिए हैशमैप का उपयोग करना पड़ता है कि संपत्ति ऑब्जेक्ट पर कहाँ है। यद्यपि JIT इस स्थान को समझदारी से कैश करने के लिए मजबूर करता है, लेकिन विशेष मामलों जैसे ऑब्जेक्ट से कम संपत्ति को हटाने के कारण अभी भी जबरदस्त ओवरहेड है।
लेकिन, निरंतर गैर-विरल पूर्णांक-अनुक्रमित PACKED_ELEMENTS सरणियों के साथ, ब्राउज़र उस ओवरहेड को बहुत अधिक छोड़ने में सक्षम है, क्योंकि आंतरिक सरणी में मूल्य का सूचकांक पहले से ही निर्दिष्ट है। हां, ECMAScript मानक के अनुसार, सभी गुणों को स्ट्रिंग्स के रूप में माना जाता है। फिर भी, ECMAScript मानक का यह पहलू प्रदर्शन के बारे में बहुत भ्रामक है, क्योंकि सभी ब्राउज़रों में सरणियों में संख्यात्मक सूचकांक के लिए विशेष अनुकूलन हैं।
/// Hashmaps are slow, even with JIT juice
var ref = {};
ref.count = 10;
ref.value = "foobar";
नीचे दिए गए कोड की तुलना कोड से करें।
/// Arrays, however, are always lightning fast
const INDEX_REFERENCE_COUNT = 0;
const INDEX_REFERENCE_VALUE = 1;
const INDEXLENGTH_REFERENCE = 2;
var ref = [];
ref[INDEX_REFERENCE_COUNT] = 10;
ref[INDEX_REFERENCE_VALUE] = "foobar";
एक कोड के साथ आपत्ति कर सकते हैं गणना सामान्य वस्तुओं के साथ कोड की तुलना में अधिक लंबा लग रहा है, लेकिन लगता है कि धोखा हो सकता है। यह याद रखना महत्वपूर्ण है कि महाकाव्य बंद करने वाले कंपाइलर का उपयोग करते समय स्रोत कोड का आकार आउटपुट आकार के लिए आनुपातिक नहीं है। ध्यान से देखें।
/// Hashmaps are slow, even with JIT juice
var a={count:10,value:"foobar"};
एन्यूमरेशंस के बिना मिनिमाइज्ड कोड ऊपर है और एन्युमेरेशंस वाला मिनिफाईड कोड नीचे है।
/// Arrays, however, are always lightning fast
var a=[10,"foobar"];
ऊपर दिए गए उदाहरण से पता चलता है कि, बेहतर प्रदर्शन करने के अलावा, एन्यूमरेटेड कोड के परिणामस्वरूप छोटे आकार का फ़ाइल आकार भी होता है।
wvwwvw wvwwww wvwxvw wvwvwv vwvwvw wvwvvw wvwwvw wvwvww wvwvw wvwvwv vwvxwv wvwvw wvwvw wvwvwwvvwwwvw
𝗘𝗮𝘀𝘆 𝗘𝗮𝘀𝘆
इसके अलावा, शीर्ष पर यह किसी की निजी चेरी जावास्क्रिप्ट स्क्रिप्ट में कोडमिरर टेक्स्ट एडिटर के साथ एन्यूमरेशन के इस रूप का उपयोग कर रही है। कोडमिरर का जावास्क्रिप्ट सिंटैक्स हाइलाइटिंग मोड वर्तमान चर में स्थानीय चरों को हाइलाइट करता है। इस तरह, आप तुरंत जानते हैं जब आप एक चर नाम में सही ढंग से लिखते हैं क्योंकि अगर चर नाम पहले साथ घोषित किया गया थाvar कीवर्ड के , तो चर नाम एक विशेष रंग (डिफ़ॉल्ट रूप से सियान) में बदल जाता है। यहां तक कि अगर आप कोडमिरर का उपयोग नहीं करते हैं, तो कम से कम ब्राउज़र एक सहायक फेंकता है[variable name] is not definedजब कोड को गलत संकलित नामों के साथ निष्पादित किया जाता है। इसके अलावा, जावास्क्रिप्ट उपकरण जैसे कि JSLint और क्लोजर कंपाइलर आपको यह बताने के बारे में बहुत जोर से कहते हैं कि जब आप किसी गणन चर नाम में गलती करते हैं। CodeMirror, ब्राउज़र, और विभिन्न जावास्क्रिप्ट उपकरण एक साथ रखे हुए इस रूप को बहुत सरल और वास्तव में आसान बनाते हैं।
const ENUM_COLORENUM_RED = 0,
ENUM_COLORENUM_GREEN = 1,
ENUM_COLORENUM_BLUE = 2,
ENUMLEN_COLORENUM = 3;
var currentColor = ENUM_COLORENUM_GREEN;
if(currentColor === ENUM_COLORENUM_RED) {
// whatever
}
if(currentColor === ENUM_COLORENUM_DNE) {
// whatever
}
उपरोक्त स्निपेट में, आपको एक त्रुटि के साथ अलर्ट किया गया था क्योंकि ENUM_COLORENUM_DNEमौजूद नहीं है।
wvwwvw wvwwww wvwxvw wvwvwv vwvwvw wvwvvw wvwwvw wvwvww wvwvw wvwvwv vwvxwv wvwvw wvwvw wvwvwwvvwwwvw
𝗖𝗼𝗻𝗰𝗹𝘂𝘀𝗶𝗼𝗻 𝗖𝗼𝗻𝗰𝗹𝘂𝘀𝗶𝗼𝗻
मुझे लगता है कि यह कहना सुरक्षित है कि गणना की यह कार्यप्रणाली वास्तव में न केवल न्यूनतम आकार के लिए, बल्कि प्रदर्शन, डिबगिंग और सहयोग के लिए भी जाने का सबसे अच्छा तरीका है।
एक सहायक प्रश्न पढ़ने के बाद, मैं लेखक को प्रश्न बॉक्स में शीर्ष बाएं ऊपर-तीर पर क्लिक करके उनके लेखन में समय डालने के लिए धन्यवाद देता हूं। प्रत्येक उत्तर बॉक्स में भी इनमें से एक है।
0गणना संख्या के रूप में उपयोग न करें । जब तक इसका उपयोग किसी ऐसी चीज के लिए नहीं किया जाता जो सेट नहीं की गई है।false || undefined || null || 0 || "" || '' || NaNउपयोग करते समय JS सभी समान मान रखता है==।