क्या जावास्क्रिप्ट में "अशक्त coalescing" ऑपरेटर है?

Question

क्या जावास्क्रिप्ट में एक अशक्त सहवर्ती ऑपरेटर है?

उदाहरण के लिए, C # में, मैं यह कर सकता हूं:

String someString = null;
var whatIWant = someString ?? "Cookies!";

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

var someString = null;
var whatIWant = someString ? someString : 'Cookies!';

जो थोथा icky IMHO है। क्या मैं बेहतर कर सकता हूं?

Comments

2018 से नोट: x ?? yवाक्यविन्यास अब चरण 1 प्रस्ताव की स्थिति में है - व्यभिचारी coalescing

— अप्रैल

अब एक बैबल प्लगइन है जो इस सटीक सिंटैक्स को शामिल करता है।

— जोनाथन सुदियामैन

2019 से ध्यान दें: अब चरण 3 की स्थिति है!

— डैनियल शेफ़र

जनवरी 2020 से नोट: Nullish coalescing ऑपरेटर फ़ायरफ़ॉक्स 72 में मूल रूप से उपलब्ध है लेकिन वैकल्पिक चेनिंग ऑपरेटर अभी भी नहीं है।

— किरो कानोस

Nullish coalescing ऑपरेटर ( x ?? y) और वैकल्पिक चेनिंग ऑपरेटर ( user.address?.street) अब दोनों स्टेज 4 हैं। यहाँ इसका क्या मतलब है के बारे में एक अच्छा वर्णन है: 2ality.com/2015/11/tc39-process.html#stage-4%3A-finished ।

— मास डॉट नेट

Answer 1

अपडेट करें

जावास्क्रिप्ट अब nullish coalescing ऑपरेटर (??) का समर्थन करता है । यह अपने दाएं हाथ के साइड ऑपरेंड को वापस लौटाता है जब इसका लेफ्ट-हैंड-साइड ऑपरेंड होता है , nullया undefinedफिर अपने लेफ्ट-हैंड-साइड ऑपरेंड को वापस करता है।

उपयोग करने से पहले संगतता की जांच करें।

---

C # null कोलेसिंग ऑपरेटर ( ??) का जावास्क्रिप्ट समतुल्य तार्किक या ( ||) का उपयोग कर रहा है :

var whatIWant = someString || "Cookies!";

ऐसे मामले हैं (नीचे स्पष्ट किए गए हैं) कि व्यवहार C # से मेल नहीं खाएगा, लेकिन यह जावास्क्रिप्ट में डिफ़ॉल्ट / वैकल्पिक मानों को निर्दिष्ट करने का सामान्य, उल्टा तरीका है।

---

स्पष्टीकरण

पहला ऑपरेंड के प्रकार के बावजूद, यदि इसे बूलियन में डालना है false, तो असाइनमेंट दूसरे ऑपरेंड का उपयोग करेगा। नीचे दिए गए सभी मामलों से सावधान रहें:

alert(Boolean(null)); // false
alert(Boolean(undefined)); // false
alert(Boolean(0)); // false
alert(Boolean("")); // false
alert(Boolean("false")); // true -- gotcha! :)

इसका मतलब है की:

var whatIWant = null || new ShinyObject(); // is a new shiny object
var whatIWant = undefined || "well defined"; // is "well defined"
var whatIWant = 0 || 42; // is 42
var whatIWant = "" || "a million bucks"; // is "a million bucks"
var whatIWant = "false" || "no way"; // is "false"

Comments

"झूठे", "अपरिभाषित", "अशक्त", "0", "खाली", "हटाए गए" जैसे तार सभी सत्य हैं क्योंकि वे गैर-रिक्त तार हैं।

— कुछ

इसे स्पष्ट करने की जरूरत है। "" अशक्त नहीं है, लेकिन इसे गलत माना जाता है। तो अगर आप अशक्त के लिए एक मूल्य की जाँच कर रहे हैं और ऐसा होता है "" यह सही ढंग से इस परीक्षण को पारित नहीं करेगा।

— स्कॉटकून

ध्यान दें कि ||पहला "ट्रू" मान या अंतिम "फॉल्सी" एक (यदि कोई भी सच का मूल्यांकन नहीं कर सकता है) &&लौटाता है और यह विपरीत तरीके से काम करता है: अंतिम ट्रू वैल्यू या पहला गलत रिटर्न।

— जस्टिन जॉनसन

FYI करें कि अभी भी किसी को भी परवाह है, 0 और खाली स्ट्रिंग को नल के समान मूल्यांकन किया जाता है यदि आप इसे घोषित करने के लिए टाइप के कंस्ट्रक्टर का उपयोग करते हैं। var whatIWant = new Number(0) || 42; // is Number {[[PrimitiveValue]]: 0} var whatIWant = new String("") || "a million bucks"; // is String {length: 0, [[PrimitiveValue]]: ""}

— केविन Heidt

@LuisAntonioPestana var value = myObj && myObj.property || ''वापस गिर जाएगी ''अगर या तो myObj या myObj.property झूठा है।

— एतस गोरल

Answer 2

function coalesce() {
    var len = arguments.length;
    for (var i=0; i<len; i++) {
        if (arguments[i] !== null && arguments[i] !== undefined) {
            return arguments[i];
        }
    }
    return null;
}

var xyz = {};
xyz.val = coalesce(null, undefined, xyz.val, 5);

// xyz.val now contains 5

यह समाधान SQL कोलेसस फ़ंक्शन की तरह काम करता है, यह किसी भी तर्क को स्वीकार करता है, और यदि उनमें से किसी का भी मूल्य नहीं है, तो वह अशक्त हो जाता है। यह C # की तरह व्यवहार करता है ?? इस अर्थ में ऑपरेटर कि "", गलत, और 0 को NULL नहीं माना जाता है और इसलिए इसे वास्तविक मान के रूप में गिना जाता है। यदि आप एक .net पृष्ठभूमि से आते हैं, तो यह सबसे प्राकृतिक भावना समाधान होगा।

Comments

for(var i in arguments)के अनुसार यात्रा के क्रम की गारंटी नहीं है, MDN । यह भी देखें कि जावास्क्रिप्ट के लिए क्यों… लूप में सरणियों के लिए अनुशंसित नहीं है? और क्यों एक बुरा विचार के साथ सरणी पुनरावृत्ति के साथ "के लिए" का उपयोग कर रहा है? ।

— MvG

इतनी देर के लिए माफी, लेकिन मैं बस पूर्णता पर ध्यान देना चाहता था कि इस समाधान में यह चेतावनी है कि इसका कोई शॉर्ट-सर्किट मूल्यांकन नहीं है; यदि आपके तर्क फ़ंक्शन कॉल हैं, तो वे सभी का मूल्यांकन किया जाएगा, भले ही उनका मान लौटाया जाए, जो तार्किक या ऑपरेटर के व्यवहार से अलग है, इसलिए ध्यान देने योग्य है।

— हरविकैक

Answer 3

हां, यह जल्द ही आ रहा है। प्रस्ताव यहां देखें और कार्यान्वयन स्थिति यहां देखें ।

यह इस तरह दिख रहा है:

x ?? y

उदाहरण

const response = {
  settings: {
    nullValue: null,
    height: 400,
    animationDuration: 0,
    headerText: '',
    showSplashScreen: false
  }
};

const undefinedValue = response.settings?.undefinedValue ?? 'some other default'; // result: 'some other default'
const nullValue = response.settings?.nullValue ?? 'some other default'; // result: 'some other default'
const headerText = response.settings?.headerText ?? 'Hello, world!'; // result: ''
const animationDuration = response.settings?.animationDuration ?? 300; // result: 0
const showSplashScreen = response.settings?.showSplashScreen ?? true; // result: false

Comments

यह अब चरण 3 में है, और अगले टाइपस्क्रिप्ट रिलीज़ के लिए योजना बनाई गई है! github.com/microsoft/TypeScript/issues/26578

— lautaro.dragan

Nullish coalescing ऑपरेटर ( x ?? y) और वैकल्पिक चेनिंग ऑपरेटर ( user.address?.street) अब दोनों स्टेज 4 हैं। यहाँ इसका क्या मतलब है के बारे में एक अच्छा वर्णन है: 2ality.com/2015/11/tc39-process.html#stage-4%3A-finished ।

— मास डॉट नेट

Answer 4

यदि आपके मामले में ||C # के प्रतिस्थापन के रूप में ??अच्छा नहीं है, क्योंकि यह खाली तारों और शून्य को निगलता है, तो आप हमेशा अपना फ़ंक्शन लिख सकते हैं:

 function $N(value, ifnull) {
    if (value === null || value === undefined)
      return ifnull;
    return value;
 }

 var whatIWant = $N(someString, 'Cookies!');

Comments

चेतावनी (अशक्त || '') अभी भी एक खाली स्ट्रिंग को सचेत करता है, और मुझे लगता है कि मैं वास्तव में उस चेतावनी ('' '' '' '' '' ') को एक रिक्त स्ट्रिंग के बजाय ब्लाह को सचेत करता हूं - हालांकि यह जानना अच्छा है! (+1)

— डैनियल शेफ़र

मुझे लगता है कि मैं वास्तव में एक फ़ंक्शन को परिभाषित करना पसंद कर सकता हूं जो falseअगर (कड़ाई से) अशक्त / अपरिभाषित है और trueअन्यथा - एक तार्किक या के साथ इसका उपयोग कर रहा है; यह कई नेस्टेड फ़ंक्शन कॉल की तुलना में अधिक पठनीय हो सकता है। की $N(a) || $N(b) || $N(c) || dतुलना में अधिक पठनीय है $N($N($N(a, b), c), d)।

— बॉब

ब्रेंट लार्सन का समाधान अधिक सामान्य है

— अस्मिललेटर

if .. return .. else ... returnएक टर्नरी के लिए एकदम सही मामला है। return (value === null || value === void 0) ? ifnull : value;

— एलेक्स मैकमिलन

Answer 5

यहाँ किसी ने भी इसका उल्लेख नहीं किया है NaN, जो - मेरे लिए - एक अशक्त-ईश मान भी है। इसलिए, मैंने सोचा कि मैं अपने दो-सेंट जोड़ूंगा।

दिए गए कोड के लिए:

var a,
    b = null,
    c = parseInt('Not a number'),
    d = 0,
    e = '',
    f = 1
;

यदि आप ||ऑपरेटर का उपयोग करते थे , तो आपको पहला गैर-गलत मूल्य मिलता है:

var result = a || b || c || d || e || f; // result === 1

यदि आप यहाँ पर पोस्ट की गई विधि के अनुसार सामान्य कोलेसस विधि का उपयोग करते हैं , तो आपको मिलेगा c, जिसका मूल्य है:NaN

var result = coalesce(a,b,c,d,e,f); // result.toString() === 'NaN'

इनमें से कोई भी मुझे सही नहीं लगता। अपने खुद के छोटे से संसार में, जो आपकी दुनिया से अलग हो सकता है, मैं अपरिभाषित, अशक्त और NaN को "अशक्त-ईश" मानता हूं। इसलिए, मैं dमोटे विधि से वापस (शून्य) प्राप्त करने की उम्मीद करूंगा ।

यदि किसी का मस्तिष्क मेरी तरह काम करता है, और आप बाहर करना चाहते हैं NaN, तो यह विधि इसे पूरा करेगी:

function coalesce() {
    var i, undefined, arg;

    for( i=0; i < arguments.length; i++ ) {
        arg = arguments[i];
        if( arg !== null && arg !== undefined
            && (typeof arg !== 'number' || arg.toString() !== 'NaN') ) {
            return arg;
        }
    }
    return null;
}

उन लोगों के लिए जो कोड को यथासंभव कम चाहते हैं, और स्पष्टता की कमी का बुरा नहीं मानते हैं, आप @impBball द्वारा सुझाए गए अनुसार भी इसका उपयोग कर सकते हैं। यह इस तथ्य का लाभ उठाता है कि NaN, NaN के बराबर नहीं है। आप यहाँ पर और अधिक पढ़ सकते हैं: NaN NaN के बराबर क्यों नहीं है?

function coalesce() {
    var i, arg;

    for( i=0; i < arguments.length; i++ ) {
        arg = arguments[i];
        if( arg != null && arg === arg ) { //arg === arg is false for NaN
            return arg;
        }
    }
    return null;
}

Comments

सर्वोत्तम प्रथाओं - तर्कों को सरणी-जैसा मानते हैं, NaN! == NaN ( typeof+ num.toString() === 'NaN'बेमानी है) का लाभ उठाते हैं , वर्तमान तर्क को चर में बदले arguments[i]।

— इसियाह मीडोज

@impinball, आपका सुझाया हुआ संपादन काम नहीं करता है, यह मेरे परीक्षण मामले से 0 (शून्य) के बजाय NaN देता है। मैं तकनीकी रूप से !== 'number'चेक को हटा सकता हूं क्योंकि मैंने पहले ही मूल्यांकन कर लिया है कि यह नहीं है nullया नहीं undefined, लेकिन इस कोड को पढ़ने वाले किसी भी व्यक्ति के लिए बहुत स्पष्ट होने का फायदा है और स्थिति आदेश की परवाह किए बिना काम करेगी। आपके अन्य सुझाव कोड को थोड़ा छोटा करते हैं, इसलिए मैं उन का उपयोग करूंगा।

— केविन नेल्सन

@impinball, मुझे आपके सुझाए गए संपादन में आपकी बग मिल गई, आपने इसे छोड़ दिया arg !== arg, लेकिन आपको इसकी आवश्यकता है arg === arg... तब यह काम करता है। हालाँकि, यह बहुत अस्पष्ट होने का नुकसान है कि आप क्या कर रहे हैं ... कोड में टिप्पणी की आवश्यकता होती है ताकि अगले व्यक्ति द्वारा हटाए जाने से रोकने के लिए कोड के बारे arg === argमें सोचता है और बेमानी है ... लेकिन मैं इसे डाल दूंगा वैसे भी।

— केविन नेल्सन

अच्छी पकड़। और वैसे, यह NaN की जाँच करने का एक तेज़ तरीका है, इस तथ्य का लाभ उठाते हुए NaN! == NaN। यदि आप चाहें, तो आप उसे समझा सकते हैं।

— इसियाह मीडोज

"एक नंबर नहीं" के लिए चेक को एक अंतर्निहित फ़ंक्शन से बदला जा सकता है: isNaN ()

— यूरी कोज़लोव

Answer 6

null की जावास्क्रिप्ट विशिष्ट परिभाषा से सावधान रहें। जावास्क्रिप्ट में "कोई मूल्य नहीं" के लिए दो परिभाषाएं हैं। 1. अशक्त: जब एक चर शून्य होता है, तो इसका मतलब है कि इसमें कोई डेटा नहीं है, लेकिन चर पहले से ही कोड में परिभाषित है। इस तरह:

var myEmptyValue = 1;
myEmptyValue = null;
if ( myEmptyValue === null ) { window.alert('it is null'); }
// alerts

ऐसे मामले में, आपके चर का प्रकार वास्तव में ऑब्जेक्ट है। झसे आज़माओ।

window.alert(typeof myEmptyValue); // prints Object

2. अपरिभाषित: जब कोड में एक चर को पहले परिभाषित नहीं किया गया है, और जैसा कि अपेक्षित है, इसमें कोई मूल्य नहीं है। इस तरह:

   if ( myUndefinedValue === undefined ) { window.alert('it is undefined'); }
   // alerts

यदि ऐसा मामला है, तो आपके चर का प्रकार 'अपरिभाषित' है।

ध्यान दें कि यदि आप टाइप-कनवर्टिंग तुलना ऑपरेटर (==) का उपयोग करते हैं, तो जावास्क्रिप्ट इन दोनों रिक्त मानों के लिए समान रूप से कार्य करेगा। उनके बीच अंतर करने के लिए, हमेशा टाइप-सख्त तुलना ऑपरेटर (===) का उपयोग करें।

Comments

दरअसल, शून्य एक मूल्य है। यह ऑब्जेक्ट का एक विशेष मूल्य है। अशक्त करने के लिए सेट किया जा रहा चर का अर्थ है इसमें डेटा, डेटा शून्य ऑब्जेक्ट का संदर्भ है। एक चर को आपके कोड में अपरिभाषित मूल्य के साथ परिभाषित किया जा सकता है। यह वैसा नहीं है जैसा कि चर घोषित नहीं किया जा रहा है।

— एटिस गोरल

एक चर के बीच वास्तविक अंतर घोषित किया जा रहा है या नहीं: चेतावनी (window.test) / * अपरिभाषित * /; चेतावनी ("परीक्षण" खिड़की में) / * झूठी * /; window.test = undefined; चेतावनी (window.test) / * अपरिभाषित * /; चेतावनी ("परीक्षण" खिड़की में) / * सच * /; के लिए (विंडो में var p) {/ * p में "टेस्ट" * /} हो सकता है

— Ates गोरल

हालांकि (थोड़ा विरोधाभास) आप अपरिभाषित मूल्य के साथ एक चर को परिभाषित कर सकते हैंvar u = undefined;

— सर्ज

@AtesGoral फिर से अशक्त। जबकि आप जो कहते हैं वह सच है, सम्मेलन द्वारा , "अशक्त" (उपयोगी) डेटा की अनुपस्थिति का प्रतिनिधित्व करता है । इसलिए इसे "नो डेटा" माना जाता है। और यह मत भूलो कि यह "अशक्त सहगामी संचालक" के बारे में एक प्रश्न का उत्तर है; इस संदर्भ में, अशक्त निश्चित रूप से "कोई डेटा नहीं" के रूप में व्यवहार किया जाता है - भले ही यह आंतरिक रूप से कैसे प्रतिनिधित्व किया जाए।

— टूलमेकरसैट

Answer 7

आपके स्पष्टीकरण को पढ़ने के बाद, @A गोरस का जवाब यह बताता है कि आप उसी ऑपरेशन को कैसे कर सकते हैं जो आप जावास्क्रिप्ट में C # में कर रहे हैं।

@ गुम्बो का उत्तर अशक्त की जाँच करने का सबसे अच्छा तरीका प्रदान करता है; हालाँकि, विशेष रूप से जब यह चेक के मुद्दों की बात आती है, तो जावास्क्रिप्ट में ==बनाम के अंतर को नोट करना महत्वपूर्ण है===undefined और / याnull ।

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

Comments

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

— अत्स गोराल

Answer 8

ध्यान दें कि रिएक्ट का create-react-appटूल-चेन संस्करण 3.3.0 (रिलीज़ 5.12.2019) के बाद से नल-कोलेसिंग का समर्थन करता है । जारी नोटों से:

वैकल्पिक चेनिंग और Nullish Coalescing ऑपरेटरों

अब हम वैकल्पिक चेनिंग और न्यूलल कोलेसिंग ऑपरेटर्स का समर्थन करते हैं!

// Optional chaining
a?.(); // undefined if `a` is null/undefined
b?.c; // undefined if `b` is null/undefined

// Nullish coalescing
undefined ?? 'some other default'; // result: 'some other default'
null ?? 'some other default'; // result: 'some other default'
'' ?? 'some other default'; // result: ''
0 ?? 300; // result: 0
false ?? true; // result: false

इसने कहा, यदि आप create-react-app3.3.0+ का उपयोग करते हैं, तो आप अपने रिएक्ट ऐप्स में पहले से ही नल-कोलेसस ऑपरेटर का उपयोग करना शुरू कर सकते हैं।

Answer 9

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

इसके व्यवहार को प्रदर्शित करने के लिए निम्नलिखित उदाहरण पर एक नज़र डालें:

// note: this will work only if you're running latest versions of aforementioned browsers
const var1 = undefined;
const var2 = "fallback value";

const result = var1 ?? var2;
console.log(`Nullish coalescing results in: ${result}`);

पिछला उदाहरण इसके बराबर है:

const var1 = undefined;
const var2 = "fallback value";

const result = (var1 !== null && var1 !== undefined) ?
    var1 :
    var2;
console.log(`Nullish coalescing results in: ${result}`);

ध्यान दें कि nullish कोलेसिंग होगा नहीं खतरा falsy मूल्यों रास्ता ||ऑपरेटर किया (यह केवल के लिए चेक undefinedया nullमान), इसलिए निम्नलिखित स्निपेट रूप में कार्य करेगा इस प्रकार है:

// note: this will work only if you're running latest versions of aforementioned browsers
const var1 = ""; // empty string
const var2 = "fallback value";

const result = var1 ?? var2;
console.log(`Nullish coalescing results in: ${result}`);

---

टाइपस्क्रिप्ट उपयोगकर्ताओं के लिए, टाइपस्क्रिप्ट 3.7 को शुरू करने से , यह सुविधा भी अब उपलब्ध है।

Answer 10

यह उम्मीद है कि जावास्क्रिप्ट में जल्द ही उपलब्ध होगा, क्योंकि यह अप्रैल, 2020 के प्रस्ताव चरण में है। आप संगतता और समर्थन के लिए यहां स्थिति की निगरानी कर सकते हैं - https://developer.mozilla.org/en-US/docs/Web/ जावास्क्रिप्ट / संदर्भ / ऑपरेटरों / Nullish_coalescing_operator

टाइपस्क्रिप्ट का उपयोग करने वाले लोगों के लिए, आप टाइपस्क्रिप्ट 3.7 से nullish coalescing ऑपरेटर का उपयोग कर सकते हैं

डॉक्स से -

इस सुविधा को के बारे में सोच सकते हैं - ??ऑपरेटर - "के रूप में गिरावट वापस" एक डिफ़ॉल्ट मान पर के लिए एक रास्ता के साथ जब काम कर nullया undefined। जब हम जैसे कोड लिखते हैं

let x = foo ?? bar();

यह कहने का एक नया तरीका है कि foo"वर्तमान" होने पर मूल्य का उपयोग किया जाएगा; लेकिन जब यह हो nullया undefined, bar()इसकी जगह पर गणना करें ।

Answer 11

ठीक है एक उचित जवाब

क्या यह जावास्क्रिप्ट में मौजूद है? हाँ यह करता है। परंतु। यह वर्तमान में स्टेज 3 पर 2020-02-06 तक है और अभी तक हर जगह समर्थित नहीं है। नीचे दिए गए URL में दिए गए लिंक का अनुसरण करें और अधिक जानकारी के लिए "विनिर्देश" और "ब्राउज़र संगतता" हेडर पर जाएं जहां यह है।

से उद्धरण: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Nullish_coalescing_operator

Nullish coalescing ऑपरेटर (??) एक तार्किक ऑपरेटर है जो अपने दाएं हाथ के साइड ऑपरेंड को वापस लौटाता है जब उसका लेफ्ट-हैंड साइड ऑपरेंड null या अपरिभाषित होता है, और अन्यथा उसका लेफ्ट-हैंड ऑपरेटर ऑपरेट करता है।

तार्किक या (()) ऑपरेटर के विपरीत, बाएं ऑपरेंड को लौटाया जाता है यदि यह एक गलत मान है जो शून्य या अपरिभाषित नहीं है। दूसरे शब्दों में, यदि आप उपयोग करते हैं || किसी अन्य चर foo के लिए कुछ डिफ़ॉल्ट मान प्रदान करने के लिए, यदि आप कुछ मिथ्या मानों को प्रयोग करने योग्य मानते हैं, तो आप अप्रत्याशित व्यवहार का सामना कर सकते हैं (जैसे। '' या 0)। अधिक उदाहरणों के लिए नीचे देखें।

उदाहरण चाहते हैं? मेरे द्वारा पोस्ट किए गए लिंक का पालन करें, इसमें सब कुछ है।

Comments

Chrome में उपलब्ध 80+ caniuse.com/#feat=mdn-javascript_operators_nullish_coalescing

— nathan

MDN लिंक सहायक है लेकिन यह एक डुप्लिकेट उत्तर है। आपको इसके बजाय विघ्न के उत्तर के तहत टिप्पणी करनी चाहिए।

— क्रिस

@ क्रिस उनका जवाब पर्याप्त नहीं है, इसलिए मेरा जवाब है।

— कार्ल मॉरिसन

Answer 12

अब इसे क्रोम, एज, फ़ायरफ़ॉक्स, सफारी आदि जैसे प्रमुख ब्राउज़रों के नवीनतम संस्करण में पूर्ण समर्थन मिला है। यहाँ पर नल ऑपरेटर और Nullish Coalescing Operator के बीच तुलना है

const response = {
        settings: {
            nullValue: null,
            height: 400,
            animationDuration: 0,
            headerText: '',
            showSplashScreen: false
        }
    };
    /* OR Operator */
    const undefinedValue = response.settings.undefinedValue || 'Default Value'; // 'Default Value'
    const nullValue = response.settings.nullValue || 'Default Value'; // 'Default Value'
    const headerText = response.settings.headerText || 'Hello, world!'; //  'Hello, world!'
    const animationDuration = response.settings.animationDuration || 300; //  300
    const showSplashScreen = response.settings.showSplashScreen || true; //  true
    /* Nullish Coalescing Operator */
    const undefinedValue = response.settings.undefinedValue ?? 'Default Value'; // 'Default Value'
    const nullValue = response.settings.nullValue ?? ''Default Value'; // 'Default Value'
    const headerText = response.settings.headerText ?? 'Hello, world!'; // ''
    const animationDuration = response.settings.animationDuration ?? 300; // 0
    const showSplashScreen = response.settings.showSplashScreen ?? true; //  false