ݺߣ

ݺߣShare a Scribd company logo
Backbone.js
Tomado de Stack Overflow y Tuts 
 
Backbone.js gives structure to web applications by providing models with key­value binding and 
custom events, collections with a rich API of enumerable functions, views with declarative 
event handling, and connects it all to your existing API over a RESTful JSON interface. 
 
Backbone is a super light­weight library that lets you create easy to maintain front ends. It's 
backend agnostic and works well with any of the modern JavaScript libraries you're already 
using. 
Key-value binding and custom events
When a model's contents or state is changed, other objects that have subscribed to the model 
are notified so they can proceed accordingly. Here, the views listen to changes in the model, and 
update themselves accordingly instead of the model having to deal with the views manually. 
Rich API of enumerable functions
Backbone ships with a number of very useful functions for handling and working with your data. 
Unlike other implementation, arrays in JavaScript are pretty neutered, which really is a 
hampering problem when you have to deal with data. 
Views with declarative event handling
Your days of writing spaghetti bind calls are over. You can programmatically declare which 
callback needs to be associated with specific elements. 
RESTful JSON interface
Even though the default method is to use a standard AJAX call when you want to talk to the 
server, you can easily switch it out to anything you need. A number of adapters have sprung up 
covering most of the favorites including Websockets and local storage. 
 
Backbone provides a clean way to surgically separate your data from your presentation. The 
model that works with the data is only concerned with synchronizing with a server while the view's 
primary duty is listening to changes to the subscribed model and rendering the HTML. 
Does it replace jQuery?
No. They're pretty complementary in their scopes with almost no overlaps in functionality. 
Backbone handles all the higher level abstractions, while jQuery ­ or similar libraries ­ work with 
the DOM, normalize events and so on. 
Documento creado por Francisco Quintero 
Their scopes and use cases are pretty different and because you know one doesn't mean that 
you shouldn't learn the other. As a JavaScript developer, you should know how to effectively work 
with both. 
Where should I be using this?
Backbone is ideally suited for creating front end heavy, data driven applications. Think the GMail 
interface, new Twitter or any other revelation of the past few years. It makes creating complex 
apps easier. 
 
While you can shoehorn it for more mainstream web pages, this is really a library that is tailored 
for web apps. 
I can still use other libraries on the page, right?
Absolutely. Not only your typical DOM accessing, AJAX wrapping kind, but also the rest of your 
templating and script loading kind. It's very, very loosely coupled, which means you can use 
almost all of your tools in conjunction with Backbone. 
 
Answers from Stack Overflow
1.
 
Backbone.js is basically an uber­light framework that allows you to structure your Javascript 
code in an MVC(Model, View, Controller) fashion where... 
 
Model is part of your code that retrieves and populates the data, 
 
View is the HTML representation of this model(views change as models change, etc) 
and Controller that in this case allows you to save the state of your javascript application via a 
hashbang url, for example: http://twitter.com/#search?q=backbone.js 
 
Some pros that I discovered with Backbone: 
● No more Javascript Spaghetti: code is organized and broken down into semantically 
meaningful .js files which are later combined using JAMMIT 
● No more jQuery.data(bla, bla): no need to store data in DOM, store data in models 
instead 
● event binding just works 
● extremely useful underscore utility library 
● backbone.js code is well documented and a great read. opened my eyes to a number of 
JS code techniques. 
Cons: 
Documento creado por Francisco Quintero 
● Took me a while to wrap my head around it and figure out how to apply it to my code, but 
im a Javascript Newb. 
 
2.
 
If you're going to build complex user interfaces in the browser then you will probably find yourself 
eventually inventing most of the pieces that make up frameworks like Backbone.js and 
Sammy.js. So the question is, are you building something complicated enough in the browser to 
merit using it (so you don't end up inventing the same thing yourself). 
 
If what you plan to build is something where the UI regularly changes how it displays but does 
not go to the server to get entire new pages then you probably need something like 
Backbone.js or Sammy.js. The cardinal example of something like that is Google's GMail. If 
you've ever used it you'll notice that it downloads one big chunk of HTML, CSS, and JavaScript 
when you first log in and then after that everything happens in the background. It can move 
between reading an email and processing the inbox and searching and back through all of them 
again without ever asking for a whole new page to be rendered. 
 
It's that kind of app that these frameworks excel at making easier to develop. Without them you'll 
either end up glomming together a diverse set of individual libraries to get parts of the 
functionality (for example, jQuery BBQ for history management, Events.js for events, etc.) or 
you'll end up building everything yourself and having to maintain and test everything yourself as 
well. Contrast that with something like Backbone.js that has thousands of people watching it on 
Github, hundreds of forks where people may be working on it, and hundreds of questions already 
asked and answered here on Stack Overflow. 
 
But none of it is of any importance if what you plan to build is not complicated enough to be worth 
the learning curve associated with a framework. If you're still building PHP, Java, or something 
else sites where the back end server is still doing all the heavy lifting of building the web pages 
upon request by the user and JavaScript/jQuery is just icing upon that process, you aren't going 
to need or are not yet ready for Backbone.js. 
Core
 
Backbone's core consists of four major classes: 
● Model 
● Collection 
● View 
● Controller 
 
Documento creado por Francisco Quintero 
Model
Models can mean different things in different implementations of MVC. In Backbone, a model 
represents a singular entity ­­ a record in a database if you will. But there are no hard and fast 
rules here. 
 
Models are the heart of any JavaScript application, containing the interactive data as well as a 
large part of the logic surrounding it: conversions, validations, computed properties, and access 
control. 
 
Example
 
var Game = Backbone.Model.extend({}); 
 
var Game = Backbone.Model.extend({ 
        initialize: function(){ 
            alert("Oh hey! "); 
        }, 
          defaults: { 
            name: 'Default title', 
            releaseDate: 2011, 
        } 
    }); 
 
 
Collection
 
Collections in Backbone are essentially just a collection of models. Going with our database 
analogy from earlier, collections are the results of a query where the results consists of a 
number of records [models]. You can define a collection like so: 
 
var GamesCollection = Backbone.Collection.extend({ 
  model : Game, 
  } 
}); 
 
View
 
A view handles two duties fundamentally: 
● Listen to events thrown by the DOM and models/collections. 
● Represent the application's state and data model to the user. 
Documento creado por Francisco Quintero 
GameView= Backbone.View.extend({ 
  tagName : "div", 
  className: "game", 
  render : function() { 
    // code for rendering the HTML for the view 
  } 
}); 
 
 
Controller
Controllers in Backbone essentially let you create bookmarkable, stateful apps by using 
hashbangs. 
 
var Hashbangs = Backbone.Controller.extend({ 
  routes: { 
    "!/":  "root", 
    "!/games":  "games", 
  }, 
  root: function() { 
    // Prep the home page and render stuff 
  }, 
  
  games: function() { 
    // Re­render views to show a collection of books 
  }, 
  }); 
 
 
 
Enlaces
 
Web oficial de Backbone.js: http://backbonejs.org/ 
Tutorial en tuts: http://code.tutsplus.com/tutorials/getting­started­with­backbone­js­­net­19751 
backbone and rails: 
http://www.jamesyu.org/2011/01/27/cloudedit­a­backbone­js­tutorial­by­example/ 
backbone and rails part 2: 
http://www.jamesyu.org/2011/02/09/backbone.js­tutorial­with­rails­part­2/ 
Documento creado por Francisco Quintero 

More Related Content

Resumen Backbone.js en Ingles