अपने आप को दोहराए बिना एक टर्नरी ऑपरेटर (उर्फ अगर) अभिव्यक्ति कैसे लिखें

Question

उदाहरण के लिए, कुछ इस तरह:

var value = someArray.indexOf(3) !== -1 ? someArray.indexOf(3) : 0

क्या यह लिखने का एक बेहतर तरीका है? फिर, मैं ऊपर दिए गए सटीक प्रश्न का उत्तर नहीं चाह रहा हूँ, बस एक उदाहरण है कि जब आपने टर्नरी ऑपरेटर में ऑपरेंड दोहराया हो सकता है ...

Comments

तो एक ifऔर नहींif/else

— zer00ne

just an example of when you might have repeated things in the ternaryपरिकलित अभिव्यक्तियों को दोहराएं नहीं। वैरिएबल किसके लिए हैं।

— Vol7ron

हम यह कैसे निर्धारित करेंगे कि 3सूचकांक 0में नहीं है someArray?

— 271314

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

— asgallant

Math.max(someArray.indexOf(3), 0)इसके बजाय उपयोग क्यों नहीं ?

— 301_Moved_Permanently

Answer 1

व्यक्तिगत रूप से मुझे यह करने का सबसे अच्छा तरीका लगता है कि यह अभी भी अच्छा पुराना ifकथन है:

var value = someArray.indexOf(3);
if (value === -1) {
  value = 0;
}

Comments

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

— ट्रिप्टिक

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

— स्लीवतमैन

गलत। valueपहली पंक्ति के बाद संग्रहीत मूल्य मध्यवर्ती है। इसमें सही मान नहीं होता है जो फिर अगली पंक्ति में तय हो जाता है और इस प्रकार एक मध्यवर्ती होता है। यह ifकथन के समापन के बाद ही valueसही मान होता है। ओपी में त्रिगुट एक बेहतर समाधान है कि यह क्योंकि यह कभी भी एक मध्यवर्ती स्थिति में प्रवेश नहीं करता है।

— बजे जैक आइडली

@ जेकएडली: "ओपी में टर्नरी एक बेहतर समाधान है क्योंकि यह कभी भी एक मध्यवर्ती स्थिति में प्रवेश नहीं करता है।" - मैं असहमत होने जा रहा हूँ। यह ओपी कोड की तुलना में बहुत अधिक पठनीय है, और पूरी तरह से मुहावरेदार है। यह ओपी के तर्क में एक बग को मेरे लिए थोड़ा अधिक स्पष्ट करता है (अर्थात्, क्या होता है अगर indexOf () शून्य लौटता है? आप "" नहीं मिला "शून्य से" वास्तविक "शून्य को कैसे भेद करते हैं?)।

— केविन

यह वह चीज है जो मैं करूंगा, सिवाय इसके कि valueयहां तकनीकी रूप से उत्परिवर्तित है, जिसे मैं टालने की कोशिश करता हूं।

— डेव कजिनो

Answer 2

कोड पठनीय होना चाहिए, इसलिए रसीला होने का मतलब यह नहीं होना चाहिए कि लागत कितनी भी हो - आपको इसके लिए https://codegolf.stackexchange.com/ पर रिपॉजिट करना चाहिए - इसलिए इसके बजाय मैं एक और स्थानीय चर का उपयोग करने की सलाह दूंगा जिसका नाम indexपढ़ने की समझ को अधिकतम करने के लिए है न्यूनतम रनटाइम लागत के साथ, मैं ध्यान दें):

var index = someArray.indexOf( 3 );
var value = index == -1 ? 0 : index;

लेकिन अगर आप वास्तव में इस अभिव्यक्ति को कम करना चाहते हैं, क्योंकि आप अपने सहकर्मियों या परियोजना सहयोगियों के लिए एक क्रूर दुखवादी हैं, तो यहां 4 दृष्टिकोण हैं जिनका आप उपयोग कर सकते हैं:

1: एक varकथन में अस्थायी चर

अल्पविराम से अलग होने पर आप varदूसरे अस्थायी चर को परिभाषित (और असाइन) करने के लिए कथन की क्षमता का उपयोग कर सकते हैं index:

var index = someArray.indexOf(3), value = index !== -1 ? index: 0;

2: स्व-निष्पादित अनाम फ़ंक्शन

एक अन्य विकल्प एक स्व-निष्पादित अनाम फ़ंक्शन है:

// Traditional syntax:
var value = function( x ) { return x !== -1 ? x : 0 }( someArray.indexOf(3) );

// ES6 syntax:
var value = ( x => x !== -1 ? x : 0 )( someArray.indexOf(3) );

3: कोमा संचालक

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

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Comma_Operator

आप कॉमा ऑपरेटर का उपयोग कर सकते हैं जब आप एक अभिव्यक्ति में कई अभिव्यक्तियों को एक स्थान पर शामिल करना चाहते हैं।

आप इसका उपयोग साइड-इफ़ेक्ट लागू करने के लिए कर सकते हैं, इस मामले में इसे पुन value: असाइन करके :

var value = ( value = someArray.indexOf(3), value !== -1 ? value : 0 );

यह काम करता है क्योंकि var valueपहले व्याख्या की जाती है (जैसा कि यह एक कथन है), और फिर बाएं-सबसे, आंतरिक-सबसेvalue असाइनमेंट, और फिर कॉमा ऑपरेटर के दाहिने हाथ, और फिर टर्नरी ऑपरेटर - सभी कानूनी जावास्क्रिप्ट।

4: सब-डेप्रिसिएशन में पुनः असाइन करें

कमेंटेटर @IllusiveBrian ने बताया कि अल्पविराम-संचालक का उपयोग (पिछले उदाहरण में) अनावश्यक है यदि असाइनमेंट को valueएक कोष्ठक उपपरिवर्तन के रूप में उपयोग किया जाता है:

var value = ( ( value = someArray.indexOf(3) ) !== -1 ? value : 0 );

ध्यान दें कि तार्किक अभिव्यक्तियों में नकारात्मकता का उपयोग मनुष्यों के लिए कठिन हो सकता है - इसलिए उपरोक्त सभी उदाहरणों को पढ़ने के लिए सरल बनाया जा सकता idx !== -1 ? x : yहै idx == -1 ? y : x:

var value = ( ( value = someArray.indexOf(3) ) == -1 ? 0 : value );

Comments

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

— गेविन एस। येंसि

@ g.rocket दृष्टिकोण 1 100% पठनीय और स्पष्ट है, और यदि आप पुनरावृत्ति से बचना चाहते हैं, तो जाने का एकमात्र तरीका (यदि आप एक सरल के बजाय कुछ जटिल और समस्याग्रस्त फ़ंक्शन को बुला रहे हैं तो यह हानिकारक हो सकता है indefOf)

— edc65

सहमत, # 1 बहुत पठनीय और बनाए रखने योग्य है, अन्य दो इतना नहीं है।

— माफ करना

# 3 के लिए, मेरा मानना ​​है कि आप var value = ((value = someArray.indexOf(3)) === -1 ? 0 : value);अल्पविराम का उपयोग करने के बजाय सरल कर सकते हैं ।

— इल्युसिवब्रियन

दूसरे उदाहरण में आत्म-निष्पादित अनाम फ़ंक्शन आप तीर फ़ंक्शन से कोष्ठक को छोड़ सकते हैं। var value = ( x => x !== -1 ? x : 0 ) ( arr.indexOf(3) );क्योंकि केवल एक पैरामीटर है।

— एलेक्स चार

Answer 3

संख्या के लिए

आप Math.max()फ़ंक्शन का उपयोग कर सकते हैं ।

var value = Math.max( someArray.indexOf('y'), 0 );

यह परिणाम की सीमाओं को 0तब तक बनाए रखेगा जब तक कि परिणाम पहले से अधिक न हो 0जाए। और अगर से परिणाम indexOfहै -1यह 0 के रूप में वापस आ जाएगी तुलना में अधिक है-1 ।

बूलियन और बूलियन-वाई मूल्यों के लिए

जेएस के लिए विशेष रूप से AFAIK कोई सामान्य नियम नहीं है क्योंकि कैसे झूठा है मूल्यों का मूल्यांकन किया जाता है।

लेकिन अगर कोई चीज आपकी मदद कर सकती है तो वह है ज्यादातर समय या ऑपरेटर ( ||):

// Instead of
var variable = this_one === true ? this_one : or_this_one;
// you can use
var variable = this_one || or_this_one;

तुम्हें पता है, क्योंकि अपने पहले उदाहरण में, यह के साथ बहुत सावधान रहना होगा indexOfलौट सकते हैं 0और यदि आप का मूल्यांकन 0 || -1यह वापस आ जाएगी -1क्योंकि0 एक मिथ्या मूल्य है।

Comments

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

— हूं

पहले उदाहरण में, हम यह कैसे निर्धारित करते हैं कि सूचकांक में नहीं है 3या "y"नहीं ? 0someArray

— Guest271314

पर Math.maxउदाहरण? indexOfतत्व का सूचकांक लौटाता है और यदि तत्व -1 नहीं पाया जाता है, तो आपके पास स्ट्रिंग की लंबाई तक -1 से संख्या प्राप्त करने के लिए एक मौका है, तो आप मौके को दूर करने के लिए 0 से लंबाई तक की Math.maxसीमा निर्धारित करते हैं एक वापसी करने के लिए,

— क्रिस्फोरो गैस्पर

@mitogh ओपी में कोड पर तर्क एक मुद्दा बनाता है, हालांकि यह जेनेरिक उदाहरण है; जहां 0 दोनों 0सरणी के भीतर मिलान तत्व के सूचकांक को इंगित कर सकते हैं , या 0सेट कर सकते हैं Math.max(); या ओपी में सशर्त ऑपरेटर पर। विचार करें var value = Math.max( ["y"].indexOf("y"), 0 )। आप यह कैसे निर्धारित करते हैं कि 0लौटाया जा रहा है? सरणी के भीतर कॉल 0करने के लिए Math.max()या 0अनुक्रमणिका को दर्शाने के लिए पारित किया गया "y"?

— 271314

@ Guest271314 अच्छा विचार है, लेकिन मुझे लगता है कि यह संदर्भ पर निर्भर करता है कि यह एक मुद्दा है या नहीं। शायद यह कोई फर्क नहीं पड़ता कि 0 कहां से आया है, और केवल महत्वपूर्ण बात यह है कि यह -1 नहीं है। एक उदाहरण: हो सकता है कि आपको किसी सरणी से कोई आइटम लेने की आवश्यकता हो। आप एक विशेष आइटम चाहते हैं (ओपी में, नंबर 3), लेकिन अगर यह सरणी में नहीं है, तो आपको अभी भी एक आइटम की आवश्यकता है, और आप जो भी पहला आइटम है, उसके बारे में डिफ़ॉल्ट होने के साथ ठीक है, यह मानते हुए कि आप सरणी को नहीं जानते हैं ' टी खाली है।

— केव

Answer 4

वास्तव में नहीं, बस एक और चर का उपयोग करें।

आपका उदाहरण कुछ इस तरह से सामान्यीकरण करता है।

var x = predicate(f()) ? f() : default;

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

var computed = f();
var x = predicate(computed) ? computed : default;

मुझे लगता है कि आपका क्या मतलब है - ऐसा लगता है कि ऐसा करने के लिए कुछ तरीका होना चाहिए जो थोड़ा साफ दिखता है। लेकिन मुझे लगता है कि ऐसा करने के लिए यह सबसे अच्छा तरीका है (मुहावरेदार)। यदि आप किसी कारण से इस पैटर्न को अपने कोड में बहुत दोहरा रहे हैं, तो आप थोड़ा सहायक कार्य लिख सकते हैं:

var setif = (value, predicate, default) => predicate(value) ? value : default;
var x = setif(someArray.indexOf(3), x => x !== -1, 0)

Answer 5

संपादित करें: यहाँ यह है, Nullary-coalescing के लिए प्रस्ताव अब जावास्क्रिप्ट में!

---

उपयोग ||

const result = a ? a : 'fallback value';

के बराबर है

const result = a || 'fallback value';

यदि रिटर्न दाखिल aकरना Booleanहै false, resultतो सौंपा जाएगा 'fallback value', अन्यथा का मूल्य a।

---

किनारे के मामले से अवगत रहें a === 0, जो (गलत तरीके से) ले जाएगा falseऔर resultले जाएगा 'fallback value'। अपने जोखिम पर इस तरह की तरकीबों का प्रयोग करें।

---

पुनश्च। स्विफ्ट जैसी भाषाओं में nil-coalescing operator ( ??) है, जो इसी तरह के उद्देश्य को पूरा करता है। उदाहरण के लिए, स्विफ्ट में आप लिखेंगे result = a ?? "fallback value"कि जावास्क्रिप्ट के बहुत करीब हैconst result = a || 'fallback value';

Comments

PHP (> 7.0) और C # भी अशक्त सहवर्ती ऑपरेटर का समर्थन करता है। सिंथेटिक चीनी लेकिन निश्चित रूप से प्यारी।

— हिसवार्ड

यह केवल तभी काम करता है जब फ़ंक्शन विफल होने पर मान लौटाता है, लेकिन indexOf()इस पैटर्न में इसका उपयोग नहीं किया जा सकता है।

— बरमार

सही है, लेकिन वह विशिष्ट उदाहरण के लिए नहीं पूछ रहा है> "फिर, ऊपर सटीक प्रश्न का उत्तर नहीं मांग रहा है, बस एक उदाहरण जब आप टर्नरी में चीजों को दोहरा सकते हैं", तो, मन में वह जगह है जिसके लिए आप एक सामान्य तरीका पूछ रहे हैं रिपीटिंग टर्नरी की जगह (परिणाम = ए? ए: बी)। और टर्नरी दोहराना बराबर है || (परिणाम = a || b)

— कम्सोमिर

क्या यह वास्तव|| में जावास्क्रिप्ट में कैसे काम करता है? अगर मैं आपको सही तरीके से समझ रहा हूं, तो यह कई अन्य प्राथमिक भाषाओं की तुलना में अलग काम करता है (मैं मुख्य रूप से सी और उसके वंशज [सी ++, जावा, आदि] सोच रहा हूं) यहां तक ​​कि अगर वास्तव ||में जावास्क्रिप्ट में काम करता है, तो मैं इसका उपयोग करने के खिलाफ सलाह दूंगा इस तरह की तरकीबें जिससे भाषा के बारे में विशेष जानकारियों को जानने के लिए रखवाले की आवश्यकता होती है। जबकि यह चाल शांत है, मैं इसे बुरा व्यवहार मानूंगा।

— लोदुविज्क

यह भी ध्यान दें कि प्रश्न मूल्य की तुलना कर रहा है -1। फिर, मैं जावास्क्रिप्ट और इसके क्वार्क्स के लिए नहीं बोल सकता, लेकिन आम तौर पर -1एक सही मूल्य होगा, न कि एक झूठा और इसलिए आपका जवाब सवाल के मामले में काम नहीं करेगा और निश्चित रूप से सामान्य मामला नहीं होगा, बल्कि केवल एक विशिष्ट में काम करेगा ( लेकिन सामान्य) उप-मामला।

— लोदुविज्क

Answer 6

अर्क चर का प्रयोग करें :

var index = someArray.indexOf(3);
var value = index !== -1 ? index : 0

इसके constबजाय यह और भी बेहतर है var। आप अतिरिक्त निकासी भी कर सकते हैं:

const index = someArray.indexOf(3);
const condition = index !== -1;
const value = condition ? index : 0;

अभ्यास में, की तुलना में अधिक सार्थक नाम का उपयोग index, conditionऔर value।

const threesIndex = someArray.indexOf(3);
const threeFound = threesIndex !== -1;
const threesIndexOrZero = threeFound ? threesIndex : 0;

Comments

"अर्क चर" क्या है? क्या यह एक स्थापित शब्द है?

— पीटर मोर्टेनसेन

Answer 7

आप शायद एक मोटे ऑपरेटर की तलाश कर रहे हैं। सौभाग्य से, हम Arrayएक बनाने के लिए प्रोटोटाइप का लाभ उठा सकते हैं :

Array.prototype.coalesce = function() {
    for (var i = 0; i < this.length; i++) {
        if (this[i] != false && this[i] != null) return this[i];
    }
}

[null, false, 0, 5, 'test'].coalesce(); // returns 5

फ़ंक्शन में एक पैरामीटर जोड़कर इसे आपके मामले में और सामान्यीकृत किया जा सकता है:

Array.prototype.coalesce = function(valid) {
    if (typeof valid !== 'function') {
        valid = function(a) {
            return a != false && a != null;
        }
    }

    for (var i = 0; i < this.length; i++) {
        if (valid(this[i])) return this[i];
    }
}

[null, false, 0, 5, 'test'].coalesce(); // still returns 5
[null, false, 0, 5, 'test'].coalesce(function(a){return a !== -1}); // returns null
[null, false, 0, 5, 'test'].coalesce(function(a){return a != null}); //returns false

Comments

सरणियों के प्रोटोटाइप में जोड़ना जोखिम भरा है, क्योंकि नया तत्व हर सरणी के अंदर एक सूचकांक बन जाता है। यह साधन सूचकांक के माध्यम से पुनरावृत्ति भी नया तरीका भी शामिल है कि: for (let x in ['b','c']) console.log(x);प्रिंट 0, 1, "coalesce"।

— चार्ली हार्डिंग

@CharlieHiring True, लेकिन यह आम तौर पर सरणियों के माध्यम से लूप करते समय फॉर-इन ऑपरेटर का उपयोग करने की अनुशंसा नहीं की जाती है। देखें stackoverflow.com/a/4374244/1486100

— Tyzoid

Answer 8

मैं व्यक्तिगत रूप से दो वेरिएंट पसंद करता हूं:

1. शुद्ध अगर, @slebetman जैसा सुझाव दिया

2. अलग फ़ंक्शन, जो डिफ़ॉल्ट मान के साथ अमान्य मान को प्रतिस्थापित करता है, जैसे इस उदाहरण में:

function maskNegative(v, def) {
  return v >= 0 ? v : def;
}

Array.prototype.indexOfOrDefault = function(v, def) {
  return maskNegative(this.indexOf(v), def);
}

var someArray = [1, 2];
console.log(someArray.indexOfOrDefault(2, 0)); // index is 1
console.log(someArray.indexOfOrDefault(3, 0)); // default 0 returned
console.log(someArray.indexOfOrDefault(3, 123)); // default 123 returned

Comments

+1, विकल्प 2 प्रश्न के इनलाइन इरादे का सम्मान करता है, जावास्क्रिप्ट की तुलना में अन्य भाषाओं में कुशलता से लागू कर सकता है, और प्रतिरूपकता को बढ़ावा देता है।

— देवसमैन

Answer 9

मुझे @ slebetman का उत्तर पसंद है। इसके तहत टिप्पणी "मध्यवर्ती राज्य" में होने वाले चर के बारे में चिंता व्यक्त करती है। अगर यह आपके लिए एक बड़ी चिंता का विषय है, तो मेरा सुझाव है कि इसे एक समारोह में संलग्न करना चाहिए:

function get_value(arr) {
   var value = arr.indexOf(3);
   if (value === -1) {
     value = 0;
   }
   return value;
}

फिर बस फोन करो

var value = get_value( someArray );

यदि आप उनके लिए अन्य स्थानों पर उपयोग करते हैं, तो आप अधिक सामान्य कार्य कर सकते हैं, लेकिन यदि यह बहुत विशिष्ट मामला है, तो ओवर-इंजीनियर न करें।

लेकिन ईमानदार होने के लिए मैं सिर्फ @slebetman के रूप में करूंगा जब तक कि मुझे कई जगहों से पुन: उपयोग करने की आवश्यकता न हो।

Answer 10

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

var value = someArray.indexOf(3) !== -1 ? someArray.indexOf(3) : 0;

हो सकता है (और होना चाहिए, फंक्शन कॉल दिया गया है) इस तरह से छोटा:

var value = someArray.indexOf(3);
value = value !== -1 ? value : 0;

यदि आप एक अधिक सामान्य समाधान की तलाश कर रहे हैं जो एक चर में दोहराव को रोकता है, जैसे:

var value = conditionalTest(foo) ? foo : bar;

जहाँ fooकेवल एक बार दिखाई देता है। फार्म के समाधानों का निर्वहन:

var cad = foo;
var value = conditionalTest(foo) ? cad : bar;

तकनीकी रूप से सही है, लेकिन बिंदु गायब है, तो आप भाग्य से बाहर हैं। ऐसे ऑपरेटर, फ़ंक्शंस और विधियाँ हैं जो आपके द्वारा चाहने वाले terse सिंटैक्स के पास हैं, लेकिन परिभाषा के अनुसार ऐसे कंस्ट्रक्शन नहीं हैं टर्निग ऑपरेटर ।

उदाहरण:

जावास्क्रिप्ट, ||LHS होने पर RHS वापस करने के लिए उपयोग करना falsey:

var value = foo || bar; // equivalent to !foo ? bar : foo

Comments

प्रश्न को जावास्क्रिप्ट टैग किया गया है और इसमें C # का उल्लेख नहीं किया गया है। सिर्फ यह सोचकर कि आप C # विशिष्ट उदाहरणों के साथ क्यों समाप्त होते हैं।

— लादुविज्क १३'१k को

मैंने प्रश्न पर जावास्क्रिप्ट टैग को याद किया; सी # हटा दिया।

— asgallant

Answer 11

एक सहायक कार्य का उपयोग करें:

function translateValue(value, match, translated) {
   return value === match ? translated : value;
}

अब आपका कोड बहुत पठनीय है, और कोई पुनरावृत्ति नहीं है।

var value = translateValue(someArray.indexOf(3), -1, 0);

कोडिंग चिंताओं की पदानुक्रम है:

1. सही (सही प्रदर्शन या SLA चिंताओं सहित)
2. स्पष्ट
3. संक्षिप्त
4. तेज

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

PS यदि आपको ES6 सिंटैक्स पसंद है:

const translateValue = (value, match, translated) => value === match ? translated : value;
let value = translateValue(someArray.indexOf(3), -1, 0); // or const

Comments

"मेरे संस्करण में सबसे अधिक स्पष्टता है" - मैं असहमत हूं। फ़ंक्शन का नाम अभी तक बहुत लंबा है और मापदंडों का नामकरण इनपुट और आउटपुट बिल्कुल भी सहायक नहीं है।

— एडेलफस

तो क्या आप बेहतर नाम सुझा सकते हैं? मुझे उनका मनोरंजन करने में खुशी होगी। आपकी शिकायत पूरी तरह से सौंदर्य प्रसाधनों के बारे में है, तो आइए सौंदर्य प्रसाधन को ठीक करें। सही? अन्यथा आप सिर्फ बाइक शेडिंग कर रहे हैं।

— एरिक

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

— Loduwijk

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

— एरिक

यह सिर्फ यह दिखाने के लिए जाता है कि यदि आप 5 अलग-अलग इंजीनियरों से एक ही सवाल पूछेंगे तो आपको 10 अलग-अलग उत्तर मिलेंगे।

— लादुविज्क

Answer 12

मुझे लगता है कि ||ऑपरेटर को इसके अनुरूप बनाया जा सकता है indexOf:

var value = ((someArray.indexOf(3) + 1) || 1) - 1;

लौटाए गए मान को 1 से स्थानांतरित कर दिया जाता है, जिससे 0 से -1 बनता है, जो कि गलत है और इसलिए दूसरी 1 से बदल दिया जाता है। फिर इसे वापस स्थानांतरित कर दिया जाता है।

हालांकि, कृपया ध्यान रखें कि पुनरावृत्ति से बचने के लिए पठनीयता बेहतर है।

Answer 13

यह बिटवाइज़ नॉट का एक सरल समाधान है और एक डिफ़ॉल्ट मान है -1जिसका परिणाम बाद में शून्य हो जाता है।

index = ~(~array.indexOf(3) || -1);

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

आइए सत्य की तालिका पर एक नजर डालते हैं:

 indexOf    ~indexOf   boolean    default     value      result         comment
---------  ---------  ---------  ---------  ---------  ---------  ------------------
      -1          0     falsy          -1         -1          0   take default value
       0         -1    truthy                     -1          0
       1         -2    truthy                     -2          1
       2         -3    truthy                     -3          2

Answer 14

आप पुन: असाइनमेंट का उपयोग कर सकते हैं:

• एक मान के लिए चर को इनिशियलाइज़ करें
• &&पुनर्मूल्यांकन के लिए ऑपरेटर के क्रमांकन का उपयोग करें , क्योंकि यदि पहली शर्त झूठी है, तो दूसरी अभिव्यक्ति का मूल्यांकन नहीं किया जाएगा

पूर्व।

var value = someArray.indexOf(3);
value == -1 && (value=0);

var someArray = [4,3,2,1];

var value = someArray.indexOf(1);
value == -1 && (value=0);
console.log('Found:',value);

var value = someArray.indexOf(5);
value == -1 && (value=0);
console.log('Not Found:',value);

Comments

@MinusFour एक हद तक। चर दोहराया जाता है, न कि अभिव्यक्ति someArray.indexOfकेवल एक बार की जाती है

— vol7ron

आप दोहराते हैं value।

— माइनसफॉर

@MinusFour सही है, लेकिन बड़े भावों के लिए यह अधिक उपयोगी है, एक चर को दोहराना ops को बचाने की तुलना में नगण्य है। मेरा अनुमान है कि ओपी साथ काम नहीं कर रहा है -1और 0; अन्यथा max()सबसे अच्छा विकल्प होगा

— vol7ron

ठीक है ... लेकिन सवाल यह है कि " अपने आप को दोहराए बिना ternaries कैसे लिखें "

— MinusFour

यह भी कहता है Again, not seeking an answer to the exact question above, जो सवाल को व्याख्या करने के लिए छोड़ देता है;)

— vol7ron

Answer 15

प्रश्न में उदाहरण कोड को देखते हुए यह स्पष्ट नहीं है कि यह कैसे निर्धारित किया जाएगा कि 3क्या सूचकांक 0में निर्धारित नहीं है या नहीं है someArray। -1से लौटा.indexOf()इस उदाहरण जाना एक मूल्यवान गैर-मैच को बाहर करने के उद्देश्य होगा, जो एक मैच हो सकता है।

यदि 3सरणी में शामिल नहीं है, -1तो वापस कर दिया जाएगा। हम जोड़ सकते हैं 1के परिणाम के .indexOf()रूप में मूल्यांकन करने के लिए falseपरिणाम के लिए किया जा रहा है -1, जहां के बाद || ORऑपरेटर और 0। जब valueसंदर्भित किया जाता है, तो 1सरणी के तत्व का सूचकांक प्राप्त करने के लिए घटाना या-1 ।

जो एक शर्त पर बस उपयोग .indexOf()और जाँच के लिए वापस जाता है । या, को परिभाषित करने के रूप में मूल संदर्भ से संबंधित का मूल्यांकन हालत के वास्तविक परिणाम के रूप में संभव भ्रम से बचने के।-1ifvalueundefined

var someArray = [1,2,3];
var value = someArray.indexOf(3) + 1 || 1;
console.log(value -= 1);

var someArray = [1,2,3];
var value = someArray.indexOf(4) + 1 || 1;
// how do we know that `4` is not at index `0`?
console.log(value -= 1);

var someArray = [1,2,3];
var value = someArray.indexOf(4) + 1 || void 0;
// we know for certain that `4` is not found in `someArray`
console.log(value, value = value || 0);

Answer 16

एक टर्नरी एक और की तरह है, अगर आपको दूसरे हिस्से की ज़रूरत नहीं है, तो इसके बजाय सिर्फ एक ही क्यों ..

if ((value = someArray.indexOf(3)) < 0) value = 0;

Answer 17

इस विशेष मामले के लिए, आप लॉजिकल ||ऑपरेटर के साथ शॉर्ट-सर्किटिंग का उपयोग कर सकते हैं । जैसा कि 0मिथ्या माना जाता है, आप 1अपने सूचकांक में जोड़ सकते हैं , इस प्रकार, यदि तब index+1है 0तो आपको तार्किक-या आपके परिणाम के रूप में दाईं ओर मिल जाएगा, अन्यथा, आप अपना प्राप्त करेंगे index+1। जैसा कि आपका वांछित परिणाम ऑफसेट है 1, तो 1आप अपने सूचकांक को प्राप्त करने के लिए इसे घटा सकते हैं :

const someArray = [1, 2, 3, 4];
const v = ((someArray.indexOf(3)+1) || 1)-1;
console.log(v);