Javascript değişkeni türünü almanın daha iyi bir yolu var mı?

JS'de bir değişkenin türünü almanın daha iyi bir yolu var mı typeof? Yaptığınızda iyi çalışır:

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

Ama denediğinizde işe yaramaz:

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

Biliyorum instanceof, ama bu önceden türü bilmenizi gerektirir.

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

Daha iyi bir yol var mı?

Angus Croll kısa süre önce bu konuda ilginç bir blog yazısı yazdı -

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

Çeşitli yöntemlerin artılarını ve eksilerini geçer ve daha sonra yeni bir yöntem 'toType' tanımlar -

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

Kullanmayı deneyebilirsiniz constructor.name.

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

Her şey JavaScript'te olduğu gibi, birisi sonunda her zaman bunun bir şekilde kötü olduğunu gösterecektir, bu yüzden burada bunu oldukça iyi kapsayan bir cevaba bağlantı var .

Bir alternatif kullanmaktır Object.prototype.toString.call

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

Oldukça iyi bir tür yakalama işlevi YUI3 tarafından kullanılan işlevdir :

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

Bu, javascript tarafından sağlanan ilkellerin çoğunu yakalar, ancak TYPESnesneyi değiştirerek her zaman daha fazlasını ekleyebilirsiniz . Not typeof HTMLElementCollectionSafari bildirir içinde function, ancak tipi (HTMLElementCollection) döndürecektirobject

Aşağıdaki işlevi yararlı bulabilirsiniz:

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

Veya ES7'de (daha fazla iyileştirme olursa yorum yapın)

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

  return type.toLowerCase();
}

Sonuçlar:

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

Beni haberdar ettiğiniz için teşekkürler @johnrees: hata, söz, jeneratör

Ayrıca ipr101'den küçük bir örnek değiştirebiliriz

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

ve olarak ara

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

bir satır fonksiyonu:

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

bu aynı sonucu verir jQuery.type()

Object.prototype.toStringHerhangi bir nesneye başvurabilirsiniz :

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]

Bu, IE hariç tüm tarayıcılarda iyi çalışır - bunu başka bir pencereden elde edilen bir değişkene çağırdığınızda tükürecektir [object Object].

Benim 2 ¢! Gerçekten, uzun cevaplar listesine rağmen, bunu buraya atmamın nedeninin bir kısmı, biraz daha all in onetip bir çözüm sağlamak ve gelecekte daha fazlasını içerecek şekilde nasıl genişleteceğiniz konusunda geri bildirim almaktır real types.

Aşağıdaki çözümle, yukarıda belirtildiği gibi, burada bulunan birkaç çözümü birleştirdim ve mevcutsa , jQuery tanımlı nesnenin değerini döndürmek için bir düzeltmejQuery ekledim . Yöntemi yerel Object prototipine de ekliyorum. Bu tür uzantılara müdahale edebileceğinden, bunun genellikle tabu olduğunu biliyorum, ama bunu bırakıyorum . Bunu yapmaktan hoşlanmıyorsanız, temel işlevi istediğiniz yere kopyalayın ve tüm değişkenlerini aktarmak için bir argüman parametresiyle değiştirin (argümanlar [0] gibi).user bewarethis

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

O zaman bu şekilde kolayca kullanın:

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

Not: 1 argüman iletilebilir. Eğer bool ise true, geri dönüş her zaman küçük harf olur .

Daha fazla örnek:

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

Başka bir kitaplıkla (Moo, Proto, Yui, Dojo, vb.) Bir nesnenin ne zaman oluşturulduğunu tanımlamak gibi yararlı olabilecek bir şey varsa, lütfen bunu yorumlamaktan veya düzenlemek ve daha fazla olmaya devam etmek için çekinmeyin doğru ve kesin. VEYA GitHubbunun için yaptım ve bana bildirin. Ayrıca orada bir cdn min dosyasına hızlı bir bağlantı bulacaksınız.

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

Ön testlerimde, bu oldukça iyi çalışıyor. İlk vaka, "yeni" ile oluşturulan herhangi bir nesnenin adını yazdıracak ve 2. vaka, diğer her şeyi yakalayacaktır.

Ben kullanıyorum (8, -1)ben sonucu her zaman birlikte başlayacak varsayarak olduğum için [objectve sona ]ama her senaryoda doğru emin değilim.

İçin kontrol etmektir - Burada en evrensel çözüm tahmin undefinedve nullilk sonra sadece ara 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 koşul, değişken türünü kontrol etmek için kullanılır, eğer if-else koşulunda değişken türünü kontrol ediyorsanız, ör.

if(typeof Varaible_Name "undefined")
{

}