Come scrivere un'espressione con operatore ternario (aka if) senza ripetersi

Ad esempio, qualcosa del genere:

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

C'è un modo migliore per scriverlo? Ancora una volta, non sto cercando una risposta alla domanda esatta sopra, solo un esempio di quando potresti avere operandi ripetuti nelle espressioni di operatori ternari ...

Personalmente trovo che il modo migliore per farlo sia ancora la buona vecchia ifaffermazione:

var value = someArray.indexOf(3);
if (value === -1) {
  value = 0;
}

Il codice dovrebbe essere leggibile, quindi essere succinti non dovrebbe significare essere conciso a qualsiasi costo - per questo dovresti ripubblicare su https://codegolf.stackexchange.com/ - quindi invece consiglierei di utilizzare una seconda variabile locale denominata indexper massimizzare la comprensibilità di lettura ( anche con un costo di runtime minimo, noto):

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

Ma se vuoi davvero ridurre questa espressione, perché sei un sadico crudele per i tuoi colleghi o collaboratori del progetto, allora ecco 4 approcci che potresti usare:

1: variabile temporanea in varun'istruzione

È possibile utilizzare la varcapacità dell'istruzione di definire (e assegnare) una seconda variabile temporanea indexse separata da virgole:

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

2: funzione anonima autoeseguibile

Un'altra opzione è una funzione anonima autoeseguibile:

// 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: operatore virgola

C'è anche il famigerato "operatore virgola" supportato da JavaScript, che è presente anche in C e C ++.

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Comma_Operator

È possibile utilizzare l'operatore virgola quando si desidera includere più espressioni in una posizione che richiede una singola espressione.

Puoi usarlo per introdurre effetti collaterali, in questo caso riassegnando a value:

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

Funziona perché var valueviene interpretato prima (poiché è un'istruzione), quindi l' valueassegnazione più a sinistra, più interna , e poi la mano destra dell'operatore virgola, e poi l'operatore ternario - tutto JavaScript legale.

4: riassegna in una sottoespressione

Il commentatore @IllusiveBrian ha sottolineato che l'uso dell'operatore virgola (nell'esempio precedente) non è necessario se l'assegnazione a valueè usata come sottoespressione tra parentesi:

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

Nota che l'uso di negativi nelle espressioni logiche può essere più difficile da seguire per gli esseri umani, quindi tutti gli esempi sopra possono essere semplificati per la lettura cambiando idx !== -1 ? x : yin idx == -1 ? y : x:

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

Per i numeri

Puoi usare la Math.max()funzione.

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

Manterrà i confini del risultato 0fino al primo risultato maggiore di 0se fosse così. E se il risultato di indexOfè -1restituirà 0 poiché è maggiore di -1.

Per valori booleani e booleani-y

Per JS non esiste una regola generale AFAIK specialmente perché vengono valutati i valori falsi .

Ma se qualcosa può aiutarti la maggior parte delle volte è l'operatore or ( ||):

// Instead of
var variable = this_one === true ? this_one : or_this_one;
// you can use
var variable = this_one || or_this_one;

Devi stare molto attento con questo, perché nel tuo primo esempio, indexOfpuò tornare 0e se lo valuti 0 || -1tornerà -1perché 0è un valore falso .

Non proprio, usa solo un'altra variabile.

Il tuo esempio generalizza a qualcosa di simile.

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

Stai testando un valore calcolato, quindi assegnando quel valore a una variabile se passa un predicato. Il modo per evitare di ricalcolare il valore calcolato è ovvio: utilizzare una variabile per memorizzare il risultato.

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

Capisco cosa intendi: sembra che dovrebbe esserci un modo per farlo che sembri un po 'più pulito. Ma penso che sia il modo migliore (idiomatico) per farlo. Se per qualche motivo ripetessi spesso questo schema nel tuo codice, potresti scrivere una piccola funzione di aiuto:

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

EDIT: Eccola qui, la proposta di coalescenza Nullary ora in JavaScript!

Uso ||

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

è equivalente a

const result = a || 'fallback value';

Se il cast adi Booleanritorni false, resultverrà assegnato 'fallback value', altrimenti il ​​valore di a.

Siate consapevoli del caso limite a === 0, che lancia falsee resultprenderà (in modo errato) 'fallback value'. Usa trucchi come questo a tuo rischio e pericolo.

PS. Linguaggi come Swift hanno un operatore a coalescenza nulla ( ??), che ha uno scopo simile. Ad esempio, in Swift scriveresti result = a ?? "fallback value"che è abbastanza vicino a JavaScriptconst result = a || 'fallback value';

Usa un refactoring di una variabile di estrazione :

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

È ancora meglio con constinvece di var. Puoi anche eseguire un'estrazione aggiuntiva:

const index = someArray.indexOf(3);
const condition = index !== -1;
const value = condition ? index : 0;

In pratica, utilizzare nomi più significativi rispetto index, conditione value.

const threesIndex = someArray.indexOf(3);
const threeFound = threesIndex !== -1;
const threesIndexOrZero = threeFound ? threesIndex : 0;

Probabilmente stai cercando un operatore di coalescenza. Fortunatamente, possiamo sfruttare il Arrayprototipo per crearne uno:

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

Questo potrebbe essere ulteriormente generalizzato al tuo caso, aggiungendo un parametro alla funzione:

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

Personalmente preferisco due varianti:

1. Pure if, come suggerito da @slebetman

2. Funzione separata, che sostituisce il valore non valido con quello predefinito, come in questo esempio:

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

Mi piace la risposta di @ slebetman. Il commento sotto esprime preoccupazione per il fatto che la variabile sia in uno "stato intermedio". se questa è una grande preoccupazione per te, suggerisco di incapsularla in una funzione:

function get_value(arr) {
   var value = arr.indexOf(3);
   if (value === -1) {
     value = 0;
   }
   return value;
}

Allora chiama

var value = get_value( someArray );

Potresti eseguire funzioni più generiche se hai usi per loro in altri luoghi, ma non esagerare se si tratta di un caso molto specifico.

Ma ad essere onesto, farei semplicemente come @slebetman a meno che non avessi bisogno di riutilizzarlo da diversi posti.

Ci sono due modi in cui posso vedere di guardare la tua domanda: o vuoi ridurre la lunghezza della linea o vuoi specificamente evitare di ripetere una variabile in un ternario. Il primo è banale (e molti altri utenti hanno pubblicato esempi):

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

può essere (e dovrebbe essere, date le chiamate di funzione) abbreviato in questo modo:

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

Se stai cercando una soluzione più generica che impedisca la ripetizione di una variabile in un ternario, in questo modo:

var value = conditionalTest(foo) ? foo : bar;

dove fooappare solo una volta. Scartare le soluzioni del modulo:

var cad = foo;
var value = conditionalTest(foo) ? cad : bar;

come tecnicamente corretto ma manca il punto, quindi sei sfortunato. Ci sono operatori, funzioni e metodi che possiedono la sintassi concisa che cerchi, ma tali costrutti, per definizione, non sono operatori ternari .

Esempi:

javascript, utilizzando ||per restituire l'RHS quando l'LHS è falsey:

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

Usa una funzione di supporto:

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

Ora il tuo codice è molto leggibile e non c'è ripetizione.

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

La gerarchia delle preoccupazioni di codifica è:

1. Corretto (comprese le prestazioni reali o i problemi di SLA)
2. Chiaro
3. Conciso
4. Veloce

Finora tutte le risposte sulla pagina sembrano corrette, ma penso che la mia versione abbia la massima chiarezza, che è più importante della concisione. Se non si conta la funzione di supporto, poiché può essere riutilizzata, è anche la più concisa. Il suggerimento in qualche modo simile di utilizzare una funzione di supporto utilizza sfortunatamente un lambda che, per me, oscura solo ciò che sta facendo. Una funzione più semplice con uno scopo che non richiede un lambda, solo valori, è per me molto meglio.

PS Se ti piace la sintassi di ES6:

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

Penso che l' ||operatore possa essere personalizzato per indexOf:

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

Il valore restituito viene spostato verso l'alto di 1, facendo 0 da -1, che è falso e quindi viene sostituito dal secondo 1. Quindi viene spostato indietro.

Tuttavia, tieni presente che la leggibilità è superiore all'evitare la ripetizione.

Questa è una soluzione semplice con NOT bit per bit e un valore predefinito il cui valore -1successivamente viene azzerato.

index = ~(~array.indexOf(3) || -1);

Funziona fondamentalmente con un doppio NOT bit per bit, che restituisce il valore originale o un valore predefinito, che dopo aver applicato il NOT bit per bit restituisce zero.

Diamo uno sguardo alla tavola della verità:

 indexOf    ~indexOf   boolean    default     value      result         comment
---------  ---------  ---------  ---------  ---------  ---------  ------------------
      -1          0     falsy          -1         -1          0   take default value
       0         -1    truthy                     -1          0
       1         -2    truthy                     -2          1
       2         -3    truthy                     -3          2

Potresti usare la riassegnazione:

• inizializza la variabile su un valore
• utilizzare la serializzazione &&dell'operatore per la riassegnazione, perché se la prima condizione è falsa, la seconda espressione non verrà valutata

Ex.

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

var someArray = [4,3,2,1];

var value = someArray.indexOf(1);
value == -1 && (value=0);
console.log('Found:',value);

var value = someArray.indexOf(5);
value == -1 && (value=0);
console.log('Not Found:',value);

Dato il codice di esempio in Question non è chiaro come verrebbe determinato se 3è o non è impostato su index 0of someArray. -1restituito da .indexOf()sarebbe utile in questo caso, allo scopo di escludere una presunta non corrispondenza che potrebbe essere una corrispondenza.

Se 3non è incluso nell'array, -1verrà restituito. Possiamo aggiungere 1al risultato di .indexOf()valutare come falserisultato essere -1, dove seguito da || ORoperatore e 0. Quando valueviene fatto riferimento, sottrarre 1per ottenere l'indice dell'elemento dell'array o -1.

Il che riconduce al semplice utilizzo .indexOf()e al controllo di -1una determinata ifcondizione. Oppure, definendo valuein modo undefinedda evitare possibili confusioni sul risultato effettivo della condizione valutata relativa al riferimento originale.

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

Un ternario è come un se-altro, se non hai bisogno dell'altra parte, perché non solo un singolo se invece ..

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

In questo caso particolare, potresti utilizzare il cortocircuito con l' ||operatore logico . Poiché 0è considerato falso, puoi aggiungere 1al tuo indice, quindi, se index+1è 0allora otterrai il lato destro del logico o come risultato, altrimenti otterrai il tuo index+1. Poiché il risultato desiderato è compensato da 1, puoi quindi sottrarlo 1per ottenere il tuo indice:

const someArray = [1, 2, 3, 4];
const v = ((someArray.indexOf(3)+1) || 1)-1;
console.log(v);