Как определить, является ли объект литералом объекта в Javascript?

Есть ли способ определить в Javascript, если объект был создан с использованием object-literal или с использованием метода конструктора?

Мне кажется, что вы просто обращаетесь к этому родительскому объекту, но если объект, в котором вы проходите, не имеет ссылки на него родителем, я не думаю, что вы можете это сказать, не так ли?

Ответы

Ответ 1

Я только что наткнулся на этот вопрос и поток во время сладкого хакерства, в котором участвовал поиск grail для оценки того, был ли объект создан с помощью {} или нового объекта Object() (я все еще не понял, что вышло.)

В любом случае, я был удивлен, чтобы найти сходство между функцией isObjectLiteral(), размещенной здесь, и моей собственной функцией isObjLiteral(), которую я написал для проекта Pollen.JS. Я считаю, что это решение было опубликовано до моего опроса Pollen.JS, поэтому - шляпы от вас! Верхняя сторона моей - это длина... меньше половины (когда включена ваша настройка), но обе дают одинаковые результаты.

Посмотрите:

function isObjLiteral(_obj) {
  var _test  = _obj;
  return (  typeof _obj !== 'object' || _obj === null ?
              false :  
              (
                (function () {
                  while (!false) {
                    if (  Object.getPrototypeOf( _test = Object.getPrototypeOf(_test)  ) === null) {
                      break;
                    }      
                  }
                  return Object.getPrototypeOf(_obj) === _test;
                })()
              )
          );
}

Кроме того, некоторые тестовые материалы:

var _cases= {
    _objLit : {}, 
    _objNew : new Object(),
    _function : new Function(),
    _array : new Array(), 
    _string : new String(),
    _image : new Image(),
    _bool: true
};

console.dir(_cases);

for ( var _test in _cases ) {
  console.group(_test);
  console.dir( {
    type:    typeof _cases[_test], 
    string:  _cases[_test].toString(), 
    result:  isObjLiteral(_cases[_test])  
  });    
  console.groupEnd();
}

Или на jsbin.com...

http://jsbin.com/iwuwa

Обязательно откройте firebug, когда вы туда доберетесь - отладка документа будет для любителей IE.

Ответ 2

Изменить: Я интерпретирую "литерал объекта" как любой, созданный с использованием объектного литерала или конструктора Object. Это то, что, вероятно, имел в виду Джон Ресиг.

У меня есть функция, которая будет работать, даже если .constructor была испорчена или если объект был создан в другом фрейме. Обратите внимание, что Object.prototype.toString.call(obj) === "[object Object]" (как полагают некоторые из них) не решит эту проблему.

function isObjectLiteral(obj) {
    if (typeof obj !== "object" || obj === null)
        return false;

    var hasOwnProp = Object.prototype.hasOwnProperty,
    ObjProto = obj;

    // get obj Object constructor prototype
    while (Object.getPrototypeOf(ObjProto = Object.getPrototypeOf(ObjProto)) !== null);

    if (!Object.getPrototypeOf.isNative) // workaround if non-native Object.getPrototypeOf
        for (var prop in obj)
            if (!hasOwnProp.call(obj, prop) && !hasOwnProp.call(ObjProto, prop)) // inherited elsewhere
                return false;

    return Object.getPrototypeOf(obj) === ObjProto;
};


if (!Object.getPrototypeOf) {
    if (typeof ({}).__proto__ === "object") {
        Object.getPrototypeOf = function (obj) {
            return obj.__proto__;
        };
        Object.getPrototypeOf.isNative = true;
    } else {
        Object.getPrototypeOf = function (obj) {
            var constructor = obj.constructor,
            oldConstructor;
            if (Object.prototype.hasOwnProperty.call(obj, "constructor")) {
                oldConstructor = constructor;
                if (!(delete obj.constructor)) // reset constructor
                    return null; // can't delete obj.constructor, return null
                constructor = obj.constructor; // get real constructor
                obj.constructor = oldConstructor; // restore constructor
            }
            return constructor ? constructor.prototype : null; // needed for IE
        };
        Object.getPrototypeOf.isNative = false;
    }
} else Object.getPrototypeOf.isNative = true;

Вот HTML для тестового файла:

<!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8"/>
    <!-- Online here: http://code.eligrey.com/testcases/all/isObjectLiteral.html -->
    <title>isObjectLiteral</title>
    <style type="text/css">
    li { background: green; } li.FAIL { background: red; }
    iframe { display: none; }
    </style>
</head>
<body>
<ul id="results"></ul>
<script type="text/javascript">
function isObjectLiteral(obj) {
    if (typeof obj !== "object" || obj === null)
        return false;

    var hasOwnProp = Object.prototype.hasOwnProperty,
    ObjProto = obj;

    // get obj Object constructor prototype
    while (Object.getPrototypeOf(ObjProto = Object.getPrototypeOf(ObjProto)) !== null);

    if (!Object.getPrototypeOf.isNative) // workaround if non-native Object.getPrototypeOf
        for (var prop in obj)
            if (!hasOwnProp.call(obj, prop) && !hasOwnProp.call(ObjProto, prop)) // inherited elsewhere
                return false;

    return Object.getPrototypeOf(obj) === ObjProto;
};


if (!Object.getPrototypeOf) {
    if (typeof ({}).__proto__ === "object") {
        Object.getPrototypeOf = function (obj) {
            return obj.__proto__;
        };
        Object.getPrototypeOf.isNative = true;
    } else {
        Object.getPrototypeOf = function (obj) {
            var constructor = obj.constructor,
            oldConstructor;
            if (Object.prototype.hasOwnProperty.call(obj, "constructor")) {
                oldConstructor = constructor;
                if (!(delete obj.constructor)) // reset constructor
                    return null; // can't delete obj.constructor, return null
                constructor = obj.constructor; // get real constructor
                obj.constructor = oldConstructor; // restore constructor
            }
            return constructor ? constructor.prototype : null; // needed for IE
        };
        Object.getPrototypeOf.isNative = false;
    }
} else Object.getPrototypeOf.isNative = true;

// Function serialization is not permitted
// Does not work across all browsers
Function.prototype.toString = function(){};

// The use case that we want to match
log("{}", {}, true);

// Instantiated objects shouldn't be matched
log("new Date", new Date, false);

var fn = function(){};

// Makes the function a little more realistic
// (and harder to detect, incidentally)
fn.prototype = {someMethod: function(){}};

// Functions shouldn't be matched
log("fn", fn, false);

// Again, instantiated objects shouldn't be matched
log("new fn", new fn, false);

var fn2 = function(){};

log("new fn2", new fn2, false);

var fn3 = function(){};

fn3.prototype = {}; // impossible to detect (?) without native Object.getPrototypeOf

log("new fn3 (only passes with native Object.getPrototypeOf)", new fn3, false);

log("null", null, false);

log("undefined", undefined, false);


/* Note:
 * The restriction against instantiated functions is
 * due to the fact that this method will be used for
 * deep-cloning an object. Instantiated objects will
 * just have their reference copied over, whereas
 * plain objects will need to be completely cloned.
 */

var iframe = document.createElement("iframe");
document.body.appendChild(iframe);

var doc = iframe.contentDocument || iframe.contentWindow.document;
doc.open();
doc.write("<body onload='window.top.iframeDone(Object);'>");
doc.close();

function iframeDone(otherObject){
    // Objects from other windows should be matched
    log("new otherObject", new otherObject, true);
}

function log(msg, a, b) {
  var pass = isObjectLiteral(a) === b ? "PASS" : "FAIL";

  document.getElementById("results").innerHTML +=
    "<li class='" + pass + "'>" + msg + "</li>";
}


</script>
</body>
</html>

Ответ 3

Похоже, вы ищете это:

function Foo() {}

var a = {};
var b = new Foo();

console.log(a.constructor == Object); // true
console.log(b.constructor == Object); // false

Свойство конструктора для объекта является указателем на функцию, которая используется для его построения. В приведенном выше примере b.constructor == Foo. Если объект был создан с использованием фигурных скобок (литеральная запись массива) или с помощью new Object(), то его свойство конструктора будет == Object.

Обновление: crescentfresh указал, что $(document).constructor == Object вместо того, чтобы быть равным конструктору jQuery, поэтому я немного поработал. Похоже, что, используя объектный литерал как прототип объекта, вы оказываете свойство конструктора почти бесполезным:

function Foo() {}
var obj = new Foo();
obj.constructor == Object; // false

function Foo() {}
Foo.prototype = { objectLiteral: true };
var obj = new Foo();
obj.constructor == Object; // true

В другом ответе здесь есть очень хорошее объяснение и более активное объяснение .

Я думаю, что другие ответы правильные, и на самом деле нет способа обнаружить это.

Ответ 4

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

Это немного похоже на вопрос, можете ли вы определить, была ли построена числовая переменная, назначив значение "2" или "3-1";

Если вам нужно это сделать, вам нужно будет поместить некоторую конкретную подпись в ваш литерал объекта для обнаружения позже.

Ответ 5

Литеральный объект - это обозначение, которое вы используете для определения объекта, который в javascript всегда находится в форме пары имя-значение, окруженной фигурными скобками. Как только это было выполнено, невозможно определить, был ли объект создан с помощью этих обозначений или нет (на самом деле, я думаю, это может быть чрезмерное упрощение, но в основном правильное). У вас просто есть объект. Это одна из замечательных особенностей js в том, что есть много коротких сокращений, чтобы делать то, что может быть намного длиннее, чтобы писать. Короче говоря, буквальная нотация заменяет необходимость писать:

var myobject = new Object();

Ответ 6

У меня была такая же проблема, поэтому я решил пойти так:

function isPlainObject(val) {
  return val ? val.constructor === {}.constructor : false;
}
// Examples:
isPlainObject({}); // true
isPlainObject([]); // false
isPlainObject(new Human("Erik", 25)); // false
isPlainObject(new Date); // false
isPlainObject(new RegExp); // false
//and so on...

Ответ 7

Что вы хотите:

Object.getPrototypeOf(obj) === Object.prototype

Это проверяет, что объект является простым объектом, созданным с помощью new Object() или {...}, а не подкласса Object.