Besserer Weg, um den Typ einer Javascript-Variablen zu erhalten?

Gibt es einen besseren Weg, um den Typ einer Variablen in JS zu erhalten als typeof? Es funktioniert gut, wenn Sie:

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

Aber es ist nutzlos, wenn Sie versuchen:

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

Ich weiß von instanceof, aber dazu müssen Sie den Typ vorher kennen.

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

Gibt es einen besseren Weg?

Angus Croll hat kürzlich einen interessanten Blog-Beitrag darüber geschrieben -

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

Er geht die Vor- und Nachteile der verschiedenen Methoden durch und definiert dann eine neue Methode 'toType' -

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

Sie können versuchen, mit constructor.name.

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

Wie bei allem JavaScript wird irgendwann jemand ausnahmslos darauf hinweisen, dass dies irgendwie böse ist. Hier ist also ein Link zu einer Antwort , die dies ziemlich gut abdeckt.

Eine Alternative ist zu verwenden Object.prototype.toString.call

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

Eine einigermaßen gute Typerfassungsfunktion ist die von YUI3 verwendete :

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

Dadurch werden viele der von Javascript bereitgestellten Grundelemente erfasst. Sie können jedoch jederzeit weitere hinzufügen, indem Sie das TYPESObjekt ändern . Beachten Sie, dass typeof HTMLElementCollectionin Safari ein Bericht erstellt functionwird, der Typ (HTMLElementCollection) jedoch zurückgegeben wirdobject

Die folgende Funktion kann hilfreich sein:

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

Oder in ES7 (Kommentar bei weiteren Verbesserungen)

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

  return type.toLowerCase();
}

Ergebnisse:

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

Vielen Dank an @johnrees, dass Sie mich benachrichtigt haben über: Fehler, Versprechen, Generatorfunktion

Wir können auch ein kleines Beispiel von ipr101 ändern

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

und anrufen als

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

Einzeilenfunktion:

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

Dies ergibt das gleiche Ergebnis wie jQuery.type()

Sie können Object.prototype.toStringauf jedes Objekt anwenden :

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]

Dies funktioniert in allen Browsern mit Ausnahme des IE gut. Wenn Sie dies für eine Variable aufrufen, die aus einem anderen Fenster stammt, wird es nur ausgespuckt [object Object].

Meine 2 ¢! Wirklich, ein Teil des Grundes, warum ich dies hier trotz der langen Liste von Antworten vorwerfe, besteht darin, eine etwas all in onetypischere Lösung bereitzustellen und in Zukunft Feedback zu erhalten, wie man sie erweitern kann, um mehr aufzunehmen real types.

Wie oben erwähnt, habe ich mit der folgenden Lösung einige der hier gefundenen Lösungen kombiniert und einen Fix für die Rückgabe eines Werts für ein von jQueryjQuery definiertes Objekt integriert, sofern verfügbar . Ich hänge die Methode auch an den nativen Objektprototyp an. Ich weiß, dass das oft tabu ist, da es andere solche Erweiterungen stören könnte, aber das überlasse ich user beware. Wenn Ihnen diese Vorgehensweise nicht gefällt, kopieren Sie einfach die Basisfunktion an eine beliebige Stelle und ersetzen Sie alle Variablen von thisdurch einen zu übergebenden Argumentparameter (z. B. Argumente [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;
})();

Dann einfach mit Leichtigkeit verwenden, so:

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

Hinweis: Es ist 1 Argument passabel. Wenn bool of ist true, wird die Rückgabe immer in Kleinbuchstaben angegeben .

Mehr Beispiele:

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

Wenn Sie etwas hinzufügen möchten, das möglicherweise hilfreich ist, z. B. das Definieren, wann ein Objekt mit einer anderen Bibliothek erstellt wurde (Moo, Proto, Yui, Dojo usw.), können Sie dies gerne kommentieren oder bearbeiten, damit es weitergeht genau und präzise. ODER rollen Sie zu dem, den GitHubich dafür gemacht habe, und lassen Sie es mich wissen. Dort finden Sie auch einen schnellen Link zu einer cdn min-Datei.

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

In meinen Vorversuchen funktioniert das ziemlich gut. Der erste Fall gibt den Namen eines Objekts aus, das mit "neu" erstellt wurde, und der zweite Fall sollte alles andere erfassen.

Ich verwende, (8, -1)weil ich davon ausgehe, dass das Ergebnis immer mit beginnen [objectund enden wird, ]aber ich bin nicht sicher, ob dies in jedem Szenario zutrifft.

Ich denke, die universellste Lösung hier ist - zuerst zu suchen undefinedund nulldann einfach anzurufen 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 Bedingung wird verwendet, um den Variablentyp zu überprüfen, wenn Sie den Variablentyp in der if-else-Bedingung überprüfen, z

if(typeof Varaible_Name "undefined")
{

}