Как работает этот волшебный Javascript?

здесь много чего есть. Круглые скобки вокруг переменных не являются функциональными.

в основном он строит эту строку:

return"145240544777244"

который является экранированной версией

return "alert(\"Hello World\")"

и, наконец, это:

Function(Function('return "alert(\"Hello World\")"')())()

двойной Function кажется произвольным, но это не так. Function() интерпретирует обратные косые черты в строке как escape-символы. Так что первый вызов декодирует, а второй выполняет.

Function("return '\110\145\154\154\157'")()
// => "Hello"

это тот же самый код, лучше отформатированный и с "нормальными" именами переменных;

var1=/｀ｍ´）ﾉ~┻━┻//*´∇｀*/['_'];
three=(threeThenFour)=_=3;
c=(one)=(threeThenFour)-(threeThenFour);
(anObject)=(one)=(three)/(three);
(anObject)={
  one:'_',
  var1:((var1==3)+'_')[one],
  var2ﾉ:(var1+'_')[three-(one)],
  var4ﾉ:((threeThenFour==3)+'_')[threeThenFour]
};
(anObject)[one]=((var1==3)+'_')[c ^ _ ^ three];
(anObject)['c']=((anObject)+'_')[(threeThenFour)+(threeThenFour)-(one)];
(anObject)['three']=((anObject)+'_')[one];
(theConstructor)=(anObject)['c']+
  (anObject)['three']+
  (var1+'_')[one]+
  ((var1==3)+'_')[threeThenFour]+
  ((anObject)+'_')[(threeThenFour)+(threeThenFour)]+
  ((threeThenFour==3)+'_')[one]+
  ((threeThenFour==3)+'_')[(threeThenFour)-(one)]+
  (anObject)['c']+
  ((anObject)+'_')[(threeThenFour)+(threeThenFour)]+
  (anObject)['three']+
  ((threeThenFour==3)+'_')[one];

// theConstructor => "constructor" 

(anObject)['_']=(three)[theConstructor][theConstructor];
(theReturn)=((threeThenFour==3)+'_')[one]+
  (anObject).var4ﾉ+
  ((anObject)+'_')[(threeThenFour)+(threeThenFour)]+
  ((threeThenFour==3)+'_')[three-one]+
  ((threeThenFour==3)+'_')[one]+
  (var1+'_')[one];

// theReturn => "return"

(threeThenFour)+=(one);
(anObject)[theReturn]='\';
(anObject).var3ﾉ=(anObject+threeThenFour)[three-(one)];
(ovar2o)=(var1+'_')[c ^ _ ^ three];
(anObject)[theConstructor]='\"';

// (anObject)['_'] => Function

(anObject)['_'](
  (anObject)['_'](theReturn+
                 (anObject)[theConstructor]+
                 (anObject)[theReturn]+
                 (one)+
                 (threeThenFour)+
                 (one)+
                 (anObject)[theReturn]+
                 (one)+
                 ((threeThenFour)+(one))+
                 (threeThenFour)+
                 (anObject)[theReturn]+
                 (one)+(
                   threeThenFour)+
                 ((threeThenFour)+(one))+
                 (anObject)[theReturn]+
                 (one)+
                 ((three)+(three))+
                 ((three)-(one))+
                 (anObject)[theReturn]+
                 (one)+
                 ((three)+(three))+
                 (threeThenFour)+
                 (anObject)[theReturn]+
                 ((threeThenFour)+(one))+
                 (c ^ _ ^ three)+
                 (anObject)[theReturn]+
                 (threeThenFour)+((three)-(one))+
                 (anObject)[theReturn]+
                 (one)+(one)+
                 (c ^ _ ^ three)+
                 (anObject)[theReturn]+
                 (one)+
                 (threeThenFour)+
                 ((threeThenFour)+(one))+
                 (anObject)[theReturn]+
                 (one)+
                 ((threeThenFour)+(one))+
                 (threeThenFour)+
                 (anObject)[theReturn]+
                 (one)+
                 ((threeThenFour)+(one))+
                 (threeThenFour)+
                 (anObject)[theReturn]+
                 (one)+
                 ((threeThenFour)+(one))+
                 ((threeThenFour)+(three))+
                 (anObject)[theReturn]+
                 (threeThenFour)+
                 (c ^ _ ^ three)+
                 (anObject)[theReturn]+
                 (one)+
                 ((three)-(one))+
                 ((threeThenFour)+(three))+
                 (anObject)[theReturn]+
                 (one)+
                 ((threeThenFour)+(one))+
                 ((threeThenFour)+(three))+
                 (anObject)[theReturn]+
                 (one)+
                 ((three)+(three))+
                 ((three)-(one))+
                 (anObject)[theReturn]+
                 (one)+
                 ((threeThenFour)+(one))+
                 (threeThenFour)+
                 (anObject)[theReturn]+
                 (one)+
                 (threeThenFour)+
                 (threeThenFour)+
                 (anObject)[theReturn]+
                 (threeThenFour)+
                 ((three)-(one))+
                 (anObject)[theReturn]+
                 ((threeThenFour)+(one))+
                 (one)+
                 (anObject)[theConstructor]
                )
  (one)
)('_');

позвольте мне объяснить ключевые шаги:

код создает объект с именем Д, а затем добавляет свойство '_' это имеет значение magic JavaScript конструктор функция. В JavaScript вы можете выполнить любую строку в виде кода, передав ее в конструктор функций.

как (ﾟДﾟ)['_'] содержать конструктор функций? Это умная техника, сделанная следующей строкой:

(ﾟДﾟ)['_'] = (o^_^o)[ﾟoﾟ][ﾟoﾟ];

здесь o и _ имеет значение 3. Так что o^_^o возвращается к 3. Очевидно автор мог бы просто использовать o, потому что o^_^o возвращает то же значение, но я думаю, что у него есть хороший вкус для запутывания :). Таким образом, приведенное выше выражение теперь становится (3)[ﾟoﾟ][ﾟoﾟ].

значение ﾟoﾟ в квадратной скобке устанавливается строка "конструктор", которая была построена путем конкатенации в предыдущем операторе. Он использует очень умный способ построить строку "конструктор", вырывая отдельные символы из встроенных строк JavaScript, таких как "объект", "истина", "ложь" и " неопределенный" которые генерируются из выражений JavaScript, преобразованных в строку. По-видимому, автор не мог найти символ "c", чтобы вырвать из этих встроенных строк, поэтому ему пришлось написать это явно. Обратите внимание, что символ в квадратной скобке-это ﾟoﾟ, который является символом Unicode, а не простой o, используемый в круглых скобках, хотя оба они очень похожи. Когда вы делаете (3)("constructor") возвращает функции конструктора. Конструктор конструктора чисел-это конструктор функций. Так что, делая (3)("constructor")("constructor") вы получаете конструктор функций, который теперь вы можете, наконец, передать произвольную строку для ее выполнения.

последняя строка строит строку "alert(\"Hello World\")" и передает его конструктору функции для выполнения.

вопрос в том, как мы получаем эту строку "alert(\"Hello World\")" без ввода реальных алфавит? Умная техника заключается в использовании \xxx где xxx-восьмеричное число и переводится в символ. Чтобы получить эту строку цифры вам нужны 0, 1, 2, 3, 4, 5, 6, 7 и 8. Но на самом деле вам не нужно все это, вместо этого вы можете произвести их с помощью простой арифметики с тремя числами 0, 1 и 4. Так например, чтобы произвести символ 'a' в "alert" вам нужно ASCII decimal 97 или octal 141, т. е. 1. Если у вас есть только 0, 1 и 4, хранящиеся в некотором свойстве выше объекта, вы можете объединить их для получения 'a'. Таким образом, вы можете создать любую строку, даже если все, что у вас есть 0, 1 и 4 хранятся в некоторых свойствах object объекта. Умно? Вы спорим!