Mi esercitavo in JavaScript quando uno dei miei amici si imbatté in questo codice JavaScript:

document.write(('b' + 'a' + + 'a' + 'a').toLowerCase());

Il codice sopra risponde "banana"! Qualcuno può spiegare perché?

+'a'si risolve in NaN("Not a Number") perché obbliga una stringa a un numero, mentre il carattere anon può essere analizzato come numero.

document.write(+'a');

Aggiungendo NaNa "ba"si trasforma NaNin stringa a "NaN"causa della conversione del tipo, dà baNaN. E poi c'è un adietro, che dà baNaNa.

Lo spazio tra + +è quello di rendere la prima una concatenazione di stringhe e la seconda un operatore più unario (cioè "positivo"). Si ottiene lo stesso risultato se si utilizza 'ba'+(+'a')+'a', risolto come 'ba'+NaN+'a', che equivale a 'ba'+'NaN'+'a'causa della manipolazione dei tipi.

document.write('ba'+(+'a')+'a');

'b' + 'a' + + 'a' + 'a'

... viene valutato come ....

('b') + ('a') + (+'a') + ('a')

^{(vedi: precedenza dell'operatore )}

(+'a')tenta di convertire 'a'in un numero utilizzando l' operatore più unario . Poiché 'a'non è un numero, il risultato è NaN ( "Not-A-Number" ):

'b'  +  'a'  +  NaN  + 'a'

Anche se NaNsta per "Not a Number", è comunque un tipo numerico ; quando aggiunto alle stringhe, si concatena esattamente come qualsiasi altro numero:

'b'  +  'a'  +  NaN  + 'a'  =>  'baNaNa'

Infine, è in minuscolo:

'baNaNa'.toLowerCase()      =>  'banana'

('b' + 'a' + + 'a' + 'a').toLowerCase()

Per chiarezza, suddividiamo questo in due passaggi. Innanzitutto, otteniamo il valore dell'espressione tra parentesi e quindi applichiamo la toLowerCase()funzione sul risultato.

Primo passo

'b' + 'a' + + 'a' + 'a'

Andando a LR , abbiamo:

• 'b' + 'a'restituisce ba , questa è concatenazione regolare.
• ba + + 'a'tenta di concatenare ba con + 'a'. Tuttavia, poiché l'operatore unario +tenta di convertire il suo operando in un numero, viene restituito il valore NaN , che viene quindi convertito in una stringa quando concatenato con il ba originale , risultando in baNaN .
• baNaN+ 'a' restituisce baNaNa . Ancora una volta, questa è concatenazione regolare.
  
  

In questa fase, il risultato del primo passaggio è baNaNa .

Passo due

Applicando .toLowerCase()sul valore restituito dal primo passaggio si ottiene:

Banana

Ci sono molti giochi di parole simili in JavaScript che puoi controllare.

È solo a causa dell'operatore + .

Possiamo ottenere ulteriori conoscenze da parte di esso.

=> ( ('b') + ('a') + (++) + ('a') + ('a'))
=> ( ('b') + ('a') + (+) + ('a') + ('a')) // Here + + convert it to +operator 
Which later on try to convert next character to the number.

Per esempio

const string =  '10';

Puoi convertire una stringa in numero in 2 modi:

1. Number (stringa);
2. + String;

Quindi torniamo alla query originale; Qui tenta di convertire il carattere successivo ('a') nel numero ma all'improvviso abbiamo ricevuto l'errore NaN,

( ('b') + ('a') + (+'a') + ('a'))
( ('b') + ('a') + NaN + ('a'))

Ma tratta come una stringa perché il carattere precedente era nella stringa. Così sarà

( ('b') + ('a') + 'NaN' + ('a'))

E infine lo converte in LowerCase (), quindi sarebbe banana

Se si mette il numero accanto ad esso, il risultato verrà modificato.

( 'b' + 'a' +  + '1' + 'a' ) 

Sarebbe "ba1a"

const example1 = ('b' + 'a' + + 'a' + 'a').toLowerCase(); // 'banana' 
const example2 = ('b' + 'a' + + '1' + 'a').toLowerCase(); // 'ba1a'
console.log(example1);
console.log(example2);

Questa riga di codice valuta un'espressione e quindi chiama un metodo basato sul valore restituito.

L'espressione ('b' + 'a' + + 'a' + 'a')è composta esclusivamente da letterali stringa e operatori di addizione.

• Letterali stringa "Un letterale stringa è zero o più caratteri racchiusi tra virgolette singole o doppie."
• L'operatore Addizione (+) "L'operatore addizione esegue la concatenazione di stringhe o l'aggiunta numerica."

Un'azione implicita è la chiamata a ToNumber su una stringa

• ToNumber applicato al tipo di stringa "ToNumber applicato alle stringhe applica la grammatica all'input String. Se la grammatica non è in grado di interpretare la stringa come un'espansione di StringNumericLiteral, il risultato di ToNumber è NaN."

L'interprete ha regole su come analizzare l'espressione, suddividendola nelle sue componenti delle espressioni della mano destra e sinistra.

Passo 1: 'b' + 'a'

Espressione sinistra: 'b'
Valore sinistro: 'b'

Operatore: + (uno dei lati dell'espressione è una stringa, quindi concatenazione di stringhe)

Espressione giusta: 'a' giusto valore: 'a'

Risultato: 'ba'

Passo 2: 'ba' + + 'a'

Espressione sinistra: 'ba'
Valore sinistro: 'ba'

Operatore: + (uno dei lati dell'espressione è una stringa, quindi concatenazione di stringhe)

Espressione giusta: + 'a'(questo valuta il valore matematico del carattere 'a' supponendo che sia un numero positivo dal segno + - il segno meno avrebbe funzionato anche qui indicando un numero negativo - che risulta in NaN)
Valore giusto: NaN (poiché l'operatore è la concatenazione di stringhe, toString viene chiamato su questo valore durante la concatenazione)

Risultato: 'baNaN'

Passaggio 3: 'baNaN' + 'a'

Espressione sinistra: 'baNaN'
Valore sinistro: 'baNaN'

Operatore: + (uno dei lati dell'espressione è una stringa, quindi concatenazione di stringhe)

Espressione giusta: 'a'
giusto valore: 'a'

Risultato: 'baNaNa'

Dopo questo è stata valutata l'espressione di raggruppamento e viene chiamato toLowerCase che ci lascia con banana.

L'uso di + converte qualsiasi valore in Numero in JavaScript!

Così...

La cosa principale qui da sapere prima e da cui imparare è usare +prima di qualsiasi valore in JavaScript, convertirà quel valore in un numero , ma se quel valore non può essere convertito, il motore JavaScript restituirà NaN , il che significa che non un numero (non può essere convertito in un numero, amico!) e il resto della storia come di seguito:

Maggiori informazioni su NaN su W3Schools o Mozilla Developer Network

Vedi la magia qui. Il secondo vantaggio è un operatore unario che dà "NaN"

console.log(('b' + 'a' + + 'a' + 'a').toLowerCase());
console.log(('b' + 'a' + + 'a' + 'a'));
console.log(('b' + 'a' + 'a' + 'a').toLowerCase());