¿Por qué UnderscoreJS usa toString.call() en lugar de typeof?

Question

Mirando bajo el capó en UnderscoreJS, veo:

_.isFunction = function(obj) { 
    return toString.call(obj) == '[object Function]'; 
    }; 

    _.isString = function(obj) { 
    return toString.call(obj) == '[object String]'; 
    }; 

    _.isNumber = function(obj) { 
    return toString.call(obj) == '[object Number]'; 
    }; 

Esto parece una elección extraña. ¿Por qué no usar simplemente typeof para determinar si un valor es una cadena, función o número? ¿Hay una ganancia de rendimiento al usar toString? ¿El tipo no es compatible con navegadores más antiguos?

Answer 1

Bueno, en realidad esto se debe a que es más rápido comprobar el [[Class]] consultando toString. También podría haber menos errores, ya que toString le da la clase exacta ...

cheque esto:

var fn = function() { 
    console.log(typeof(arguments)) // returns object 
    console.log(arguments.toString()) // returns object Arguments 
} 

Se podía ver el punto de referencia para typeof subrayado vs toString aquí:

http://jsperf.com/underscore-js-istype-alternatives

También hay algunos problemas de github con una mejor explicación:

https://github.com/documentcloud/underscore/pull/332

https://github.com/documentcloud/underscore/pull/321

EDIT 1:

También puede comprobar este gran artículo: Respuesta

http://javascriptweblog.wordpress.com/2011/08/08/fixing-the-javascript-typeof-operator/

Answer 2

de drinchev es parcialmente correcta. toString es actualmente mucho más lento que el uso de typeOf en la mayoría de los navegadores. See the 7th revision of the test he posted que usa typeOf. Sin embargo, ambos siguen siendo muy rápidos, por lo que en la mayoría de los casos esta diferencia de rendimiento no se notará y la compensación vale la pena cumplir con las especificaciones mejor que pato escribir/typeOf.

Underscore pull request 321 (que lista drinchev) tiene una discusión en profundidad de las compensaciones y por qué decidieron usar toString.