javascript - speed - performance html

¿Por qué "usar estricto" mejora el rendimiento 10 veces en este ejemplo?

Question

Siguiendo la pregunta Extendiendo el rendimiento de String.prototype Estoy realmente intrigado, porque solo agregar "use strict" a un método String.prototype mejoró el rendimiento 10 veces. La explanation de bergi es corta y no me la explica. ¿Por qué hay una diferencia tan dramática entre dos métodos casi idénticos, que solo difieren en "use strict" en la parte superior? ¿Puedes explicar con más detalle y con la teoría detrás de esto?

String.prototype.count = function(char) {
  var n = 0;
  for (var i = 0; i < this.length; i++)
    if (this[i] == char) n++;
  return n;
};

String.prototype.count_strict = function(char) {
  "use strict";
  var n = 0;
  for (var i = 0; i < this.length; i++)
    if (this[i] == char) n++;
  return n;
};
// Here is how I measued speed, using Node.js 6.1.0

var STR = ''0110101110010110100111010011101010101111110001010110010101011101101010101010111111000'';
var REP = 1e4;

console.time(''proto'');
for (var i = 0; i < REP; i++) STR.count(''1'');
console.timeEnd(''proto'');

console.time(''proto-strict'');
for (var i = 0; i < REP; i++) STR.count_strict(''1'');
console.timeEnd(''proto-strict'');

Resultado:

proto: 101 ms
proto-strict: 7.5 ms

Answer 1

En modo estricto, this contexto no está obligado a ser un objeto. Si llama a una función en un no objeto, será simplemente ese no objeto.

Por el contrario, en modo no estricto, this contexto siempre se envuelve primero en un objeto si aún no es un objeto. Por ejemplo, (42).toString() primero envuelve 42 en un objeto Number y luego llama a Number.prototype.toString con el objeto Number como this contexto. En modo estricto, this contexto se deja intacto y solo llama a Number.prototype.toString con 42 como this contexto.

(function() {
  console.log(typeof this);
}).call(42); // ''object''

(function() {
  ''use strict'';
  console.log(typeof this);
}).call(42); // ''number''

En su caso, la versión en modo no estricto pasa mucho tiempo envolviendo y desenvolviendo string primitivas en envoltorios de objetos de String y viceversa. La versión en modo estricto, por otro lado, funciona directamente en la string primitiva, lo que mejora el rendimiento.