Come abbreviare le mie dichiarazioni condizionali

Ho una dichiarazione condizionale molto lunga come la seguente:

if(test.type == 'itema' || test.type == 'itemb' || test.type == 'itemc' || test.type == 'itemd'){
    // do something.
}

Mi chiedevo se avrei potuto riformattare questa espressione / affermazione in una forma più concisa.

Qualche idea su come raggiungere questo obiettivo?

Inserisci i tuoi valori in un array e controlla se il tuo articolo è nell'array:

if ([1, 2, 3, 4].includes(test.type)) {
    // Do something
}

Se un browser supportato non ha il Array#includesmetodo, è possibile utilizzare questo polyfill .

Breve spiegazione della ~scorciatoia tilde:

Aggiornamento: dato che ora abbiamo il includesmetodo, non ha più senso utilizzare l' ~hacking. Tieni questo qui solo per le persone che sono interessate a sapere come funziona e / o che lo hanno riscontrato nel codice di altri.

Invece di verificare se il risultato di indexOfè >= 0, esiste una piccola scorciatoia:

if ( ~[1, 2, 3, 4].indexOf(test.type) ) {
    // Do something
}

Ecco il violino: http://jsfiddle.net/HYJvK/

Come funziona? Se viene trovato un elemento nell'array, indexOfrestituisce il suo indice. Se l'articolo non è stato trovato, tornerà -1. Senza entrare troppo nei dettagli, ~è un operatore NOT bit per bit , che tornerà 0solo per -1.

Mi piace usare la ~scorciatoia, poiché è più concisa che fare un confronto sul valore restituito. Vorrei che JavaScript avesse una in_arrayfunzione che restituisse direttamente un booleano (simile a PHP), ma è solo un pio desiderio ( Aggiornamento: adesso lo fa. Si chiama includes. Vedi sopra). Nota che jQuery inArray, pur condividendo la firma del metodo PHP, imita effettivamente la indexOffunzionalità nativa (che è utile in diversi casi, se l'indice è ciò che stai veramente cercando).

Nota importante: l' uso della scorciatoia tilde sembra essere oggetto di controversie, poiché alcuni credono con veemenza che il codice non sia abbastanza chiaro e dovrebbe essere evitato a tutti i costi (vedere i commenti su questa risposta). Se condividi il loro sentimento, dovresti attenersi alla .indexOf(...) >= 0soluzione.

Una spiegazione un po 'più lunga:

I numeri interi in JavaScript sono firmati, il che significa che il bit più a sinistra è riservato come bit di segno; una bandiera per indicare se il numero è positivo o negativo, con un 1essere negativo.

Ecco alcuni numeri positivi di esempio in formato binario a 32 bit:

1 :    00000000000000000000000000000001
2 :    00000000000000000000000000000010
3 :    00000000000000000000000000000011
15:    00000000000000000000000000001111

Ora ecco gli stessi numeri, ma negativi:

-1 :   11111111111111111111111111111111
-2 :   11111111111111111111111111111110
-3 :   11111111111111111111111111111101
-15:   11111111111111111111111111110001

Perché combinazioni così strane per i numeri negativi? Semplice. Un numero negativo è semplicemente l'inverso del numero positivo + 1; l'aggiunta del numero negativo al numero positivo dovrebbe sempre produrre 0.

Per capirlo, facciamo un po 'di semplice aritmetica binaria.

Ecco come aggiungeremmo -1a +1:

   00000000000000000000000000000001      +1
+  11111111111111111111111111111111      -1
-------------------------------------------
=  00000000000000000000000000000000       0

Ed ecco come aggiungeremmo -15a +15:

   00000000000000000000000000001111      +15
+  11111111111111111111111111110001      -15
--------------------------------------------
=  00000000000000000000000000000000        0

Come possiamo ottenere quei risultati? Facendo regolarmente aggiunte, il modo in cui ci è stato insegnato a scuola: inizi dalla colonna più a destra e sommi tutte le righe. Se la somma è maggiore del massimo numero a una cifra (che è in decimale 9, ma in binario è 1), il resto viene trasferito alla colonna successiva.

Ora, come noterai, quando aggiungi un numero negativo al suo numero positivo, la colonna più a destra che non è tutte le 0s avrà sempre due 1s, che una volta sommate comporteranno 2. La rappresentazione binaria di due essere 10, portiamo la 1colonna successiva e inseriamo un 0risultato nella prima colonna. Tutte le altre colonne a sinistra hanno solo una riga con a 1, quindi il 1riporto dalla colonna precedente si aggiungerà di nuovo a 2, che poi riporterà ... Questo processo si ripete fino a raggiungere la colonna più a sinistra, dove l' 1essere trasportato non ha nessun posto dove andare, quindi trabocca e si perde, e ci rimane 0tutto s.

Questo sistema si chiama Complemento 2 . Puoi leggere di più su questo qui:

Rappresentazione del complemento di 2 per numeri interi firmati .

Ora che il corso intensivo nel complemento di 2 è terminato, noterai che -1è l'unico numero la cui rappresentazione binaria è in 1tutto.

Utilizzando l' ~operatore NOT bit a bit, tutti i bit di un dato numero vengono invertiti. L'unico modo per tornare 0indietro dall'inversione di tutti i bit è se iniziamo con 1tutto.

Quindi, tutto questo era un modo prolisso di dire che ~ntornerà solo 0se lo nè -1.

È possibile utilizzare l'istruzione switch con fall thru:

switch (test.type) {

  case "itema":
  case "itemb":
  case "itemc":
  case "itemd":
    // do something
}

Usando la scienza: dovresti fare ciò che ha detto idfah e questo per la massima velocità, mantenendo il codice breve:

QUESTO È PIÙ VELOCE DEL ~Metodo

var x = test.type;
if (x == 'itema' ||
    x == 'itemb' ||
    x == 'itemc' ||
    x == 'itemd') {
    //do something
}

http://jsperf.com/if-statements-test-techsin (Set superiore: Chrome, set inferiore: Firefox)

Conclusione :

Se le possibilità sono poche e si sa che alcuni sono più probabilità di verificarsi di quanto si ottiene il massimo delle prestazioni fuori if ||, switch fall throughe if(obj[keyval]).

Se le possibilità sono molte , e chiunque di loro potrebbe essere il più presente, in altre parole, non puoi sapere quale è la probabilità che si verifichi più di quanto ottieni la maggior parte delle prestazioni dalla ricerca degli oggetti if(obj[keyval])e regexse si adatta.

http://jsperf.com/if-statements-test-techsin/12

aggiornerò se arriva qualcosa di nuovo.

Se stai confrontando con stringhe e c'è un modello, considera l'utilizzo di espressioni regolari.

Altrimenti, sospetto che il tentativo di accorciarlo offuschi il tuo codice. Considera semplicemente di avvolgere le linee per renderlo carino.

if (test.type == 'itema' ||
    test.type == 'itemb' ||
    test.type == 'itemc' ||
    test.type == 'itemd') {
    do something.
}

var possibilities = {
  "itema": 1,
  "itemb": 1,
  "itemc": 1,
…};
if (test.type in possibilities) { … }

L'uso di un oggetto come un array associativo è una cosa abbastanza comune, ma poiché JavaScript non ha un set nativo, puoi usare gli oggetti anche come set economici.

if( /^item[a-d]$/.test(test.type) ) { /* do something */ }

o se gli articoli non sono così uniformi, allora:

if( /^(itema|itemb|itemc|itemd)$/.test(test.type) ) { /* do something */ }

Risposte eccellenti, ma potresti rendere il codice molto più leggibile racchiudendone uno in una funzione.

Questa è un'affermazione complessa se, quando tu (o qualcun altro) leggerai il codice tra un anno, eseguirai la scansione per trovare la sezione per capire cosa sta succedendo. Una dichiarazione con questo livello di logica aziendale ti farà inciampare per alcuni secondi mentre elaborerai ciò che stai testando. Dove come codice come questo, ti permetterà di continuare la scansione.

if(CheckIfBusinessRuleIsTrue())
{
    //Do Something
}

function CheckIfBusinessRuleIsTrue() 
{
    return (the best solution from previous posts here);
}

Assegna un nome esplicito alla tua funzione in modo che sia immediatamente ovvio cosa stai testando e il tuo codice sarà molto più facile da scansionare e capire.

È possibile inserire tutte le risposte in un set Javascript e quindi chiamare .contains()il set.

Devi ancora dichiarare tutto il contenuto, ma la chiamata in linea sarà più breve.

Qualcosa di simile a:

var itemSet = new Set(["itema","itemb","itemc","itemd"]);
if( itemSet.contains( test.type ){}

Uno dei miei modi preferiti per raggiungere questo obiettivo è con una libreria come underscore.js ...

var isItem = _.some(['itema','itemb','itemc','itemd'], function(item) {
    return test.type === item;
});

if(isItem) {
    // One of them was true
}

http://underscorejs.org/#some

in un altro modo o in un altro fantastico modo che ho trovato è questo ...

if ('a' in oc(['a','b','c'])) { //dosomething }

function oc(a)
{
  var o = {};
  for(var i=0;i<a.length;i++)  o[a[i]]='';
  return o;
}

ovviamente, come puoi vedere, questo fa un ulteriore passo avanti e semplifica la logica.

http://snook.ca/archives/javascript/testing_for_a_v

utilizzando operatori come ~ && || ((), ()) ~~ va bene solo se il codice si rompe in seguito. Non saprai da dove iniziare. Quindi la leggibilità è GRANDE.

se devi, potresti accorciarlo.

('a' in oc(['a','b','c'])) && statement;
('a' in oc(['a','b','c'])) && (statements,statements);
('a' in oc(['a','b','c']))?statement:elseStatement;
('a' in oc(['a','b','c']))?(statements,statements):(elseStatements,elseStatements);

e se vuoi fare inverso

('a' in oc(['a','b','c'])) || statement;

Basta usare switchun'istruzione anziché ifun'istruzione:

switch (test.type) {

  case "itema":case "itemb":case "itemc":case "itemd":
    // do your process
  case "other cases":...:
    // do other processes
  default:
    // do processes when test.type does not meet your predictions.
}

Switch funziona anche più velocemente rispetto al confronto di molti condizionali all'interno di un if

Per elenchi di stringhe molto lunghi, questa idea salverebbe alcuni caratteri (senza dire che lo consiglierei nella vita reale, ma dovrebbe funzionare).

Scegli un carattere che sai non si verificherà nel tuo test.type, usalo come delimitatore, inseriscili tutti in una lunga stringa e cerca che:

if ("/itema/itemb/itemc/itemd/".indexOf("/"+test.type+"/")>=0) {
  // doSomething
}

Se le tue stringhe sono ulteriormente vincolate, potresti persino omettere i delimitatori ...

if ("itemaitembitemcitemd".indexOf(test.type)>=0) {
  // doSomething
}

... ma dovresti fare attenzione ai falsi positivi in ​​quel caso (ad es. "embite" corrisponderebbe a quella versione)

Per la leggibilità, creare una funzione per il test (sì, una funzione a una riga):

function isTypeDefined(test) {
    return test.type == 'itema' ||
           test.type == 'itemb' ||
           test.type == 'itemc' ||
           test.type == 'itemd';
}

quindi chiamalo:

…
    if (isTypeDefined(test)) {
…
}
...

Penso che ci siano 2 obiettivi quando si scrive questo tipo di if condition.

1. concisione
2. leggibilità

Pertanto, a volte il n. 1 potrebbe essere il più veloce, ma in seguito prenderò il n. 2 per una facile manutenzione. A seconda dello scenario, sceglierò spesso una variante della risposta di Walter.

Per iniziare, ho una funzione disponibile a livello globale come parte della mia libreria esistente.

function isDefined(obj){
  return (typeof(obj) != 'undefined');
}

e poi quando in realtà voglio eseguire una condizione if simile alla tua creerei un oggetto con un elenco di valori validi:

var validOptions = {
  "itema":1,
  "itemb":1,
  "itemc":1,
  "itemd":1
};
if(isDefined(validOptions[test.type])){
  //do something...
}

Non è veloce come un'istruzione switch / case e un po 'più dettagliato di alcuni degli altri esempi, ma spesso riesco a riutilizzare l'oggetto altrove nel codice che può essere abbastanza utile.

Piggybacking su uno dei campioni jsperf fatti sopra ho aggiunto questo test e una variazione per confrontare le velocità. http://jsperf.com/if-statements-test-techsin/6 La cosa più interessante che ho notato è che alcune combo di test in Firefox sono molto più veloci di Chrome.

Questo può essere risolto con un semplice ciclo per:

test = {};
test.type = 'itema';

for(var i=['itema','itemb','itemc']; i[0]==test.type && [
    (function() {
        // do something
        console.log('matched!');
    })()
]; i.shift());

Usiamo la prima sezione del ciclo for per inizializzare gli argomenti che si desidera abbinare, la seconda sezione per interrompere l'esecuzione del ciclo for e la terza sezione per causare la fine del ciclo.