कोमा संचालक

हम ऑपरेटरों के विषय को जारी रखते हैं , इस समय आप ऑपरेटर कॉमा के बारे में एक कहानी की प्रतीक्षा कर रहे हैं।

आइए शुरुआत करते हैं एक मजेदार ट्वीट से:



अंत में 'c' अल्पविराम ऑपरेटर है। महत्वपूर्ण ऑपरेटरों की सूची में अंतिम, थोड़ा प्रलेखित, लेकिन बहुत उपयोगी है। यह इतना आम नहीं है, लेकिन मैं वास्तव में इसे पसंद करता हूं। वह सरल, शिष्ट है और उसके साथ अच्छे रिश्ते में रहना बेहतर है।

वह क्या कर रही है?

अल्पविराम ऑपरेटर दोनों ऑपरेंड (बाएं से दाएं) को निष्पादित करता है और दूसरे ऑपरेटर का मान लौटाता है। ( MDC )

var a = (7, 5); a; //5 var x, y, z x = (y=1, z=4); x; //4 y; //1 z; //4 

आपके उदाहरण में कोष्ठक से घिरे चर असाइनमेंट क्यों हैं?

संचालकों की प्राथमिकता के कारण। एक जावास्क्रिप्ट अभिव्यक्ति में कई अलग-अलग ऑपरेटर हो सकते हैं। निम्नलिखित अभिव्यक्ति में तीन ऑपरेटर (* + और) शामिल हैं:

 return 5 * 2 + 3, 22; 

ऑपरेटरों की प्राथमिकता निर्धारित करती है कि अभिव्यक्ति के अंदर ऑपरेटरों को किस क्रम में निष्पादित किया जाएगा।
यहाँ ऑपरेटरों की पूरी सूची। अल्पविराम ऑपरेटर सभी ऑपरेटरों की सबसे कम प्राथमिकता है। आइए एक उदाहरण देखें:

 //original return 5 * 2 + 3, 22; //apply * operator return 10 + 3, 22; //apply + operator return 13, 22; //apply , operator return 22; 

अब देखते हैं कि यदि हम कोष्ठक हटाते हैं तो क्या होता है:

 //original var a = 7, 5; //apply = operator var a, 5; //a is now 7 //SyntaxError: missing variable name 

कोष्ठक के साथ अभिव्यक्ति को परिभाषित करते हुए, हम उस समूह का निर्माण करते हैं जिसकी सर्वोच्च प्राथमिकता है।
यह सुनिश्चित करता है कि अल्पविराम ऑपरेटर पहले लागू किया जाता है।

 //original var a = (7, 5); //apply group var a = 5; 

व्यवहार में, इसकी कम प्राथमिकता के कारण, अल्पविराम एक शक्तिशाली उपकरण है। वास्तव में, वह दुभाषिया से कहती है: पहले देखो, मेरे आसपास के अन्य सभी ऑपरेटर क्या करते हैं, और फिर मुझे परिणाम को सुशोभित करते हैं।

कुछ भावों में कई अल्पविराम होते हैं। यह कैसे काम करता है?

श्रृंखला के प्रत्येक ऑपरेटर को बाएं से दाएं क्रमिक रूप से संसाधित किया जाता है।

 var a = (1, 2, 3, 4); a; //4 

यह इसके बराबर है:

 var a = (((1, 2), 3), 4); a; //4 

टाइप शाब्दिक और घोषणाओं में प्रयुक्त कॉमा के बारे में क्या?

ये सीमांकक वास्तव में अल्पविराम संचालक नहीं हैं। अल्पविराम सीमांकक का उद्देश्य एक सूची में सदस्यों को अलग करना है। उदाहरण के लिए:

 //    4  var arr = [1, 2, 3, 4]; //     var obj = { a: 22, f: function() {return this.a*this.a} } //   var a = 1, b = 2, c = 3; // ,  2  Math.max(4, 7); 

अल्पविराम ऑपरेटर का उपयोग क्यों करें?

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

 var r = [], n = 0, a = 0, b = 1, next; function nextFibonacci() { next = a + b; return b = (a = b, next); // <<<   } while(n++ < 10) { r.push(nextFibonacci()); } r; //[1, 2, 3, 5, 8, 13, 21, 34, 55, 89] 

 function getRandomPrime() { while(n = Math.round(Math.random()*1000000000), !isPrime(n)); // <<<   return n; } var isPrime = function(n) { d = Math.ceil(Math.sqrt(n)); while(n%(d--) && d); return !d; } getRandomPrime(); //425593109 getRandomPrime(); //268274719 

क्या अर्धविराम एक नकाबपोश नहीं है?

अर्धविराम घोषणाओं के लिए विभाजक है, और अल्पविराम घोषणाओं के अंदर अभिव्यक्तियों के लिए विभाजक है।

क्रमिक रूप से एकाधिक अभिव्यक्तियों को निष्पादित करने के लिए && ऑपरेटर का उपयोग क्यों नहीं किया जाता?

अल्पविराम ऑपरेटर && और ऑपरेटर के बहुत करीब है || इन सभी कथनों में उनके द्वारा निष्पादित अंतिम अभिव्यक्ति वापस आती है। यहाँ उनका अंतर है:

LHE - बाईं अभिव्यक्ति
आरएचएच - सही अभिव्यक्ति

LHE && RHE
1. हमेशा LHE करता है
2. यदि LHE सही है, RHE करता है

LHE || RHE
1. हमेशा LHE करता है
2. यदि LHE गलत है, RHE करता है

LHE, RHE
1. हमेशा LHE करता है
2. हमेशा RHE करता है

आपको एक कॉमा चुनना चाहिए अगर दोनों अभिव्यक्तियों को निष्पादित किया जाना चाहिए।

उदाहरणों के बारे में क्या?

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

छोरों के लिए

यहाँ फिबोनाची संख्या जनरेटर का वैकल्पिक संस्करण है जो अल्पविराम ऑपरेटर का भी उपयोग करता है:

 for ( var i=2, r=[0,1]; i<15; r.push(r[i-1] + r[i-2]), i++ ); r //"0,1,1,2,3,5,8,13,21,34,55,89,144,233,377" 

एक अन्य उदाहरण के लिए, एक उपयोगिता पर विचार करें जो विक्रेता को बैंकनोट और सिक्कों का चयन करने में मदद करता है जो खरीदार के परिवर्तन को बनाते हैं:

 function toCurrency(total, values) { total *= 100; for( var i=0,counts=[]; counts[i]=total/values[i], total=total%values[i]; //   i++ ); return counts.map(Math.floor); } toCurrency(32.47, [500, 100, 25, 10, 5, 1]); //[6, 2, 1, 2, 0, 2] 

समान उपयोगिता, लेकिन प्रारूपण के साथ:

 function toCurrency(total, values, sym) { total *= 100; //do the calc for( var i=0,counts=[]; counts[i]=total/values[i], total=total%values[i]; //   i++ ); //format var results = counts.map(function(s,i) { return s>=1 && [Math.floor(s),"x",(sym || '$') + (values[i]/100).toFixed(2)].join(' '); }); return results.filter(Boolean).join(', '); } toCurrency(19.77, [500,100,25,10,5,1]); //"3 x $5.00, 4 x $1.00, 3 x $0.25, 2 x $0.01" toCurrency(19.77, [500,100,50,20,10,5,1], '£'); //"3 x £5.00, 4 x £1.00, 1 x £0.50, 1 x £0.20, 1 x £0.05, 2 x £0.01" toCurrency(19.77, [500,100,50,20,10,5,2,1], '€'); //"3 x €5.00, 4 x €1.00, 1 x €0.50, 1 x €0.20, 1 x €0.05, 1 x €0.02" 

निम्न फ़ंक्शन एक लूप के भीतर दो चर को एक साथ बढ़ाने और घटाने के लिए अल्पविराम का उपयोग करता है। आउटपुट एक वक्र है:

 function renderCurve() { for(var a = 1, b = 10; a*b; a++, b--) //   console.log(new Array(a*b).join('*')); } renderCurve(); /* ********* ***************** *********************** *************************** ***************************** ***************************** *************************** *********************** ***************** ********* */ 

जबकि लूप

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

 function firstAncestor(el, tagName) { while(el = el.parentNode, el && (el.tagName != tagName.toUpperCase())); return el; } //element in http://ecma262-5.com/ELS5_HTML.htm var a = $('Section_15.1.1.2'); firstAncestor(a, 'div'); //<div class="page"> 

टर्नरी ऑपरेटर

टर्नेरी ऑपरेटर केवल एक अभिव्यक्ति को निष्पादित करने की अनुमति देता है। यदि आपको कई अभिव्यक्तियों को निष्पादित करने की आवश्यकता है, तो आपको इसे और पर स्विच करना होगा। अल्प अभिव्यक्ति को संयोजित करने के लिए अल्पविराम ऑपरेटर अधिक पठनीय होता है:

 //player loses lives ? (gameOver(), exit()) : (lives--, go()); 

डिबग

अल्पविराम ऑपरेटर आपको कोड बदले बिना कहीं भी कंसोल एम्बेड करने की अनुमति देता है:

 // products  i > n var i=10, n=0, total=0; while(console.log(i,n), i-- > n++); { total += i*n } 

 //   var arr = [1,2,3]; for ( var i=0, total=0; i<arr.length; console.log(i,total), total += arr[i++]); ) 

 // 4        var testArray = [3, 5, 8, 4], total = 0; var plusFour = testArray.map(function(e) {e + 4}) plusFour.forEach(function(n) {console.log(n), isNaN(n) || (total += n)}); 

इटरेटर बाइंडिंग

@wavded ने कॉमा का उपयोग करने का एक तरीका पोस्ट किया है।

 var colorIndex = 0, colors = ["FF0000", "008000", "FF0086", "A2FF00", "0000FF", "800080"]; function selectNextColor(){ return colors[colorIndex++] || colors[colorIndex = 0, colorIndex++]; } 

अप्रत्यक्ष की अप्रत्यक्ष कॉल

eval ¹ उस संदर्भ का उपयोग करता है जिसमें इसे कहा जाता था। इसलिए, इस बात की कोई गारंटी नहीं है कि लूप में eval कॉल करना एक ही परिणाम देगा।

kangax ने लिखा कि हम कॉमा ऑपरेटर का उपयोग अप्रत्यक्ष रूप से कॉल को निकालने के लिए कर सकते हैं, जिसे हमेशा वैश्विक संदर्भ ² में कहा जाएगा:

 var a = {}; (function() { eval("this.alert('If you can read this I must be global!')"); }).call(a); //TypeError: this.alert is not a function (function() { (0,eval)("this.alert('If you can read this I must be global!')"); }).call(a); //alerts: 'If you can read this I must be global!' 

1. कृपया होलीवरोव के बिना, हर कोई जानता है कि बुराई बुराई है
2. ES5 मानक कहता है कि किसी भी गैर-प्रत्यक्ष कॉल को वैश्विक संदर्भ का उपयोग करने के लिए कहा जाता है,
हालाँकि, सभी ब्राउज़र इस नियम का समर्थन नहीं करते हैं (IE <= 8)

निष्कर्ष

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

आदर

ECMA-262 5 वां संस्करण
11.14 अल्पविराम ऑपरेटर
10.4.2 निष्कासन कोड दर्ज करना
१५.१.२.१.१ प्रत्यक्ष से कॉल करें

मोज़िला डेवलपर केंद्र
अल्पविराम ऑपरेटर
ऑपरेटर पूर्वता

जूरि जायत्सेव ( कंगैक्स ): वैश्विक विकास, विकल्प क्या हैं
मार्क हैटर (@wavded): अल्पविराम ऑपरेटर का उपयोग करके एक सरणी के माध्यम से साइकिल चलाना

UPD को ध्यान में रखा और अनुवाद की खामियों को ठीक किया