Najbardziej dokładny sposób sprawdzenia typu obiektu JS?

Question

Operator typeof tak naprawdę nie pomaga nam w znalezieniu prawdziwego typu obiektu.

Już widziałem następujący kod:

Object.prototype.toString.apply(t) 

Pytanie:

Czy to najbardziej dokładny sposób sprawdzania typu obiektu?

Answer 1

Specyfikacja JavaScript daje dokładnie jeden właściwy sposób określić klasę obiektu:

Object.prototype.toString.call(t); 

http://bonsaiden.github.com/JavaScript-Garden/#types

Answer 2

var o = ... 
var proto = Object.getPrototypeOf(o); 
proto === SomeThing; 

Trzymać uchwyt na prototypie można oczekiwać obiekt, aby mieć, a następnie porównać przeciwko niemu.

np

var o = "someString"; 
var proto = Object.getPrototypeOf(o); 
proto === String.prototype; // true 

Answer 3

Object.prototype.toString to dobry sposób, ale jego wydajność jest najgorsza.

http://jsperf.com/check-js-type

Zastosowanie typeof rozwiązać podstawowe problemy (String, Number, Boolean ...) i używać Object.prototype.toString rozwiązać coś złożonego (jak Array, data, RegExp).

i to jest moje rozwiązanie:

var type = (function(global) { 
    var cache = {}; 
    return function(obj) { 
     var key; 
     return obj === null ? 'null' // null 
      : obj === global ? 'global' // window in browser or global in nodejs 
      : (key = typeof obj) !== 'object' ? key // basic: string, boolean, number, undefined, function 
      : obj.nodeType ? 'object' // DOM element 
      : cache[key = ({}).toString.call(obj)] // cached. date, regexp, error, object, array, math 
      || (cache[key] = key.slice(8, -1).toLowerCase()); // get XXXX from [object XXXX], and cache it 
    }; 
}(this)); 

zastosowanie jako:

type(function(){}); // -> "function" 
type([1, 2, 3]); // -> "array" 
type(new Date()); // -> "date" 
type({}); // -> "object" 

Answer 4

Akceptowane odpowiedź jest poprawna, ale chciałbym, aby zdefiniować tę małą przydatność w większości projektów buduję.

var types = { 
    'get': function(prop) { 
     return Object.prototype.toString.call(prop); 
    }, 
    'object': '[object Object]', 
    'array': '[object Array]', 
    'string': '[object String]', 
    'boolean': '[object Boolean]', 
    'number': '[object Number]' 
} 

Używane tak:

if(types.get(prop) == types.number) { 

} 

Jeśli używasz kątowe można nawet to czysto wstrzykiwany:

angular.constant('types', types); 

Answer 5

ułożyła małą użyteczność wyboru typu Zainspirowany powyżej prawidłowych odpowiedzi:

thetypeof = function(name) { 
     let obj = {}; 
     obj.object = 'object Object' 
     obj.array = 'object Array' 
     obj.string = 'object String' 
     obj.boolean = 'object Boolean' 
     obj.number = 'object Number' 
     obj.type = Object.prototype.toString.call(name).slice(1, -1) 
     obj.name = Object.prototype.toString.call(name).slice(8, -1) 
     obj.is = (ofType) => { 
      ofType = ofType.toLowerCase(); 
      return (obj.type === obj[ofType])? true: false 
     } 
     obj.isnt = (ofType) => { 
      ofType = ofType.toLowerCase(); 
      return (obj.type !== obj[ofType])? true: false 
     } 
     obj.error = (ofType) => { 
      throw new TypeError(`The type of ${name} is ${obj.name}: ` 
      +`it should be of type ${ofType}`) 
     } 
     return obj; 
    }; 

przykład:

if (thetypeof(prop).isnt('String')) thetypeof(prop).error('String') 
if (thetypeof(prop).is('Number')) // do something