Cara paling akurat untuk memeriksa tipe objek JS?

The typeofoperator tidak benar-benar membantu kita untuk menemukan jenis nyata dari suatu objek.

Saya sudah melihat kode berikut:

Object.prototype.toString.apply(t)  

Pertanyaan:

Apakah ini cara paling akurat untuk memeriksa tipe objek?

Spesifikasi JavaScript memberikan satu cara yang tepat untuk menentukan kelas suatu objek:

Object.prototype.toString.call(t);

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

yang Object.prototype.toStringadalah cara yang baik, tapi kinerjanya adalah yang terburuk.

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

Gunakan typeofuntuk memecahkan beberapa masalah dasar (String, Angka, Boolean ...) dan gunakan Object.prototype.toStringuntuk menyelesaikan sesuatu yang kompleks (seperti Array, Date, RegExp).

dan inilah solusi saya:

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

digunakan sebagai:

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

Jawaban yang diterima benar, tetapi saya ingin mendefinisikan utilitas kecil ini di sebagian besar proyek yang saya bangun.

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]',
}

Digunakan seperti ini:

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

}

Jika Anda menggunakan sudut, Anda bahkan dapat menyuntikkannya dengan bersih:

angular.constant('types', types);

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

Pegang kendali pada prototipe yang Anda harapkan dimiliki objek, lalu bandingkan dengannya.

sebagai contoh

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

Saya berpendapat bahwa sebagian besar solusi yang ditampilkan di sini menderita karena rekayasa berlebihan. Mungkin cara paling sederhana untuk memeriksa apakah suatu nilai bertipe [object Object]adalah dengan memeriksa .constructorpropertinya:

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

atau bahkan lebih pendek dengan fungsi panah:

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

Bagian a != nullini diperlukan karena salah satu mungkin lolos nullatau undefineddan Anda tidak dapat mengekstrak properti konstruktor dari salah satu dari ini.

Ia bekerja dengan objek apa pun yang dibuat melalui:

• yang Objectkonstruktor
• literal {}

Fitur rapi lainnya, adalah kemampuannya untuk memberikan laporan yang benar untuk kelas khusus yang memanfaatkan Symbol.toStringTag. Sebagai contoh:

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

Masalahnya di sini adalah ketika memanggil Object.prototype.toStringsebuah instance, laporan palsu [object Object]akan dikembalikan:

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

Tetapi memeriksa konstruktor memberikan hasil yang benar:

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

Cara terbaik untuk mengetahui tipe NYATA dari suatu objek (termasuk KEDUA objek asli atau nama Tipe Data (seperti String, Tanggal, Angka, ..etc) DAN tipe NYATA dari suatu objek (bahkan yang khusus); adalah dengan mengambil properti nama konstruktor prototipe objek:

Jenis Asli Ex1:

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

menampilkan:

String

Ex2:

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

menampilkan:

Array

Kelas Kustom:

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

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

menampilkan:

CustomClass

Pertanyaan lama yang saya tahu. Anda tidak perlu mengubahnya. Lihat fungsi ini:

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;

}; 

Contoh:

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

Biaya rendah dan sederhana.

The solusi terbaik adalah toString(seperti yang disebutkan di atas):

function getRealObjectType(obj: {}): string {
    return Object.prototype.toString.call(obj).match(/\[\w+ (\w+)\]/)[1].toLowerCase();
}

FAIR PERINGATAN: toString menganggap NaNsuatu numbersehingga Anda harus secara manual menjaga kemudian dengan Number.isNaN(value).

Solusi lain yang disarankan, menggunakan Object.getPrototypeOf gagal dengan nulldanundefined

Saya mengumpulkan utilitas pemeriksaan tipe kecil yang terinspirasi oleh jawaban yang benar di atas:

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

contoh:

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