Cara yang lebih baik untuk mendapatkan jenis variabel Javascript?

Apakah ada cara yang lebih baik untuk mendapatkan jenis variabel dalam JS daripada typeof? Ini berfungsi dengan baik ketika Anda melakukannya:

> typeof 1
"number"
> typeof "hello"
"string"

Tapi itu tidak berguna ketika Anda mencoba:

> typeof [1,2]
"object"
>r = new RegExp(/./)
/./
> typeof r
"function"

Saya tahu instanceof, tapi ini mengharuskan Anda untuk mengetahui jenisnya sebelumnya.

> [1,2] instanceof Array
true
> r instanceof RegExp
true

Apakah ada cara yang lebih baik?

Angus Croll baru-baru ini menulis posting blog yang menarik tentang ini -

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

Dia melewati pro dan kontra dari berbagai metode kemudian mendefinisikan metode baru 'toType' -

var toType = function(obj) {
  return ({}).toString.call(obj).match(/\s([a-zA-Z]+)/)[1].toLowerCase()
}

Anda dapat mencoba menggunakan constructor.name.

[].constructor.name
new RegExp().constructor.name

Seperti halnya semua JavaScript, seseorang pada akhirnya akan selalu menunjukkan bahwa ini entah bagaimana jahat, jadi di sini ada tautan ke jawaban yang mencakup hal ini dengan cukup baik.

Alternatifnya adalah menggunakan Object.prototype.toString.call

Object.prototype.toString.call([])
Object.prototype.toString.call(/./)

Fungsi penangkapan tipe yang cukup bagus adalah yang digunakan oleh YUI3 :

var TYPES = {
    'undefined'        : 'undefined',
    'number'           : 'number',
    'boolean'          : 'boolean',
    'string'           : 'string',
    '[object Function]': 'function',
    '[object RegExp]'  : 'regexp',
    '[object Array]'   : 'array',
    '[object Date]'    : 'date',
    '[object Error]'   : 'error'
},
TOSTRING = Object.prototype.toString;

function type(o) {
    return TYPES[typeof o] || TYPES[TOSTRING.call(o)] || (o ? 'object' : 'null');
};

Ini menangkap banyak primitif yang disediakan oleh javascript, tetapi Anda selalu dapat menambahkan lebih banyak dengan memodifikasi TYPESobjek. Perhatikan bahwa typeof HTMLElementCollectiondi Safari akan melaporkan function, tetapi ketik (HTMLElementCollection) akan kembaliobject

Anda mungkin menemukan fungsi berikut bermanfaat:

function typeOf(obj) {
  return {}.toString.call(obj).split(' ')[1].slice(0, -1).toLowerCase();
}

Atau di ES7 (komentar jika perbaikan lebih lanjut)

function typeOf(obj) {
  const { toString } = Object.prototype;
  const stringified = obj::toString();
  const type = stringified.split(' ')[1].slice(0, -1);

  return type.toLowerCase();
}

Hasil:

typeOf(); //undefined
typeOf(null); //null
typeOf(NaN); //number
typeOf(5); //number
typeOf({}); //object
typeOf([]); //array
typeOf(''); //string
typeOf(function () {}); //function
typeOf(/a/) //regexp
typeOf(new Date()) //date
typeOf(new Error) //error
typeOf(Promise.resolve()) //promise
typeOf(function *() {}) //generatorfunction
typeOf(new WeakMap()) //weakmap
typeOf(new Map()) //map

Terima kasih @johnrees karena memberi tahu saya tentang: kesalahan, janji, fungsi generator

Kita juga dapat mengubah sedikit contoh dari ipr101

Object.prototype.toType = function() {
  return ({}).toString.call(this).match(/\s([a-zA-Z]+)/)[1].toLowerCase()
}

dan panggil sebagai

"aaa".toType(); // 'string'

fungsi satu baris:

function type(obj) {
    return Object.prototype.toString.call(obj).replace(/^\[object (.+)\]$/,"$1").toLowerCase()
}

ini memberikan hasil yang sama dengan jQuery.type()

Anda dapat menerapkan Object.prototype.toStringke objek apa pun:

var toString = Object.prototype.toString;

console.log(toString.call([]));
//-> [object Array]

console.log(toString.call(/reg/g));
//-> [object RegExp]

console.log(toString.call({}));
//-> [object Object]

Ini bekerja dengan baik di semua browser, dengan pengecualian IE - ketika memanggil ini pada variabel yang diperoleh dari jendela lain, itu hanya akan dimuntahkan [object Object].

2 ¢ saya! Sungguh, bagian dari alasan saya melemparkan ini di sini, meskipun daftar panjang jawaban, adalah untuk memberikan all in onesolusi tipe yang lebih sedikit dan mendapatkan umpan balik di masa depan tentang bagaimana mengembangkannya untuk memasukkan lebih banyak real types.

Dengan solusi berikut, seperti yang disebutkan di atas, saya menggabungkan beberapa solusi yang ditemukan di sini, serta memasukkan perbaikan untuk mengembalikan nilai jQuerypada objek yang didefinisikan pada jQuery jika tersedia . Saya juga menambahkan metode ke prototipe Object asli. Saya tahu itu sering kali tabu, karena bisa mengganggu ekstensi lain, tapi saya biarkan begitu user beware. Jika Anda tidak suka cara melakukannya, cukup salin fungsi basis di mana saja Anda suka dan ganti semua variabel thisdengan parameter argumen untuk dilewatkan (seperti argumen [0]).

;(function() {  //  Object.realType
    function realType(toLower) {
        var r = typeof this;
        try {
            if (window.hasOwnProperty('jQuery') && this.constructor && this.constructor == jQuery) r = 'jQuery';
            else r = this.constructor && this.constructor.name ? this.constructor.name : Object.prototype.toString.call(this).slice(8, -1);
        }
        catch(e) { if (this['toString']) r = this.toString().slice(8, -1); }
        return !toLower ? r : r.toLowerCase();
    }
    Object['defineProperty'] && !Object.prototype.hasOwnProperty('realType')
        ? Object.defineProperty(Object.prototype, 'realType', { value: realType }) : Object.prototype['realType'] = realType;
})();

Maka cukup gunakan dengan mudah, seperti:

obj.realType()  //  would return 'Object'
obj.realType(true)  //  would return 'object'

Catatan: Ada 1 argumen yang bisa diterima. Jika bool of true, maka pengembalian akan selalu dalam huruf kecil .

Lebih banyak contoh:

true.realType();                            //  "Boolean"
var a = 4; a.realType();                    //  "Number"
$('div:first').realType();                   // "jQuery"
document.createElement('div').realType()    //  "HTMLDivElement"

Jika Anda memiliki sesuatu untuk ditambahkan yang mungkin bermanfaat, seperti mendefinisikan kapan suatu objek dibuat dengan perpustakaan lain (Moo, Proto, Yui, Dojo, dll ...) silakan berkomentar atau edit ini dan pertahankan agar lebih akurat dan tepat. ATAU berguling ke arah yang GitHubsaya buat untuk itu dan beri tahu saya. Anda juga akan menemukan tautan cepat ke file min cdn di sana.

function getType(obj) {
    if(obj && obj.constructor && obj.constructor.name) {
        return obj.constructor.name;
    }
    return Object.prototype.toString.call(obj).slice(8, -1).toLowerCase();
}

Dalam tes pendahuluan saya, ini bekerja dengan cukup baik. Kasing pertama akan mencetak nama objek yang dibuat dengan "baru", dan kasing kedua harus menangkap yang lainnya.

Saya menggunakan (8, -1)karena saya berasumsi bahwa hasilnya akan selalu dimulai [objectdan diakhiri dengan ]tetapi saya tidak yakin itu benar dalam setiap skenario.

Saya kira solusi paling universal di sini - adalah untuk memeriksa undefineddan nullpertama, lalu panggil saja constructor.name.toLowerCase().

const getType = v =>
  v === undefined
    ? 'undefined'
    : v === null
      ? 'null'
      : v.constructor.name.toLowerCase();




console.log(getType(undefined)); // 'undefined'
console.log(getType(null)); // 'null'
console.log(getType('')); // 'string'
console.log(getType([])); // 'array'
console.log(getType({})); // 'object'
console.log(getType(new Set())); // `set'
console.log(getType(Promise.resolve())); // `promise'
console.log(getType(new Map())); // `map'

typeof kondisi digunakan untuk memeriksa tipe variabel, jika Anda memeriksa tipe variabel dalam kondisi if-else misalnya

if(typeof Varaible_Name "undefined")
{

}