Wie kann man feststellen, ob ein Objekt ein Objektliteral in Javascript ist?

Question

Gibt es einen Weg, um in Javascript zu bestimmen, ob ein Objekt mit der Objektliteral Notation oder mit einem Konstruktor erstellt wurde?

Es scheint mir, dass man einfach auf das Elternobjekt zugreift. Aber wenn das Objekt, das Sie übergeben, keine Referenz auf sein Elternobjekt hat, glaube ich nicht, dass Sie das erkennen können. Oder doch?

Answer 1

Ich hatte das gleiche Problem, also habe ich mich entschieden, diesen Weg zu gehen:

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

Answer 2

Es gibt keine Möglichkeit, den Unterschied zwischen einem aus einem Objektliteral erstellten Objekt und einem aus anderen Mitteln erstellten Objekt zu erkennen.

Es ist ein bisschen wie die Frage, ob man feststellen kann, ob eine numerische Variable konstruiert wurde, indem man den Wert '2' oder '3-1' zugewiesen hat;

Wenn Sie dies tun müssen, müssten Sie später einige spezifische Signaturen in Ihr Objektliteral einfügen, um sie zu erkennen.

Answer 3

Heutzutage gibt es eine elegantere Lösung, die genau auf Ihre Frage antwortet:

function isObject(value) {
  return value !== null && value !== undefined && Object.is(value.constructor, Object)
}

// Test stuff below //

class MyClass extends Object {
  constructor(args) {
    super(args)
  }
  say() {
    console.log('hello')
  }
}

function MyProto() {
  Object.call(this)
}
MyProto.prototype = Object.assign(Object.create(Object.prototype), {

  constructor: MyProto,

  say: function() {
    console.log('hello')
  }

});

const testsCases = {
  objectLiteral: {},
  objectFromNew: new Object(),
  null: null,
  undefined: undefined,
  number: 123,
  function: new Function(),
  array: new Array([1, 2, 3]),
  string: new String('foobar'),
  image: new Image(),
  bool: true,
  error: new Error('oups'),
  myClass: new MyClass(),
  myProto: new MyProto()
}

for (const [key, value] of Object.entries(testsCases)) {
  console.log(`${key.padEnd(15)} => ${isObject(value)}`)
}

Mit freundlichen Grüßen

Answer 4

typeof obj === 'object' && obj !== null && Object.getPrototypeOf(obj) === Object.prototype

darunter alle geben false zurück

123
null
undefined
'abc'
false
true
[]
new Number()
new Boolean()
() => {}
function () {}

eine Verbesserung gegenüber Jesses Antwort

Answer 5

11 Jahre alte Frage hier ist meine ordentliche Lösung, offen für Randfall-Vorschläge; Schritte -> suche nur nach Objekten und vergleiche dann Eigenschaften -> Objektliterale haben keine Länge, Prototyp und für den Randfall stringifizieren Eigenschaften.

versucht im Test für JSON und Object.create(Object.create({cool: "joes"})).

 "use strict"
let isObjectL = a => { 
        if (typeof a !=='object' || ['Number','String','Boolean', 'Symbol'].includes(a.constructor.name)) return false;
       let props = Object.getOwnPropertyNames(a);
        if ( !props.includes('length') && !props.includes('prototype') || !props.includes('stringify')) return true;
         };

let A={type:"Fiat", model:"500", color:"white"};
let B= new Object();
let C = { "name":"John", "age":30, "city":"New York"};
let D= '{ "name":"John", "age":30, "city":"New York"}';
let E = JSON.parse(D);
let F = new Boolean();
let G = new Number();

    console.log(isObjectL(A));

    console.log(isObjectL(B));

    console.log(isObjectL(C));

    console.log(isObjectL(D));

    console.log(isObjectL(E));

    console.log(isObjectL(JSON));

    console.log(isObjectL(F));

    console.log(isObjectL(G));

    console.log(isObjectL(
Object.create(Object.create({cool: "joes"}))));

    console.log(isObjectL());

Andere Variante, die das innere Arbeiten zeigt

isObject=function(a) { 
    let exclude = ['Number','String','Boolean', 'Symbol'];
    let types = typeof a;
    let props = Object.getOwnPropertyNames(a);
    console.log((types ==='object' && !exclude.includes(a.constructor.name) &&
    ( !props.includes('length') && !props.includes('prototype') && !props.includes('stringify'))));
    return `type: ${types} props: ${props}
    ----------------`}

    A={type:"Fiat", model:"500", color:"white"};
B= new Object();
C = { "name":"John", "age":30, "city":"New York"};
D= '{ "name":"John", "age":30, "city":"New York"}';
E = JSON.parse(D);
F = new Boolean();
G = new Number();

    console.log(isObject(A));

    console.log(isObject(B));

    console.log(isObject(C));

    console.log(isObject(D));

    console.log(isObject(E));

    console.log(isObject(JSON));

    console.log(isObject(F));

    console.log(isObject(G));

    console.log(isObject(
Object.create(Object.create({cool: "joes"}))));