Ich habe JavaScript geübt, als einer meiner Freunde auf diesen JavaScript-Code stieß:

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

Der obige Code antwortet "banana"! Kann jemand erklären warum?

+'a'wird in NaN("Keine Zahl") aufgelöst, da eine Zeichenfolge zu einer Zahl gezwungen wird, während das Zeichen anicht als Zahl analysiert werden kann.

document.write(+'a');

Das Hinzufügen NaNzu "ba"wird aufgrund der Typkonvertierung NaNzur Zeichenfolge . Und dann gibt es ein Hinterteil, das gibt ."NaN"baNaNabaNaNa

Der Abstand dazwischen + +besteht darin, die erste Verkettung eines Strings und den zweiten zu einem unären Plus-Operator (dh "positiv") zu machen. Sie haben das gleiche Ergebnis, wenn Sie " 'ba'+(+'a')+'a'aufgelöst als" verwenden 'ba'+NaN+'a', was 'ba'+'NaN'+'a'aufgrund des Typ-Jonglierens gleichbedeutend ist .

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

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

... wird bewertet als ....

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

^{(siehe: Vorrang des Operators )}

(+'a')versucht, 'a'mit dem unären Plus-Operator in eine Zahl zu konvertieren . Da 'a'es sich nicht um eine Zahl handelt, lautet das Ergebnis NaN ( "Not-A-Number" ):

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

Obwohl es NaNfür "Not a Number" steht, ist es immer noch ein numerischer Typ . Wenn es zu Zeichenfolgen hinzugefügt wird, verkettet es wie jede andere Zahl:

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

Schließlich ist es in Kleinbuchstaben geschrieben:

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

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

Lassen Sie uns dies aus Gründen der Klarheit in zwei Schritte unterteilen. Zuerst erhalten wir den Wert des Ausdrucks in Klammern und dann wenden wir die toLowerCase()Funktion auf das Ergebnis an.

Schritt eins

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

Wenn wir LR gehen , haben wir:

• 'b' + 'a'Gibt ba zurück , dies ist eine regelmäßige Verkettung.
• ba + + 'a'Versuche, ba mit zu verketten + 'a'. Da der unäre Operator jedoch +versucht, seinen Operanden in eine Zahl umzuwandeln, wird der Wert NaN zurückgegeben, der dann in eine Zeichenfolge umgewandelt wird, wenn er mit dem ursprünglichen ba verkettet wird - was zu baNaN führt .
• baNaN+ 'a' gibt baNaNa zurück . Auch dies ist eine regelmäßige Verkettung.
  
  

Zu diesem Zeitpunkt ist das Ergebnis von Schritt eins baNaNa .

Schritt zwei

Wenn Sie .toLowerCase()den in Schritt 1 zurückgegebenen Wert anwenden, erhalten Sie:

Banane

Es gibt viele ähnliche Wortspiele in JavaScript, die Sie überprüfen können.

Es ist nur wegen + Operator.

Wir können weiteres Wissen daraus gewinnen.

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

Zum Beispiel

const string =  '10';

Sie können eine Zeichenfolge auf zwei Arten in Zahlen umwandeln:

1. Nummer (Zeichenfolge);
2. + string;

Also zurück zur ursprünglichen Abfrage; Hier wird versucht, das nächste Zeichen ('a') in die Zahl umzuwandeln, aber plötzlich haben wir den Fehler NaN erhalten.

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

Es wird jedoch als Zeichenfolge behandelt, da sich das vorherige Zeichen in der Zeichenfolge befand. So wird es sein

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

Und zuletzt konvertiert es es in LowCase (), also wäre es Banane

Wenn Sie eine Nummer daneben haben, ändert sich Ihr Ergebnis.

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

Es wäre 'ba1a'

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

Diese Codezeile wertet einen Ausdruck aus und ruft dann eine Methode auf, die auf dem zurückgegebenen Wert basiert.

Der Ausdruck ('b' + 'a' + + 'a' + 'a')besteht ausschließlich aus Zeichenfolgenliteralen und Additionsoperatoren.

• String-Literale "Ein String-Literal besteht aus null oder mehr Zeichen in einfachen oder doppelten Anführungszeichen."
• Der Additionsoperator (+) "Der Additionsoperator führt entweder eine Zeichenfolgenverkettung oder eine numerische Addition durch."

Eine implizite Aktion ist der Aufruf von ToNumber für eine Zeichenfolge

• Auf den String-Typ angewendete ToNumber "Auf Strings angewendete ToNumber wendet Grammatik auf den eingegebenen String an. Wenn die Grammatik den String nicht als Erweiterung von StringNumericLiteral interpretieren kann, ist das Ergebnis von ToNumber NaN."

Der Interpreter hat Regeln zum Parsen des Ausdrucks, indem er ihn in seine Bestandteile der linken und rechten Ausdrücke zerlegt.

Schritt 1: 'b' + 'a'

Linker Ausdruck: 'b'
Linker Wert: 'b'

Operator: + (eine der Ausdrucksseiten ist eine Zeichenfolge, also Zeichenfolgenverkettung)

Richtiger Ausdruck: 'a' Richtiger Wert: 'a'

Ergebnis: 'ba'

Schritt 2: 'ba' + + 'a'

Linker Ausdruck: 'ba'
Linker Wert: 'ba'

Operator: + (eine der Ausdrucksseiten ist eine Zeichenfolge, also Zeichenfolgenverkettung)

Rechter Ausdruck: + 'a'(Dies wertet den mathematischen Wert des Zeichens 'a' aus, vorausgesetzt, es handelt sich um eine positive Zahl aus dem + -Zeichen - das Minuszeichen hätte auch hier eine negative Zahl angezeigt - was zu NaN führt.)
Richtiger Wert: NaN (da der Operator eine Zeichenfolgenverkettung ist, wird toString für diesen Wert während der Verkettung aufgerufen.)

Ergebnis: 'baNaN'

Schritt 3: 'baNaN' + 'a'

Linker Ausdruck: 'baNaN'
Linker Wert: 'baNaN'

Operator: + (eine der Ausdrucksseiten ist eine Zeichenfolge, also Zeichenfolgenverkettung)

Richtiger Ausdruck: 'a'
Richtiger Wert: 'a'

Ergebnis: 'baNaNa'

Danach wurde der Gruppierungsausdruck ausgewertet und toLowerCase aufgerufen, wodurch wir mit Banane zurückbleiben.

Wenn Sie + verwenden, wird jeder Wert in JavaScript in Zahl konvertiert!

Damit...

Das Wichtigste, was Sie hier zuerst wissen und daraus lernen müssen, ist, +vor jedem Wert in JavaScript diesen Wert in eine Zahl zu konvertieren. Wenn dieser Wert jedoch nicht konvertiert werden kann, gibt die JavaScript-Engine NaN zurück , dh keine Zahl (kann nicht) in eine Zahl umgewandelt werden, Kumpel!) und den Rest der Geschichte wie folgt:

Weitere Informationen zu NaN finden Sie bei W3Schools oder im Mozilla Developer Network

Sehen Sie die Magie hier. Das zweite Plus ist ein unärer Operator, der 'NaN' gibt.

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