Cách chính xác nhất để kiểm tra loại đối tượng JS?

Các typeofnhà điều hành không thực sự giúp chúng ta tìm ra loại thực sự của một đối tượng.

Tôi đã thấy đoạn mã sau:

Object.prototype.toString.apply(t)  

Câu hỏi:

Đó có phải là hầu hết các con đường chính xác của kiểm tra kiểu của đối tượng?

Đặc tả JavaScript cung cấp chính xác một cách thích hợp để xác định lớp của một đối tượng:

Object.prototype.toString.call(t);

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

đó Object.prototype.toStringlà một cách tốt, nhưng hiệu suất của nó là tồi tệ nhất.

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

Sử dụng typeofđể giải quyết một số vấn đề cơ bản (Chuỗi, Số, Boolean ...) và sử dụng Object.prototype.toStringđể giải quyết một vấn đề phức tạp (như Mảng, Ngày, RegExp).

và đây là giải pháp của tôi:

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));

sử dụng như là:

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

Câu trả lời được chấp nhận là chính xác, nhưng tôi muốn xác định tiện ích nhỏ này trong hầu hết các dự án tôi xây dựng.

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

Được sử dụng như thế này:

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

}

Nếu bạn đang sử dụng góc, bạn thậm chí có thể tiêm sạch:

angular.constant('types', types);

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

Giữ một tay cầm trên nguyên mẫu mà bạn mong muốn đối tượng có, sau đó so sánh với nó.

ví dụ

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

Tôi cho rằng hầu hết các giải pháp được trình bày ở đây đều bị quá kỹ sư. Có lẽ cách đơn giản nhất để kiểm tra xem giá trị có thuộc loại hay không [object Object]là kiểm tra đối với thuộc .constructortính của nó:

function isObject (a) { return a != null && a.constructor === Object; }

hoặc thậm chí ngắn hơn với các chức năng mũi tên:

const isObject = a => a != null && a.constructor === Object;

Phần a != nullnày là cần thiết bởi vì người ta có thể chuyển vào nullhoặc undefinedbạn không thể trích xuất thuộc tính của hàm tạo từ một trong hai thuộc tính này.

Nó hoạt động với bất kỳ đối tượng nào được tạo thông qua:

• người Objectxây dựng
• chữ {}

Một tính năng thú vị khác của nó là khả năng đưa ra các báo cáo chính xác cho các lớp tùy chỉnh sử dụng Symbol.toStringTag. Ví dụ:

class MimicObject {
  get [Symbol.toStringTag]() {
    return 'Object';
  }
}

Vấn đề ở đây là khi gọi Object.prototype.toStringmột thể hiện của nó, báo cáo sai [object Object]sẽ được trả về:

let fakeObj = new MimicObject();
Object.prototype.toString.call(fakeObj); // -> [object Object]

Nhưng kiểm tra đối với các nhà xây dựng cho một kết quả chính xác:

let fakeObj = new MimicObject();
fakeObj.constructor === Object; // -> false

Cách tốt nhất để tìm ra loại REAL của một đối tượng (bao gồm cả HAI đối tượng gốc hoặc tên DataType (chẳng hạn như String, Date, Number, ..etc) VÀ loại REAL của một đối tượng (thậm chí là tùy chỉnh); thuộc tính tên của hàm tạo của đối tượng:

Kiểu bản địa Ex1:

var string1 = "Test";
console.log(string1.__proto__.constructor.name);

hiển thị:

String

Ex2:

var array1 = [];
console.log(array1.__proto__.constructor.name);

hiển thị:

Array

Các lớp tùy chỉnh:

function CustomClass(){
  console.log("Custom Class Object Created!");
}
var custom1 = new CustomClass();

console.log(custom1.__proto__.constructor.name);

hiển thị:

CustomClass

Câu hỏi cũ tôi biết. Bạn không cần phải chuyển đổi nó. Xem chức năng này:

function getType( oObj )
{
    if( typeof oObj === "object" )
    {
          return ( oObj === null )?'Null':
          // Check if it is an alien object, for example created as {world:'hello'}
          ( typeof oObj.constructor !== "function" )?'Object':
          // else return object name (string)
          oObj.constructor.name;              
    }   

    // Test simple types (not constructed types)
    return ( typeof oObj === "boolean")?'Boolean':
           ( typeof oObj === "number")?'Number':
           ( typeof oObj === "string")?'String':
           ( typeof oObj === "function")?'Function':false;

}; 

Ví dụ:

function MyObject() {}; // Just for example

console.log( getType( new String( "hello ") )); // String
console.log( getType( new Function() );         // Function
console.log( getType( {} ));                    // Object
console.log( getType( [] ));                    // Array
console.log( getType( new MyObject() ));        // MyObject

var bTest = false,
    uAny,  // Is undefined
    fTest  function() {};

 // Non constructed standard types
console.log( getType( bTest ));                 // Boolean
console.log( getType( 1.00 ));                  // Number
console.log( getType( 2000 ));                  // Number
console.log( getType( 'hello' ));               // String
console.log( getType( "hello" ));               // String
console.log( getType( fTest ));                 // Function
console.log( getType( uAny ));                  // false, cannot produce
                                                // a string

Chi phí thấp và đơn giản.

Tôi kết hợp một tiện ích kiểm tra loại nhỏ lấy cảm hứng từ các câu trả lời đúng ở trên:

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;
    };

thí dụ:

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