JavaScript o (||) spiegazione dell'assegnazione delle variabili

Dato questo frammento di JavaScript ...

var a;
var b = null;
var c = undefined;
var d = 4;
var e = 'five';

var f = a || b || c || d || e;

alert(f); // 4

Qualcuno può spiegarmi come si chiama questa tecnica (la mia ipotesi migliore è nel titolo di questa domanda!)? E come / perché funziona esattamente?

La mia comprensione è che alla variabile fverrà assegnato il valore più vicino (da sinistra a destra) della prima variabile che ha un valore che non è né nullo né indefinito, ma non sono riuscito a trovare molto materiale di riferimento su questa tecnica e ho visto che ha usato molto.

Inoltre, questa tecnica è specifica per JavaScript? So che fare qualcosa di simile in PHP porterebbe ad favere un vero valore booleano, piuttosto che il valore di dse stesso.

Vedere la valutazione del corto circuito per la spiegazione. È un modo comune di implementare questi operatori; non è univoco per JavaScript.

Questo viene fatto per assegnare un valore predefinito , in questo caso il valore di y, se la xvariabile è falsa .

Gli operatori booleani in JavaScript possono restituire un operando e non sempre un risultato booleano come in altre lingue.

L'operatore Logical OR ( ||) restituisce il valore del suo secondo operando, se il primo è errato, altrimenti viene restituito il valore del primo operando.

Per esempio:

"foo" || "bar"; // returns "foo"
false || "bar"; // returns "bar"

Falsy valori sono quelli che costringere a falsequando usato in contesto booleano, e sono 0, null, undefined, una stringa vuota, NaNe naturalmente false.

Javacript utilizza la valutazione di corto circuito per operatori logici ||e &&. Tuttavia, è diverso da altre lingue in quanto restituisce il risultato dell'ultimo valore che ha interrotto l'esecuzione, anziché un valore trueo false.

I seguenti valori sono considerati falsi in JavaScript.

• falso
• nullo
• "" (stringa vuota)
• 0
• Nan
• non definito

Ignorando le regole di precedenza dell'operatore e mantenendo le cose semplici, i seguenti esempi mostrano quale valore ha interrotto la valutazione e, di conseguenza, viene restituito.

false || null || "" || 0 || NaN || "Hello" || undefined // "Hello"

I primi 5 valori fino a NaNsono falsi, quindi vengono tutti valutati da sinistra a destra, fino a quando non incontra il primo valore di verità - il "Hello"che rende vera l'intera espressione, quindi qualsiasi cosa più in alto non verrà valutata e "Hello"verrà restituita come risultato dell'espressione . Allo stesso modo, in questo caso:

1 && [] && {} && true && "World" && null && 2010 // null

I primi 5 valori sono tutti veritieri e vengono valutati fino a quando non soddisfano il primo valore falsy ( null) che rende l'espressione falsa, quindi 2010non viene più valutata e nullviene restituita come risultato dell'espressione.

L'esempio che hai fornito è l'utilizzo di questa proprietà di JavaScript per eseguire un compito. Può essere utilizzato ovunque sia necessario ottenere il primo valore di verità o falsità tra un insieme di valori. Questo codice di seguito assegnerà il valore "Hello"in bquanto semplifica l'assegnazione di un valore predefinito, invece di eseguire controlli if-else.

var a = false;
var b = a || "Hello";

Potresti chiamare l'esempio seguente uno sfruttamento di questa funzionalità e credo che renda il codice più difficile da leggere.

var messages = 0;
var newMessagesText = "You have " + messages + " messages.";
var noNewMessagesText = "Sorry, you have no new messages.";
alert((messages && newMessagesText) || noNewMessagesText);

All'interno messagesdell'avviso, controlliamo se è falso, e se sì, quindi valutiamo e restituiamo noNewMessagesText, altrimenti valutiamo e restituiamo newMessagesText. Dato che in questo esempio è falso, ci fermiamo a noNewMessagesText e avvisiamo "Sorry, you have no new messages.".

Le variabili Javascript non vengono digitate, quindi a f può essere assegnato un valore intero anche se è stato assegnato tramite operatori booleani.

A f viene assegnato il valore più vicino che non equivale a false . Quindi 0, false, null, non definiti, vengono tutti passati sopra:

alert(null || undefined || false || '' || 0 || 4 || 'bar'); // alerts '4'

Non c'è magia ad esso. Le espressioni booleane come a || b || c || dsono valutate pigramente. Interpeter cerca il valore di a, è indefinito, quindi è falso, quindi va avanti, poi vede bquale è nullo, il che dà ancora risultati falsi così va avanti, poi vede c- stessa storia. Alla fine vede de dice 'huh, non è null, quindi ho il mio risultato' e lo assegna alla variabile finale.

Questo trucco funzionerà in tutti i linguaggi dinamici che eseguono una valutazione pigra del cortocircuito delle espressioni booleane. Nei linguaggi statici non verrà compilato (digitare errore). Nelle lingue desiderose di valutare le espressioni booleane, restituirà un valore logico (vale a dire vero in questo caso).

Questa domanda ha già ricevuto diverse buone risposte.

In sintesi, questa tecnica sfrutta una caratteristica di come viene compilata la lingua. Cioè, JavaScript "cortocircuita" la valutazione degli operatori booleani e restituirà il valore associato al primo valore della variabile non falsa o qualunque cosa contenga l'ultima variabile. Vedi la spiegazione di Anurag di quei valori che verranno valutati come falsi.

L'uso di questa tecnica non è una buona pratica per diversi motivi; però.

1. Leggibilità del codice: utilizza operatori booleani e se il comportamento di come viene compilato non è compreso, il risultato atteso sarebbe un valore booleano.
2. Stabilità: utilizza una funzionalità del modo in cui viene compilata la lingua che è incoerente in più lingue e, di conseguenza, è qualcosa che potrebbe essere oggetto di potenziali cambiamenti in futuro.

3. Caratteristiche documentate: esiste un'alternativa esistente che soddisfa questa esigenza ed è coerente in più lingue. Questo sarebbe l'operatore ternario:

   ()? valore 1: valore 2.

L'uso dell'operatore ternario richiede un po 'più di battitura, ma distingue chiaramente tra l'espressione booleana che viene valutata e il valore assegnato. Inoltre, può essere concatenato, quindi è possibile ricreare i tipi di assegnazioni predefinite eseguite in precedenza.

var a;
var b = null;
var c = undefined;
var d = 4;
var e = 'five';

var f =  ( a ) ? a : 
                ( b ) ? b :
                       ( c ) ? c :
                              ( d ) ? d :
                                      e;

alert(f); // 4

Restituisce l'output del primo vero valore .

Se tutti sono falsi, restituire l'ultimo valore falso.

Esempio:-

  null || undefined || false || 0 || 'apple'  // Return apple

Sta impostando la nuova variabile ( z) sul valore di xse è "verità" (diverso da zero, un oggetto / array / funzione valido / qualunque cosa sia) o yaltrimenti. È un modo relativamente comune di fornire un valore predefinito nel caso in cui xnon esista.

Ad esempio, se si dispone di una funzione che accetta un parametro di callback opzionale, è possibile fornire un callback predefinito che non fa nulla:

function doSomething(data, callback) {
    callback = callback || function() {};
    // do stuff with data
    callback(); // callback will always exist
}

Significa che se ximpostato, il valore per zsarà x, altrimenti se yimpostato, il suo valore verrà impostato come zvalore di.

è lo stesso di

if(x)
  z = x;
else
  z = y;

È possibile perché gli operatori logici in JavaScript non restituiscono valori booleani ma il valore dell'ultimo elemento necessario per completare l'operazione (in una frase OR sarebbe il primo valore non falso, in una frase AND sarebbe l'ultimo ). Se l'operazione non riesce, falseviene restituita.

Si chiama operatore di corto circuito.

La valutazione del corto circuito dice che il secondo argomento viene eseguito o valutato solo se il primo argomento non è sufficiente per determinare il valore dell'espressione. quando il primo argomento della funzione OR (||) viene valutato come vero, il valore complessivo deve essere vero.

Potrebbe anche essere utilizzato per impostare un valore predefinito per l'argomento della funzione

function theSameOldFoo(name){ 
  name = name || 'Bar' ;
  console.log("My best friend's name is " + name);
}
theSameOldFoo();  // My best friend's name is Bar
theSameOldFoo('Bhaskar');  // My best friend's name is Bhaskar`

Valuterà X e, se X non è null, la stringa vuota o 0 (falso logico), quindi lo assegnerà a z. Se X è null, la stringa vuota o 0 (falso logico), assegnerà y alla z.

var x = '';
var y = 'bob';
var z = x || y;
alert(z);

Emetterà 'bob';

Secondo il post del blog di Bill Higgins ; il linguaggio logico di assegnazione OR logico Javascript (febbraio 2007), questo comportamento è vero a partire dalla v1.2 (almeno)

Suggerisce anche un altro uso (citato): " leggera normalizzazione delle differenze tra browser "

// determine upon which element a Javascript event (e) occurred
var target = /*w3c*/ e.target || /*IE*/ e.srcElement;