Valutazione del cortocircuito per fare solo il primo di un certo numero di azioni

Che dire di qualcosa sulla falsariga di

var tagCombiList = [['7',CombinedSearch.ITEMS.avail_morning, 'morning'],
                    ['12',CombinedSearch.ITEMS.avail_midday, 'midday'],
                    ...]

for(t of tagCombiList)
{
    if(this.initSingleTag(tags.open_at === t[0],t[1],'search-functions-open', t[3]) 
       break;
}

Il vantaggio di questo codice non solo evita la necessità di cortocircuiti. È anche molto più ASCIUTTO: in entrambe le versioni, è stata ripetuta quasi la stessa riga di codice quattro volte. Inoltre, separando la combinazione di dati tabulari dei dati di input dal codice che effettivamente utilizza i dati, si ha una migliore separazione delle preoccupazioni, che come "effetto collaterale" richiede meno colonne, il che migliora anche leggibilità.

La versione in cortocircuito potrebbe non essere il pezzo di codice più bello ma certamente non è neanche terribile. strongmente consiglio comunque di formattarlo in modo diverso,

Guardando questo codice, non è immediatamente chiaro cosa sta succedendo.

this.initSingleTag(tags.open_at === '7', CombinedSearch.ITEMS.avail_morning, 'search-functions-open', 'morning') ||
this.initSingleTag(tags.open_at === '12', CombinedSearch.ITEMS.avail_midday, 'search-functions-open', 'midday') ||
this.initSingleTag(tags.open_at === '18', CombinedSearch.ITEMS.avail_evening, 'search-functions-open', 'evening') ||
this.initSingleTag(tags.open_at === '22', CombinedSearch.ITEMS.avail_late, 'search-functions-open', 'late');

Questa versione - che è identica tranne che per lo spazio bianco - è molto più chiara.

this.initSingleTag(tags.open_at === '7', CombinedSearch.ITEMS.avail_morning, 'search-functions-open', 'morning')
    || this.initSingleTag(tags.open_at === '12', CombinedSearch.ITEMS.avail_midday, 'search-functions-open', 'midday')
    || this.initSingleTag(tags.open_at === '18', CombinedSearch.ITEMS.avail_evening, 'search-functions-open', 'evening')
    || this.initSingleTag(tags.open_at === '22', CombinedSearch.ITEMS.avail_late, 'search-functions-open', 'late');

Generalmente ritengo che l'uso dello spazio bianco sia principalmente una questione di gusti, ma non così in questo caso.

Le altre due risposte hanno già indicato che il tuo codice è in realtà un'iterazione che si arresta al primo elemento per il quale initSingleTag restituisce true quindi sono d'accordo che un ciclo (o, preferibilmente, una combinazione lenta di any e map se la tua tecnologia lo supporta) dovrebbe essere usato qui.

Se la logica non può essere formulata come un ciclo - ad esempio, perché stai chiamando funzioni diverse ogni volta e le funzioni non sono cittadini di prima classe nella tua lingua - allora nota che c'è un'altra alternativa agli operatori di cortocircuito e lo stile freccia nidificato if cascade.

if (firstStrategy(...)) {
} else if (secondStrategy(...)) {
} else if (thirdStrategy(...)) {
} else {
    this.isNotYourLuckyDay(...);
}

Tecnicamente, questo è ancora un% co_de nidificato ma molto più bello da guardare. Usare i rendimenti iniziali sarebbe ancora un'altra alternativa.

if (firstStrategy(...)) {
    return;
}
if (secondStrategy(...)) {
    return;
}
if (thirdStrategy(...)) {
    return;
}
this.isNotYourLuckyDay(...);

Se vuoi creare un codice più leggibile puoi:

a.- Crea un dizionario con le coppie chiave / valore per CombinedSearchItems .

b.- Crea un altro metodo / funzione per chiamare initSingleTag come rimuovere il codice duplicato.

c.- Suddividi le condizioni if .

CombinedSearchItemsDict = {
  'morning': CombinedSearch.ITEMS.avail_morning,
  'midday': CombinedSearch.ITEMS.avail_midday, 
  'evening': CombinedSearch.ITEMS.avail_evening, 
  'late': CombinedSearch.ITEMS.avail_late 
}

cond1 = magicFunction(7, 'morning')
cond2 = !cond1 && magicFunction(12, 'midday')
cond3 = !cond1 && !cond2 && magicFunction(18, 'evening')
if (!cond3) {
       magicFunction(22, 'late')
}

function magicFunction(time, day_time)
{
  timeStr = str(time)
  combinedSearch = CombinedSearchItemsDict[day_time] 

  return this.initSingleTag(tags.open_at === time, combinedSearch, 'search-functions-open', day_time)
}

... ma come puoi vedere è ancora difficile da capire. La chiave è creare codice che sarà facile da leggere per qualcuno in futuro ... (che qualcuno può essere te stesso) ..

Voglio dire, se qualcuno legge 'magicFunction' non c'è nulla su quel nome che dice cosa sta succedendo!

Quindi, invece di usare un nome enigmatico come magicFunction, dovresti usare un nome che descriva cosa stai facendo all'interno di quella funzione. Lo stesso per cond1 , cond2 e cond3 , un altro nome come morningTagSuccess , middayTagSuccess e eveningTagSuccess possono dare più informazioni su cosa sta succedendo, ma ancora ...

Forse più importante, devi chiedertelo, Cosa sto cercando di fare? e Perché? Stai cercando di fare qualcosa con la forza bruta? Perché stai cercando di vedere "Se non ho successo, prova un'altra cosa?" Perché non verificare prima quale caso devi eseguire in base ai tuoi parametri / stato del sistema? Qualcosa di simile a;

if (isTagValid('morning'))
{
    applySingleTag(7, 'morning')
}
else if (isTagValid('midday'))
{
    applySingleTag(12, 'midday')
}
else if (isTagValid('evening'))
{
    applySingleTag(18, 'evening')
}
else
{
    applySingleTag(22, 'late')
}

Sì, non stiamo usando il cortocircuito, ma forse questo non è il posto giusto per farlo.