eindeutige Objektkennung in Javascript

Ich muss einige Experimente durchführen und eine eindeutige Kennung für Objekte in Javascript kennen, damit ich sehen kann, ob sie identisch sind. Ich möchte keine Gleichheitsoperatoren verwenden, ich brauche so etwas wie die Funktion id () in Python.

Gibt es so etwas?

Update Meine ursprüngliche Antwort unten wurde vor 6 Jahren in einem Stil geschrieben, der der Zeit und meinem Verständnis entspricht. Als Reaktion auf einige Gespräche in den Kommentaren lautet ein moderner Ansatz wie folgt:

(function() {
    if ( typeof Object.id == "undefined" ) {
        var id = 0;

        Object.id = function(o) {
            if ( typeof o.__uniqueid == "undefined" ) {
                Object.defineProperty(o, "__uniqueid", {
                    value: ++id,
                    enumerable: false,
                    // This could go either way, depending on your 
                    // interpretation of what an "id" is
                    writable: false
                });
            }

            return o.__uniqueid;
        };
    }
})();

var obj = { a: 1, b: 1 };

console.log(Object.id(obj));
console.log(Object.id([]));
console.log(Object.id({}));
console.log(Object.id(/./));
console.log(Object.id(function() {}));

for (var k in obj) {
    if (obj.hasOwnProperty(k)) {
        console.log(k);
    }
}
// Logged keys are `a` and `b`

Wenn Sie archaische Browseranforderungen haben, überprüfen Sie hier die Browserkompatibilität für Object.defineProperty.

Die ursprüngliche Antwort wird unten aufbewahrt (anstatt nur in der Änderungshistorie), da ich den Vergleich für wertvoll halte.

Sie können Folgendes ausprobieren. Dies gibt Ihnen auch die Möglichkeit, die ID eines Objekts explizit in seinem Konstruktor oder anderswo festzulegen.

(function() {
    if ( typeof Object.prototype.uniqueId == "undefined" ) {
        var id = 0;
        Object.prototype.uniqueId = function() {
            if ( typeof this.__uniqueid == "undefined" ) {
                this.__uniqueid = ++id;
            }
            return this.__uniqueid;
        };
    }
})();

var obj1 = {};
var obj2 = new Object();

console.log(obj1.uniqueId());
console.log(obj2.uniqueId());
console.log([].uniqueId());
console.log({}.uniqueId());
console.log(/./.uniqueId());
console.log((function() {}).uniqueId());

Stellen Sie sicher, dass das Mitglied, mit dem Sie die eindeutige ID intern speichern, nicht mit einem anderen automatisch erstellten Mitgliedsnamen kollidiert.

Nach meiner Beobachtung kann jede hier veröffentlichte Antwort unerwartete Nebenwirkungen haben.

In einer ES2015-kompatiblen Umgebung können Sie mithilfe von WeakMap Nebenwirkungen vermeiden .

const id = (() => {
    let currentId = 0;
    const map = new WeakMap();

    return (object) => {
        if (!map.has(object)) {
            map.set(object, ++currentId);
        }

        return map.get(object);
    };
})();

id({}); //=> 1

Die neuesten Browser bieten eine übersichtlichere Methode zum Erweitern von Object.prototype. Dieser Code macht die Eigenschaft vor der Eigenschaftsaufzählung verborgen (für p in o)

Für die Browser, die defineProperty implementieren , können Sie die uniqueId-Eigenschaft wie folgt implementieren:

(function() {
    var id_counter = 1;
    Object.defineProperty(Object.prototype, "__uniqueId", {
        writable: true
    });
    Object.defineProperty(Object.prototype, "uniqueId", {
        get: function() {
            if (this.__uniqueId == undefined)
                this.__uniqueId = id_counter++;
            return this.__uniqueId;
        }
    });
}());

Weitere Informationen finden Sie unter https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Object/defineProperty

Eigentlich müssen Sie den objectPrototyp nicht ändern und dort eine Funktion hinzufügen. Das Folgende sollte für Ihren Zweck gut funktionieren.

var __next_objid=1;
function objectId(obj) {
    if (obj==null) return null;
    if (obj.__obj_id==null) obj.__obj_id=__next_objid++;
    return obj.__obj_id;
}

Für Browser, die die Object.defineProperty()Methode implementieren , generiert der folgende Code eine Funktion, die Sie an jedes Objekt binden können, das Sie besitzen.

Dieser Ansatz hat den Vorteil, dass er nicht erweitert wird Object.prototype.

Der Code überprüft, ob das angegebene Objekt eine __objectID__Eigenschaft hat, und definiert es als versteckte (nicht aufzählbare) schreibgeschützte Eigenschaft, wenn nicht.

Es ist also sicher gegen jeden Versuch, die schreibgeschützte obj.__objectID__Eigenschaft nach ihrer Definition zu ändern oder neu zu definieren, und löst durchweg einen netten Fehler aus, anstatt stillschweigend fehlzuschlagen.

Im extremen Fall, in dem bereits __objectID__ein anderer Code für ein bestimmtes Objekt definiert worden wäre, würde dieser Wert einfach zurückgegeben.

var getObjectID = (function () {

    var id = 0;    // Private ID counter

    return function (obj) {

         if(obj.hasOwnProperty("__objectID__")) {
             return obj.__objectID__;

         } else {

             ++id;
             Object.defineProperty(obj, "__objectID__", {

                 /*
                  * Explicitly sets these two attribute values to false,
                  * although they are false by default.
                  */
                 "configurable" : false,
                 "enumerable" :   false,

                 /* 
                  * This closure guarantees that different objects
                  * will not share the same id variable.
                  */
                 "get" : (function (__objectID__) {
                     return function () { return __objectID__; };
                  })(id),

                 "set" : function () {
                     throw new Error("Sorry, but 'obj.__objectID__' is read-only!");
                 }
             });

             return obj.__objectID__;

         }
    };

})();

jQuery-Code verwendet eine eigene data()Methode als solche ID.

var id = $.data(object);

Bei der Backstage-Methode datawird ein ganz besonderes Feld in der so objectgenannten "jQuery" + now()put there next-ID eines Streams eindeutiger IDs wie erstellt

id = elem[ expando ] = ++uuid;

Ich würde vorschlagen, dass Sie dieselbe Methode verwenden, mit der John Resig offensichtlich alles über JavaScript weiß, und seine Methode basiert auf all diesem Wissen.

Typoskript-Version von @justin answer, ES6-kompatibel, mit Symbolen, um Schlüsselkollisionen zu verhindern, und der Einfachheit halber in die globale Object.id eingefügt. Kopieren Sie einfach den folgenden Code, fügen Sie ihn ein oder fügen Sie ihn in eine ObjecId.ts-Datei ein, die Sie importieren möchten.

(enableObjectID)();

declare global {
    interface ObjectConstructor {
        id: (object: any) => number;
    }
}

const uniqueId: symbol = Symbol('The unique id of an object');

export function enableObjectID(): void {
    if (typeof Object['id'] !== 'undefined') {
        return;
    }

    let id: number = 0;

    Object['id'] = (object: any) => {
        const hasUniqueId: boolean = !!object[uniqueId];
        if (!hasUniqueId) {
            object[uniqueId] = ++id;
        }

        return object[uniqueId];
    };
}

Anwendungsbeispiel:

console.log(Object.id(myObject));

Ich habe Code wie diesen verwendet, der dazu führt, dass Objekte mit eindeutigen Zeichenfolgen stringifiziert werden:

Object.prototype.__defineGetter__('__id__', function () {
    var gid = 0;
    return function(){
        var id = gid++;
        this.__proto__ = {
             __proto__: this.__proto__,
             get __id__(){ return id }
        };
        return id;
    }
}.call() );

Object.prototype.toString = function () {
    return '[Object ' + this.__id__ + ']';
};

Die __proto__Bits sollen verhindern, dass der __id__Getter im Objekt auftaucht. Dies wurde nur in Firefox getestet.

Ungeachtet der Empfehlung, Object.prototype nicht zu ändern, kann dies in einem begrenzten Umfang dennoch zum Testen sehr nützlich sein. Der Autor der akzeptierten Antwort hat sie geändert, stellt sie aber immer noch ein Object.id, was für mich keinen Sinn ergibt. Hier ist ein Ausschnitt, der den Job macht:

// Generates a unique, read-only id for an object.
// The _uid is generated for the object the first time it's accessed.

(function() {
  var id = 0;
  Object.defineProperty(Object.prototype, '_uid', {
    // The prototype getter sets up a property on the instance. Because
    // the new instance-prop masks this one, we know this will only ever
    // be called at most once for any given object.
    get: function () {
      Object.defineProperty(this, '_uid', {
        value: id++,
        writable: false,
        enumerable: false,
      });
      return this._uid;
    },
    enumerable: false,
  });
})();

function assert(p) { if (!p) throw Error('Not!'); }
var obj = {};
assert(obj._uid == 0);
assert({}._uid == 1);
assert([]._uid == 2);
assert(obj._uid == 0);  // still

Ich hatte das gleiche Problem und hier ist die Lösung, die ich mit ES6 implementiert habe

code
let id = 0; // This is a kind of global variable accessible for every instance 

class Animal {
constructor(name){
this.name = name;
this.id = id++; 
}

foo(){}
 // Executes some cool stuff
}

cat = new Animal("Catty");


console.log(cat.id) // 1 

Um zwei Objekte zu vergleichen, besteht die einfachste Möglichkeit darin, einem der Objekte zu dem Zeitpunkt, zu dem Sie die Objekte vergleichen müssen, eine eindeutige Eigenschaft hinzuzufügen, zu überprüfen, ob die Eigenschaft in dem anderen vorhanden ist, und sie dann erneut zu entfernen. Dies spart übergeordnete Prototypen.

function isSameObject(objectA, objectB) {
   unique_ref = "unique_id_" + performance.now();
   objectA[unique_ref] = true;
   isSame = objectB.hasOwnProperty(unique_ref);
   delete objectA[unique_ref];
   return isSame;
}

object1 = {something:true};
object2 = {something:true};
object3 = object1;

console.log(isSameObject(object1, object2)); //false
console.log(isSameObject(object1, object3)); //true