जावास्क्रिप्ट में स्टेटमेंट के कई मामलों को स्विच करें

Question

मुझे जावास्क्रिप्ट में स्विच स्टेटमेंट में कई मामले चाहिए, जैसे कुछ:

switch (varName)
{
   case "afshin", "saeed", "larry": 
       alert('Hey');
       break;

   default: 
       alert('Default case');
       break;
}

मैं उसे कैसे कर सकता हूँ? यदि जावास्क्रिप्ट में ऐसा कुछ करने का कोई तरीका नहीं है, तो मैं एक वैकल्पिक समाधान जानना चाहता हूं जो DRY अवधारणा का अनुसरण करता है ।

Comments

इस प्रश्न को बंद करने के लिए मतदान करने वाले को। यह 5 साल से अधिक पुराना है और इसका एक संक्षिप्त जवाब है - करीबी वोट क्यों?

— सर्फ करें

@surfmuggle क्योंकि अधिक उत्तर जोड़ना आवश्यक नहीं है।

— अफशीन मेहरबानी

@AfshinMehrabani शायद इसे संरक्षित किया जा सकता है, बंद नहीं?

— evolutionxbox

Answer 1

switchस्टेटमेंट के फ़ॉल-थ्रू फ़ीचर का उपयोग करें । एक मिलान मामला तब तक चलेगा जब तक कि break(या switchकथन का अंत ) नहीं मिल जाता है, इसलिए आप इसे इस तरह लिख सकते हैं:

switch (varName)
{
   case "afshin":
   case "saeed":
   case "larry": 
       alert('Hey');
       break;

   default: 
       alert('Default case');
}

Comments

देखें: developer.mozilla.org/en-US/docs/JavaScript/Reference/…

— Xitalogy

किसी तरह यह क्रोम में मेरे लिए काम करता है, जावास्क्रिप्ट कंसोल में: switch('10') { case 1, '10': console.log('ok') }प्रिंटok

— nafg

@nafg: कोशिश करो switch(1)। यहाँ लेबल सिर्फ एक अल्पविराम अभिव्यक्ति है।

— kennytm

@ बार्नी नहीं, ब्रेक के बिना आप अगले मामले में गिर सकते हैं।

— सियारिया

@ परिभाषा के अनुसार, अंतिम के बाद कोई अगला मामला नहीं है। इसके अलावा, यह एक डिफ़ॉल्ट है।

— बार्नी

Answer 2

यह रेगुलर जावास्क्रिप्ट में काम करता है

function theTest(val) {
  var answer = "";
  switch( val ) {
    case 1: case 2: case 3:
      answer = "Low";
      break;
    case 4: case 5: case 6:
      answer = "Mid";
      break;
    case 7: case 8: case 9:
      answer = "High";
      break;
    default:
      answer = "Massive or Tiny?";
  } 
  return answer;  
}

theTest(9);

चीयर्स।

Comments

@believesInSanta यह अजीब स्वरूपण (नई-पंक्तियों के बजाय रिक्त स्थान) के साथ सचमुच सामान्य मामले fallthrough

— Mihail Malostanidis

Answer 3

यहाँ switchकथन को पूरी तरह से टालने का अलग तरीका है :

var cases = {
  afshin: function() { alert('hey'); },
  _default: function() { alert('default'); }
};
cases.larry = cases.saeed = cases.afshin;

cases[ varName ] ? cases[ varName ]() : cases._default();

Comments

मैं निश्चित रूप से इस संस्करण को पसंद करता हूं। इसके माध्यम से गिरना बग-प्रवण विशेषता है switch ... case। किसी breakकथन को भूलना बहुत आसान है , और यदि आप जानबूझकर गिरावट का उपयोग करते हैं, तो उन भूल गए breakबयानों को स्पॉट करना बहुत मुश्किल हो सकता है। इस विधि लुकअप संस्करण में बहुत सारी शानदार विशेषताएं हैं switch ... case, जिनमें कमी है, जैसे कि डायनेमिक एक्स्टेंसिबिलिटी, या मोड स्विचिंग को पूरा करने के लिए ऑब्जेक्ट को पूरी तरह से बदलने की क्षमता। सफाई से व्यवस्थित रखना भी आसान है, और अधिक रखरखाव योग्य कोड हो सकता है। Ericleads.com/2012/12/switch-case-considered-harmful

— एरिक इलियट

जब भी मैं जानबूझकर छोड़ता हूं //fallthrough, breakतो मैं हमेशा टिप्पणी करता हूं break। यह पहचानने में मदद करता है कि कब गलती हुई और कब यह जानबूझकर हुआ।

— मेनेबोरो

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

— contactmatt

कोई भी हमेशा अपने दाहिने हाथ को गर्दन के पीछे से गुजरते हुए बाएं कान को खरोंच सकता है ... (मेरे अंग्रेजी के लिए खेद है, मेरा मतलब है: "कोई भी हमेशा चीजों को जितना संभव हो उतना जटिल कर सकता है ... इस मामले में, स्विच स्टेटमेंट से बचना चाहिए इस जटिल समाधान के पक्ष में करने के लिए सही बात नहीं लगती है ...)

— क्लिंट ईस्टवुड

मैं वास्तव में चकित हूं कि इसने 34 वोट कैसे प्राप्त किए हैं। पठनीयता और स्थिरता के संदर्भ में, यह बिल्कुल भीषण है। अगर मैं देखना चाहता हूं कि क्या परिस्थितियां कुछ ट्रिगर करेंगी, तो एक केस स्टेटमेंट अविश्वसनीय रूप से सरल है और लेबल को देखकर देखना आसान है। दूसरी ओर, आपके संस्करण के लिए किसी को हर एक पंक्ति को बहुत अधिक पढ़ने और यह देखने की आवश्यकता होगी कि आपने क्या सौंपा है। यह और भी बदतर हो जाता है जितना अधिक मामले आप मैच करना चाहते हैं।

— माइकल

Answer 4

जावास्क्रिप्ट में एक स्विच में कई मामलों को असाइन करने के लिए, हमें different case without break inbetweenनीचे दिए गए की तरह परिभाषित करना होगा :

   <script>
      function checkHere(varName){
        switch (varName)
           {
           case "saeed":
           case "larry":
           case "afshin":
                alert('Hey');
                break;
          case "ss":
               alert('ss');
               break;
         default:
               alert('Default case');
               break;
       }
      }
     </script>

कृपया उदाहरण देखें लिंक पर क्लिक करें

Comments

यह भाषाओं की एक बहुतायत में एक सामान्य तकनीक है, जेएस के लिए बाध्य नहीं है

— drAlberT

Answer 5

यदि आप ES6 का उपयोग कर रहे हैं, तो आप यह कर सकते हैं:

if (['afshin', 'saeed', 'larry'].includes(varName)) {
   alert('Hey');
} else {
   alert('Default case');
}

या जावास्क्रिप्ट के पुराने संस्करणों के लिए, आप यह कर सकते हैं:

if (['afshin', 'saeed', 'larry'].indexOf(varName) !== -1) {
   alert('Hey');
} else {
   alert('Default case');
}

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

Comments

एक स्विच पर इसका क्या लाभ है?

— ब्रायस स्नाइडर

@BryceSnyder एक अभिव्यक्ति और एक बयान के बीच का अंतर? टाइपिंग कम? कम ऊर्ध्वाधर लाइनों का सेवन किया? प्रतिनिधित्व की संक्षिप्तता और घनत्व के माध्यम से ग्रेटर अभिव्यंजक शक्ति? includesशब्द के माध्यम से बेहतर शब्दार्थ ? अपना चयन ले लो।

— यूरिक

Answer 6

नोड में यह प्रतीत होता है कि आपको ऐसा करने की अनुमति है:

data = "10";
switch(data){
case "1": case "2": case "3": //put multiple cases on the same line to save vertical space.
   console.log("small"); break;
case "10": case "11": case "12":
   console.log("large"); break;
default:
   console.log("strange");
   break;
}

यह कुछ मामलों में बहुत अधिक कॉम्पैक्ट कोड बनाता है।

Comments

मुझे लगता है कि सिंटैक्स अन्य जेएस वातावरण के समान है।

— अफशीन मेहरबानी 11

@AfshinMehrabani यह हो सकता है, मैंने केवल नोडज संदर्भ में इसका परीक्षण किया है।

— Automatico

हाँ। मुझे वर्टिकल स्पेस बचाना पसंद है!

— चैनल

Answer 7

स्टेफानो के उत्तर को जोड़ना और स्पष्ट करना, आप स्विच में स्थितियों के लिए मूल्यों को निर्धारित करने के लिए भावों का उपयोग कर सकते हैं, जैसे:

var i = 3
switch (i) {
    case ((i>=0 && i<=5)?i:-1): console.log('0-5'); break;
    case 6: console.log('6');
}

तो आपकी समस्या में, आप कुछ ऐसा कर सकते हैं:

var varName = "afshin"
switch (varName) {
    case (["afshin", "saeed", "larry"].indexOf(varName)+1 && varName):
      console.log("hey");
      break;

    default:
      console.log('Default case');
}

हालांकि इतना नहीं किया जा रहा है DRY ।।

Comments

अभी तक परीक्षण नहीं किया गया है, लेकिन varNameमामले की अभिव्यक्ति के अंदर संशोधन करना दिलचस्प होगा , उम्मीद करते हैं कि varName को कैश किया गया है।

— वलन

Answer 8

आप ' इन ' ऑपरेटर का उपयोग कर सकते हैं ...
ऑब्जेक्ट / हैश इनवोकेशन पर निर्भर करता है ...
इसलिए इसका जावास्क्रिप्ट जितना तेज़ हो सकता है ...

// assuming you have defined functions f(), g(a) and h(a,b) 
// somewhere in your code
// you can define them inside the object but... 
// the code becomes hard to read, I prefer this way

o = { f1:f, f2:g, f3:h };

// if you use "STATIC" code can do:
o['f3']( p1, p2 )

// if your code is someway "DYNAMIC", to prevent false invocations
// m brings the function/method to be invoked (f1, f2, f3)
// and you can rely on arguments[] to solve any parameter problems
if ( m in o ) o[m]()

आनंद लें, ZEE

Comments

यह स्विच से कैसे संबंधित है? क्या आप इसे स्पष्ट कर सकते हैं?

— जेड। खुल्लाह

आप अपने कोड को "पढ़ने में कठिन" क्यों बनाना चाहेंगे। एक प्रोग्रामर के रूप में मुझे पहली बात यह बताई गई कि मानसिकता के साथ कोड लिखना था कि आपका कोड पढ़ने वाला अगला व्यक्ति एक कुल्हाड़ी मारने वाला सीरियल किलर है और वह कोड को समझने में सक्षम नहीं होने से नफरत करता है।

— मैट

हाय मैट ... मैं इसे अवधारणा के प्रमाण के रूप में यहाँ प्रस्तुत कर रहा हूँ ... वैसे भी यह रूप आपको अधिक मज़बूती और लचीलापन प्रदान करता है ... और आप इसका उपयोग केवल तभी कर सकते हैं यदि आप चाहते हैं ... या यदि आपको इसमें कोई अड़चन आती है चीजों को करने का सामान्य रूप ... अपने प्रोग्रामर टूलबॉक्स में एक और उपकरण के रूप में ir पर विचार करें ...

— ZEE

Answer 9

मैं इस तरह का उपयोग करता हूं:

switch (true){
     case /Pressure/.test(sensor):{
        console.log('Its pressure!');
        break;
     }
     case /Temperature/.test(sensor):{
        console.log('Its temperature!');
        break;
     }
}

Comments

आपको gध्वज का उपयोग करने की आवश्यकता नहीं है , क्योंकि आप केवल एक बार रेगीक्स का उपयोग कर रहे हैं और उन्हें फेंक रहे हैं। वास्तव में, यदि आप उन्हें फंक्शन के बाहर रख रहे थे, तो gध्वज बाद के .test(एस पर गैर-0 इंडेक्स से मिलान करने की कोशिश करके आपको नुकसान पहुंचाएगा । मैंने एक टाइपो भी तय किया जहां स्विच का मामला sensorचर पर था और trueबूलियन अभिव्यक्तियों के मिलान के लिए स्थिर नहीं था । संपादन देखें।

— मिहेल मलोस्तानिडिस

मैंने इस प्रारूप का उपयोग फ़ाइल प्रकारों के विरुद्ध परीक्षण करने के लिए किया था। Ex:case /officedocument/.test(type) && /presentation/.test(type): iconClass = "far fa-file-powerpoint red"; break;

— tbone849

Answer 10

निर्भर करता है। स्विच एक बार और केवल एक बार मूल्यांकन करता है। एक मैच के बाद, बाद के सभी केस स्टेटमेंट तब तक आग लगाते हैं जब तक कि मामला क्या कहता है।

var onlyMen = true;
var onlyWomen = false;
var onlyAdults = false;
 
 (function(){
   switch (true){
     case onlyMen:
       console.log ('onlymen');
     case onlyWomen:
       console.log ('onlyWomen');
     case onlyAdults:
       console.log ('onlyAdults');
       break;
     default:
       console.log('default');
   }
})(); // returns onlymen onlywomen onlyadults

<script src="https://getfirebug.com/firebug-lite-debug.js"></script>

Answer 11

मुझे स्पष्टता और DRY सिंटैक्स के लिए यह पसंद है।

varName = "larry";

switch (true)
{
    case ["afshin", "saeed", "larry"].includes(varName) :
       alert('Hey');
       break;

    default: 
       alert('Default case');

}

Answer 12

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

 function isAccessible(varName){
     let accessDenied = ['Liam','Noah','William','James','Logan','Benjamin',
                        'Mason','Elijah','Oliver','Jacob','Daniel','Lucas'];
      switch (varName) {
         case (accessDenied.includes(varName)?varName:null): 
             return 'Access Denied!';
         default:
           return 'Access Allowed.';
       }
    }

    console.log(isAccessible('Liam'));

Comments

यह स्विच स्टेटमेंट का दुरुपयोग है। बस if (accessDenied.includes(varName)) return 'Access Denied!'; return 'Access Allowed.'जरूरत से ज्यादा है।

— मिखाइल मलोस्तानिडिस

Answer 13

उपरोक्त दृष्टिकोणों के साथ समस्या यह है कि आपको caseहर बार फ़ंक्शन को कॉल करने के लिए कई बार दोहराना पड़ता है जिसमें है switch। एक अधिक मजबूत समाधान एक नक्शा या एक शब्दकोश है ।

यहाँ एक उदाहरण है

// the Map, divided by concepts
var dictionary = {
  timePeriod: {
    'month': [1, 'monthly', 'mensal', 'mês'],
    'twoMonths': [2, 'two months', '2 motnhs', 'bimestral', 'bimestre'],
    'trimester': [3, 'trimesterly', 'quarterly', 'trimestral'],
    'semester': [4, 'semesterly', 'semestral', 'halfyearly'],
    'year': [5, 'yearly', 'anual', 'ano']
  },
  distance: {
    'km': [1, 'kms', 'kilometre', 'kilometers', 'kilometres'],
    'mile': [2, 'mi', 'miles'],
    'nordicMile': [3, 'nordic mile', 'mil(10km)', 'scandinavian mile']
  },
  fuelAmount: {
    'ltr': [1, 'l', 'litre', 'Litre', 'liter', 'Liter'],
    'gal(imp)': [2, 'imp gallon', 'imperial gal', 'gal(UK)'],
    'gal(US)': [3, 'US gallon', 'US gal'],
    'kWh': [4, 'KWH']
  }
};

//this function maps every input to a certain defined value
function mapUnit (concept, value) {
  for (var key in dictionary[concept]) {
    if (key === value || 
      dictionary[concept][key].indexOf(value) !== -1) {
      return key
    }
  }
  throw Error('Uknown "'+value+'" for "'+concept+'"')
}

//you would use it simply like this
mapUnit("fuelAmount", "ltr") // => ltr
mapUnit("fuelAmount", "US gal") // => gal(US)
mapUnit("fuelAmount", 3) // => gal(US)
mapUnit("distance", "kilometre") // => km
  
//now you can use the switch statement safely without the need 
//to repeat the combinations every time you call the switch
var foo = 'monthly'
switch (mapUnit ('timePeriod', foo)) {
  case 'month': 
    console.log('month')
    break
  case 'twoMonths': 
    console.log('twoMonths')
    break
  case 'trimester': 
    console.log('trimester')
    break
  case 'semester': 
    console.log('semester')
    break
  case 'year': 
    console.log('year')
    break
  default:
    throw Error('error')
}

Answer 14

तुम यह केर सकते हो:

alert([
  "afshin", 
  "saeed", 
  "larry",
  "sasha",
  "boby",
  "jhon",
  "anna",
  // ...
].includes(varName)? 'Hey' : 'Default case')

या कोड की सिर्फ एक पंक्ति:

alert(["afshin", "saeed", "larry",...].includes(varName)? 'Hey' : 'Default case')

एरिक के जवाब से थोड़ा सुधार

Answer 15

किसी के पास यहाँ आने के लिए एक समान मुद्दा है जो मेरे पास है, जिसे मैं कोडिंग और एक बर्नआउट के हफ्तों के बाद भाग गया, मेरी स्थिति कुछ इस तरह थी:

switch (text) {
  case SOME_CONSTANT || ANOTHER_CONSTANT:
    console.log('Case 1 entered');

  break;

  case THIRD_CONSTANT || FINAL_CONSTANT:
    console.log('Case 2 entered');

  break;

  default:
    console.log('Default entered');
}

हमेशा defaultकेस दर्ज हुआ। यदि आप एक समान मल्टी-केस स्विच स्टेटमेंट समस्या में चल रहे हैं, तो आप जो खोज रहे हैं वह है:

switch (text) {
  case SOME_CONSTANT:
  case ANOTHER_CONSTANT:
    console.log('Case 1 entered');

  break;

  case THIRD_CONSTANT:
  case FINAL_CONSTANT:
    console.log('Case 2 entered');

  break;

  default:
    console.log('Default entered');
}

आशा है कि यह किसी की मदद करता है, मैं स्विच केस का उपयोग करने के लिए याद करने से पहले अपने बालों को बाहर कर रहा था उसी तरह जैसे कि मैं इसे अपने redux reducers में उपयोग करता हूं।

Answer 16

संभावित समाधानों में से एक है:

const names = {
afshin: 'afshin',
saeed: 'saeed',
larry: 'larry'
};

switch (varName) {
   case names[varName]: {
       alert('Hey');
       break;
   }

   default: {
       alert('Default case');
       break;
   }
}

Comments

Q pls कौन सा #ecma यह है?

— बीजी ब्रूनो

नमस्ते। यह

— ईएस 6 है

Answer 17

मेरे लिए यह सबसे सरल तरीका है:

switch (["afshin","saeed","larry"].includes(varName) ? 1 : 2) {
   case 1: 
       alert('Hey');
       break;

   default: 
       alert('Default case');
       break;
}

Answer 18

जब एक फ़ंक्शन के अंदर, स्विच स्टेटमेंट में कई मामलों को करने का दूसरा तरीका

function name(varName){
  switch (varName) {
     case 'afshin':
     case 'saeed':
     case 'larry':
       return 'Hey';
     default:
       return 'Default case';
   }
}
        
console.log(name('afshin')); //Hey

Answer 19

आप इसे इस तरह लिख सकते हैं:

switch (varName)
{
   case "afshin": 
   case "saeed": 
   case "larry": 
       alert('Hey');
       break;

   default: 
       alert('Default case');
       break;
}         

Comments

यह सभी के रूप में एक ही उत्तर है, मैं "जो आप भूल गए, उसे ठीक कर देंगे, लेकिन इसे हटाने के बारे में सोचें।

— गौंट

Answer 20

<head>
    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
    <title>Example1</title>
    <link rel="stylesheet" href="css/style.css" >
    <script src="js/jquery-1.11.3.min.js" type="text/javascript"></script>
    <script>
        function display_case(){
            var num =   document.getElementById('number').value;

                switch(num){

                    case (num = "1"):
                    document.getElementById("result").innerHTML = "You select day Sunday";
                    break;

                    case (num = "2"):
                    document.getElementById("result").innerHTML = "You select day  Monday";
                    break;

                    case (num = "3"):
                    document.getElementById("result").innerHTML = "You select day  Tuesday";
                    break;

                    case (num = "4"):
                    document.getElementById("result").innerHTML = "You select day  Wednesday";
                    break;

                    case (num = "5"):
                    document.getElementById("result").innerHTML = "You select day  Thusday";
                    break;

                    case (num = "6"):
                    document.getElementById("result").innerHTML = "You select day  Friday";
                    break;

                    case (num = "7"):
                    document.getElementById("result").innerHTML = "You select day  Saturday";
                    break;

                    default:
                    document.getElementById("result").innerHTML = "You select day  Invalid Weekday";
                    break
                }

        }
    </script>
</head>
<body>
    <center>
        <div id="error"></div>
        <center>
            <h2> Switch Case Example </h2>
            <p>Enter a Number Between 1 to 7</p>
            <input type="text" id="number" />
            <button onclick="display_case();">Check</button><br />
            <div id="result"><b></b></div>
        </center>
    </center>
</body>

Comments

क्लासिक

— जूलरी इंक्लूजन

यह नहीं है कि switchकथन को कैसे काम करना चाहिए। यह सिर्फ है case "1":, नहीं case (num = "1"):।

— user4642212

केस के अंदर और document.getElementById("result").innerHTML = ....स्विच के बाहर दिन का मूल्य क्यों नहीं रखा गया और अंत में दिन का मूल्य परिणाम जोड़ें?

— स्टेफो डिम्फेल्ट

@Xufox मुझे पसंद है कि वह सचमुच कैसे ओवरराइट numकरता है लेकिन यह अभी भी काम करता है क्योंकि switchपहले से ही मूल्यांकन किया गया है और असाइनमेंट का मूल्य प्राप्त होता है। यह म्यूटेशन / मशीन लर्निंग द्वारा अपने बेहतरीन तरीके से प्रोग्रामिंग है।

— मिखाइल मलोस्तानिडिस

Answer 21

बस स्विच स्थिति aprroach स्विच करें

switch (true) {
    case (function(){ return true; })():
        alert('true');
        break;
    case (function(){ return false; })():
        alert('false');
        break;
    default:
        alert('default');
}

Comments

यदि आप स्विच अभिव्यक्ति के रूप में सही रखते हैं, तो "केस" स्टेटमेंट (एस) में आप जो कुछ भी चाहते हैं उसका मूल्यांकन कर सकते हैं, बशर्ते आप एक बूलियन लौटाएं

— स्टेफानो फेवरो

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

— जेड खुल्लाह

इस @StefanoFavero नोट के लिए आपको वास्तव में एक फ़ंक्शन की आवश्यकता नहीं है, बस (expression)कोष्ठक में, और वापसी मूल्य इनपुट होना चाहिए। मेरा जवाब देखें

— Z. खुल्ला

आपने इसे क्यों छोटा किया ?? मैं इस समाधान की वकालत करता हूं क्योंकि यह जटिल परिस्थितियों के लिए एक लचीलापन प्रदान करता है। यहां तक ​​कि अगर आप फफूंद को शर्तों के रूप में पसंद नहीं करते हैं, तो आप उन्हें कई शर्तों के साथ बदल सकते हैं जैसे किswitch(true) { case (var1 === 0 && var2 === true): {} }

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