Wie kann ich überprüfen, dass zwei Objekte denselben Eigenschaftsnamen haben?

Ich bin mit Knoten, mocha und chai für meine Anwendung. Ich möchte testen, ob meine Ergebnisse die data-Eigenschaft ist der gleiche "Typ des Objekts" als eines meiner model-Objekte. (Sehr ähnlich zu dem von chai ' s instanceof). Ich will einfach nur, um zu bestätigen, dass die beiden Objekte haben die gleichen Sätze mit den Namen der Eigenschaften. Ich bin zwar nicht daran interessiert, die tatsächlichen Werte der Eigenschaften.

Können sagen, ich habe das Modell Mensch wie unten. Ich möchte überprüfen, ob meine Ergebnisse.alle Daten die gleichen Eigenschaften wie das erwartete Modell funktioniert. Also in diesem Fall, die Person, die die hat eine firstName und lastName.

Also, wenn results.data.lastName und results.data.firstName beide existieren, dann sollte es wieder wahr. Wenn man entweder nicht vorhanden ist, sollte es false zurück. Ein bonus wäre es, wenn die Ergebnisse.Daten hat zusätzliche Eigenschaften wie Ergebnisse.Daten.Familienname, dann würde es wieder falsch, weil Nachname nicht vorhanden in Person.

Modell

function Person(data) {
  var self = this;
  self.firstName = "unknown";
  self.lastName = "unknown";

  if (typeof data != "undefined") {
     self.firstName = data.firstName;
     self.lastName = data.lastName;
  }
}

InformationsquelleAutor der Frage dan27 | 2013-01-16

Können Sie serialisieren, einfache Daten, um zu überprüfen für die Gleichstellung:

data1 = {firstName: 'John', lastName: 'Smith'};
data2 = {firstName: 'Jane', lastName: 'Smith'};
JSON.stringify(data1) === JSON.stringify(data2)

Dies wird Ihnen etwas wie

'{firstName:"John",lastName:"Smith"}' === '{firstName:"Jane",lastName:"Smith"}'

Als Funktion...

function compare(a, b) {
  return JSON.stringify(a) === JSON.stringify(b);
}
compare(data1, data2);

BEARBEITEN

Wenn Sie chai, wie Sie sagen, überprüfen Sie heraus http://chaijs.com/api/bdd/#equal-section

EDIT 2

Wenn Sie nur wollen, um zu überprüfen, Schlüssel...

function compareKeys(a, b) {
  var aKeys = Object.keys(a).sort();
  var bKeys = Object.keys(b).sort();
  return JSON.stringify(aKeys) === JSON.stringify(bKeys);
}

sollte es tun.

InformationsquelleAutor der Antwort Casey Foster

Hier eine kurze ES6 variadic version:

function objectsHaveSameKeys(...objects):boolean {
   const allKeys = objects.reduce((keys, object) => keys.concat(Object.keys(object)), []);
   const union = new Set(allKeys);
   return objects.every(object => union.size === Object.keys(object).length);
}

Etwas performance-test (MacBook Pro 2,8 GHz Intel Core i7, Knoten 5.5.0):

var x = {};
var y = {};

for (var i = 0; i < 5000000; ++i) {
    x[i] = i;
    y[i] = i;
}

Ergebnisse:

objectsHaveSameKeys(x, y) //took  4996 milliseconds
compareKeys(x, y)               //took 14880 milliseconds
hasSameProps(x,y)               //after 10 minutes I stopped execution

InformationsquelleAutor der Antwort schirrmacher

8

Wenn Sie möchten, um zu überprüfen, ob beide Objekte die gleichen Eigenschaften haben Namen, können Sie dies tun:
```
function hasSameProps( obj1, obj2 ) {
  return Object.keys( obj1 ).every( function( prop ) {
    return obj2.hasOwnProperty( prop );
  });
}

var obj1 = { prop1: 'hello', prop2: 'world', prop3: [1,2,3,4,5] },
    obj2 = { prop1: 'hello', prop2: 'world', prop3: [1,2,3,4,5] };

console.log(hasSameProps(obj1, obj2));
```
In dieser Weise sind Sie sicher, zu überprüfen, nur durchsuchbar und zugänglich-Eigenschaften beider Objekte.

BEARBEITEN - 2013.04.26:

Vorherigen Funktion geschrieben werden kann in der folgenden Weise:
```
function hasSameProps( obj1, obj2 ) {
    var obj1Props = Object.keys( obj1 ),
        obj2Props = Object.keys( obj2 );

    if ( obj1Props.length == obj2Props.length ) {
        return obj1Props.every( function( prop ) {
          return obj2Props.indexOf( prop ) >= 0;
        });
    }

    return false;
}
```
Auf diese Weise überprüfen wir, dass beide Objekte haben die gleiche Anzahl von Eigenschaften (sonst werden die Objekte nicht die gleichen Eigenschaften haben, und wir müssen ein logisches false) dann, wenn die Zahl übereinstimmt, die wir gehen, um zu überprüfen, ob Sie die gleichen Eigenschaften haben.

Bonus

Eine mögliche Verbesserung könnte sich vorstellen, auch eine Art Prüfung zu erzwingen, die passen auf jedes Grundstück.

InformationsquelleAutor der Antwort Ragnarokkr

Wenn Sie möchten umfassende Validierung wie @speculees, hier ist eine Antwort, die die Verwendung deep-keys (Offenlegung: ich bin eine Art Verwalter dieses kleine Paket)

//obj1 should have all of obj2's properties
var deepKeys = require('deep-keys');
var _ = require('underscore');
assert(0 === _.difference(deepKeys(obj2), deepKeys(obj1)).length);

//obj1 should have exactly obj2's properties
var deepKeys = require('deep-keys');
var _ = require('lodash');
assert(0 === _.xor(deepKeys(obj2), deepKeys(obj1)).length);

oder mit chai:

var expect = require('chai').expect;
var deepKeys = require('deep-keys');
//obj1 should have all of obj2's properties
expect(deepKeys(obj1)).to.include.members(deepKeys(obj2));
//obj1 should have exactly obj2's properties
expect(deepKeys(obj1)).to.have.members(deepKeys(obj2));

InformationsquelleAutor der Antwort Philip Garrison

-1

Hier ist mein Versuch zur Validierung von JSON-Eigenschaften. Ich benutzte @casey-foster 's Ansatz, aber Hinzugefügt, die Rekursion für tiefere überprüfung. Der Dritte parameter in der Funktion ist optional und nur für die Tests verwendet.

//compare json2 to json1
function isValidJson(json1, json2, showInConsole) {

    if (!showInConsole)
        showInConsole = false;

    var aKeys = Object.keys(json1).sort();
    var bKeys = Object.keys(json2).sort();

    for (var i = 0; i < aKeys.length; i++) {

        if (showInConsole)
            console.log("---------" + JSON.stringify(aKeys[i]) + "  " + JSON.stringify(bKeys[i]))

        if (JSON.stringify(aKeys[i]) === JSON.stringify(bKeys[i])) {

            if (typeof json1[aKeys[i]] === 'object'){ //contains another obj

                if (showInConsole)
                    console.log("Entering " + JSON.stringify(aKeys[i]))

                if (!isValidJson(json1[aKeys[i]], json2[bKeys[i]], showInConsole)) 
                    return false; //if recursive validation fails

                if (showInConsole)
                    console.log("Leaving " + JSON.stringify(aKeys[i]))

            }

        } else {

            console.warn("validation failed at " + aKeys[i]);
            return false; //if attribute names dont mactch

        }

    }

    return true;

}

InformationsquelleAutor der Antwort speculees

-2

Wenn Sie underscoreJs, dann können Sie einfach verwenden _.isEqual-Funktion
und es vergleicht alle Schlüssel und Werte auf jeder Ebene der Hierarchie wie unter Beispiel.

var object = {"status":"inserted","id":"5799acb792b0525e05ba074c","data":{"workout":[{"set":[{"setNo":1,"exercises":[{"name":"hjkh","type":"Reps","category":"Cardio","set":{"reps":5}}],"isLastSet":false,"index":0,"isStart":true,"startDuration":1469689001989,"isEnd":true,"endDuration":1469689003323,"speed":"00:00:01"}],"setType":"Set","isSuper":false,"index":0}],"time":"2016-07-28T06:56:52.800Z"}};

var object1 = {"status":"inserted","id":"5799acb792b0525e05ba074c","data":{"workout":[{"set":[{"setNo":1,"exercises":[{"name":"hjkh","type":"Reps","category":"Cardio","set":{"reps":5}}],"isLastSet":false,"index":0,"isStart":true,"startDuration":1469689001989,"isEnd":true,"endDuration":1469689003323,"speed":"00:00:01"}],"setType":"Set","isSuper":false,"index":0}],"time":"2016-07-28T06:56:52.800Z"}};

console.log(_.isEqual(object, object1));//return true

Wenn alle Schlüssel und Werte für diesen Schlüssel sind die gleichen in beiden die Objekte, dann wird true zurückgegeben, sonst false zurück.

InformationsquelleAutor der Antwort Mahima Agrawal

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.