Получить название типа объекта

Вы можете использовать оператор instanceof, чтобы увидеть, является ли объект экземпляром другого, но поскольку классов нет, вы не можете получить имя класса.

Ответ Джейсона Бантинга дал мне достаточно подсказок, чтобы найти то, что мне нужно:

<<Object instance>>.constructor.name

Так, например, в следующем фрагменте кода:

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

myInstance.constructor.name вернет "MyObject".

Самое близкое, что вы можете получить, - это typeof, но оно возвращает «объект» только для любого пользовательского типа. Для тех, см. Джейсон Бантинг.

Редактировать, Джейсон по какой-то причине удалил свой пост, поэтому просто используйте свойство constructor объекта.

Вы можете использовать оператор instanceof, чтобы определить, является ли объект экземпляром определенного класса или нет. Если вы не знаете имя типа объекта, вы можете использовать его свойство конструктора. Свойство конструктора объектов - это ссылка на функцию, которая используется для их инициализации. Пример:

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

Теперь c1.constructor - это ссылка на функцию Circle(). Вы также можете использовать оператор typeof, но оператор typeof показывает ограниченную информацию. Одно из решений - использовать метод toString() глобального объекта Object. Например, если у вас есть объект, скажем myObject, вы можете использовать метод toString() глобального объекта, чтобы определить тип класса myObject. Использовать это:

Object.prototype.toString.apply(myObject);

Небольшой трюк, который я использую:

function Square(){
    this.className = "Square";
    this.corners = 4;
}

var MySquare = new Square();
console.info(MySquare.className); // "Square"

Используйте constructor.name, когда можете, и функцию регулярного выражения, когда я не могу.

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

Обновлять

Чтобы быть точным, я думаю, что OP запросил функцию, которая извлекает имя конструктора для определенного объекта. С точки зрения Javascript, object не имеет типа, но является типом из и в себе. Однако разные объекты могут иметь разные конструкторы.

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"

Примечание: в приведенном ниже примере устарел.

Сообщение блога, связанный Кристиан Скиберрас, содержит хороший пример того, как это сделать. А именно, расширяя прототип объекта:

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

Вот решение, которое я придумал, которое устраняет недостатки instanceof. Он может проверять типы объекта из кросс-окон и кросс-фреймов и не имеет проблем с примитивными типами.

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 требует двух параметров: объекта и типа. Настоящая уловка в том, как это работает, заключается в том, что он проверяет, находится ли объект из того же окна, и, если нет, получает окно объекта.

Примеры:

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

Аргумент типа также может быть функцией обратного вызова, которая возвращает конструктор. Функция обратного вызова получит один параметр, который является окном предоставленного объекта.

Примеры:

//"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

Следует иметь в виду, что IE <9 не предоставляет конструктор для всех объектов, поэтому приведенный выше тест для NodeList вернет false, а также isInstance (alert, «Функция») вернет false.

Использование Object.prototype.toString

Оказывается, как подробно описано в этом посте, вы можете использовать Object.prototype.toString - низкоуровневую и общую реализацию toString - чтобы получить тип для всех встроенных типов.

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

Можно написать короткую вспомогательную функцию, например

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

Функция Добрый() из Agave.JS вернет:

• ближайший прототип в дереве наследования
• для всегда примитивных типов, таких как 'null' и 'undefined', имя примитива.

Он работает со всеми объектами и примитивами JS, независимо от того, как они были созданы, и не вызывает никаких сюрпризов. Примеры:

Числа

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'

Струны

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

Булевы

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

Массивы

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

Объекты

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

Даты

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

Функции

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

неопределенный

kind(undefined) === 'undefined'

нулевой

kind(null) === 'null'

Я действительно искал похожую вещь и наткнулся на этот вопрос. Вот как я получаю типы: 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);
}

Если кто-то искал решение, работающее с jQuery, вот скорректированный код вики (исходный ломает 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 имеет множество isMethods, поэтому, если вы используете Lodash, возможно, такой миксин может быть полезен:

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

Он добавляет в lodash метод, называемый "identify", который работает следующим образом:

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

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

Хорошо, ребята, я несколько лет медленно создавал для этого метод улова всех, лол! Уловка заключается в следующем:

1. Есть механизм для создания классов.
2. Имейте механизм для проверки всех созданных пользователем классов, примитивов и значений, созданных / сгенерированных собственными конструкторами.
3. Имейте механизм для расширения классов, созданных пользователем, на новые, чтобы вышеуказанная функциональность пронизывала ваш код / ​​приложение / библиотеку / и т. д.

В качестве примера (или чтобы увидеть, как я справился с проблемой) посмотрите следующий код на github: https://github.com/elycruz/sjljs/blob/master/src/sjl/sjl.js и выполните поиск:

classOf =, classOfIs =, и или defineSubClass = (без обратных кавычек (`)).

Как вы можете видеть, у меня есть некоторые механизмы, чтобы заставить classOf всегда предоставлять мне имя типа классов / конструкторов независимо от того, является ли он примитивом, определяемым пользователем классом, значением, созданным с использованием собственного конструктора, Null, NaN и т. д. Для каждого значения javascript я получу его уникальное имя типа из функции classOf. Вдобавок я могу передать в sjl.classOfIs фактические конструкторы, чтобы проверить тип значения в дополнение к возможности передать его имя типа! Так например:

`` // Простите за длинные пространства имен! Я понятия не имел о воздействии, пока не использовал их некоторое время (они отстой, ха-ха)

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`!

``

Если вам интересно узнать больше о том, как я использую упомянутую выше настройку, взгляните на репо: https://github.com/elycruz/sjljs

Также книги с содержанием по теме: - «Паттерны JavaScript» Стояна Стефанова. - «Javascript - полное руководство». Дэвида Фланагана. - и многие другие .. (поиск в Интернете).

Также вы можете быстро протестировать функции, о которых я говорю здесь: - http://sjljs.elycruz.com/0.5.18/tests/for-browser/ (также путь 0.5.18 в URL-адресе содержит источники из github без node_modules и т. д.).

Удачного кодирования!

Вот реализация, основанная на принятый ответ:

/**
 * 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 <a href = "https://stackoverflow.com/a/332429/14731">https://stackoverflow.com/a/332429/14731</a>
 * @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\s+([^(]+)?\(/;
    const match = instanceToString.match(getFunctionName);
    if (match === null)
      return "AnonymousFunction";
    return "Function";
  }
  // Built-in types (e.g. 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\s+([^(]+)?\(/;
    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\s+([^(]+)?\(/;
  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.info("getTypeName(undefined): " + getTypeName(undefined));
console.info("getTypeName(null): " + getTypeName(null));
console.info("getTypeName(true): " + getTypeName(true));
console.info("getTypeName(5): " + getTypeName(5));
console.info("getTypeName(\"text\"): " + getTypeName("text"));
console.info("getTypeName(userFunction): " + getTypeName(UserFunction));
console.info("getFunctionName(userFunction): " + getFunctionName(UserFunction));
console.info("getTypeName(anonymousFunction): " + getTypeName(anonymousFunction));
console.info("getFunctionName(anonymousFunction): " + getFunctionName(anonymousFunction));
console.info("getTypeName(arrowFunction): " + getTypeName(arrowFunction));
console.info("getFunctionName(arrowFunction): " + getFunctionName(arrowFunction));
//console.info("getFunctionName(userClass): " + getFunctionName(new UserClass()));
console.info("getTypeName(userClass): " + getTypeName(new UserClass()));
console.info("getObjectClass(userClass): " + getObjectClass(new UserClass()));
//console.info("getObjectClass(userFunction): " + getObjectClass(UserFunction));
//console.info("getObjectClass(userFunction): " + getObjectClass(anonymousFunction));
//console.info("getObjectClass(arrowFunction): " + getObjectClass(arrowFunction));
console.info("getTypeName(nativeObject): " + getTypeName(navigator.mediaDevices.getUserMedia));
console.info("getFunctionName(nativeObject): " + getFunctionName(navigator.mediaDevices.getUserMedia));

Мы используем свойство конструктора только тогда, когда у нас нет другого выбора.

Скажем, у вас есть var obj;

Если вам просто нужно имя типа объекта, например «Объект», «Массив» или «Строка», вы можете использовать это:

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

Вы должны использовать somevar.constructor.name как:

    
    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.info(res1); // 'date'
    console.info(res2); // 'number'
    console.info(res3); // 'function'

Используйте class.name. Это также работает с function.name.

class TestA {}
console.info(TestA.name); // "TestA"

function TestB() {}
console.info(TestB.name); // "TestB"

Довольно простой!

• Мой любимый способ получить что-нибудь в JS

function getType(entity){
    var x = Object.prototype.toString.call(entity)
    return x.split(" ")[1].split(']')[0].toLowerCase()
}

• мой любимый метод проверки типа чего-либо в JS

function checkType(entity, type){
    return getType(entity) === type
}

Для тех из вас, кто читает это и хочет простое решение, которое достаточно хорошо работает и было протестировано:

const getTypeName = (thing) => {
  const name = typeof thing
  if (name !== 'object') return name
  if (thing instanceof Error) return 'error'
  if (!thing) return 'null'
  return ({}).toString.call(thing).match(/\s([a-zA-Z]+)/)[1].toLowerCase()
}

Чтобы понять, почему это работает, ознакомьтесь с документацией по полифилу для Array.isArray (): https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/isArray#polyfill