switch-case con ritorno e rompere

Question

Solo per curiosità, ho spesso di vedere situazioni come:

switch(something) { 
    case 'alice': 
     return something; 
    break; 
} 

Qualora il break sembra essere completamente inutile, non v'è alcun motivo per essere là in ogni modo?

Answer 1

La dichiarazione break; potrebbe essere stata presente prima dell'introduzione della dichiarazione return. Come tale, è diventato ridondante e può essere rimosso.

In realtà, quando si esegue il codice che attraverso jslint, mostrerà questo errore:

Unreachable 'break' after 'return'.

o meno di ascoltare questo consiglio sta a voi; potrebbe essere utile durante lo sviluppo se stai provando alcune cose prima di stabilirti su uno stile particolare.

Si tratta di uno stile di scrittura alternativa che alcuni potrebbero sostenere è una pratica migliore:

var retval = null; 
switch (something) { 
    case 'alice': 
     retval = something; 
     break; 
    // ... 
} 
return retval; 

Answer 2

il caso è in realtà molto necessario

Hai un caso, allora avete bisogno di rompere quel caso, altrimenti gli altri casi sono raccolti pure.

l'uso dei casi è spesso considerato una cattiva pratica, stare lontani da loro il più possibile.

switch(casein){ 
case 1:{ 
break; 
} 
case 2:{ 
break 
} 
} 

Answer 3

break dice JavaScript per fermare valutare casi nel blocco switch. L'esecuzione del codice continua dopo la parentesi chiusa switch. L'istruzione return nel codice di esempio impedirà in effetti di superare qualsiasi cosa, comprese le altre istruzioni case e qualsiasi altra cosa che segue il blocco switch.

Ho messo una dichiarazione break in ogni caso per abitudine. Se ho scritto un caso senza un break allora potrei copiare e incollare blocchi di codice in giro per il futuro e la mancanza di una dichiarazione break sarebbe diventato un bug in questo modo:

function whereLivesA(species){ 
    switch(species){ 
    case 'worms': 
     // Relying on return to prevent further code execution within the switch 
     // block works but is ~bad~ smelly (according to plato :D) 
     var habitat = 'dirt' 
     return (species + ' live in ' + habitat); 
    case 'bees': 
     var habitat = 'hive'; 
     break; 
    } 
    // Stuff to do after the switch statement (unless you returned already) 
    var str = species+' live in '+habitat; 
    return str; 
} 
console.log('whereLivesA'); 
console.log(whereLivesA("worms")); 
console.log(whereLivesA("bees")); 
    /* Output: 
    whereLivesA 
    worms live in dirt 
    bees live in hive 
    */ 


function whereLivesB(species){ 
    switch(species){ 
    case "worms": 
     // what if future code changes remove `return` and don't add `break`? 
     // return (species + ' live in ' + habitat) 
     var habitat = 'dirt'; 
     // break; 
    case "bees": 
     var habitat = 'hive' 
     break; 
    } 
    // Stuff to do after the switch statement (unless you returned already) 
    var str = species+' live in '+habitat; 
    return str; 
} 
console.log('whereLivesB'); 
console.log(whereLivesB("bees")); 
console.log(whereLivesB("worms")); 
    /* Output: 
    whereLivesB 
    bees live in hive 
    worms live in hive 
    */ 


function whereLivesCorrect(species){ 
    switch(species){ 
    case "worms": 
     var habitat = 'dirt'; 
     break; 
    case "bees": 
     var habitat = 'hive' 
     break; 
    } 
    // Stuff to do after the switch statement (unless you returned already) 
    var str = species+' live in '+habitat; 
    return str; 
} 

console.log('whereLivesCorrect'); 
console.log(whereLivesCorrect("bees")); 
console.log(whereLivesCorrect("worms")); 
    /* Output: 
    whereLivesCorrect 
    bees live in hive 
    worms live in dirt 
    */ 

JS neofiti: se non lo fai vuoi salvarlo in un file ed eseguire node filename, puoi premere F12 e incollare questo script o altri script autonomi nella console del tuo browser per eseguirlo.

Se si utilizza node.js, è inoltre possibile digitare node da una riga comandi per avviare una console node e incollarla lì.

Answer 4

La parola chiave break viene utilizzata per terminare l'istruzione o uscire dal ciclo in modo che non continui a funzionare.

ad esempio:

html

what's your age?: <input type="text" id="ageOf"><br> 
<input type="submit" onSubmit="postReply();"> 
<div id="reply"></div> 

js

var userResponse = document.getElementById('ageOf'); 
var response = document.getElementById('reply'); 

function postReply() { 
    switch(ageOf) { 

    case 1: ageOf<18 { 
     response.innerHTML = "You are still young."; 
     break; 
    } 

    case 2: ageOf>18 && ageOf<45 { 
     response.innerHTML = "You are getting up there..."; 
     break; 
    } 

    case 3: ageOf >= 45 { 
     response.innerHTML = "You are over the hill!"; 
     break; 
    } 
} 

così su presentazione, il modulo deve chiamare il function postReply(), controllare la risposta degli utenti e in base al valore, si dovrebbe restituire una di quelle dichiarazioni.