¿Por qué {} + {} es NaN solo en el lado del cliente? ¿Por qué no en Node.js?

Mientras que [] + []es una cadena vacía, [] + {}es "[object Object]"y {} + []es 0. ¿Por qué es {} + {}NaN?

> {} + {}
  NaN

Mi pregunta no es por qué ({} + {}).toString()es "[object Object][object Object]"mientras que NaN.toString()es "NaN", esta parte tiene una respuesta aquí ya .

Mi pregunta es ¿por qué sucede esto solo en el lado del cliente? En el lado del servidor ( Node.js ) {} + {}está "[object Object][object Object]".

> {} + {}
'[object Object][object Object]'

Resumiendo :

En el lado del cliente:

 [] + []              // Returns ""
 [] + {}              // Returns "[object Object]"
 {} + []              // Returns 0
 {} + {}              // Returns NaN

 NaN.toString()       // Returns "NaN"
 ({} + {}).toString() // Returns "[object Object][object Object]"
 var a = {} + {};     // 'a' will be "[object Object][object Object]"

En Node.js:

 [] + []   // Returns "" (like on the client)
 [] + {}   // Returns "[object Object]" (like on the client)
 {} + []   // Returns "[object Object]" (not like on the client)
 {} + {}   // Returns "[object Object][object Object]" (not like on the client)

Nota actualizada: esto se ha solucionado en Chrome 49 .

Muy interesante pregunta! Vamos a profundizar en.

La causa principal

La raíz de la diferencia está en cómo Node.js evalúa estas declaraciones frente a cómo lo hacen las herramientas de desarrollo de Chrome.

Lo que hace Node.js

Node.js usa el módulo repl para esto.

Del código fuente Node.js REPL :

self.eval(
    '(' + evalCmd + ')',
    self.context,
    'repl',
    function (e, ret) {
        if (e && !isSyntaxError(e))
            return finish(e);
        if (typeof ret === 'function' && /^[\r\n\s]*function/.test(evalCmd) || e) {
            // Now as statement without parens.
            self.eval(evalCmd, self.context, 'repl', finish);
        }
        else {
            finish(null, ret);
        }
    }
);

Esto actúa como si se ejecutara ({}+{})en las herramientas de desarrollador de Chrome, que también produce "[object Object][object Object]"lo que cabría esperar.

Lo que hacen las herramientas para desarrolladores de Chrome

Por otro lado, las herramientas de Chrome Dveloper hacen lo siguiente :

try {
    if (injectCommandLineAPI && inspectedWindow.console) {
        inspectedWindow.console._commandLineAPI = new CommandLineAPI(this._commandLineAPIImpl, isEvalOnCallFrame ? object : null);
        expression = "with ((window && window.console && window.console._commandLineAPI) || {}) {\n" + expression + "\n}";
    }
    var result = evalFunction.call(object, expression);
    if (objectGroup === "console")
        this._lastResult = result;
    return result;
}
finally {
    if (injectCommandLineAPI && inspectedWindow.console)
        delete inspectedWindow.console._commandLineAPI;
}

Entonces, básicamente, realiza un callen el objeto con la expresión. La expresión es:

with ((window && window.console && window.console._commandLineAPI) || {}) {
    {}+{};// <-- This is your code
}

Entonces, como puede ver, la expresión se está evaluando directamente, sin el paréntesis de ajuste.

Por qué Node.js actúa de manera diferente

La fuente de Node.js justifica esto:

// This catches '{a : 1}' properly.

Nodo no siempre actuaba así. Aquí está la confirmación real que lo cambió . Ryan dejó el siguiente comentario sobre el cambio: "Mejore cómo se evaden los comandos REPL" con un ejemplo de la diferencia.

Rinoceronte

Actualización: OP estaba interesado en cómo se comporta Rhino (y por qué se comporta como las herramientas de Chrome y a diferencia de nodejs).

Rhino utiliza un motor JS completamente diferente a diferencia de las herramientas de desarrollador de Chrome y REPL de Node.js, que usan V8.

Aquí está la línea básica de lo que sucede cuando evalúa un comando de JavaScript con Rhino en el shell de Rhino.

• La cáscara corre org.mozilla.javascript.tools.shell.main.

• A su vez, llama a esto, new IProxy(IProxy.EVAL_INLINE_SCRIPT); por ejemplo, si el código se pasó directamente con el modificador en línea -e.

• Esto golpea el runmétodo de IProxy .

• Invoca evalInlineScript( src ). Esto simplemente compila la cadena y la evalúa.

Básicamente:

Script script = cx.compileString(scriptText, "<command>", 1, null);
if (script != null) {
    script.exec(cx, getShellScope()); // <- just an eval
}

De los tres, el caparazón de Rhino es el que hace lo más parecido a un real evalsin ningún tipo de envoltura. Rhino's es el más cercano a una eval()declaración real y puede esperar que se comporte exactamente como lo evalharía.