parsowania zagnieżdżone Records w Immutable.js

Question

Załóżmy, że mam następujące rekordy zdefiniowana Immutable.js:

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

Jak przekonwertować obiekt zwykły javascript w rekordzie użytkownika? Próbowałem następujących ale nie wywołuje oczekiwany wynik:

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

Mam świadomość, że możliwe jest jawnie utworzyć rekord Adres:

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

ale to nie jest rozwiązanie szukam . Wyobraź sobie, że masz Rekordy zagnieżdżone na kilku poziomach i chcesz przechowywać/pobierać dane jako JSON (np. W bazie danych). Chciałbym użyć faktycznej struktury rekordów użytkownika jako informacji o schemacie do odtworzenia zagnieżdżonych rekordów. Czy istnieje lepszy sposób na reprezentowanie zagnieżdżonych i uporządkowanych niezmiennych danych?

Answer 1

Przeznaczeniem struktury rekordu nie jest weryfikacja struktury dostarczanych danych, tylko określenie zestawu kluczy, które są dozwolone i podanie wartości domyślnych, jeśli nie są podane.

Więc za pomocą przykładu, jeśli zainicjować rekord bez podania adresu, dostaniesz właściwego dla przedmiotu Immutable.Record Adres:

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

Jeden hackish sposób, aby osiągnąć to, co chcesz byłoby napisać otoki na Immutable.fromJS metody z niestandardowym reviver funkcji:

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); 
} 

Wtedy można go używać tak:

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

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

Jednak jeśli chcesz mieć właściwe sprawdzanie struktur danych, polecam korzystania Immutable.js razem z pewnym statycznym typu sprawdzania, jak http://flowtype.org/ lub http://www.typescriptlang.org/

Answer 2

Można dokonać User podklasy i rozdzielczości Record analizować address w konstruktorze:

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) 

wyjściowa:

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