Cartographie JSON à backbone.js collections

Il peut être écrasante quand vous essayez d'écrire le code pour le faire fonctionner pour les objets imbriqués. Mais pour faire plus simple vous permet de le casser en petits morceaux maniables.

Je pense que dans ces lignes.

Collections

 Posts
 Comments

Modèles

 Post
 Comment
 Author

---

Main collection --  Posts collection
                    (Which contains list of Post Models)

Et each model in the Posts collection aura 3 ensembles d'attributs(Peut-être pas le bon terme).

1er niveau d'attributs (état , id).

2e - Auteur de l'attribut qui peut être placée dans un autre Modèle(Authod Modèle).

3e - recueil des commentaires pour chaque Poste du Modèle.

Collection dans les Collections serait un peu déroutant ici.
Comme vous l'auriez des Modèles de la Collection(Post Model inside Posts Collection) et chaque Modèle d'imbriquer une collection de nouveau(Comments collection inside Post Model). Fondamentalement, vous serait de la Manipulation d'un Collection inside a Model.

À partir de ma compréhension, je dois remplacer les analyser.

Est cette mauvaise normes /est-il une meilleure structure JSON que je devrais utiliser?

Il est parfaitement plausible solution pour gérer le traitement de cette dans la méthode d'analyse. Lorsque vous initialisez une Collection ou d'un Modèle , d'Analyser les méthodes est appelée en premier et ensuite initialiser est appelé. Donc il est parfaitement logique pour gérer la logique à l'intérieur de la méthode d'analyse et il n'est pas du tout une mauvaise série.

Serait-il préférable de le garder aussi plat que possible?

Je ne pense pas que c'est une bonne idée de garder ce plat à un seul niveau, comme les autres données n'est pas requise sur le premier niveau, en premier lieu.

Donc la façon dont je l'approche de ce problème est d'écrire le parse méthode dans le Post Model qui traite la réponse et de joindre l'Auteur du modèle et les Observations de la collection directement sur le Modèle plutôt que comme un attribut sur le Modèle de garder les attributs de hachage propre composé de 1er niveau des données Post. J'ai l'impression sera plus propre et beaucoup plus évolutif sur le long terme.

var postsObject = [{
"_id": "50f5f5d4014e045f000002",
"author": {
"name": "Chris Crawford",
"photo": "http://example.com/photo.jpg"
},
"status": "This is a sample message.",
"comments": [{
"_id": "5160eacbe4b020ec56a46844",
"text": "This is the content of the comment.",
"author": "Bob Hope"
}, {
"_id": "5160eacbe4b020ec56a46845",
"text": "This is the content of the comment.",
"author": "Bob Hope"
}]
}, {
"_id": "50f5f5d4014e045f000003",
"author": {
"name": "Brown Robert",
"photo": "http://example.com/photo.jpg"
},
"status": "This is another sample message.",
"comments": [{
"_id": "5160eacbe4b020ec56a46846",
"text": "This is the content of the comment.",
"author": "Bob Hope"
}, {
"_id": "5160eacbe4b020ec56a46847",
"text": "This is the content of the comment.",
"author": "Bob Hope"
}]
}];
//Comment Model
var Comment = Backbone.Model.extend({
idAttribute: '_id',
defaults: {
text: "",
author: ""
}
});
//Comments collection
var Comments = Backbone.Collection.extend({
model: Comment
});
//Author Model
var Author = Backbone.Model.extend({
defaults: {
text: "",
author: ""
}
});
//Post Model
var Post = Backbone.Model.extend({
idAttribute: '_id',
defaults: {
author: "",
status: ""
},
parse: function (resp) {
//Create a Author model on the Post Model
this.author = new Author(resp.author || null, {
parse: true
});
//Delete from the response object as the data is
//alredy available on the  model
delete resp.author;
//Create a comments objecton model 
//that will hold the comments collection
this.comments = new Comments(resp.comments || null, {
parse: true
});
//Delete from the response object as the data is
//alredy available on the  model
delete resp.comments;
//return the response object 
return resp;
}
})
//Posts Collection 
var Posts = Backbone.Collection.extend({
model: Post
});
var PostsListView = Backbone.View.extend({
el: "#container",
renderPostView: function(post) {
//Create a new postView
var postView = new PostView({
model : post
});
//Append it to the container
this.$el.append(postView.el);
postView.render();
},
render: function () {
var thisView = this;
//Iterate over each post Model
_.each(this.collection.models, function (post) {
//Call the renderPostView method
thisView.renderPostView(post);
});
}
});
var PostView = Backbone.View.extend({
className: "post",
template: _.template($("#post-template").html()),
renderComments: function() {
var commentsListView = new CommentsListView({
//Comments collection on the Post Model
collection : this.model.comments,
//Pass the container to which it is to be appended
el : $('.comments', this.$el)
});
commentsListView.render();        
},
render: function () {
this.$el.empty();
// Extend the object toi contain both Post attributes
//and also the author attributes
this.$el.append(this.template(_.extend(this.model.toJSON(),
this.model.author.toJSON()
)));
//Render the comments for each Post
this.renderComments();
}
});
var CommentsListView = Backbone.View.extend({
renderCommentView: function(comment) {
//Create a new CommentView
var commentView = new CommentView({
model : comment
});
//Append it to the comments ul that is part
//of the view
this.$el.append(commentView.el);
commentView.render();
},
render: function () {
var thisView = this;
//Iterate over each Comment Model
_.each(this.collection.models, function (comment) {
//Call the renderCommentView method
thisView.renderCommentView(comment);
});
}
});
var CommentView = Backbone.View.extend({
tagName: "li",
className: "comment",
template: _.template($("#comment-template").html()),
render: function () {
this.$el.empty();
this.$el.append(this.template(this.model.toJSON()));
}
});
//Create a posts collection 
var posts = new Posts(postsObject, {parse: true});
//Pass it to the PostsListView
var postsListView = new PostsListView({
collection: posts
});
//Render the view
postsListView.render();

Vérifier Violon

OriginalL'auteur Sushanth --

Mise à jour, j'ai trouvé un Mannequin pour la colonne vertébrale qui fournit des relations entre les modèles et entre les collections. Il s'est avéré être une excellente solution pour les Collections à l'intérieur de Collections ainsi que de Profonds Imbriquée Modèle de données.

Les modèles sont pré-définis avec leurs relations à d'autres modèles via clé. Pendant l'initialisation/analyser le modèle de toutes les valeurs dans le JSON à cette clé est passée à un nouveau modèle ou d'une collection. Une relation est créée entre les deux modèles et des collections.

Cela veut dire avec l'exemple ci-dessus, nous pouvons faire quelque chose comme cela avec nos modèles:

Installation

var Author = Supermodel.Model.extend({});
var Post = Supermodel.Model.extend({});
var Comment = Supermodel.Model.extend({});
var Posts = Backbone.Collection.extend({
model: function(attrs, options) {
return Post.create(attrs, options);
}
});
var Comments = Backbone.Collection.extend({
model: function(attrs, options) {
return Comment.create(attrs, options);
}
});
Post.has().one('author', {
model: Author,
inverse: 'post'
}).many('comments', {
collection: Comments,
inverse: 'post'
});
//reverse relationships could also be setup

Utilisation

var posts = new Posts( postsObject ); //where postsObject is an array of posts
//With SuperModel, we are able to navigate the related models
posts.first().comments();
posts.first().comments().author();
posts.last().author();

Violon

Exemple de travail en JSFiddle

OriginalL'auteur Sir.Nathan Stassen