Eu estava praticando JavaScript quando um dos meus amigos encontrou este código JavaScript:

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

O código acima responde "banana"! Alguém pode explicar o porquê?

+'a'resolve para NaN("Não é um número") porque restringe uma sequência a um número, enquanto o caractere anão pode ser analisado como um número.

document.write(+'a');

Adicionando NaNa "ba"transforma NaNna string "NaN"devido à conversão de tipo, dá baNaN. E então há um apor trás, dando baNaNa.

O espaço entre eles + +é tornar a primeira concatenação de uma sequência e a segunda um operador de adição unário (isto é, "positivo"). Você tem o mesmo resultado se usar 'ba'+(+'a')+'a', resolvido como 'ba'+NaN+'a', o que equivale a 'ba'+'NaN'+'a'devido ao malabarismo de tipo.

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

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

... é avaliado como ....

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

^{(veja: precedência do operador )}

(+'a')tenta converter 'a'para um número usando o operador mais unário . Como 'a'não é um número, o resultado é NaN ( "Não é um número" ):

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

Embora NaNsignifique "Não é um número", ainda é um tipo numérico ; quando adicionado às strings, concatena como qualquer outro número faria:

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

Por fim, está em minúsculas:

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

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

Para maior clareza, vamos dividir isso em duas etapas. Primeiro, obtemos o valor da expressão entre parênteses e depois aplicamos a toLowerCase()função no resultado.

Passo um

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

Indo LR , temos:

• 'b' + 'a'retorna ba , isso é concatenação regular.
• ba + + 'a'tenta concatenar ba com + 'a'. No entanto, como o operador unário +tenta converter seu operando em um número, o valor NaN é retornado, que é convertido em uma string quando concatenado com o ba original - resultando em baNaN .
• baNaN+ 'a' retorna baNaNa . Novamente, isso é concatenação regular.
  
  

Nesta fase, o resultado da etapa um é baNaNa .

Passo dois

A aplicação .toLowerCase()do valor retornado da etapa um fornece:

banana

Existem muitos trocadilhos semelhantes em JavaScript que você pode conferir.

É apenas por causa do operador + .

Podemos obter mais conhecimento a partir do pedaço.

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

Por exemplo

const string =  '10';

Você pode converter uma string em número de duas maneiras:

1. Número (string);
2. + string;

Então, de volta à consulta original; Aqui, ele tenta converter o próximo caractere ('a') para o número, mas de repente recebemos o erro NaN,

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

Mas trata como uma sequência porque o caractere anterior estava na sequência. Então será

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

E por último, converte para toCowerCase (), então seria banana

Se você colocar um número ao lado, seu resultado será alterado.

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

Seria 'ba1a'

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

Essa linha de código avalia uma expressão e chama um método com base no valor retornado.

A expressão ('b' + 'a' + + 'a' + 'a')é composta exclusivamente de literais de string e operadores de adição.

• Literais de sequência "Um literal de sequência é zero ou mais caracteres entre aspas simples ou duplas."
• O operador Addition (+) "O operador de adição executa concatenação de cadeias ou adição numérica".

Uma ação implícita tomada é a chamada para ToNumber em uma sequência

• ToNumber Aplicado ao Tipo de String "ToNumber aplicado a Strings aplica gramática à String de entrada. Se a gramática não puder interpretar a String como uma expansão de StringNumericLiteral, o resultado de ToNumber será NaN."

O intérprete possui regras de como analisar a expressão, dividindo-a em seus componentes de expressões da mão esquerda e direita.

Passo 1: 'b' + 'a'

Expressão à esquerda: 'b'
Valor à esquerda: 'b'

Operador: + (um dos lados da expressão é uma string, portanto, concatenação de string)

Expressão correta: 'a' Valor correto: 'a'

Resultado: 'ba'

Passo 2: 'ba' + + 'a'

Expressão à esquerda: 'ba'
Valor à esquerda: 'ba'

Operador: + (um dos lados da expressão é uma string, portanto, concatenação de string)

Expressão direita: + 'a'(este avalia o valor de matemática do caráter 'a' supondo que é um número positivo a partir do sinal de + - o sinal de menos teria também trabalhou aqui, indicando um número negativo - o que resulta em NaN)
Valor direita: NaN (porque o operador é concatenação de cadeias, toString é chamado nesse valor durante a concatenação)

Resultado: 'baNaN'

Etapa 3: 'baNaN' + 'a'

Expressão à esquerda: 'baNaN'
Valor à esquerda: 'baNaN'

Operador: + (um dos lados da expressão é uma string, portanto, concatenação de string)

Expressão correta: 'a'
Valor correto: 'a'

Resultado: 'baNaNa'

Depois disso, a expressão de agrupamento foi avaliada e toLowerCase é chamado, o que nos deixa com banana.

Usar + converterá qualquer valor para Number em JavaScript!

Assim...

A principal coisa aqui para saber primeiro e aprender é usar +antes de qualquer valor em JavaScript, converterá esse valor em um número , mas se esse valor não puder ser convertido, o mecanismo JavaScript retornará NaN , o que significa que não é um número (não pode ser convertido em um número, companheiro!) e no restante da história, como abaixo:

Leia mais sobre o NaN na W3Schools ou na Mozilla Developer Network

Veja a mágica aqui. O segundo plus é um operador unário que fornece 'NaN'

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