javascript - নিজেকে পুনরাবৃত্তি না করে কীভাবে কোনও টার্নারি অপারেটর(ওরফে যদি) এক্সপ্রেশন লিখতে হয়




conditional-operator (11)

সম্পাদনা: এটি এখন, জাভাস্ক্রিপ্টে Nullary-coalescing প্রস্তাব!

ব্যবহার করুন ||

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

সমতুল্য

const result = a || 'fallback value';

যদি Boolean কাস্টিং করা false , 'fallback value' বরাদ্দ করা হবে, অন্যথায় 'fallback value'

প্রান্তের ক্ষেত্রে সচেতন হন a === 0 , যা false ফেলেছে এবং result (ভুলভাবে) 'fallback value' নেবে। নিজের ঝুঁকিতে এ জাতীয় কৌশলগুলি ব্যবহার করুন।

গীত। সুইফ্টের মতো ভাষাতে nil-coalescing অপারেটর ( ?? ) থাকে, যা একই উদ্দেশ্যে কাজ করে। উদাহরণস্বরূপ, সুইফটে আপনি ফলাফল লিখবেন result = a ?? "fallback value" result = a ?? "fallback value" যা জাভাস্ক্রিপ্টের গঠন const result = a || 'fallback value'; const result = a || 'fallback value';

উদাহরণস্বরূপ, এর মতো কিছু:

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

এটি লেখার আরও ভাল উপায় আছে কি? আবার, আমি উপরের সঠিক প্রশ্নের উত্তর চাইছি না, কেবল যখন আপনি বার্ষিক অপারেটরগুলি বার্ষিক অপারেটর এক্সপ্রেশন হতে পারে তার একটি উদাহরণ ...


আপনার প্রশ্নটি দেখার জন্য আমি দুটি উপায় দেখতে পাচ্ছি: আপনি হয় লাইনের দৈর্ঘ্য হ্রাস করতে চান, বা আপনি বিশেষত কোনও ত্রৈমাসিকের কোনও ভেরিয়েবল পুনরাবৃত্তি করা এড়াতে চান। প্রথমটি তুচ্ছ (এবং অন্যান্য অনেক ব্যবহারকারী উদাহরণ পোস্ট করেছেন):

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;

প্রযুক্তিগতভাবে সঠিক হিসাবে তবে পয়েন্টটি অনুপস্থিত, তবে আপনার ভাগ্য নেই। এমন অপারেটর, ফাংশন এবং পদ্ধতি রয়েছে যা আপনি অনুসন্ধান করে এমন সংশ্লেষের বাক্স ধারণ করে তবে সংজ্ঞা অনুসারে এ জাতীয় নির্মাণগুলি ত্রৈমাসিক অপারেটর নয়

উদাহরণ:

জাভাস্ক্রিপ্ট, ব্যবহার || এলএইচএস falsey হলে আরএইচএস falsey :

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

আপনি সম্ভবত একটি coalescing অপারেটর খুঁজছেন। ভাগ্যক্রমে, একটি তৈরি করতে আমরা 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

আমার মনে হয় || অপারেটরটি indexOf :

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

প্রত্যাবর্তিত মান 1 দ্বারা স্থানান্তরিত হয়, 0 -1 থেকে 0 তৈরি করে যা মিথ্যা এবং তাই দ্বিতীয়টি 1 দ্বারা প্রতিস্থাপিত হয় Then তারপরে এটি আবার স্থানান্তরিত হয়।

তবে, দয়া করে মনে রাখবেন যে পুনরাবৃত্তি এড়ানোর চেয়ে পাঠযোগ্যতা সর্বোত্তম।


আমি ব্যক্তিগতভাবে দুটি রূপ পছন্দ করি:

  1. বিশুদ্ধ যদি @ স্লেবেটম্যান পরামর্শ দেয়

  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


আসলেই নয়, কেবল অন্য ভেরিয়েবল ব্যবহার করুন।

আপনার উদাহরণটি এরকম কিছুকে সাধারণীকরণ করে।

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

আপনি একটি গণিত মান পরীক্ষা করছেন, তারপরে কোনও ভেরিয়েবলকে যদি সেই মানটি নির্দিষ্ট করে দেয় তবে এটি কোনও ভেরিয়েবলকে পাস করে। গণনা করা মানটি পুনরায় গণনা এড়ানোর উপায় সুস্পষ্ট: ফলাফল সংরক্ষণের জন্য একটি ভেরিয়েবল ব্যবহার করুন।

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

আপনি যা বলতে চাইছেন তা আমি পেয়েছি - দেখে মনে হচ্ছে এটির কিছু উপায় হওয়া উচিত যা দেখতে একটু পরিষ্কার দেখাচ্ছে। তবে আমি মনে করি এটি করার পক্ষে এটি সর্বোত্তম উপায় matically আপনি যদি কোনও কারণে আপনার কোডটিতে এই প্যাটার্নটি প্রচুর পুনরাবৃত্তি করে থাকেন তবে আপনি সম্ভবত কিছু সহায়ক ফাংশন লিখতে পারেন:

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

একটি ত্রৈমাসিকিট হ'ল যদি-অন্যরকম, আপনার যদি অন্য অংশের প্রয়োজন না হয় তবে পরিবর্তে যদি কেবল একটি একক কেন হয় না ..

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

একটি সহায়ক ফাংশন ব্যবহার করুন:

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

এখন আপনার কোডটি খুব পঠনযোগ্য এবং কোনও পুনরাবৃত্তি নেই।

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

কোডিং উদ্বেগের শ্রেণিবিন্যাস হ'ল:

  1. সঠিক (সত্য পারফরম্যান্স বা এসএলএ উদ্বেগ সহ)
  2. পরিষ্কার
  3. সংক্ষিপ্ত
  4. দ্রুত

এখন পর্যন্ত পৃষ্ঠায় থাকা সমস্ত উত্তর সঠিক বলে মনে হয়েছে, তবে আমি মনে করি আমার সংস্করণটিতে সর্বাধিক স্পষ্টতা রয়েছে, যা সংক্ষিপ্ততার চেয়ে গুরুত্বপূর্ণ। আপনি যদি সহায়তা সহায়কটিকে গণনা না করেন - যেমন এটি পুনরায় ব্যবহার করা যায় — এটিও সবচেয়ে সংক্ষিপ্ত। সহায়ক ফাংশনটি ব্যবহার করার জন্য কিছুটা অনুরূপ পরামর্শ দুর্ভাগ্যক্রমে একটি ল্যাম্বডা ব্যবহার করে যা আমার কাছে, এটি কী করছে তা কেবল অস্পষ্ট করে। একটি উদ্দেশ্য সহ একটি সরল ফাংশন যা ল্যাম্বডা নেয় না, কেবল মানগুলি, আমার কাছে আরও ভাল better

পিএস আপনি যদি ES6 সিনট্যাক্স পছন্দ করেন:

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

কোডটি পঠনযোগ্য হওয়া উচিত, সুতরাং সংক্ষিপ্ত হওয়ার অর্থটি যে পরিমাণই ব্যয় করা উচিত নয় - এর জন্য আপনার https://codegolf.stackexchange.com/ পুনরায় পোস্ট করা উচিত - সুতরাং পরিবর্তে আমি পঠন বোধগম্যতা সর্বাধিকতর করতে দ্বিতীয় স্থানীয় পরিবর্তনশীল index ব্যবহার করার পরামর্শ দেব (ন্যূনতম রানটাইম ব্যয় সহ, আমি দ্রষ্টব্য):

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

তবে আপনি যদি সত্যিই এই ভাবটি কমিয়ে দিতে চান, কারণ আপনি যদি আপনার সহকর্মী বা প্রকল্পের সহযোগীদের প্রতি নিষ্ঠুর অনুরাগী হন, তবে আপনি ব্যবহার করতে পারেন এমন 4 টি পদ্ধতি এখানে:

1: একটি var স্টেটমেন্টে অস্থায়ী পরিবর্তনশীল

কমা দিয়ে আলাদা হয়ে যাওয়ার পরে আপনি দ্বিতীয় অস্থায়ী ভেরিয়েবল index সংজ্ঞায়িত (এবং নির্ধারিত) করার জন্য var স্টেটমেন্টের ক্ষমতাটি ব্যবহার করতে পারেন:

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: একটি subexpression পুনরায় নিয়োগ

ভাষ্যকার @ ইলিউসিভ ব্রায়ান উল্লেখ করেছেন যে কমা-অপারেটরের ব্যবহার (পূর্ববর্তী উদাহরণে) অপ্রয়োজনীয় যদি value ক্ষেত্রে অ্যাসাইনমেন্টটি একটি প্রথম বন্ধনীযুক্ত subexpression হিসাবে ব্যবহৃত হয়:

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

মনে রাখবেন যে লজিক্যাল এক্সপ্রেশনগুলিতে নেতিবাচক ব্যবহারগুলি মানুষের পক্ষে অনুসরণ করা আরও শক্ত হতে পারে - সুতরাং উপরের সমস্ত উদাহরণ idx !== -1 ? x : y পরিবর্তন করে পড়ার জন্য সহজ করা যেতে পারে idx !== -1 ? x : y idx !== -1 ? x : y থেকে idx == -1 ? y : x idx == -1 ? y : x :

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

প্রশ্নে উদাহরণ কোড দেওয়া হলেও এটি কীভাবে নির্ধারণ করা হবে যে someArray সূচি 0 তে 3 হয় বা সেট করা হয় না তা পরিষ্কার নয়। -1 .indexOf() থেকে ফিরে আসা এই উদাহরণে মূল্যবান হতে পারে, .indexOf() ম্যাচটি বাদ দেওয়ার উদ্দেশ্যে যা কোনও ম্যাচ হতে পারে।

3 অ্যারেতে অন্তর্ভুক্ত না করা হলে, -1 হবে। ফলাফল -1 হওয়ার জন্য false হিসাবে মূল্যায়ন করতে আমরা .indexOf() এর .indexOf() 1 যুক্ত করতে পারি, যেখানে অনুসরণ করা হয় || OR অপারেটর এবং 0 । যখন value উল্লেখ করা হয়, অ্যারে বা -1 এর উপাদান সূচি পেতে 1 বিয়োগ করুন-

যা কেবলমাত্র .indexOf() ব্যবহার করে এবং if শর্তে -1 করে .indexOf() বা, মূল রেফারেন্স সম্পর্কিত মূল্যায়ন শর্তের প্রকৃত ফলাফল হিসাবে সম্ভাব্য বিভ্রান্তি এড়াতে value সংজ্ঞায়িত হিসাবে সংজ্ঞায়িত করা হচ্ছে।

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);


সংখ্যার জন্য

আপনি Math.max() ফাংশনটি ব্যবহার করতে পারেন।

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

যদি ফলাফল হয় তবে এটি 0 থেকে প্রথম ফলাফল 0 চেয়ে বড় পর্যন্ত সীমানা বজায় রাখবে। এবং যদি indexOf থেকে ফলাফল -1 এটি 0 -1 চেয়ে বড় হিসাবে ফিরে আসবে।

বুলিয়ান এবং বুলিয়ান- y মানের জন্য

falsy পক্ষে falsy কোনও সাধারণ নিয়ম নেই বিশেষভাবে কারণ falsy মানগুলি কীভাবে মূল্যায়ন করা হয়।

তবে যদি কোনও কিছু আপনাকে বেশিরভাগ সময় সাহায্য করতে পারে তবে তা হ'ল অপারেটর ( || ):

// 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 মূল্যায়ন করেন 0 || -1 এটি ফিরে আসবে -1 কারণ 0 একটি falsy মান।





conditional-operator