Добавление объектов с номерами [дубликат]

Чтобы подкрепить то, что было ранее ранее.

Основная причина этого поведения частично объясняется слабо типизированным характером JavaScript. Например, выражение 1 + «2» неоднозначно, поскольку существуют две возможные интерпретации, основанные на типах операндов (int, string) и (int int):

• Пользователь намеревается объединить две строки , результат: «12»
• Пользователь намеревается добавить два числа, результат: 3

Таким образом, с различными типами ввода возможности вывода увеличиваются.

Алгоритм сложения

1. Поверенные операнды к примитивным значениям

Примитивы JavaScript - это строка, число, значение null, undefined и boolean (Symbol скоро появится в ES6). Любое другое значение - это объект (например, массивы, функции и объекты). Процесс принуждения для преобразования объектов в примитивные значения описывается таким образом:

• Если примитивное значение возвращается при вызове object.valueOf (), тогда возвращайте это значение, в противном случае продолжайте
• Если примитивное значение возвращается при вызове object.toString (), тогда возвращайте это значение, в противном случае продолжайте
• Бросьте TypeError

Примечание: для значений даты , порядок должен вызывать toString до valueOf.

2. Если какое-либо значение операнда является строкой, тогда выполните конкатенацию строк
3. В противном случае преобразуйте оба операнда в их числовое значение и затем добавьте эти значения

. Знание различных значений принуждения типов в JavaScript помогает сделать путаные результаты более ясными. См. Таблицу принуждения ниже

+-----------------+-------------------+---------------+
| Primitive Value |   String value    | Numeric value |
+-----------------+-------------------+---------------+
| null            | “null”            | 0             |
| undefined       | “undefined”       | NaN           |
| true            | “true”            | 1             |
| false           | “false”           | 0             |
| 123             | “123”             | 123           |
| []              | “”                | 0             |
| {}              | “[object Object]” | NaN           |
+-----------------+-------------------+---------------+

. Также хорошо знать, что оператор JavaScript + является лево-ассоциативным, поскольку это определяет, какие результаты будут иметь случаи, связанные с более чем одной операцией.

Использование таким образом 1 + «2» даст «12», потому что любое добавление, включающее строку, всегда будет по умолчанию для конкатенации строк.

Вы можете прочитать больше примеров в в этом сообщении в блоге (отказ от ответственности я написал).

I второе решение Ventero. Если вы хотите, вы можете подробнее рассказать о том, как + преобразует свои операнды.

Первый шаг (§9.1): конвертировать оба операнда в примитивы (примитивные значения: undefined, null, booleans, numbers, strings, все остальные значения - объекты, включая массивы и функции). Если операнд уже примитивен, все готово. Если нет, это объект obj, и выполняются следующие шаги:

1. Вызов obj.valueOf(). Если он возвращает примитив, вы закончите. Прямые экземпляры Object и массивы возвращаются, поэтому вы еще не закончили.
2. Вызов obj.toString(). Если он возвращает примитив, вы закончите. {} и [] оба возвращают строку, поэтому вы закончили.
3. В противном случае введите TypeError.

Для дат, шагов 1 и 2 меняются местами. Вы можете наблюдать поведение преобразования следующим образом:

var obj = {
    valueOf: function () {
        console.log("valueOf");
        return {}; // not a primitive
    },
    toString: function () {
        console.log("toString");
        return {}; // not a primitive
    }
}

Взаимодействие (Number() сначала преобразуется в примитив, а затем в число):

> Number(obj)
valueOf
toString
TypeError: Cannot convert object to primitive value

Второй шаг (§11.6.1 ): Если один из операндов является строкой, другой операнд также преобразуется в строку, и результат получается путем объединения двух строк. В противном случае оба операнда преобразуются в числа, и результат получается путем их добавления.

Более подробное объяснение процесса преобразования: « Что такое {} + {} в JavaScript? «

Это скорее комментарий, чем ответ, но по какой-то причине я не могу прокомментировать ваш вопрос. Я хотел исправить код JSFiddle. Тем не менее, я опубликовал это в Hacker News, и кто-то предложил мне его перепечатать.

Проблема в коде JSFiddle заключается в том, что ({}) (открытие скобок внутри круглых скобок) не совпадает с {} (открытие скобок как начало строки кода). Поэтому, когда вы вводите out({} + []), вы вынуждаете {} быть тем, чего нет, когда вы набираете {} + []. Это часть общей «ваттности» Javascript.

Основная идея заключалась в простом JavaScript, который хотел бы разрешить обе эти формы:

if (u)
    v;

if (x) {
    y;
    z;
}

Чтобы сделать это, два были сделаны интерпретации открывающей скобки: 1. не требуется и 2. он может появиться где угодно .

Это был неправильный ход. Реальный код не имеет открывающей скобки, появляющейся в середине нигде, и реальный код также имеет тенденцию быть более хрупким, когда он использует первую форму, а не вторую. (Примерно раз в другой месяц на моей последней работе меня вызывали на стол коллеги, когда их изменения в моем коде не работали, и проблема заключалась в том, что они добавили строку в «if» без добавления фигурных скобки. В конце концов я просто принял привычку, что фигурные скобки всегда требуются, даже когда вы пишете только одну строку.)

К счастью, во многих случаях eval () будет воспроизводить полную ваттность JavaScript , Код JSFiddle должен читать:

function out(code) {
    function format(x) {
        return typeof x === "string" ?
            JSON.stringify(x) : x;
    }   
    document.writeln('>>> ' + code);
    document.writeln(format(eval(code)));
}
document.writeln("<pre>");
out('[] + []');
out('[] + {}');
out('{} + []');
out('{} + {}');
out('Array(16).join("wat" + 1)');
out('Array(16).join("wat - 1")');
out('Array(16).join("wat" - 1) + " Batman!"');
document.writeln("</pre>");

[Также это первый раз, когда я написал document.writeln за многие много лет, и я чувствую себя немного грязным, пишу что-нибудь, связанное с document.writeln () и eval ().]

Мы можем ссылаться на спецификацию, и это замечательно и точно, но большинство случаев также можно объяснить более понятным образом со следующими утверждениями:

• + и - работают только с примитивными значениями. Более конкретно + (дополнение) работает с любыми строками или числами, а + (унарный) и - (вычитание и унарный) работает только с числами.
• Все нативные функции или операторы, которые ожидают примитивное значение как аргумент, сначала преобразует этот аргумент в нужный примитивный тип. Это делается с помощью valueOf или toString, которые доступны для любого объекта. Вот почему такие функции или операторы не вызывают ошибок при вызове на объекты.

Таким образом, мы можем сказать, что:

• [] + [] как String([]) + String([]), который аналогичен '' + ''. Я упомянул выше, что + (дополнение) также справедливо для чисел, но в JavaScript нет допустимого числа в массиве, поэтому вместо этого используется добавление строк.
• [] + {} такое же, как String([]) + String({}), который аналогичен '' + '[object Object]'
• {} + []. Это заслуживает большего объяснения (см. Ответ Вентеро). В этом случае фигурные скобки обрабатываются не как объект, а как пустой блок, поэтому он оказывается таким же, как +[]. Unary + работает только с числами, поэтому реализация пытается получить номер из []. Сначала он пытается valueOf, который в случае массивов возвращает один и тот же объект, поэтому он пытается использовать последнее средство: преобразование результата toString в число. Мы можем записать его как +Number(String([])), который аналогичен +Number(''), который аналогичен +0.
• Array(16).join("wat" - 1) вычитание - работает только с числами, поэтому это то же самое, что: Array(16).join(Number("wat") - 1), поскольку "wat" не может быть преобразовано в действительное число. Мы получаем NaN, и любая арифметическая операция на NaN получается с NaN, поэтому мы имеем: Array(16).join(NaN).