Obter o nome do tipo de um object

Existe um equivalente JavaScript do class.getName() do Java?

Existe um equivalente JavaScript do class.getName() do Java?

Não

Atualização do ES2015 : o nome da class Foo {} é Foo.name . O nome da class da thing , independentemente do tipo de thing , é thing.constructor.name . Os construtores internos em um ambiente ES2015 têm a propriedade de name correto; por exemplo (2).constructor.name é "Number" .


Mas aqui estão vários hacks que caem de uma forma ou de outra:

Aqui está um hack que fará o que você precisa – esteja ciente de que ele modifica o protótipo do Objeto, algo que as pessoas desaprovam (geralmente por uma boa razão)

 Object.prototype.getName = function() { var funcNameRegex = /function (.{1,})\(/; var results = (funcNameRegex).exec((this).constructor.toString()); return (results && results.length > 1) ? results[1] : ""; }; 

Agora, todos os seus objects terão a function getName() , que retornará o nome do construtor como uma string. Eu testei isso em FF3 e IE7 , não posso falar de outras implementações.

Se você não quer fazer isso, aqui está uma discussão sobre as várias formas de determinar tipos em JavaScript …


Eu recentemente atualizei isso para ser um pouco mais exaustivo, embora dificilmente seja isso. Correções bem-vindas …

Usando a propriedade do constructor

Cada object tem um valor para sua propriedade de constructor , mas dependendo de como esse object foi construído, bem como o que você deseja fazer com esse valor, ele pode ou não ser útil.

De um modo geral, você pode usar a propriedade constructor para testar o tipo do object da seguinte forma:

 var myArray = [1,2,3]; (myArray.constructor == Array); // true 

Então, isso funciona bem o suficiente para a maioria das necessidades. Dito isto…

Ressalvas

Não vai funcionar em todos os casos

Esse padrão, embora quebrado, é bastante comum:

 function Thingy() { } Thingy.prototype = { method1: function() { }, method2: function() { } }; 

Objects construídos através do new Thingy terão uma propriedade de constructor que aponta para Object , não Thingy . Então caímos logo no início; você simplesmente não pode confiar em um constructor em uma base de código que você não controla.

Herança Múltipla

Um exemplo em que não é tão óbvio é usar inheritance múltipla:

 function a() { this.foo = 1;} function b() { this.bar = 2; } b.prototype = new a(); // b inherits from a 

As coisas agora não funcionam como você espera:

 var f = new b(); // instantiate a new object with the b constructor (f.constructor == b); // false (f.constructor == a); // true 

Assim, você pode obter resultados inesperados se o object seu teste tiver um object diferente definido como seu prototype . Existem maneiras de contornar isso fora do escopo desta discussão.

Existem outros usos para a propriedade do constructor , alguns deles interessantes, outros nem tanto; por enquanto, não nos aprofundaremos nesses usos, uma vez que isso não é relevante para essa discussão.

Não funcionará cross-frame e cross-window

O uso de .constructor para verificação de tipos será interrompido quando você quiser verificar o tipo de objects provenientes de objects de window diferentes, digamos, de um iframe ou de uma janela pop-up. Isto é porque há uma versão diferente de cada constructor tipo core em cada `janela ‘, ie

 iframe.contentWindow.Array === Array // false 

Usando o instanceof operator …

O operador instanceof é uma maneira limpa de testar o tipo de object , mas tem seus próprios problemas potenciais, assim como a propriedade constructor .

 var myArray = [1,2,3]; (myArray instanceof Array); // true (myArray instanceof Object); // true 

Mas o instanceof não funciona para valores literais (porque os literais não são Objects )

 3 instanceof Number // false 'abc' instanceof String // false true instanceof Boolean // false 

Os literais precisam ser agrupados em um Object para que, por exemplo, funcionem, por exemplo

 new Number(3) instanceof Number // true 

A verificação de .constructor funciona bem para literais porque o . invocação de método envolve implicitamente os literais em seu respectivo tipo de object

 3..constructor === Number // true 'abc'.constructor === String // true true.constructor === Boolean // true 

Por que dois pontos para os 3? Porque o Javascript interpreta o primeiro ponto como um ponto decimal;)

Não funcionará cross-frame e cross-window

instanceof também não funcionará em janelas diferentes, pelo mesmo motivo que a verificação da propriedade do constructor .


Usando a propriedade name propriedade constructor

Não funciona em todos os casos

Mais uma vez, veja acima; É muito comum que o constructor seja total e completamente errado e inútil.

NÃO funciona em

Usar myObjectInstance.constructor.name fornecerá uma string contendo o nome da function constructor usada, mas está sujeita às advertências sobre a propriedade do constructor que foram mencionadas anteriormente.

Para IE9 e acima, você pode macacos no suporte :

 if (Function.prototype.name === undefined && Object.defineProperty !== undefined) { Object.defineProperty(Function.prototype, 'name', { get: function() { var funcNameRegex = /function\s+([^\s(]+)\s*\(/; var results = (funcNameRegex).exec((this).toString()); return (results && results.length > 1) ? results[1] : ""; }, set: function(value) {} }); } 

Versão atualizada do artigo em questão. Isto foi adicionado 3 meses após o artigo ter sido publicado, esta é a versão recomendada para ser usada pelo autor do artigo, Matthew Scharley. Essa mudança foi inspirada em comentários apontando possíveis armadilhas no código anterior.

 if (Function.prototype.name === undefined && Object.defineProperty !== undefined) { Object.defineProperty(Function.prototype, 'name', { get: function() { var funcNameRegex = /function\s([^(]{1,})\(/; var results = (funcNameRegex).exec((this).toString()); return (results && results.length > 1) ? results[1].trim() : ""; }, set: function(value) {} }); } 

Usando Object.prototype.toString

Acontece que, conforme este post detalha , você pode usar Object.prototype.toString – o baixo nível e implementação genérica de toString – para obter o tipo para todos os tipos internos

 Object.prototype.toString.call('abc') // [object String] Object.prototype.toString.call(/abc/) // [object RegExp] Object.prototype.toString.call([1,2,3]) // [object Array] 

Pode-se escrever uma function auxiliar curta, como

 function type(obj){ return Object.prototype.toString.call(obj).slice(8, -1); } 

para remover o lixo e obter apenas o nome do tipo

 type('abc') // String 

No entanto, ele retornará Object para todos os tipos definidos pelo usuário.


Advertências para todos …

Todos eles estão sujeitos a um problema em potencial, e essa é a questão de como o object em questão foi construído. Aqui estão várias maneiras de criar objects e os valores que os diferentes methods de verificação de tipo retornarão:

 // using a named function: function Foo() { this.a = 1; } var obj = new Foo(); (obj instanceof Object); // true (obj instanceof Foo); // true (obj.constructor == Foo); // true (obj.constructor.name == "Foo"); // true // let's add some prototypical inheritance function Bar() { this.b = 2; } Foo.prototype = new Bar(); obj = new Foo(); (obj instanceof Object); // true (obj instanceof Foo); // true (obj.constructor == Foo); // false (obj.constructor.name == "Foo"); // false // using an anonymous function: obj = new (function() { this.a = 1; })(); (obj instanceof Object); // true (obj.constructor == obj.constructor); // true (obj.constructor.name == ""); // true // using an anonymous function assigned to a variable var Foo = function() { this.a = 1; }; obj = new Foo(); (obj instanceof Object); // true (obj instanceof Foo); // true (obj.constructor == Foo); // true (obj.constructor.name == ""); // true // using object literal syntax obj = { foo : 1 }; (obj instanceof Object); // true (obj.constructor == Object); // true (obj.constructor.name == "Object"); // true 

Embora nem todas as permutações estejam presentes neste conjunto de exemplos, esperamos que haja o suficiente para fornecer uma idéia sobre como as coisas podem ficar confusas, dependendo de suas necessidades. Não assuma nada, se você não entende exatamente o que você está procurando, você pode acabar quebrando o código onde você não espera, por causa da falta de grokking nas sutilezas.

NOTA:

Discussão do typeof operador pode parecer uma omissão gritante, mas realmente não é útil para ajudar a identificar se um object é um tipo dado, uma vez que é muito simplista. Entender onde o typeof é útil é importante, mas atualmente não sinto que isso seja terrivelmente relevante para essa discussão. Minha mente está aberta a mudar embora. 🙂

A resposta de Jason Bunting me deu uma pista suficiente para encontrar o que eu precisava:

 <>.constructor.name 

Então, por exemplo, no seguinte trecho de código:

 function MyObject() {} var myInstance = new MyObject(); 

myInstance.constructor.name retornaria "MyObject" .

Um pequeno truque que eu uso:

 function Square(){ this.className = "Square"; this.corners = 4; } var MySquare = new Square(); console.log(MySquare.className); // "Square" 

Atualizar

Para ser preciso, acho que o OP pediu uma function que recupera o nome do construtor para um object específico. Em termos de Javascript, o object não tem um tipo, mas é um tipo de e em si mesmo . No entanto, objects diferentes podem ter diferentes construtores .

 Object.prototype.getConstructorName = function () { var str = (this.prototype ? this.prototype.constructor : this.constructor).toString(); var cname = str.match(/function\s(\w*)/)[1]; var aliases = ["", "anonymous", "Anonymous"]; return aliases.indexOf(cname) > -1 ? "Function" : cname; } new Array().getConstructorName(); // returns "Array" (function () {})().getConstructorName(); // returns "Function" 


Nota: o exemplo abaixo é obsoleto.

Uma postagem de blog vinculada por Christian Sciberras contém um bom exemplo de como fazer isso. Ou seja, estendendo o protótipo do object:

 if (!Object.prototype.getClassName) { Object.prototype.getClassName = function () { return Object.prototype.toString.call(this).match(/^\[object\s(.*)\]$/)[1]; } } var test = [1,2,3,4,5]; alert(test.getClassName()); // returns Array 

Usando Object.prototype.toString

Acontece que, conforme este post detalha, você pode usar Object.prototype.toString – o baixo nível e implementação genérica de toString – para obter o tipo para todos os tipos internos

 Object.prototype.toString.call('abc') // [object String] Object.prototype.toString.call(/abc/) // [object RegExp] Object.prototype.toString.call([1,2,3]) // [object Array] 

Pode-se escrever uma function auxiliar curta, como

 function type(obj){ return Object.prototype.toString.call(obj]).match(/\s\w+/)[0].trim() } return [object String] as String return [object Number] as Number return [object Object] as Object return [object Undefined] as Undefined return [object Function] as Function 

Aqui está uma solução que eu resolvi que resolve as deficiências do instanceof. Ele pode verificar tipos de um object de janelas cruzadas e cross-frames e não tem problemas com tipos primitivos.

 function getType(o) { return Object.prototype.toString.call(o).match(/^\[object\s(.*)\]$/)[1]; } function isInstance(obj, type) { var ret = false, isTypeAString = getType(type) == "String", functionConstructor, i, l, typeArray, context; if (!isTypeAString && getType(type) != "Function") { throw new TypeError("type argument must be a string or function"); } if (obj !== undefined && obj !== null && obj.constructor) { //get the Function constructor functionConstructor = obj.constructor; while (functionConstructor != functionConstructor.constructor) { functionConstructor = functionConstructor.constructor; } //get the object's window context = functionConstructor == Function ? self : functionConstructor("return window")(); //get the constructor for the type if (isTypeAString) { //type is a string so we'll build the context (window.Array or window.some.Type) for (typeArray = type.split("."), i = 0, l = typeArray.length; i < l && context; i++) { context = context[typeArray[i]]; } } else { //type is a function so execute the function passing in the object's window //the return should be a constructor context = type(context); } //check if the object is an instance of the constructor if (context) { ret = obj instanceof context; if (!ret && (type == "Number" || type == "String" || type == "Boolean")) { ret = obj.constructor == context } } } return ret; } 

isInstance requer dois parâmetros: um object e um tipo. O truque real de como funciona é que ele verifica se o object é da mesma janela e se não recebe a janela do object.

Exemplos:

 isInstance([], "Array"); //true isInstance("some string", "String"); //true isInstance(new Object(), "Object"); //true function Animal() {} function Dog() {} Dog.prototype = new Animal(); isInstance(new Dog(), "Dog"); //true isInstance(new Dog(), "Animal"); //true isInstance(new Dog(), "Object"); //true isInstance(new Animal(), "Dog"); //false 

O argumento type também pode ser uma function de retorno de chamada que retorna um construtor. A function de retorno de chamada receberá um parâmetro que é a janela do object fornecido.

Exemplos:

 //"Arguments" type check var args = (function() { return arguments; }()); isInstance(args, function(w) { return w.Function("return arguments.constructor")(); }); //true //"NodeList" type check var nl = document.getElementsByTagName("*"); isInstance(nl, function(w) { return w.document.getElementsByTagName("bs").constructor; }); //true 

Uma coisa a ter em mente é que o IE <9 não fornece o construtor em todos os objetos, portanto, o teste acima para NodeList retornaria false e também um isInstance (alert, "Function") retornaria false.

Use constructor.name quando puder e regex quando não puder.

 Function.prototype.getName = function(){ if (typeof this.name != 'undefined') return this.name; else return /function (.+)\(/.exec(this.toString())[1]; }; 

A function kind () do Agave.JS retornará:

  • o protótipo mais próximo na tree de inheritance
  • para tipos sempre primitivos como ‘null’ e ‘undefined’, o nome primitivo.

Ele funciona em todos os objects JS e primitivos, independentemente de como eles foram criados , e não tem nenhuma surpresa. Exemplos:

Números

 kind(37) === 'Number' kind(3.14) === 'Number' kind(Math.LN2) === 'Number' kind(Infinity) === 'Number' kind(Number(1)) === 'Number' kind(new Number(1)) === 'Number' 

NaN

 kind(NaN) === 'NaN' 

Cordas

 kind('') === 'String' kind('bla') === 'String' kind(String("abc")) === 'String' kind(new String("abc")) === 'String' 

Booleanos

 kind(true) === 'Boolean' kind(false) === 'Boolean' kind(new Boolean(true)) === 'Boolean' 

Matrizes

 kind([1, 2, 4]) === 'Array' kind(new Array(1, 2, 3)) === 'Array' 

Objetos

 kind({a:1}) === 'Object' kind(new Object()) === 'Object' 

datas

 kind(new Date()) === 'Date' 

Funções

 kind(function(){}) === 'Function' kind(new Function("console.log(arguments)")) === 'Function' kind(Math.sin) === 'Function' 

Indefinido

 kind(undefined) === 'undefined' 

nulo

 kind(null) === 'null' 

Você pode usar o operador instanceof para ver se um object é uma instância de outro, mas como não há classs, não é possível obter um nome de class.

Eu estava realmente procurando por algo semelhante e me deparei com essa questão. Aqui está como eu obtenho tipos: jsfiddle

 var TypeOf = function ( thing ) { var typeOfThing = typeof thing; if ( 'object' === typeOfThing ) { typeOfThing = Object.prototype.toString.call( thing ); if ( '[object Object]' === typeOfThing ) { if ( thing.constructor.name ) { return thing.constructor.name; } else if ( '[' === thing.constructor.toString().charAt(0) ) { typeOfThing = typeOfThing.substring( 8,typeOfThing.length - 1 ); } else { typeOfThing = thing.constructor.toString().match( /function\s*(\w+)/ ); if ( typeOfThing ) { return typeOfThing[1]; } else { return 'Function'; } } } else { typeOfThing = typeOfThing.substring( 8,typeOfThing.length - 1 ); } } return typeOfThing.charAt(0).toUpperCase() + typeOfThing.slice(1); } 

Você pode usar o operador “instanceof” para determinar se um object é uma instância de uma determinada class ou não. Se você não souber o nome do tipo de um object, poderá usar sua propriedade de construtor. A propriedade constructor de objects é uma referência à function usada para inicializá-los. Exemplo:

 function Circle (x,y,radius) { this._x = x; this._y = y; this._radius = raduius; } var c1 = new Circle(10,20,5); 

Agora c1.constructor é uma referência à function Circle() . Você também pode usar o operador typeof , mas o operador typeof mostra informações limitadas. Uma solução é usar o toString() do object global Object. Por exemplo, se você tiver um object, digamos myObject, poderá usar o toString() do object global para determinar o tipo da class myObject. Usa isto:

 Object.prototype.toString.apply(myObject); 

O mais próximo que você pode obter é typeof , mas só retorna “object” para qualquer tipo de tipo personalizado. Para aqueles, veja Jason Bunting .

Editar, Jason’s deletou sua postagem por algum motivo, então apenas use a propriedade constructor de Object.

Aqui está uma implementação baseada na resposta aceita :

 /** * Returns the name of an object's type. * * If the input is undefined, returns "Undefined". * If the input is null, returns "Null". * If the input is a boolean, returns "Boolean". * If the input is a number, returns "Number". * If the input is a string, returns "String". * If the input is a named function or a class constructor, returns "Function". * If the input is an anonymous function, returns "AnonymousFunction". * If the input is an arrow function, returns "ArrowFunction". * If the input is a class instance, returns "Object". * * @param {Object} object an object * @return {String} the name of the object's class * @see https://stackoverflow.com/a/332429/14731 * @see getFunctionName * @see getObjectClass */ function getTypeName(object) { const objectToString = Object.prototype.toString.call(object).slice(8, -1); if (objectToString === "Function") { const instanceToString = object.toString(); if (instanceToString.indexOf(" => ") != -1) return "ArrowFunction"; const getFunctionName = /^function ([^(]+)\(/; const match = instanceToString.match(getFunctionName); if (match === null) return "AnonymousFunction"; return "Function"; } // Built-in types (eg String) or class instances return objectToString; }; /** * Returns the name of a function. * * If the input is an anonymous function, returns "". * If the input is an arrow function, returns "=>". * * @param {Function} fn a function * @return {String} the name of the function * @throws {TypeError} if {@code fn} is not a function * @see getTypeName */ function getFunctionName(fn) { try { const instanceToString = fn.toString(); if (instanceToString.indexOf(" => ") != -1) return "=>"; const getFunctionName = /^function ([^(]+)\(/; const match = instanceToString.match(getFunctionName); if (match === null) { const objectToString = Object.prototype.toString.call(fn).slice(8, -1); if (objectToString === "Function") return ""; throw TypeError("object must be a Function.\n" + "Actual: " + getTypeName(fn)); } return match[1]; } catch (e) { throw TypeError("object must be a Function.\n" + "Actual: " + getTypeName(fn)); } }; /** * @param {Object} object an object * @return {String} the name of the object's class * @throws {TypeError} if {@code object} is not an Object * @see getTypeName */ function getObjectClass(object) { const getFunctionName = /^function ([^(]+)\(/; const result = object.constructor.toString().match(getFunctionName)[1]; if (result === "Function") { throw TypeError("object must be an Object.\n" + "Actual: " + getTypeName(object)); } return result; }; function UserFunction() { } function UserClass() { } let anonymousFunction = function() { }; let arrowFunction = i => i + 1; console.log("getTypeName(undefined): " + getTypeName(undefined)); console.log("getTypeName(null): " + getTypeName(null)); console.log("getTypeName(true): " + getTypeName(true)); console.log("getTypeName(5): " + getTypeName(5)); console.log("getTypeName(\"text\"): " + getTypeName("text")); console.log("getTypeName(userFunction): " + getTypeName(UserFunction)); console.log("getFunctionName(userFunction): " + getFunctionName(UserFunction)); console.log("getTypeName(anonymousFunction): " + getTypeName(anonymousFunction)); console.log("getFunctionName(anonymousFunction): " + getFunctionName(anonymousFunction)); console.log("getTypeName(arrowFunction): " + getTypeName(arrowFunction)); console.log("getFunctionName(arrowFunction): " + getFunctionName(arrowFunction)); //console.log("getFunctionName(userClass): " + getFunctionName(new UserClass())); console.log("getTypeName(userClass): " + getTypeName(new UserClass())); console.log("getObjectClass(userClass): " + getObjectClass(new UserClass())); //console.log("getObjectClass(userFunction): " + getObjectClass(UserFunction)); //console.log("getObjectClass(userFunction): " + getObjectClass(anonymousFunction)); //console.log("getObjectClass(arrowFunction): " + getObjectClass(arrowFunction)); console.log("getTypeName(nativeObject): " + getTypeName(navigator.mediaDevices.getUserMedia)); console.log("getFunctionName(nativeObject): " + getFunctionName(navigator.mediaDevices.getUserMedia)); 

Você deve usar o somevar.constructor.name como um:

 const getVariableType = a => a.constructor.name.toLowerCase(); const d = new Date(); const res1 = getVariableType(d); // 'date' const num = 5; const res2 = getVariableType(num); // 'number' const fn = () => {}; const res3 = getVariableType(fn); // 'function' console.log(res1); // 'date' console.log(res2); // 'number' console.log(res3); // 'function' 

Se alguém estava procurando uma solução que estivesse trabalhando com o jQuery, aqui está o código wiki ajustado (o original quebra o jQuery).

 Object.defineProperty(Object.prototype, "getClassName", { value: function() { var funcNameRegex = /function (.{1,})\(/; var results = (funcNameRegex).exec((this).constructor.toString()); return (results && results.length > 1) ? results[1] : ""; } }); 

Lodash tem muitos isMethods então se você estiver usando Lodash talvez um mixin como esse pode ser útil:

  // Mixin for identifying a Javascript Object _.mixin({ 'identify' : function(object) { var output; var isMethods = ['isArguments', 'isArray', 'isArguments', 'isBoolean', 'isDate', 'isArguments', 'isElement', 'isError', 'isFunction', 'isNaN', 'isNull', 'isNumber', 'isPlainObject', 'isRegExp', 'isString', 'isTypedArray', 'isUndefined', 'isEmpty', 'isObject'] this.each(isMethods, function (method) { if (this[method](object)) { output = method; return false; } }.bind(this)); return output; } }); 

Adiciona um método ao lodash chamado “identificar”, que funciona da seguinte forma:

 console.log(_.identify('hello friend')); // isString 

Plunker: http://plnkr.co/edit/Zdr0KDtQt76Ul3KTEDSN

Ok, pessoal eu venho lentamente construindo um método para todos os anos, lol! O truque é:

  1. Tem um mecanismo para criar classs.
  2. Ter um mecanismo para verificar todas as classs criadas pelo usuário, primitivos e valores criados / gerados por construtores nativos.
  3. Ter um mecanismo para estender as classs criadas pelo usuário para novas classs, de modo que a funcionalidade acima permeie através do seu código / aplicativo / biblioteca / etc.

Para um exemplo (ou para ver como lidei com o problema), veja o seguinte código no github: https://github.com/elycruz/sjljs/blob/master/src/sjl/sjl.js e procure por:

classOf = , classOfIs = , e ou defineSubClass = (sem os backticks (`)).

Como você pode ver, eu tenho alguns mecanismos para forçar classOf sempre me dar o nome do tipo classs / construtores, independentemente de ser uma primitiva, uma class definida pelo usuário, um valor criado usando um construtor nativo, Null, NaN, etc. Para cada valor de javascript, recebo seu nome de tipo exclusivo da function classOf . Além disso, posso passar em construtores reais para sjl.classOfIs para verificar o tipo de um valor, além de ser capaz de passar seu nome de tipo também! Então, por exemplo:

“ `// Por favor, perdoe namespaces longos! Eu não tinha ideia do impacto até depois de usá-los por um tempo (eles chupam haha)

 var SomeCustomClass = sjl.package.stdlib.Extendable.extend({ constructor: function SomeCustomClass () {}, // ... }), HelloIterator = sjl.ns.stdlib.Iterator.extend( function HelloIterator () {}, { /* ... methods here ... */ }, { /* ... static props/methods here ... */ } ), helloIt = new HelloIterator(); sjl.classOfIs(new SomeCustomClass(), SomeCustomClass) === true; // `true` sjl.classOfIs(helloIt, HelloIterator) === true; // `true` var someString = 'helloworld'; sjl.classOfIs(someString, String) === true; // `true` sjl.classOfIs(99, Number) === true; // true sjl.classOf(NaN) === 'NaN'; // true sjl.classOf(new Map()) === 'Map'; sjl.classOf(new Set()) === 'Set'; sjl.classOfIs([1, 2, 4], Array) === true; // `true` // etc.. // Also optionally the type you want to check against could be the type's name sjl.classOfIs(['a', 'b', 'c'], 'Array') === true; // `true`! sjl.classOfIs(helloIt, 'HelloIterator') === true; // `true`! 

“ `

Se você está interessado em ler mais sobre como eu uso a configuração mencionada acima, dê uma olhada no repository: https://github.com/elycruz/sjljs

Também livros com conteúdo sobre o assunto: – “JavaScript Patterns” por Stoyan Stefanov. – “Javascript – o guia definitivo”. por David Flanagan. – e muitos outros .. (pesquisa le` web).

Além disso, você pode testar rapidamente os resources que estou falando aqui: – http://sjljs.elycruz.com/0.5.18/tests/for-browser/ (também o caminho 0.5.18 no URL tem as fonts do github lá menos os node_modules e tal).

Codificação Feliz!

Digamos que você tenha var obj;

Se você quer apenas o nome do tipo de obj, como “Object”, “Array” ou “String”, você pode usar isto:

 Object.prototype.toString.call(obj).split(' ')[1].replace(']', '');