अल्पविराम ऑपरेटर कब उपयोगी है?

Question

मैंने अभिव्यक्ति ( ) और एमडीएन डॉक्स में "अल्पविराम ऑपरेटर" के बारे में यह प्रश्न पढ़ा है, लेकिन मैं ऐसे परिदृश्य के बारे में नहीं सोच सकता जहां यह उपयोगी है।,

तो, अल्पविराम ऑपरेटर कब उपयोगी है?

Comments

var i, j, k;बनाम var i; var j, var k?

— सलमान ए

@SalmanA। मुझे यकीन नहीं है कि इसका ,ऑपरेटर के साथ कुछ भी लेना-देना है । वह लाइन भी मान्य है C#, लेकिन ,ऑपरेटर वहां मौजूद नहीं है।

— gdoron मोनिका

@SalmanA। मैंने किया। यह नहीं मिला, मुझे बताइए ...

— गदोरन

@ सलमानआ ,हमेशा ,ऑपरेटर नहीं होते हैं (और यह कभी भी ,C # में ऑपरेटर नहीं होता है )। तो C # सिंटैक्स के हिस्से के रूप में ,स्वतंत्र ,रूप से उपयोग करते हुए एक ऑपरेटर की कमी कर सकता है ।

— सेठ कार्नेगी

मुझे लगता है कि यहां के जवाबों ने इस तथ्य को अभिव्यक्त किया है कि इसका ,व्यापक रूप से उपयोग नहीं किया जाता है (और प्रत्येक घटना ,अल्पविराम ऑपरेटर नहीं है) । लेकिन आप एक अस्थायी चर बनाने के बिना एक चर स्वैप इनलाइन करने के लिए इसे और एक ऐरे को उधार ले सकते हैं। यह देखते हुए कि आप के मूल्यों को स्वैप करना चाहते हैं aऔर bआप कर सकते हैं a = [b][b = a,0]। यह bऐरे में करंट लगाता है। दूसरा []है प्रॉपर्टी एक्सेस नोटेशन। इंडेक्स एक्सेस किया गया है 0, लेकिन असाइन aकरने से पहले नहीं b, जो अब सुरक्षित है क्योंकि bएरे में रखा गया है। ,हमें में एक से अधिक भाव करने की सुविधा देता []।

Answer 1

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

if(x){foo();return bar()}else{return 1}

बन जाएगा:

return x?(foo(),bar()):1

? :ऑपरेटर, अब के बाद से इस्तेमाल किया जा सकता अल्पविराम ऑपरेटर (कुछ हद तक) की अनुमति देता है के लिए दो बयान एक बयान के रूप में लिखा जाना।

इसमें यह उपयोगी है कि यह कुछ साफ संपीड़न (39 -> 24 बाइट्स) के लिए अनुमति देता है।

---

मैं तथ्य यह है कि में अल्पविराम तनाव करना चाहते हैं var a, bहै नहीं अल्पविराम ऑपरेटर है क्योंकि यह एक के भीतर मौजूद नहीं है अभिव्यक्ति । var बयानों में अल्पविराम का एक विशेष अर्थ है । a, bएक अभिव्यक्ति में दो चर का जिक्र होगा और मूल्यांकन किया जाएगा b, जो कि ऐसा नहीं है var a, b।

Comments

आपने उसके बारे में कैसे सोचा? क्या आपने इसे कुछ पढ़ा है? क्या यह वास्तव में इस्तेमाल किया जा रहा है?

— गदोरन

मैं दूसरे दिन बस क्लोजर कंपाइलर के साथ गड़बड़ कर रहा था , यह देखने के लिए कि यह वास्तव में क्या करता है, और मैंने इस प्रतिस्थापन को नोटिस किया।

— pimvdb

एक समान उपयोग जो मुझे लगता है कि आपके कोड में उपयोगी है, यदि कथन में एक इनलाइन में कई चर निर्दिष्ट करने के लिए होगा। उदाहरण के लिए: if (condition) var1 = val1, var2 = val2;मुझे व्यक्तिगत रूप से लगता है कि कोष्ठक से बचना जहाँ संभव हो कोड को अधिक पठनीय बनाता है।

— इदियाकापी

केवल उसी समय के बारे में जब मैं अल्पविराम ऑपरेटर का उपयोग कर रहा हूं, जब मैं भावों में लॉग स्टेटमेंट जोड़ रहा हूं (foo => (कंसोल.लॉग ('फू', फू), फू)), या अगर मैं इसे कम करने के साथ बहुत चालाक हो रहा हूं । (जोड़ो। क्रूस ((ए.सी., [के, वी]) => (एसीसी ([के] = वी, एसीसी), {})

— जोसेफ सिकोरस्की

Answer 2

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

मैं व्यक्तिगत रूप से बहुत बार इसका उपयोग नहीं करता हूं क्योंकि ऐसी कई स्थितियां नहीं हैं जहां एक से अधिक अभिव्यक्ति की उम्मीद है और कॉमा ऑपरेटर का उपयोग करने की तुलना में कोड लिखने के लिए कम भ्रमित तरीका नहीं है। एक दिलचस्प संभावना एक forलूप के अंत में है जब आप एक से अधिक वैरिएबल को बढ़ाना चाहते हैं:

// j is initialized to some other value
// as the for loop executes both i and j are incremented
// because the comma operator allows two statements to be put in place of one
for (var i = 0; i < items.len; i++, j++) {
    // loop code here that operates on items[i] 
    // and sometimes uses j to access a different array
}

यहां आप देख i++, j++सकते हैं कि ऐसी जगह पर रखा जा सकता है जहां एक अभिव्यक्ति की अनुमति है। इस विशेष मामले में, पक्ष के लिए कई अभिव्यक्तियों का उपयोग किया जाता है, इसलिए इससे कोई फर्क नहीं पड़ता है कि यौगिक अभिव्यक्तियां पिछले एक के मूल्य पर लेती हैं, लेकिन ऐसे अन्य मामले हैं जहां वास्तव में मामला हो सकता है।

Answer 3

जावास्क्रिप्ट में कार्यात्मक कोड लिखते समय कोमा ऑपरेटर अक्सर उपयोगी होता है।

इस कोड पर विचार करें जो मैंने थोड़ी देर पहले एसपीए के लिए लिखा था, जिसमें कुछ इस तरह था

const actions = _.chain(options)
                 .pairs() // 1
                 .filter(selectActions) // 2
                 .map(createActionPromise) // 3
                 .reduce((state, pair) => (state[pair[0]] = pair[1], state), {}) // 4
                 .value();

यह एक काफी जटिल, लेकिन वास्तविक दुनिया का परिदृश्य था। मेरे साथ सहन करें जबकि मैं समझाता हूं कि क्या हो रहा है, और इस प्रक्रिया में कॉमा ऑपरेटर के लिए मामला बनाते हैं।

---

यह अंडरस्कोर की चाइनिंग का उपयोग करता है

1. इस फ़ंक्शन में दिए गए सभी विकल्पों को अलग से लें, pairs जिनका उपयोग करके यह चालू { a: 1, b: 2}हो जाएगा[['a', 1], ['b', 2]]

2. संपत्ति जोड़े के इस सरणी को फ़िल्टर किया जाता है जिसके द्वारा सिस्टम में 'कार्रवाई' मानी जाती है।

3. फिर एरे में दूसरे इंडेक्स को एक फ़ंक्शन से बदल दिया जाता है जो उस एक्शन का प्रतिनिधित्व करने वाले वादे का उपयोग करता है (उपयोग करते हुए map)

4. अंत में कॉल करने के reduceलिए प्रत्येक "संपत्ति सरणी" ( ['a', 1]) एक अंतिम वस्तु में वापस विलय होगा ।

अंतिम परिणाम optionsतर्क का एक रूपांतरित संस्करण है , जिसमें केवल उचित कुंजी होती है और जिसका मान कॉलिंग फ़ंक्शन द्वारा उपभोग्य होता है।

---

बस देख रहा हूं

.reduce((state, pair) => (state[pair[0]] = pair[1], state), {})

आप देख सकते हैं कि कम फ़ंक्शन एक खाली स्थिति ऑब्जेक्ट के साथ शुरू होता है state, और प्रत्येक जोड़ी के लिए एक कुंजी और मूल्य का प्रतिनिधित्व करता है, फ़ंक्शन stateकुंजी / मूल्य जोड़ी के अनुरूप ऑब्जेक्ट में एक संपत्ति जोड़ने के बाद उसी ऑब्जेक्ट को वापस करता है । ECMAScript 2015 के तीर फ़ंक्शन सिंटैक्स के कारण, फ़ंक्शन बॉडी एक अभिव्यक्ति है, और परिणामस्वरूप, कॉमा ऑपरेटर एक संक्षिप्त और उपयोगी "पुनरावृति" फ़ंक्शन की अनुमति देता है ।

ECMAScript 2015 + एरो फ़ंक्शंस के साथ जावास्क्रिप्ट को और अधिक कार्यात्मक शैली में लिखते हुए व्यक्तिगत रूप से मैं कई मामलों में आया हूं। यह कहने के बाद कि, तीर फ़ंक्शन (जैसे प्रश्न के लेखन के समय) का सामना करने से पहले, मैंने कभी भी अल्पविराम तरीके से अल्पविराम ऑपरेटर का उपयोग नहीं किया।

Comments

एक प्रोग्रामर कॉमा ऑपरेटर का उपयोग कैसे / कब कर सकता है, इसके संबंध में यह एकमात्र उपयोगी उत्तर है। विशेष रूप से बहुत उपयोगी हैreduce

— hgoebl

अच्छा जवाब है, लेकिन अगर मैं कुछ सुझाव दे सकते हैं थोड़ा अधिक पठनीय: .reduce((state, [key, value]) => (state[key] = value, state), {})। और मुझे लगता है कि यह उत्तर के उद्देश्य को हरा देता है लेकिन .reduce((state, [key, value]) => Object.assign(state, { [key]: value }), {})पूरी तरह से अल्पविराम ऑपरेटर की आवश्यकता को समाप्त कर देगा।

— पैट्रिक रॉबर्ट्स

जबकि Object.assign शायद इन दिनों अधिक मुहावरेदार है, या यहां तक ​​कि सिर्फ प्रसार ऑपरेटर, मुझे यकीन नहीं है कि वे उस समय व्यापक उपयोग में थे। मैं यह भी कहना चाहूंगा कि जबकि अल्पविराम ऑपरेटर थोड़ा अधिक अस्पष्ट है, यह उन स्थितियों में बहुत कम कचरा उत्पन्न कर सकता है जहां डेटा का सेट बहुत बड़ा है। हालांकि विनाशकारी निश्चित रूप से पठनीयता में मदद करेगा!

— सायनथ

Answer 4

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

उदाहरण के लिए, यदि आप उत्तर myVariable = aWholeLotOfTextया कंसोल में मूल्यांकन करते हैं, तो यह आपके द्वारा असाइन किए गए सभी डेटा को प्रिंट करेगा। यह पृष्ठ और पृष्ठ हो सकते हैं, और यदि आप इसे नहीं देखना पसंद करते हैं, तो आप इसके बजाय मूल्यांकन कर सकते हैं myVariable = aWholeLotOfText, 'done', और उत्तर / कंसोल बस 'किया' प्रिंट करेगा।

ओरिएल सही ढंग से ^† बताता है कि अनुकूलित toString()या get()फ़ंक्शंस भी इसे उपयोगी बना सकते हैं।

Comments

हा, बहुत अच्छा विचार है! (अंत में एक उत्तर जो वास्तव में लगभग सभी उत्तरों के विपरीत प्रश्न का उत्तर दे रहा है {और 3 हटाए गए उत्तर जिन्हें आपको देखने के लिए 20K प्रतिष्ठा की आवश्यकता है ...})

— gdoron

यदि निर्दिष्ट मान एक ऑब्जेक्ट है, तो कंसोल इसे अच्छी तरह से प्रदर्शित करने का प्रयास कर सकता है। ऐसा करने के लिए, यह उदाहरण के लिए कॉल गेटर्स हो सकता है, जो ऑब्जेक्ट की स्थिति को बदल सकता है। अल्पविराम का उपयोग करके इसे रोका जा सकता है।

— ओरोल

@ ऑरिओल - अच्छा! तुम बिलकुल सही हो। किसी तरह यह संभावित रूप से उपयोगी होने के नाते बस थोड़ा सा निराशाजनक लगता है :)

— जूलियन डे भाल

Answer 5

कोमा ऑपरेटर जावास्क्रिप्ट के लिए विशिष्ट नहीं है, यह सी और सी ++ जैसी अन्य भाषाओं में उपलब्ध है । एक बाइनरी ऑपरेटर के रूप में यह तब उपयोगी होता है जब पहला ऑपरेंड, जो आम तौर पर एक अभिव्यक्ति है, दूसरे ऑपरेंड द्वारा आवश्यक वांछित प्रभाव है। विकिपीडिया से एक उदाहरण:

i = a += 2, a + b;

जाहिर है आप दो अलग-अलग लाइनों के कोड लिख सकते हैं, लेकिन अल्पविराम का उपयोग करना एक और विकल्प है और कभी-कभी अधिक पठनीय है।

Comments

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

— टास्किनर

BTW, मैं चर घोषणा में अल्पविराम के उपयोग या लूप में कई चर को शुरू करने पर विचार नहीं कर रहा हूं। उन मामलों में कॉमा ज्यादातर बेहतर है।

— टास्किनर

यह भ्रमित करने वाला af लगता है ... wtf

— टिमरज

Answer 6

मैं फ़्लेगन से असहमत हूँ, और कहूँगा, कि अल्पविराम वास्तव में उपयोगी है और अधिक पठनीय और सुरुचिपूर्ण कोड लिखने की अनुमति देता है, खासकर जब आप जानते हैं कि आप क्या कर रहे हैं:

यहाँ अल्पविराम उपयोग पर बहुत विस्तृत लेख है :

प्रदर्शन के प्रमाण के लिए वहाँ से कई उदाहरण:

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

एक जेनरेटर जनरेटर:

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

पहला मूल तत्व खोजें, jQuery .parent()फ़ंक्शन का एनालॉग :

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">

Comments

मुझे यकीन नहीं है कि अगर मैं कहूंगा कि कोई भी अधिक पठनीय है, लेकिन यह निश्चित रूप से बहुत

— स्पष्ट है

अंतिम उदाहरण में आपको लूप में अल्पविराम की आवश्यकता नहीं है, while ((el = el.parentNode) && (el.tagName != tagName.toUpperCase()))इस संदर्भ में यह ठीक रहेगा।

— पीटीजेजे

Answer 7

मुझे इसके अलावा इसका व्यावहारिक उपयोग नहीं मिला है, लेकिन यहां एक परिदृश्य है जिसमें जेम्स पोडल्से ने कुछ ही समय में IE का पता लगाने के लिए इस तकनीक का उपयोग किया है:

var ie = (function(){

    var undef,
        v = 3,
        div = document.createElement('div'),
        all = div.getElementsByTagName('i');

    while ( // <-- notice no while body here
        div.innerHTML = '<!--[if gt IE ' + (++v) + ']><i></i><![endif]-->',
        all[0]
    );

    return v > 4 ? v : undef;

}());

इन दो लाइनों को निष्पादित करना होगा:

div.innerHTML = '<!--[if gt IE ' + (++v) + ']><i></i><![endif]-->',
all[0]

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

Comments

यह एक हो सकता था do- whileपाश।

— केसी चु

Answer 8

कुछ "विषम" है जो जावास्क्रिप्ट में किया जा सकता है एक फ़ंक्शन को अप्रत्यक्ष रूप से कॉमा ऑपरेटर का उपयोग करके बुलाता है।

यहां एक लंबा वर्णन है: जावास्क्रिप्ट में अप्रत्यक्ष फ़ंक्शन कॉल

इस सिंटैक्स का उपयोग करके:

(function() {
    "use strict";
  
    var global = (function () { return this || (1,eval)("this"); })();
    console.log('Global === window should be true: ', global === window);
  
    var not_global = (function () { return this })();
    console.log('not_global === window should be false: ', not_global === window);
  
  }());

आप वैश्विक वैरिएबल तक पहुंच प्राप्त कर सकते हैं क्योंकि evalप्रत्यक्ष या अप्रत्यक्ष रूप से कहे जाने पर अलग-अलग तरीके से काम करता है।

Answer 9

मैंने इस तरह से हेल्पर्स लिखते समय अल्पविराम ऑपरेटर को सबसे उपयोगी पाया है।

const stopPropagation = event => (event.stopPropagation(), event);
const preventDefault = event => (event.preventDefault(), event);
const both = compose(stopPropagation, preventDefault);

आप अल्पविराम को या तो बदल सकते हैं || या &&, लेकिन तब आपको यह जानना होगा कि फ़ंक्शन क्या देता है।

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

स्वाभाविक रूप से आप एक ही चीज़ को अन्य तरीकों से हासिल कर सकते हैं, लेकिन उतनी सहजता से नहीं। अगर || और && को सामान्य उपयोग में जगह मिली, इसलिए भी अल्पविराम ऑपरेटर कर सकता है।

Comments

Ramda \ Lodash tap( ramdajs.com/docs/#tap ) के साथ ऐसा ही करता है । अनिवार्य रूप से, आप एक साइड-इफ़ेक्ट को निष्पादित कर रहे हैं और फिर प्रारंभिक मूल्य लौटा रहे हैं; कार्यात्मक प्रोग्रामिंग में बहुत उपयोगी है :)

— avalanche1

Answer 10

एक विशिष्ट मामला जो मैं इसका उपयोग कर रहा हूं वह वैकल्पिक तर्क पार्सिंग के दौरान है। मुझे लगता है कि यह दोनों को अधिक पठनीय और अधिक संक्षिप्त बनाता है ताकि तर्क पार्सिंग फ़ंक्शन बॉडी पर हावी न हो।

/**
 * @param {string} [str]
 * @param {object} [obj]
 * @param {Date} [date]
 */
function f(str, obj, date) {
  // handle optional arguments
  if (typeof str !== "string") date = obj, obj = str, str = "default";
  if (obj instanceof Date) date = obj, obj = {};
  if (!(date instanceof Date)) date = new Date();

  // ...
}

Comments

हालाँकि मैं खुद इसका पक्ष नहीं लेता, लेकिन यह केवल एक उदाहरण है जो किसी के द्वारा दिया गया है जो मुझे लगता है कि एक व्यक्ति कह सकता है कि पठनीयता के लिए व्यक्तिगत अभिव्यक्ति के बयानों की समान सूची की तुलना में बेहतर है मेरे बिना यह सोचना कि वे पूरी तरह से पागल हैं।

— अर्धविराम

Answer 11

मान लीजिए कि आपके पास एक सरणी है:

arr = [];

जब आप pushउस सरणी पर आते हैं, तो आप शायद ही कभी pushवापसी के मूल्य में रुचि रखते हैं , अर्थात् सरणी की नई लंबाई, बल्कि खुद सरणी:

arr.push('foo')  // ['foo'] seems more interesting than 1

अल्पविराम ऑपरेटर का उपयोग करके, हम सरणी पर धक्का दे सकते हैं, सरणी को अंतिम ओपेरा के रूप में अल्पविराम तक निर्दिष्ट कर सकते हैं, और फिर परिणाम का उपयोग कर सकते हैं - बाद के सरणी विधि कॉल के लिए, सरणी - एक प्रकार की जंजीर:

(arr.push('bar'), arr.push('baz'), arr).sort(); // [ 'bar', 'baz', 'foo' ]

Answer 12

एक अन्य क्षेत्र जहां अल्पविराम ऑपरेटर का उपयोग किया जा सकता है, वह है कोड ऑब्सफिकेशन ।

मान लीजिए कि एक डेवलपर इस तरह से कुछ कोड लिखता है:

var foo = 'bar';

अब, वह कोड को बाधित करने का फैसला करती है। प्रयुक्त उपकरण इस तरह कोड को बदल सकता है:

var Z0b=(45,87)>(195,3)?'bar':(54,65)>(1,0)?'':'baz';// Z0b == 'bar'

डेमो: http://jsfiddle.net/uvDuE/

Comments

@gdoron कृपया इस उत्तर पर एक नज़र डालें । C ++ में कोमा ऑपरेटर के बारे में stackoverflow.com/a/17903036/363573 । आप जेम्स कान्जे की टिप्पणी को आपत्तिजनक मानते हैं।

— Stephan