Parsing verschachtelte Datensätze in Immutable.js

Question

Angenommen, ich habe folgende Einträge definiert mit Immutable.js:

var Address = Immutable.Record({street: '', city: '', zip: ''}); 
var User = Immutable.Record({name: '', address: new Address()}); 

Wie konvertiere ich Ebene Javascript-Objekt in den Benutzerdatensatz? Ich habe versucht, die folgenden, aber es produziert nicht die erwartete Ausgabe:

var user = new User({name: 'Foo', address: {street: 'Bar', city: 'Baz'}}); 
// => Record { "name": "Foo", "address": [object Object] } 

Ich bin mir bewusst, dass es möglich ist, ausdrücklich die Adresseintrag zu erstellen:

var user = new User({name: 'Foo', address: new Address({street: 'Bar', city: 'Baz'})}); 
// => Record { "name": "Foo", "address": Record { "street": "Bar", "city": "Baz", "zip": "" } } 

Aber das ist nicht Lösung Ich suche . Stellen Sie sich vor, Sie haben Datensätze mehrere Ebenen tief geschachtelt und möchten die Daten als JSON (z. B. in der Datenbank) speichern/abrufen. Ich möchte die tatsächliche Benutzerdatensatzstruktur als eine Schemainformation für das Neuerstellen der geschachtelten Datensätze verwenden. Oder gibt es eine bessere Möglichkeit, verschachtelte und strukturierte unveränderbare Daten darzustellen?

Answer 1

Die beabsichtigte Verwendung der Record-Struktur besteht nicht darin, die Struktur der bereitgestellten Daten zu überprüfen, sondern nur die Menge der zulässigen Schlüssel zu bestimmen und Standardwerte anzugeben, wenn sie nicht angegeben sind.

Ihr Beispiel also mit, wenn Sie den Datensatz ohne Angabe von Adresse initialisieren, werden Sie das richtige Objekt Immutable.Record für Adresse erhalten:

var user = new User({name: 'Foo'}); 
// => Record { "name": "Foo", "address": Record { "street": "", "city": "", "zip": "" } } 

One hackish Art und Weise zu erreichen, was Sie würden wollen ein Wrapper auf Immutable.fromJS Methode mit benutzerdefinierten reviver Funktion schreiben:

Immutable.Record.constructor.prototype.fromJS = function(values) { 
    var that = this; 
    var nested = Immutable.fromJS(values, function(key, value){ 
    if(that.prototype[key] && that.prototype[key].constructor.prototype instanceof Immutable.Record){return that.prototype[key].constructor.fromJS(value)} 
    else { return value } 
    }); 
    return this(nested); 
} 

Dann können Sie es wie folgt verwenden:

var user = User.fromJS({name: 'Foo', address: {street: 'Bar', city: 'Baz'}}); 

// => User { "name": "Foo", "address": Record { "street": "Bar", "city": "Baz", "zip": "" } } 

Allerdings, wenn Sie Ihre Datenstrukturen richtige haben wollen Überprüfung, würde ich mit einigen statischen Typ-Checker, wie http://flowtype.org/ oder http://www.typescriptlang.org/

Answer 2

Sie mit Immutable.js zusammen empfehlen User Unterklasse der Record Definition machen und analysieren address im Konstruktor:

import {Record} from 'immutable' 

const Address = Record({street: '', city: '', zip: ''}); 
class User extends Record({name: '', address: new Address()}) { 
    constructor({name, address} = {}) { 
    super({name, address: new Address(address)}) 
    } 
} 

const user = new User({ 
    name: 'Andy', 
    address: { 
    street: 'wherever', 
    city: 'Austin', 
    zip: 'TX' 
    } 
}) 

console.log(user) 
console.log('user.address instanceof Address:', user.address instanceof Address) 

const user2 = new User({name: 'Bob'}) 

console.log(user2) 
console.log('user2.address instanceof Address:', user2.address instanceof Address) 

Ausgang:

User { "name": "Andy", "address": Record { "street": "wherever", "city": "Austin", "zip": "TX" } } 
user.address instanceof Address: true 
User { "name": "Bob", "address": Record { "street": "", "city": "", "zip": "" } } 
user2.address instanceof Address: true