index.html | searchcode

/index.html

Large files files are truncated, but you can click here to view the full file

<!DOCTYPE HTML>
<html>
<head>
  <meta http-equiv="content-type" content="text/html;charset=UTF-8" />
  <meta http-equiv="X-UA-Compatible" content="chrome=1">
  <title>Backbone.js</title>
  <style>
    body {
      font-size: 14px;
      line-height: 22px;
      font-family: Helvetica Neue, Helvetica, Arial;
      background: #f4f4f4 url(docs/images/background.png);
    }
    .interface {
      font-family: "Lucida Grande", "Lucida Sans Unicode", Helvetica, Arial, sans-serif !important;
    }
    div#sidebar {
      background: #fff;
      position: fixed;
      top: 0; left: 0; bottom: 0;
      width: 200px;
      overflow-y: auto;
      overflow-x: hidden;
      padding: 15px 0 30px 30px;
      border-right: 1px solid #ddd;
      box-shadow: 0 0 20px #ccc; -webkit-box-shadow: 0 0 20px #ccc; -moz-box-shadow: 0 0 20px #ccc;
    }
      a.toc_title, a.toc_title:visited {
        display: block;
        color: black;
        font-weight: bold;
        margin-top: 15px;
      }
        a.toc_title:hover {
          text-decoration: underline;
        }
        #sidebar .version {
          font-size: 10px;
          font-weight: normal;
        }
      ul.toc_section {
        font-size: 11px;
        line-height: 14px;
        margin: 5px 0 0 0;
        padding-left: 0px;
        list-style-type: none;
        font-family: Lucida Grande;
      }
        .toc_section li {
          cursor: pointer;
          margin: 0 0 3px 0;
        }
          .toc_section li a {
            text-decoration: none;
            color: black;
          }
            .toc_section li a:hover {
              text-decoration: underline;
            }
    div.container {
      position: relative;
      width: 550px;
      margin: 40px 0 50px 260px;
    }
    div.run {
      position: absolute;
      right: 15px;
      width: 26px; height: 18px;
      background: url('docs/images/arrows.png') no-repeat -26px 0;
    }
      div.run:active {
        background-position: -51px 0;
      }
    p, div.container ul {
      margin: 20px 0;
      width: 550px;
    }
      p.warning {
        font-size: 12px;
        line-height: 18px;
        font-style: italic;
      }
      div.container ul {
        list-style: circle;
        font-size: 12px;
        padding-left: 15px;
      }
    a, a:visited {
      color: #444;
    }
    a:active, a:hover {
      color: #000;
    }
    a img {
      border: 0;
    }
    h1, h2, h3, h4, h5, h6 {
      padding-top: 20px;
    }
      h2 {
        font-size: 20px;
      }
    b.header {
      font-size: 16px;
      line-height: 30px;
    }
    span.alias {
      font-size: 14px;
      font-style: italic;
      margin-left: 20px;
    }
    table {
      margin: 15px 0 0; padding: 0;
    }
      tr, td {
        margin: 0; padding: 0;
      }
        td {
          padding: 0px 15px 5px 0;
        }
    code, pre, tt {
      font-family: Monaco, Consolas, "Lucida Console", monospace;
      font-size: 12px;
      line-height: 18px;
      font-style: normal;
    }
      tt {
        padding: 0px 3px;
        background: #fff;
        border: 1px solid #ddd;
        zoom: 1;
      }
      code {
        margin-left: 20px;
      }
      pre {
        font-size: 12px;
        padding: 2px 0 2px 15px;
        border: 4px solid #bbb; border-top: 0; border-bottom: 0;
        margin: 0px 0 30px;
      }
      img.example_image {
        margin: 0px auto;
      }
  </style>
</head>
<body>

  <div id="sidebar" class="interface">

    <a class="toc_title" href="#">
      Backbone.js <span class="version">(0.3.3)</span>
    </a>

    <a class="toc_title" href="#Introduction">
      Introduction
    </a>

    <a class="toc_title" href="#Events">
      Events
    </a>
    <ul class="toc_section">
      <li>– <a href="#Events-bind">bind</a></li>
      <li>– <a href="#Events-unbind">unbind</a></li>
      <li>– <a href="#Events-trigger">trigger</a></li>
    </ul>

    <a class="toc_title" href="#Model">
      Model
    </a>
    <ul class="toc_section">
      <li>– <a href="#Model-extend">extend</a></li>
      <li>– <a href="#Model-constructor">constructor / initialize</a></li>
      <li>– <a href="#Model-get">get</a></li>
      <li>– <a href="#Model-set">set</a></li>
      <li>– <a href="#Model-escape">escape</a></li>
      <li>– <a href="#Model-has">has</a></li>
      <li>– <a href="#Model-unset">unset</a></li>
      <li>– <a href="#Model-clear">clear</a></li>
      <li>– <a href="#Model-id">id</a></li>
      <li>– <a href="#Model-cid">cid</a></li>
      <li>– <a href="#Model-attributes">attributes</a></li>
      <li>– <a href="#Model-defaults">defaults</a></li>
      <li>- <a href="#Model-toJSON">toJSON</a></li>
      <li>– <a href="#Model-fetch">fetch</a></li>
      <li>– <a href="#Model-save">save</a></li>
      <li>– <a href="#Model-destroy">destroy</a></li>
      <li>– <a href="#Model-validate">validate</a></li>
      <li>– <a href="#Model-url">url</a></li>
      <li>– <a href="#Model-urlRoot">urlRoot</a></li>
      <li>– <a href="#Model-parse">parse</a></li>
      <li>– <a href="#Model-clone">clone</a></li>
      <li>– <a href="#Model-isNew">isNew</a></li>
      <li>– <a href="#Model-change">change</a></li>
      <li>– <a href="#Model-hasChanged">hasChanged</a></li>
      <li>– <a href="#Model-changedAttributes">changedAttributes</a></li>
      <li>– <a href="#Model-previous">previous</a></li>
      <li>– <a href="#Model-previousAttributes">previousAttributes</a></li>
    </ul>

    <a class="toc_title" href="#Collection">
      Collection
    </a>
    <ul class="toc_section">
      <li>– <a href="#Collection-extend">extend</a></li>
      <li>– <a href="#Collection-model">model</a></li>
      <li>– <a href="#Collection-constructor">constructor / initialize</a></li>
      <li>– <a href="#Collection-models">models</a></li>
      <li>– <a href="#Collection-toJSON">toJSON</a></li>
      <li>– <a href="#Collection-Underscore-Methods"><b>Underscore Methods (25)</b></a></li>
      <li>– <a href="#Collection-add">add</a></li>
      <li>– <a href="#Collection-remove">remove</a></li>
      <li>– <a href="#Collection-get">get</a></li>
      <li>– <a href="#Collection-getByCid">getByCid</a></li>
      <li>– <a href="#Collection-at">at</a></li>
      <li>– <a href="#Collection-length">length</a></li>
      <li>– <a href="#Collection-comparator">comparator</a></li>
      <li>– <a href="#Collection-sort">sort</a></li>
      <li>– <a href="#Collection-pluck">pluck</a></li>
      <li>– <a href="#Collection-url">url</a></li>
      <li>– <a href="#Collection-parse">parse</a></li>
      <li>– <a href="#Collection-fetch">fetch</a></li>
      <li>– <a href="#Collection-reset">reset</a></li>
      <li>– <a href="#Collection-create">create</a></li>
    </ul>

    <a class="toc_title" href="#Router">
      Router
    </a>
    <ul class="toc_section">
      <li>– <a href="#Router-extend">extend</a></li>
      <li>– <a href="#Router-routes">routes</a></li>
      <li>– <a href="#Router-constructor">constructor / initialize</a></li>
      <li>– <a href="#Router-route">route</a></li>
      <li>– <a href="#Router-saveLocation">saveLocation</a></li>
      <li>– <a href="#Router-setLocation">setLocation</a></li>
    </ul>

    <a class="toc_title" href="#History">
      History
    </a>
    <ul class="toc_section">
      <li>– <a href="#History-start">start</a></li>
    </ul>

    <a class="toc_title" href="#Sync">
      Sync
    </a>
    <ul class="toc_section">
      <li>– <a href="#Sync">Backbone.sync</a></li>
      <li>– <a href="#Sync-emulateHTTP">Backbone.emulateHTTP</a></li>
      <li>– <a href="#Sync-emulateJSON">Backbone.emulateJSON</a></li>
    </ul>

    <a class="toc_title" href="#View">
      View
    </a>
    <ul class="toc_section">
      <li>– <a href="#View-extend">extend</a></li>
      <li>– <a href="#View-constructor">constructor / initialize</a></li>
      <li>– <a href="#View-el">el</a></li>
      <li>– <a href="#View-dollar">$ (jQuery or Zepto)</a></li>
      <li>– <a href="#View-render">render</a></li>
      <li>– <a href="#View-remove">remove</a></li>
      <li>– <a href="#View-make">make</a></li>
      <li>– <a href="#View-delegateEvents">delegateEvents</a></li>
    </ul>

    <a class="toc_title" href="#Utility">
      Utility
    </a>
    <ul class="toc_section">
      <li>– <a href="#Utility-noConflict">noConflict</a></li>
    </ul>

    <a class="toc_title" href="#examples">
      Examples
    </a>
    <ul class="toc_section">
      <li>– <a href="#examples-todos">Todos</a></li>
      <li>– <a href="#examples-documentcloud">DocumentCloud</a></li>
      <li>– <a href="#examples-basecamp">Basecamp Mobile</a></li>
      <li>– <a href="#examples-flow">Flow</a></li>
      <li>– <a href="#examples-cloudapp">CloudApp</a></li>
      <li>– <a href="#examples-soundcloud">Mobile SoundCloud</a></li>
      <li>– <a href="#examples-tilemill">TileMill</a></li>
      <li>- <a href="#examples-instagreat">Insta-great!</a></li>
      <li>- <a href="#examples-bittorrent">BitTorrent</a></li>
      <li>- <a href="#examples-chop">Chop</a></li>
      <li>- <a href="#examples-quietwrite">QuietWrite</a></li>
      <li>- <a href="#examples-tzigla">Tzigla</a></li>
      <li>- <a href="#examples-substance">Substance</a></li>
    </ul>

    <a class="toc_title" href="#faq">
      F.A.Q.
    </a>
    <ul class="toc_section">
      <li>– <a href="#FAQ-events">Catalog of Events</a></li>
      <li>– <a href="#FAQ-nested">Nested Models &amp; Collections</a></li>
      <li>– <a href="#FAQ-bootstrap">Loading Bootstrapped Models</a></li>
      <li>– <a href="#FAQ-mvc">Traditional MVC</a></li>
      <li>– <a href="#FAQ-this">Binding "this"</a></li>
      <li>- <a href="#FAQ-rias">Other RIA Frameworks</a></li>
    </ul>

    <a class="toc_title" href="#changelog">
      Change Log
    </a>

  </div>

  <div class="container">

    <p>
      <img style="width: 385px; height: 126px;" src="docs/images/backbone.png" alt="Backbone.js" />
    </p>

    <p>
      <a href="http://github.com/documentcloud/backbone/">Backbone</a>
      supplies structure to JavaScript-heavy applications by providing <b>models</b> with
      key-value binding and custom events, <b>collections</b> with a rich API of enumerable functions,
      <b>views</b> with declarative event handling, and connects it all to your
      existing application over a RESTful JSON interface.
    </p>

    <p>
      The project is <a href="http://github.com/documentcloud/backbone/">hosted on GitHub</a>,
      and the <a href="docs/backbone.html">annotated source code</a> is available,
      as well as an online <a href="test/test.html">test suite</a>, and
      <a href="examples/todos/index.html">example application</a>.
    </p>

    <p>
      You can report bugs and discuss features on the
      <a href="http://github.com/documentcloud/backbone/issues">GitHub issues page</a>,
      on Freenode IRC in the <tt>#documentcloud</tt> channel, post questions to the
      <a href="https://groups.google.com/forum/#!forum/backbonejs">Google Group</a>,
      or send tweets to <a href="http://twitter.com/documentcloud">@documentcloud</a>.
    </p>

    <p>
      <i>
        Backbone is an open-source component of
        <a href="http://documentcloud.org/">DocumentCloud</a>.
      </i>
    </p>

    <h2 id="downloads">
      Downloads &amp; Dependencies
      <span style="padding-left: 7px; font-size:11px; font-weight: normal;" class="interface">(Right-click, and use "Save As")</span>
    </h2>

    <table>
      <tr>
        <td><a href="backbone.js">Development Version (0.3.3)</a></td>
        <td><i>35kb, Uncompressed with Comments</i></td>
      </tr>
      <tr>
        <td><a href="backbone-min.js">Production Version (0.3.3)</a></td>
        <td><i>3.9kb, Packed and Gzipped</i></td>
      </tr>
    </table>

    <p>
      Backbone's only hard dependency is
      <a href="http://documentcloud.github.com/underscore/">Underscore.js</a>.
      For RESTful persistence, "hashchange" History, and DOM manipulation with
      <a href="#View">Backbone.View</a>,
      it's highly recommended to include
      <a href="https://github.com/douglascrockford/JSON-js">json2.js</a>, and either
      <a href="http://jquery.com">jQuery</a> <small>( > 1.4.2)</small> or 
      <a href="http://zeptojs.com/">Zepto</a>.
    </p>

    <h2 id="Introduction">Introduction</h2>

    <p>
      When working on a web application that involves a lot of JavaScript, one
      of the first things you learn is to stop tying your data to the DOM. It's all
      too easy to create JavaScript applications that end up as tangled piles of
      jQuery selectors and callbacks, all trying frantically to keep data in
      sync between the HTML UI, your JavaScript logic, and the database on your
      server. For rich client-side applications, a more structured approach
      is helpful.
    </p>

    <p>
      With Backbone, you represent your data as
      <a href="#Model">Models</a>, which can be created, validated, destroyed,
      and saved to the server. Whenever a UI action causes an attribute of
      a model to change, the model triggers a <i>"change"</i> event; all
      the <a href="#View">Views</a> that display the model's data are notified of the
      event, causing them to re-render. You don't have to write the glue
      code that looks into the DOM to find an element with a specific <i>id</i>,
      and update the HTML manually
      &mdash; when the model changes, the views simply update themselves.
    </p>

    <p>
      Many of the examples that follow are runnable. Click the <i>play</i> button
      to execute them.
    </p>

    <h2 id="Events">Backbone.Events</h2>

    <p>
      <b>Events</b> is a module that can be mixed in to any object, giving the
      object the ability to bind and trigger custom named events. Events do not
      have to be declared before they are bound, and may take passed arguments.
      For example:
    </p>

<pre class="runnable">
var object = {};

_.extend(object, Backbone.Events);

object.bind("alert", function(msg) {
  alert("Triggered " + msg);
});

object.trigger("alert", "an event");
</pre>

    <p id="Events-bind">
      <b class="header">bind</b><code>object.bind(event, callback)</code>
      <br />
      Bind a <b>callback</b> function to an object. The callback will be invoked
      whenever the <b>event</b> (specified by an arbitrary string identifier) is fired.
      If you have a large number of different events on a page, the convention is to use colons to
      namespace them: <tt>"poll:start"</tt>, or <tt>"change:selection"</tt>
    </p>

    <p>
      Callbacks bound to the special
      <tt>"all"</tt> event will be triggered when any event occurs, and are passed
      the name of the event as the first argument. For example, to proxy all events
      from one object to another:
    </p>

<pre>
proxy.bind("all", function(eventName) {
  object.trigger(eventName);
});
</pre>

    <p id="Events-unbind">
      <b class="header">unbind</b><code>object.unbind([event], [callback])</code>
      <br />
      Remove a previously-bound <b>callback</b> function from an object. If no
      callback is specified, all callbacks for the <b>event</b> will be
      removed. If no event is specified, <i>all</i> event callbacks on the object
      will be removed.
    </p>

<pre>
object.unbind("change", onChange);  // Removes just the onChange callback.

object.unbind("change");            // Removes all "change" callbacks.

object.unbind();                    // Removes all callbacks on object.
</pre>

    <p id="Events-trigger">
      <b class="header">trigger</b><code>object.trigger(event, [*args])</code>
      <br />
      Trigger callbacks for the given <b>event</b>. Subsequent arguments to
      <b>trigger</b> will be passed along to the event callbacks.
    </p>

    <h2 id="Model">Backbone.Model</h2>

    <p>
      <b>Models</b> 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. You
      extend <b>Backbone.Model</b> with your domain-specific methods, and
      <b>Model</b> provides a basic set of functionality for managing changes.
    </p>

    <p>
      The following is a contrived example, but it demonstrates defining a model
      with a custom method, setting an attribute, and firing an event keyed
      to changes in that specific attribute.
      After running this code once, <tt>sidebar</tt> will be
      available in your browser's console, so you can play around with it.
    </p>

<pre class="runnable">
var Sidebar = Backbone.Model.extend({
  promptColor: function() {
    var cssColor = prompt("Please enter a CSS color:");
    this.set({color: cssColor});
  }
});

window.sidebar = new Sidebar;

sidebar.bind('change:color', function(model, color) {
  $('#sidebar').css({background: color});
});

sidebar.set({color: 'white'});

sidebar.promptColor();
</pre>

    <p id="Model-extend">
      <b class="header">extend</b><code>Backbone.Model.extend(properties, [classProperties])</code>
      <br />
      To create a <b>Model</b> class of your own, you extend <b>Backbone.Model</b>
      and provide instance <b>properties</b>, as well as optional
      <b>classProperties</b> to be attached directly to the constructor function.
    </p>

    <p>
      <b>extend</b> correctly sets up the prototype chain, so subclasses created
      with <b>extend</b> can be further extended and subclassed as far as you like.
    </p>

<pre>
var Note = Backbone.Model.extend({

  initialize: function() { ... },

  author: function() { ... },

  coordinates: function() { ... },

  allowedToEdit: function(account) {
    return true;
  }

});

var PrivateNote = Note.extend({

  allowedToEdit: function(account) {
    return account.owns(this);
  }

});
</pre>

    <p class="warning">
        Brief aside on <tt>super</tt>: JavaScript does not provide
        a simple way to call super &mdash; the function of the same name defined
        higher on the prototype chain. If you override a core function like
        <tt>set</tt>, or <tt>save</tt>, and you want to invoke the
        parent object's implementation, you'll have to explicitly call it, along these lines:
    </p>

<pre>
var Note = Backbone.Model.extend({
  set: function(attributes, options) {
    Backbone.Model.prototype.set.call(this, attributes, options);
    ...
  }
});
</pre>

    <p id="Model-constructor">
      <b class="header">constructor / initialize</b><code>new Model([attributes])</code>
      <br />
      When creating an instance of a model, you can pass in the initial values
      of the <b>attributes</b>, which will be <a href="#Model-set">set</a> on the
      model. If you define an <b>initialize</b> function, it will be invoked when
      the model is created.
    </p>

<pre>
new Book({
  title: "One Thousand and One Nights",
  author: "Scheherazade"
});
</pre>

    <p id="Model-get">
      <b class="header">get</b><code>model.get(attribute)</code>
      <br />
      Get the current value of an attribute from the model. For example:
      <tt>note.get("title")</tt>
    </p>

    <p id="Model-set">
      <b class="header">set</b><code>model.set(attributes, [options])</code>
      <br />
      Set a hash of attributes (one or many) on the model. If any of the attributes
      change the models state, a <tt>"change"</tt> event will be triggered, unless
      <tt>{silent: true}</tt> is passed as an option. Change events for specific
      attributes are also triggered, and you can bind to those as well, for example:
      <tt>change:title</tt>, and <tt>change:content</tt>.
    </p>

<pre>
note.set({title: "October 12", content: "Lorem Ipsum Dolor Sit Amet..."});
</pre>

    <p>
      If the model has a <a href="#Model-validate">validate</a> method,
      it will be validated before the attributes are set, no changes will
      occur if the validation fails, and <b>set</b> will return <tt>false</tt>.
      You may also pass an <tt>error</tt>
      callback in the options, which will be invoked instead of triggering an
      <tt>"error"</tt> event, should validation fail.
    </p>

    <p id="Model-escape">
      <b class="header">escape</b><code>model.escape(attribute)</code>
      <br />
      Similar to <a href="#Model-get">get</a>, but returns the HTML-escaped version
      of a model's attribute. If you're interpolating data from the model into
      HTML, using <b>escape</b> to retrieve attributes will prevent
      <a href="http://en.wikipedia.org/wiki/Cross-site_scripting">XSS</a> attacks.
    </p>

<pre class="runnable">
var hacker = new Backbone.Model({
  name: "&lt;script&gt;alert('xss')&lt;/script&gt;"
});

alert(hacker.escape('name'));
</pre>

    <p id="Model-has">
      <b class="header">has</b><code>model.has(attribute)</code>
      <br />
      Returns <tt>true</tt> if the attribute is set to a non-null or non-undefined
      value.
    </p>

<pre>
if (note.has("title")) {
  ...
}
</pre>

    <p id="Model-unset">
      <b class="header">unset</b><code>model.unset(attribute, [options])</code>
      <br />
      Remove an attribute by deleting it from the internal attributes hash.
      Fires a <tt>"change"</tt> event unless <tt>silent</tt> is passed as an option.
    </p>

    <p id="Model-clear">
      <b class="header">clear</b><code>model.clear([options])</code>
      <br />
      Removes all attributes from the model. Fires a <tt>"change"</tt> event unless
      <tt>silent</tt> is passed as an option.
    </p>

    <p id="Model-id">
      <b class="header">id</b><code>model.id</code>
      <br />
      A special property of models, the <b>id</b> is an arbitrary string
      (integer id or UUID). If you set the <b>id</b> in the
      attributes hash, it will be copied onto the model as a direct property.
      Models can be retrieved by id from collections, and the id is used to generate
      model URLs by default.
    </p>

    <p id="Model-cid">
      <b class="header">cid</b><code>model.cid</code>
      <br />
      A special property of models, the <b>cid</b> or client id is a unique identifier
      automatically assigned to all models when they're first created. Client ids
      are handy when the model has not yet been saved to the server, and does not
      yet have its eventual true <b>id</b>, but already needs to be visible in the UI.
      Client ids take the form: <tt>c1, c2, c3 ...</tt>
    </p>

    <p id="Model-attributes">
      <b class="header">attributes</b><code>model.attributes</code>
      <br />
      The <b>attributes</b> property is the internal hash containing the model's
      state. Please use <a href="#Model-set">set</a> to update the attributes instead of modifying
      them directly. If you'd like to retrieve and munge a copy of the model's
      attributes, use <a href="#Model-toJSON">toJSON</a> instead.
    </p>

    <p id="Model-defaults">
      <b class="header">defaults</b><code>model.defaults or model.defaults()</code>
      <br />
      The <b>defaults</b> hash (or function) can be used to specify the default
      attributes for your model. When creating an instance of the model,
      any unspecified attributes will be set to their default value.
    </p>

<pre class="runnable">
var Meal = Backbone.Model.extend({
  defaults: {
    "appetizer":  "caesar salad",
    "entree":     "ravioli",
    "dessert":    "cheesecake"
  }
});

alert("Dessert will be " + (new Meal).get('dessert'));
</pre>

    <p class="warning">
      Remember that in JavaScript, objects are passed by reference, so if you
      include an object as a default value, it will be shared among all instances.
    </p>

    <p id="Model-toJSON">
      <b class="header">toJSON</b><code>model.toJSON()</code>
      <br />
      Return a copy of the model's <a href="#Model-attributes">attributes</a> for JSON stringification.
      This can be used for persistence, serialization, or for augmentation before
      being handed off to a view. The name of this method is a bit confusing, as
      it doesn't actually return a JSON string &mdash; but I'm afraid that it's
      the way that the <a href="https://developer.mozilla.org/en/JSON#toJSON()_method">JavaScript API for <b>JSON.stringify</b> works</a>.
    </p>

<pre class="runnable">
var artist = new Backbone.Model({
  firstName: "Wassily",
  lastName: "Kandinsky"
});

artist.set({birthday: "December 16, 1866"});

alert(JSON.stringify(artist));
</pre>

    <p id="Model-fetch">
      <b class="header">fetch</b><code>model.fetch([options])</code>
      <br />
      Refreshes the model's state from the server. Useful if the model has never
      been populated with data, or if you'd like to ensure that you have the
      latest server state. A <tt>"change"</tt> event will be triggered if the
      server's state differs from the current attributes. Accepts
      <tt>success</tt> and <tt>error</tt> callbacks in the options hash, which
      are passed <tt>(model, response)</tt> as arguments.
    </p>

<pre>
// Poll every 10 seconds to keep the channel model up-to-date.
setInterval(function() {
  channel.fetch();
}, 10000);
</pre>

    <p id="Model-save">
      <b class="header">save</b><code>model.save([attributes], [options])</code>
      <br />
      Save a model to your database (or alternative persistence layer),
      by delegating to <a href="#Sync">Backbone.sync</a>. The <b>attributes</b>
      hash (as in <a href="#Model-set">set</a>) should contain the attributes
      you'd like to change -- keys that aren't mentioned won't be altered.
      If the model has a <a href="#Model-validate">validate</a>
      method, and validation fails, the model will not be saved. If the model
      <a href="#Model-isNew">isNew</a>, the save will be a <tt>"create"</tt>
      (HTTP <tt>POST</tt>), if the model already
      exists on the server, the save will be an <tt>"update"</tt> (HTTP <tt>PUT</tt>).
    </p>

    <p>
      In the following example, notice how because the model has never been
      saved previously, our overridden version of <tt>Backbone.sync</tt> receives a <tt>"create"</tt> request.
    </p>

<pre class="runnable">
Backbone.sync = function(method, model) {
  alert(method + ": " + JSON.stringify(model));
};

var book = new Backbone.Model({
  title: "The Rough Riders",
  author: "Theodore Roosevelt"
});

book.save();
</pre>

    <p>
      <b>save</b> accepts <tt>success</tt> and <tt>error</tt> callbacks in the
      options hash, which are passed <tt>(model, response)</tt> as arguments.
      The <tt>error</tt> callback will also be invoked if the model has a
      <tt>validate</tt> method, and validation fails. If a server-side
      validation fails, return a non-<tt>200</tt> HTTP response code, along with
      an error response in text or JSON.
    </p>

<pre>
book.save({author: "F.D.R."}, {error: function(){ ... }});
</pre>

    <p id="Model-destroy">
      <b class="header">destroy</b><code>model.destroy([options])</code>
      <br />
      Destroys the model on the server by delegating an HTTP <tt>DELETE</tt>
      request to <a href="#Sync">Backbone.sync</a>. Accepts
      <tt>success</tt> and <tt>error</tt> callbacks in the options hash.
      Triggers a <tt>"destroy"</tt> event on the model, which will bubble up
      through any collections that contain it.
    </p>

<pre>
book.destroy({success: function(model, response) {
  ...
}});
</pre>

    <p id="Model-validate">
      <b class="header">validate</b><code>model.validate(attributes)</code>
      <br />
      This method is left undefined, and you're encouraged to override it with
      your custom validation logic, if you have any that can be performed
      in JavaScript. <b>validate</b> is called before <tt>set</tt> and
      <tt>save</tt>, and is passed the attributes that are about to be updated.
      If the model and attributes are valid, don't return anything from <b>validate</b>;
      if the attributes are invalid, return an error of your choosing. It
      can be as simple as a string error message to be displayed, or a complete
      error object that describes the error programmatically. <tt>set</tt> and
      <tt>save</tt> will not continue if <b>validate</b> returns an error.
      Failed validations trigger an <tt>"error"</tt> event.
    </p>

<pre class="runnable">
var Chapter = Backbone.Model.extend({
  validate: function(attrs) {
    if (attrs.end < attrs.start) {
      return "can't end before it starts";
    }
  }
});

var one = new Chapter({
  title : "Chapter One: The Beginning"
});

one.bind("error", function(model, error) {
  alert(model.get("title") + " " + error);
});

one.set({
  start: 15,
  end:   10
});
</pre>

    <p>
      <tt>"error"</tt> events are useful for providing coarse-grained error
      messages at the model or collection level, but if you have a specific view
      that can better handle the error, you may override and suppress the event
      by passing an <tt>error</tt> callback directly:
    </p>

<pre>
account.set({access: "unlimited"}, {
  error: function(model, error) {
    alert(error);
  }
});
</pre>

    <p id="Model-url">
      <b class="header">url</b><code>model.url()</code>
      <br />
      Returns the relative URL where the model's resource would be located on
      the server. If your models are located somewhere else, override this method
      with the correct logic. Generates URLs of the form: <tt>"/[collection.url]/[id]"</tt>,
      falling back to <tt>"/[urlRoot]/id"</tt> if the model is not part of a collection.
    </p>

    <p>
      Delegates to <a href="#Collection-url">Collection#url</a> to generate the
      URL, so make sure that you have it defined, or a <a href="#Model-urlRoot">urlRoot</a>
      property, if all models of this class share a common root URL.
      A model with an id of <tt>101</tt>, stored in a
      <a href="#Collection">Backbone.Collection</a> with a <tt>url</tt> of <tt>"/documents/7/notes"</tt>,
      would have this URL: <tt>"/documents/7/notes/101"</tt>
    </p>

    <p id="Model-urlRoot">
      <b class="header">urlRoot</b><code>model.urlRoot</code>
      <br />
      Specify a <tt>urlRoot</tt> if you're using a model outside of a collection,
      to enable the default <a href="#Model-url">url</a> function to generate
      URLs based on the model id. <tt>"/[urlRoot]/id"</tt>
    </p>

<pre class="runnable">
var Book = Backbone.Model.extend({urlRoot : '/books'});

var solaris = new Book({id: "1083-lem-solaris"});

alert(solaris.url());
</pre>

    <p id="Model-parse">
      <b class="header">parse</b><code>model.parse(response)</code>
      <br />
      <b>parse</b> is called whenever a model's data is returned by the
      server, in <a href="#Model-fetch">fetch</a>, and <a href="#Model-save">save</a>.
      The function is passed the raw <tt>response</tt> object, and should return
      the attributes hash to be <a href="#Model-set">set</a> on the model. The
      default implementation is a no-op, simply passing through the JSON response.
      Override this if you need to work with a preexisting API, or better namespace
      your responses.
    </p>

    <p>
      If you're working with a Rails backend, you'll notice that Rails' default
      <tt>to_json</tt> implementation includes a model's attributes under a
      namespace. To disable this behavior for seamless Backbone integration, set:
    </p>

<pre>
ActiveRecord::Base.include_root_in_json = false
</pre>

    <p id="Model-clone">
      <b class="header">clone</b><code>model.clone()</code>
      <br />
      Returns a new instance of the model with identical attributes.
    </p>

    <p id="Model-isNew">
      <b class="header">isNew</b><code>model.isNew()</code>
      <br />
      Has this model been saved to the server yet? If the model does not yet have
      an <tt>id</tt>, it is considered to be new.
    </p>

    <p id="Model-change">
      <b class="header">change</b><code>model.change()</code>
      <br />
      Manually trigger the <tt>"change"</tt> event.
      If you've been passing <tt>{silent: true}</tt> to the <a href="#Model-set">set</a> function in order to
      aggregate rapid changes to a model, you'll want to call <tt>model.change()</tt>
      when you're all finished.
    </p>

    <p id="Model-hasChanged">
      <b class="header">hasChanged</b><code>model.hasChanged([attribute])</code>
      <br />
      Has the model changed since the last <tt>"change"</tt> event? If an <b>attribute</b>
      is passed, returns <tt>true</tt> if that specific attribute has changed.
    </p>
    
    <p class="warning">
      Note that this method, and the following change-related ones, 
      are only useful during the course of a <tt>"change"</tt> event.
    </p>

<pre>
book.bind("change", function() {
  if (book.hasChanged("title")) {
    ...
  }
});
</pre>

    <p id="Model-changedAttributes">
      <b class="header">changedAttributes</b><code>model.changedAttributes([attributes])</code>
      <br />
      Retrieve a hash of only the model's attributes that have changed. Optionally,
      an external <b>attributes</b> hash can be passed in, returning
      the attributes in that hash which differ from the model. This can be used
      to figure out which portions of a view should be updated, or what calls
      need to be made to sync the changes to the server.
    </p>

    <p id="Model-previous">
      <b class="header">previous</b><code>model.previous(attribute)</code>
      <br />
      During a <tt>"change"</tt> event, this method can be used to get the
      previous value of a changed attribute.
    </p>

<pre class="runnable">
var bill = new Backbone.Model({
  name: "Bill Smith"
});

bill.bind("change:name", function(model, name) {
  alert("Changed name from " + bill.previous("name") + " to " + name);
});

bill.set({name : "Bill Jones"});
</pre>

    <p id="Model-previousAttributes">
      <b class="header">previousAttributes</b><code>model.previousAttributes()</code>
      <br />
      Return a copy of the model's previous attributes. Useful for getting a
      diff between versions of a model, or getting back to a valid state after
      an error occurs.
    </p>

    <h2 id="Collection">Backbone.Collection</h2>

    <p>
      Collections are ordered sets of models. You can to bind <tt>"change"</tt> events
      to be notified when any model in the collection has been modified,
      listen for <tt>"add"</tt> and <tt>"remove"</tt> events, <tt>fetch</tt>
      the collection from the server, and use a full suite of
      <a href="#Collection-Underscore-Methods">Underscore.js methods</a>.
    </p>

    <p>
      Any event that is triggered on a model in a collection will also be
      triggered on the collection directly, for convenience.
      This allows you to listen for changes to specific attributes in any
      model in a collection, for example:
      <tt>Documents.bind("change:selected", ...)</tt>
    </p>

    <p id="Collection-extend">
      <b class="header">extend</b><code>Backbone.Collection.extend(properties, [classProperties])</code>
      <br />
      To create a <b>Collection</b> class of your own, extend <b>Backbone.Collection</b>,
      providing instance <b>properties</b>, as well as optional <b>classProperties</b> to be attached
      directly to the collection's constructor function.
    </p>

    <p id="Collection-model">
      <b class="header">model</b><code>collection.model</code>
      <br />
      Override this property to specify the model class that the collection
      contains. If defined, you can pass raw attributes objects (and arrays) to
      <a href="#Collection-add">add</a>, <a href="#Collection-create">create</a>,
      and <a href="#Collection-reset">reset</a>, and the attributes will be
      converted into a model of the proper type.
    </p>

<pre>
var Library = Backbone.Collection.extend({
  model: Book
});
</pre>

    <p id="Collection-constructor">
      <b class="header">constructor / initialize</b><code>new Collection([models], [options])</code>
      <br />
      When creating a Collection, you may choose to pass in the initial array of <b>models</b>.
      The collection's <a href="#Collection-comparator">comparator</a> function
      may be included as an option. If you define an <b>initialize</b> function, it will be
      invoked when the collection is created.
    </p>

<pre>
var tabs = new TabSet([tab1, tab2, tab3]);
</pre>

    <p id="Collection-models">
      <b class="header">models</b><code>collection.models</code>
      <br />
      Raw access to the JavaScript array of models inside of the collection. Usually you'll
      want to use <tt>get</tt>, <tt>at</tt>, or the <b>Underscore methods</b>
      to access model objects, but occasionally a direct reference to the array
      is desired.
    </p>

    <p id="Collection-toJSON">
      <b class="header">toJSON</b><code>collection.toJSON()</code>
      <br />
      Return an array containing the attributes hash of each model in the
      collection. This can be used to serialize and persist the
      collection as a whole. The name of this method is a bit confusing, because
      it conforms to
      <a href="https://developer.mozilla.org/en/JSON#toJSON()_method">JavaScript's JSON API</a>.
    </p>

<pre class="runnable">
var collection = new Backbone.Collection([
  {name: "Tim", age: 5},
  {name: "Ida", age: 26},
  {name: "Rob", age: 55}
]);

alert(JSON.stringify(collection));
</pre>

    <p id="Collection-Underscore-Methods">
      <b class="header">Underscore Methods (25)</b>
      <br />
      Backbone proxies to <b>Underscore.js</b> to provide 25 iteration functions
      on <b>Backbone.Collection</b>. They aren't all documented here, but
      you can take a look at the Underscore documentation for the full details&hellip;
    </p>

    <ul>
      <li><a href="http://documentcloud.github.com/underscore/#each">forEach (each)</a></li>
      <li><a href="http://documentcloud.github.com/underscore/#map">map</a></li>
      <li><a href="http://documentcloud.github.com/underscore/#reduce">reduce (foldl, inject)</a></li>
      <li><a href="http://documentcloud.github.com/underscore/#reduceRight">reduceRight (foldr)</a></li>
      <li><a href="http://documentcloud.github.com/underscore/#detect">find (detect)</a></li>
      <li><a href="http://documentcloud.github.com/underscore/#select">filter (select)</a></li>
      <li><a href="http://documentcloud.github.com/underscore/#reject">reject</a></li>
      <li><a href="http://documentcloud.github.com/underscore/#all">every (all)</a></li>
      <li><a href="http://documentcloud.github.com/underscore/#any">some (any)</a></li>
      <li><a href="http://documentcloud.github.com/underscore/#include">include</a></li>
      <li><a href="http://documentcloud.github.com/underscore/#invoke">invoke</a></li>
      <li><a href="http://documentcloud.github.com/underscore/#max">max</a></li>
      <li><a href="http://documentcloud.github.com/underscore/#min">min</a></li>
      <li><a href="http://documentcloud.github.com/underscore/#sortBy">sortBy</a></li>
      <li><a href="http://documentcloud.github.com/underscore/#sortedIndex">sortedIndex</a></li>
      <li><a href="http://documentcloud.github.com/underscore/#toArray">toArray</a></li>
      <li><a href="http://documentcloud.github.com/underscore/#size">size</a></li>
      <li><a href="http://documentcloud.github.com/underscore/#first">first</a></li>
      <li><a href="http://documentcloud.github.com/underscore/#rest">rest</a></li>
      <li><a href="http://documentcloud.github.com/underscore/#last">last</a></li>
      <li><a href="http://documentcloud.github.com/underscore/#without">without</a></li>
      <li><a href="http://documentcloud.github.com/underscore/#indexOf">indexOf</a></li>
      <li><a href="http://documentcloud.github.com/underscore/#lastIndexOf">lastIndexOf</a></li>
      <li><a href="http://documentcloud.github.com/underscore/#isEmpty">isEmpty</a></li>
      <li><a href="http://documentcloud.github.com/underscore/#chain">chain</a></li>
    </ul>

<pre>
Books.each(function(book) {
  book.publish();
});

var titles = Books.map(function(book) {
  return book.get("title");
});

var publishedBooks = Books.filter(function(book) {
  return book.get("published") === true;
});

var alphabetical = Books.sortBy(function(book) {
  return book.author.get("name").toLowerCase();
});
</pre>

    <p id="Collection-add">
      <b class="header">add</b><code>collection.add(models, [options])</code>
      <br />
      Add a model (or an array of models) to the collection. Fires an <tt>"add"</tt>
      event, which you can pass <tt>{silent: true}</tt> to suppress. If a
      <a href="#Collection-model">model</a> property is defined, you may also pass
      raw attributes objects, and have them be vivified as instances of the model.
      Pass <tt>{at: index}</tt> to splice the model into the collection at the
      specified <tt>index</tt>.
    </p>

<pre class="runnable">
var ships = new Backbone.Collection;

ships.bind("add", function(ship) {
  alert("Ahoy " + ship.get("name") + "!");
});

ships.add([
  {name: "Flying Dutchman"},
  {name: "Black Pearl"}
]);
</pre>

    <p id="Collection-remove">
      <b class="header">remove</b><code>collection.remove(models, [options])</code>
      <br />
      Remove a model (or an array of models) from the collection. Fires a
      <tt>"remove"</tt> event, which you can use <tt>silent</tt>
      to suppress.
    </p>

    <p id="Collection-get">
      <b class="header">get</b><code>collection.get(id)</code>
      <br />
      Get a model from a collection, specified by <b>id</b>.
    </p>

<pre>
var book = Library.get(110);
</pre>

    <p id="Collection-getByCid">
      <b class="header">getByCid</b><code>collection.getByCid(cid)</code>
      <br />
      Get a model from a collection, specified by client id. The client id
      is the <tt>.cid</tt> property of the model, automatically assigned whenever
      a model is created. Useful for models which have not yet been saved to
      the server, and do not yet have true ids.
    </p>

    <p id="Collection-at">
      <b class="header">at</b><code>collection.at(index)</code>
      <br />
      Get a model from a collection, specified by index. Useful if your collection
      is sorted, and if your collection isn't sorted, <b>at</b> will still
      retrieve models in insertion order.
    </p>

    <p id="Collection-length">
      <b class="header">length</b><code>collection.length</code>
      <br />
      Like an array, a Collection maintains a <tt>length</tt> property, counting
      the number of models it contains.
    </p>

    <p id="Collection-comparator">
      <b class="header">comparator</b><code>collection.comparator</code>
      <br />
      By default there is no <b>comparator</b> function on a collection.
      If you define a comparator, it will be used to maintain
      the collection in sorted order. This means that as models are added,
      they are inserted at the correct index in <tt>collection.models</tt>.
      Comparator functions take a model and return a numeric or string value
      by which the model should be ordered relative to others.
    </p>

    <p>
      Note how even though all of the chapters in this example are added backwards,
      they come out in the proper order:
    </p>

<pre class="runnable">
var Chapter  = Backbone.Model;
var chapters = new Backbone.Collection;

chapters.comparator = function(chapter) {
  return chapter.get("page");
};

chapters.add(new Chapter({page: 9, title: "The End"}));
chapters.add(new Chapter({page: 5, title: "The Middle"}));
chapters.add(new Chapter({page: 1, title: "The Beginning"}));

alert(chapters.pluck('title'));
</pre>

    <p class="warning">
      Brief aside: This comparator function is different than JavaScript's regular
      "sort", which must return <tt>0</tt>, <tt>1</tt>, or <tt>-1</tt>,
      and is more similar to a <tt>sortBy</tt> &mdash; a much nicer API.
    </p>

    <p id="Collection-sort">
      <b class="header">sort</b><code>collection.sort([options])</code>
      <br />
      Force a collection to re-sort itself. You don't need to call this under
      normal circumstances, as a collection with a <a href="#Collection-comparator">comparator</a> function
      will maintain itself in proper sort order at all times. Calling <b>sort</b>
      triggers the collection's <tt>"reset"</tt> event, unless silenced by passing
      <tt>{silent: true}</tt>
    </p>

    <p id="Collection-pluck">
      <b class="header">pluck</b><code>collection.pluck(attribute)</code>
      <br />
      Pluck an attribute from each model in the collection. Equivalent to calling
      <tt>map</tt>, and returning a single attribute from the iterator.
    </p>

<pre class="runnable">
var stooges = new Backbone.Collection([
  new Backbone.Model({name: "Curly"}),
  new Backbone.Model({name: "Larry"}),
  new Backbone.Model({name: "Moe"})
]);

var names = stooges.pluck("name");

alert(JSON.stringify(names));
</pre>

    <p id="Collection-url">
      <b class="header">url</b><code>collection.url or collection.url()</code>
      <br />
      Set the <b>url</b> property (or function) on a collection to reference
      its location on the server. Models within the collection will use <b>url</b>
      to construct URLs of their own.
    </p>

<pre>
var Notes = Backbone.Collection.extend({
  url: '/notes'
});

// Or, something more sophisticated:

var Notes = Backbone.Collection.extend({
  url: function() {
    return this.document.url() + '/notes';
  }
});
</pre>

    <p id="Collection-parse">
      <b class="header">parse</b><code>collection.parse(response)</code>
      <br />
      <b>parse</b> is called by Backbone whenever a collection's models are
      returned by the server, in <a href="#Collection-fetch">fetch</a>.
      The function is passed the raw <tt>response</tt> object, and should return
      the array of model attributes to be <a href="#Collection-add">added</a>
      to the collection. The default implementation is a no-op, simply passing
      through the JSON response. Override this if you need to work with a
      preexisting API, or better namespace your responses.
    </p>

<pre>
var Tweets = Backbone.Collection.extend({
  // The Twitter Search API returns tweets under "results".
  parse: function(response) {
    return response.results;
  }
});
</pre>

    <p id="Collection-fetch">
      <b class="header">fetch</b><code>collection.fetch([options])</code>
      <br />
      Fetch the default set of models for this collection from the server,
      refreshing the collection when they arrive. The <b>options</b> hash takes
      <tt>success</tt> and <tt>error</tt>
      callbacks which will be passed <tt>(collection, response)</tt> as arguments.
      When the model data returns from the server, the collection will
      <a href="#Collection-reset">reset</a>.
      Delegates to <a href="#Sync">Backbone.sync</a>
      under the covers, for custom persistence strategies.
      The server handler for <b>fetch</b> requests should return a JSON array of
      models.
    </p>

<pre class="runnable">
Backbone.sync = function(method, model) {
  alert(method + ": " + model.url);
};

var Accounts = new Backbone.Collection;
Accounts.url = '/accounts';

Accounts.fetch();
</pre>

    <p>
      If you'd like to add the incoming models to the current collection, instead
      of replacing the collection's contents, pass <tt>{add: true}</tt> as an
      option to <b>fetch</b>.
    </p>
    
    <p>
      <b>jQuery.ajax</b> options can also be passed directly as <b>fetch</b> options, 
      so to fetch a specific page of a paginated collection: 
      <tt>Documents.fetch({data: {page: 3}})</tt>
    </p>

    <p>
      Note that <b>fetch</b> should not be used to populate collections on
      page load &mdash; all models needed at load time should already be
      <a href="#FAQ-bootstrap">bootstrapped</a> in to place. <b>fetch</b> is
      intended for lazily-loading models for interfaces that are not needed
      immediately: for example, documents with collections of notes that may be
      toggled open and closed.
    </p>

    <p id="Collection-reset">
      <b class="header">reset</b><code>collection.reset(models, [options])</code>
      <br />
      Adding and removing models one at a time is all well and good, but sometimes
      you have so many models to change that you'd rather just update the collection
      in bulk. Use <b>reset</b> to replace a collection with a new list
      of models (or attribute hashes), triggering a single <tt>"reset"</tt> event
      at the end. Pass <tt>{silent: true}</tt> to suppress the <tt>"reset"</tt> event.
      Using reset with no arguments is useful as a way to empty the collection.
    </p>

    <p>
      Here's an example using <b>reset</b> to bootstrap a collection during initial page load,
      in a Rails application.
    </p>

<pre>
&lt;script&gt;
  Accounts.reset(&lt;%= @accounts.to_json %&gt;);
&lt;/script&gt;
</pre>

    <p>
      Calling <tt>collection.reset()</tt> without passing any models as arguments
      will empty the entire collection.
    </p>

    <p id="Collection-create">
      <b class="header">create</b><code>collection.create(attributes, [options])</code>
      <br />
      Convenience to create a new instance of a model within a collection.
      Equivalent to instantiating a model with a hash of attributes,
      saving the model to the server, and adding the model to the set after being
      successfully created. Returns
      the model, or <tt>false…
Large files files are truncated, but you can click here to view the full file