Почему ++ [[]] [+ []] + [+ []] возвращает строку «10»?

++[[]][+[]] => 1 // [+[]] = [0], ++0 = 1
[+[]] => [0]

Тогда у нас есть конкатенация строк

1+[0].toString() = 10

Ниже приведена адаптация из сообщения в блоге, отвечая на этот вопрос, который я опубликовал, пока этот вопрос все еще закрыт. Ссылки представляют собой (копию HTML) спецификации ECMAScript 3, все еще базовую для JavaScript в современных широко используемых веб-браузерах.

Во-первых, комментарий: этот вид выражения никогда не появится в какой-либо (здоровой) производственной среде и будет использоваться только как упражнение только в том, насколько хорошо читатель знает грязные грани JavaScript. Общий принцип, что операторы JavaScript неявно конвертировать между типами полезен, а также некоторые из общих преобразований, но большая часть деталей в этом случае не является.

Выражение ++[[]][+[]]+[+[]] может сначала выглядеть довольно внушительным и неясным, но на самом деле относительно легко разбивать на отдельные выражения. Ниже Ive просто добавил круглые скобки для ясности; Я могу заверить вас, что они ничего не меняют, но если вы хотите проверить, что тогда не стесняйтесь читать о оператора группировки. Таким образом, выражение может быть более четко записано как

( ++[[]][+[]] ) + ( [+[]] )

Разрушая это, мы можем упростить, заметив, что +[] оценивается как 0. Чтобы убедиться, почему это так, проверьте унарный + оператор и следуйте слегка извилистой дорожке, которая заканчивается ToPrimitive преобразование пустого массива в пустую строку, которая затем окончательно преобразуется в 0 с помощью ToNumber. Теперь мы можем заменить 0 для каждого экземпляра +[]:

( ++[[]][0] ) + [0]

Проще уже. Что касается ++[[]][0], то это комбинация приращения приращения префиксов (++), массив literal определение массива с одним элементом, который сам по себе является пустым массивом ([[]]) и аксессуар свойств ([0]), вызываемый в массиве, определяемом литералом массива.

Итак, мы можем упростить [[]][0] до просто [] и имеем ++[], правильно? На самом деле это не так, потому что оценка ++[] вызывает ошибку, которая может показаться запутанной. Тем не менее, небольшая мысль о природе ++ делает это ясным: он используется для увеличения переменной (например, ++i) или свойства объекта (например, ++obj.count). Он не только оценивает значение, но и сохраняет это значение где-то. В случае ++[] ему некуда поставить новое значение (каким бы оно ни было), потому что нет ссылки на свойство или переменную объекта для обновления. В спецификациях это покрывается внутренней операцией PutValue, которая вызывается оператором приращения префикса.

Итак, что делает ++[[]][0]? Ну, по аналогичной логике, как +[], внутренний массив преобразуется в 0, и это значение увеличивается на 1, чтобы дать нам окончательное значение 1. Значение свойства 0 во внешнем массиве обновляется до 1, и все выражение оценивается как 1.

Это оставляет нас с

1 + [0]

..., который является простым использованием оператора добавления . Оба операнда первыми преобразуются в примитивы, и если примитивное значение является строкой, выполняется конкатенация строк, в противном случае выполняется цифровое добавление. [0] преобразуется в "0", поэтому используется конкатенация строк, создавая "10".

В качестве окончательного в стороне, то, что может не сразу проявиться, заключается в том, что переопределение одного из методов toString() или valueOf() Array.prototype изменит результат выражения, поскольку оба проверяются и используются, если они присутствуют при преобразовании объекта в примитивное значение. Например, следующие

Array.prototype.toString = function() {
  return "foo";
};
++[[]][+[]]+[+[]]

... производит "NaNfoo". Почему это происходит, остается как упражнение для читателя...

Позволяет сделать это простым:

++[[]][+[]]+[+[]] = "10"

var a = [[]][+[]];
var b = [+[]];

// so a == [] and b == [0]

++a;

// then a == 1 and b is still that array [0]
// when you sum the var a and an array, it will sum b as a string just like that:

1 + "0" = "10"

Этот результат оценивается одинаково, но немного меньше

+!![]+''+(+[])

• [] - преобразуется массив, который преобразуется в 0 при добавлении или вычитании из него, поэтому, следовательно, + [] = 0
• ! [] - оценивается как false, поэтому отсюда. [] оценивается как true
• +!! [] - преобразует значение true в числовое значение, которое вычисляется как true, поэтому в этом случае 1
• + '' - добавляет пустую строку в выражение, заставляя число преобразовываться в строку
• + [] - оценивается как 0

поэтому вычисляется

+(true) + '' + (0)
1 + '' + 0
"10"

Итак, теперь вы получили это, попробуйте следующее:

_=$=+[],++_+''+$

+ [] оценивается как 0 [...], а затем суммируя (+ операцию), он преобразует содержимое массива в его строковое представление, состоящее из элементов, соединенных с запятой.

Все, что угодно, например, принимать индекс массива (иметь более высокий приоритет, чем + операция), является порядковым и ничего интересного.

Возможно, кратчайшие пути оценки выражения в "10" без цифр:

+!+[] + [+[]]// "10"

-~[] + [+[]]// "10"

//========== Объяснение ==========\\

+!+[]: +[] Преобразует в 0. !0 преобразует в true. +true преобразуется в 1. -~[]= -(-1), который равен 1

[+[]]: +[] Преобразует в 0. [0] - это массив с одним элементом 0.

Затем JS оценивает выражение 1 + [0], таким образом Number + Array. Затем выполняется спецификация ECMA: оператор + преобразует оба операнда в строку, вызывая функции toString()/valueOf() из базового прототипа Object. Он работает как аддитивная функция, если оба операнда выражения являются числами. Хитрость заключается в том, что массивы легко преобразуют свои элементы в конкатенированное строковое представление.

Некоторые примеры:

1 + {} //    "1[object Object]"
1 + [] //    "1"
1 + new Date() //    "1Wed Jun 19 2013 12:13:25 GMT+0400 (Caucasus Standard Time)"

Хорошее исключение состоит в том, что два сложения Objects приводят к NaN:

[] + []   //    ""
[1] + [2] //    "12"
{} + {}   //    NaN
{a:1} + {b:2}     //    NaN
[1, {}] + [2, {}] //    "1,[object Object]2,[object Object]"

• Унарная плюс заданная строка преобразуется в число
• Оператор приращения данной строки преобразует и увеличивает на 1
• [] == ''. Пустая строка

• + '' или + [] оценивает 0.

  ++[[]][+[]]+[+[]] = 10 
  ++[''][0] + [0] : First part is gives zeroth element of the array which is empty string 
  1+0 
  10
  

Посмотрите на компилятор JSFuck и вот полный вывод.

Шаг за шагом, + превратить значение в число, и если вы добавите в пустой массив +[]... так как он пустой и равен 0, он будет

Итак, оттуда, теперь посмотрите на ваш код, это ++[[]][+[]]+[+[]]...

И между ними есть плюс ++[[]][+[]] + [+[]]

Таким образом, эти [+[]] вернут [0] поскольку у них есть пустой массив, который преобразуется в 0 внутри другого массива...

Итак, представьте, что первое значение - это двумерный массив с одним массивом внутри... так что [[]][+[]] будет равен [[]][0] который будет возвращать []...

И в конце ++ преобразовать его и увеличить до 1...

Таким образом, вы можете себе представить, 1 + "0" будет "10"...