backbone库的结构http://www.cnblogs.com/nuysoft/archive/2012/03/19/2404274.html
本文的例子来自http://blog.****.net/eagle_110119/article/details/8842032
Backbone.Router担任了一部分Controller（控制器）的工作，它一般运行在单页应用中，能将特定的URL或锚点规则绑定到一个指定的方法（后文中称Action）。
当我们开发一个单页应用时，常常会遇到这样两个问题：
我们在同一个页面中通过用户的操作来隐藏、显示HTML块，为用户提供一个无刷新、完整流畅的体验，但用户可能并不知道他当前正处于同一个页面中，因此他希望通过浏览器的“前进”和“后退”按钮来返回和前进到上一步操作。当他真正这样操作时，会离开当前页面，这显然不是用户所期望的。
另一个问题是用户在单页应用中操作，当他读到一篇好的文章，或看到一个中意的商品时，他可能会将URL收藏起来或分享给自己的好友。但当他下一次重新打开这个链接地址，看到的却是应用的初始化状态，而并不是当初那篇文章或那个商品。
以上来自http://blog.****.net/eagle_110119/article/details/8842032
1.1 Router
ok，下面我们先上例子再看：
var AppRouter = Backbone.Router.extend({
routes : {
'' : 'main',
'topic' : 'renderList',
'topic/:id' : 'renderDetail',
'*error' : 'renderError'
},
main : function() {
console.log('应用入口方法');
},
renderList : function() {
console.log('渲染列表方法');
},
renderDetail : function(id) {
console.log('渲染详情方法, id为: ' + id);
},
renderError : function(error) {
console.log('URL错误, 错误信息: ' + error);
}
});
var router = new AppRouter();
Backbone.history.start();
这里我们自定义的route，main，renderList，renderDetail和renderError都会被绑定到AppRouter的原型上，这里与之前的model，collection和view是一样的。
下面代码：
var router = new AppRouter();
我们来看一下构造器：
var Router = Backbone.Router = function(options) {
options || (options = {});
if (options.routes) this.routes = options.routes;//可以在实例中定义路由规则，而且权值高，将不使用原型上的routers规则
this._bindRoutes();//进入_bindRoutes方法
this.initialize.apply(this, arguments);//执行initialize，使用时自己定义扩展
};
这里initialize依旧需要我们使用的时候自行定义，ok，我们进入_bindRoutes方法。
_bindRoutes: function() {
if (!this.routes) return;//没有定义routes规则，将返回
this.routes = _.result(this, 'routes');
var route, routes = _.keys(this.routes);//获取属性名
while ((route = routes.pop()) != null) {
this.route(route, this.routes[route]);//依次执行route方法
}
}
关于_的result方法和key方法，之前我们都已经提及过，看一下原型上的route方法
这里方法比较麻烦，充斥着正则表达式，我们先将源码，分开阅读，先弄懂正则，再去理清逻辑。
route: function(route, name, callback) {
if (!_.isRegExp(route)) route = this._routeToRegExp(route);//`转成相应的正则表达式
if (_.isFunction(name)) {
callback = name;
name = '';
}
if (!callback) callback = this[name];//将同名的方法相关联
..........
看一下_的isRegExp方法
each(['Arguments', 'Function', 'String', 'Number', 'Date', 'RegExp'], function(name) {
_['is' + name] = function(obj) {
return toString.call(obj) == '[object ' + name + ']';
};
});
不多说，我们看一下_routeToRegExp方法
_routeToRegExp: function(route) {
route = route.replace(escapeRegExp, '\\$&')// /[\-{}\[\]+?.,\\\^$|#\s]/g,给所有匹配的字符前面加转义符'\'
.replace(optionalParam, '(?:$1)?')// /\((.*?)\)/g
.replace(namedParam, function(match, optional) {
return optional ? match : '([^\/]+)'; // /(\(\?)?:\w+/g
})
.replace(splatParam, '(.*?)');
return new RegExp('^' + route + '$');
}
分析之前，我们先看一下这4个正则
var optionalParam = /\((.*?)\)/g;
var namedParam = /(\(\?)?:\w+/g;
var splatParam = /\*\w+/g;
var escapeRegExp = /[\-{}\[\]+?.,\\\^$|#\s]/g;
这里我们逐一讲下，/g标识全局匹配。先看optionalParam
分解一下：'\('匹配'('，'()'表示子表达式，其中的'.*?'，表示匹配任何字符，但是要忽略优先，像*这样的量词，正则默认是匹配优先的，可以理解为尽可能的去匹配更多的字符，如果在其后加了?，则表示在完成的要求上，尽可能少匹配。然后'\)'
匹配一个')'，源码中有用replace方法，注意其中的\\$&，这个则表示，将正则匹配的结果前面添加'\'，这里$&就是标识正则匹配的结果。注意这里的.*?因为最后有个)需要匹配，所以文本中的()的所有字符都必须匹配，这样你写成(.*)也能达到要求，其实就是，虽然告诉正则引擎要尽可能的少匹配，但是不能匹配最后的)仍然需要继续匹配。
namedParam：分解成两块：(\(\?)? 和:\w+，前者是一个子表达式，它匹配'(?'，匹配数是没有或者1个，后者是匹配':'，然后是至少一个字符(字母或数字或下划线或汉字)。
splatParam： 这个简单，匹配'*'，然后是至少一个字符(字母或数字或下划线或汉字)
escapeRegExp：这个很长，其实很简单，先看[..........]，表示分组，即表示只需要匹配分组中的任意一个就可以了，再看分组的内容有:'[','-','{}',']','+','?','.','\','^','$','|','#',空格(空字符串)
这个方法只是将我们传入的字符串，进行装饰，变成需要的正则表达式。
继续看route方法的后半部分
.....
var router = this;
Backbone.history.route(route, function(fragment) {//执行route方法
var args = router._extractParameters(route, fragment);
callback && callback.apply(router, args);
router.trigger.apply(router, ['route:' + name].concat(args));
router.trigger('route', name, args);
Backbone.history.trigger('route', router, name, args);
});
return this;
}
调用了Backbone库的history原型上的route方法，传入了正则规则，和回调函数。我们看一下Backbone.history.route这个方法
route: function(route, callback) {
this.handlers.unshift({route: route, callback: callback});//从头插入。将相关正则和触发函数关联后，存入对象属性数组
}
将相关正则和触发函数关联后，存入对象属性数组中，以上完成了new Router构造器的任务，例子中还有一个
Backbone.history.start();
1.2 History
例子中使用了与history相关的模块，那我们先不看start这个方法，由于页面中我们并没有实例化相关的history，很有可能history是在backbone库中自行实例化的，那我们先看一下结构：
var History = Backbone.History = function() {} //history构造器
var routeStripper = /^[#\/]|\s+$/g; //相关正则
...
History.started = false;
_.extend(History.prototype, Events, {}) //history的原型
Backbone.history = new History;//实例化History
老规矩，先看构造器
var History = Backbone.History = function() { //history构造器
this.handlers = [];
_.bindAll(this, 'checkUrl');//将this中的属性绑定checkUrl函数
// Ensure that `History` can be used outside of the browser.
if (typeof window !== 'undefined') {
this.location = window.location;//原生location信息
this.history = window.history;//存在一条历史记录
}
}
history实例对象Backbone.History拥有了一些bom原生的参数信息。
在看start方法之前，我们再过一下history中存在的几条正则
var routeStripper = /^[#\/]|\s+$/g;
var rootStripper = /^\/+|\/+$/g;
var isExplorer = /msie [\w.]+/;
var trailingSlash = /\/$/;
我们逐条来看一下：
routeStripper：分解一下：首先看到|符号，它的前面是[#\/]，表示分组，意思是文本开头可以是#或者/，如何都不是那可以匹配|后面的\s+，表示开头是空白字符。
rootStripper： 与上一条看上去相似，实际上不同，分解一下，首先看到|符号，它的前面是\/+表示文本开头可以至少有/，如果没有/则匹配|的后者\/+，感觉一样啊。。。
isExplorer：这个比较简单，匹配msie,后面至少一个字符(字母或数字或下划线或汉字)
trailingSlash：这个匹配文本结尾最后一个字符是/
下面我们来看一下start方法：
start: function(options) {
if (History.started) throw new Error("Backbone.history has already been started");//默认history.start属性是false，没有开启，如果没有调用就开启了肯定是要抛错的
History.started = true;//调用start之后，将History.started设置为true。
// Figure out the initial configuration. Do we need an iframe?
// Is pushState desired ... is it available?
this.options = _.extend({}, {root: '/'}, this.options, options);//将参数，都传入对象的options属性中。该例子中只有{root:'/'}
this.root = this.options.root;//默认是'/'一般系统默认是/，但只要你自定义，都可以被覆盖
this._wantsHashChange = this.options.hashChange !== false;//这里默认hashChange为undefined，默认_wantsHashChange是true
this._wantsPushState = !!this.options.pushState;//!!转成boolean型，默认this.options.pushState为undefined，所有这个例子中wantsPushState为false
this._hasPushState = !!(this.options.pushState && this.history && this.history.pushState);//因为pushState为undefined，所以hasPushState为false
var fragment = this.getFragment();//这里没有传值，默认是undefined
var docMode = document.documentMode;//获取IE版本(使用于IE8+)
//navigator.userAgent取浏览器版本详细信息，以下考虑旧版本的IE(IE7-)
var oldIE = (isExplorer.exec(navigator.userAgent.toLowerCase()) && (!docMode || docMode <= 7));//低版本IE没有documentMode属性
// Normalize root to always include a leading and trailing slash.
this.root = ('/' + this.root + '/').replace(rootStripper, '/');
//兼容低版本IE
if (oldIE && this._wantsHashChange) {
this.iframe = Backbone.$('<iframe src="javascript:0" tabindex="-1" />').hide().appendTo('body')[0].contentWindow;
this.navigate(fragment);
}
// Depending on whether we're using pushState or hashes, and whether
// 'onhashchange' is supported, determine how we check the URL state.
if (this._hasPushState) {
Backbone.$(window).on('popstate', this.checkUrl);
} else if (this._wantsHashChange && ('onhashchange' in window) && !oldIE) {//非老版本IE
Backbone.$(window).on('hashchange', this.checkUrl);//为window绑定hashchange监听事件，事件函数是checkUrl，主要是控制url的变化，
} else if (this._wantsHashChange) {
this._checkUrlInterval = setInterval(this.checkUrl, this.interval);
}
// Determine if we need to change the base url, for a pushState link
// opened by a non-pushState browser.
this.fragment = fragment;
var loc = this.location;//获取当前location的信息
var atRoot = loc.pathname.replace(/[^\/]$/, '$&/') === this.root;//处理路径名
// Transition from hashChange to pushState or vice versa if both are
// requested.
if (this._wantsHashChange && this._wantsPushState) {
// If we've started off with a route from a `pushState`-enabled
// browser, but we're currently in a browser that doesn't support it...
if (!this._hasPushState && !atRoot) {
this.fragment = this.getFragment(null, true);
this.location.replace(this.root + this.location.search + '#' + this.fragment);
// Return immediately as browser will do redirect to new url
return true;
// Or if we've started out with a hash-based route, but we're currently
// in a browser where it could be `pushState`-based instead...
} else if (this._hasPushState && atRoot && loc.hash) {
this.fragment = this.getHash().replace(routeStripper, '');
this.history.replaceState({}, document.title, this.root + this.fragment + loc.search);
}
}
if (!this.options.silent) return this.loadUrl();//默认silent没有
}
我使用的浏览器是ff，暂时我们认为源码的运行流程按非IE来看，(之后我们会看一下代码处理IE和低版本IE的部分)
先看一下
var fragment = this.getFragment();
看一下getFragment方法：
getFragment: function(fragment, forcePushState) {
if (fragment == null) {
if (this._hasPushState || !this._wantsHashChange || forcePushState) {
fragment = this.location.pathname;
var root = this.root.replace(trailingSlash, '');
if (!fragment.indexOf(root)) fragment = fragment.slice(root.length);
} else {
fragment = this.getHash();//正则匹配去取锚点
}
}
return fragment.replace(routeStripper, '');
}
再看一下getHash()方法：
getHash: function(window) {
var match = (window || this).location.href.match(/#(.*)$/);//取子表达式所匹配的内容，实际上去取锚点,match结果第一个是匹配整个正则，第二个是$1
return match ? match[1] : '';//如果子表达式匹配了，则返回，没有则返回空，实际上返回#之后的信息
}
因为，我们的地址是file:///E:/backbone-learn/demo6.html是没有锚点的，所以，这个fragment返回应该是空字符串。
看到这部分代码：
if (this._hasPushState) {
Backbone.$(window).on('popstate', this.checkUrl);
} else if (this._wantsHashChange && ('onhashchange' in window) && !oldIE) {//非老版本IE
Backbone.$(window).on('hashchange', this.checkUrl);//为window绑定hashchange监听事件，事件函数是checkUrl，主要是控制url的变化，
} else if (this._wantsHashChange) {
this._checkUrlInterval = setInterval(this.checkUrl, this.interval);
}
这里只要是绑定了hashchange的监听事件，触发函数是checkUrl。看一下吧
checkUrl: function(e) {
var current = this.getFragment();//获取当前的锚点
if (current === this.fragment && this.iframe) {//兼容低版本IE
current = this.getFragment(this.getHash(this.iframe));
}
if (current === this.fragment) return false;//没有发生改变则返回
if (this.iframe) this.navigate(current);
this.loadUrl();
}
这里getFragment实际上是一个获取当前锚点的方法。如果锚点发生改变了，事件会触发，获取最新的锚点，更换上去。哪里实现更换了？看一下loadUrl：
loadUrl: function(fragmentOverride) {
var fragment = this.fragment = this.getFragment(fragmentOverride);
return _.any(this.handlers, function(handler) {
if (handler.route.test(fragment)) {
handler.callback(fragment);
return true;
}
});
}
在一次获取当前锚点，return了一个_.any的方法，看一下：
var any = _.some = _.any = function(obj, iterator, context) {
iterator || (iterator = _.identity);
var result = false;
if (obj == null) return result;
if (nativeSome && obj.some === nativeSome) return obj.some(iterator, context);//支持原生some
each(obj, function(value, index, list) { //自定义方法实现
if (result || (result = iterator.call(context, value, index, list))) return breaker;
});
return !!result;
}
对于some方法，我开始也不了解，于是乎百度了一下，给大家一个例子吧。(some的例子) http://msdn.microsoft.com/zh-SG/library/ie/ff679978.aspx
这里浏览器支持some方法，理解一下一下代码：
return _.any(this.handlers, function(handler) {
if (handler.route.test(fragment)) {
handler.callback(fragment);
return true;
}
});
这里的handler.callback是什么，这个回调应该是：
function(fragment) {//执行route方法,所有的正则绑定这个回调函数
var args = router._extractParameters(route, fragment);
callback && callback.apply(router, args);//这里的回调是我们自定义的触发函数
router.trigger.apply(router, ['route:' + name].concat(args));//同时可以触发router+name的事件，该事件需要我们自行创建
router.trigger('route', name, args);//同时触发route事件
Backbone.history.trigger('route', router, name, args);//router与history相关联，触发history的route事件，以上一个触发事件需要我们在页面定义。
}
如果你乱了，请看一下router的构造器，不记得的，一路做一点记录。其中一个代码if(handler.route.test(fragment))可以这样理解，我们在初始化router构造器的时候，传入了一系列的hash规则，现在规则定义，如果我们传入了一个锚点，或是监听到了一个锚点的改变，取到这个这个锚点(最新的锚点)去这个我们先前定义好的hash规则中去匹配，如果匹配成功，则执行相应的我们定义的hash回调函数，此时这里的回调函数，才是我们之前自己定义的回调函数。如果我们修改的url，这里的hash规则没有一个能匹配，则返回fslse。这边回调有点多，大家耐心理解下，如果我哪里理解错了，也麻烦提出来修正。
ok，如果匹配成功了，第一会执行我们自定义的响应方法(回调函数)，系统内部会触发三个监听事件，这三个监听事件需要你事先写在页面中
1：route：name类型的监听事件
2：route类型的监听事件
3：之前两个是router上的监听事件，这个是history的监听事件。是也是route类型的
至此，我们完成了FF下的start流程。
1.3 路由规则设定
从上面的例子中就能看出，它可以将不同的URL锚点导航到对应的Action方法中。
以上的源码分析，我们也应该清楚Backbone的路由导航是由Backbone.Router和backbone.History两个类共同完成的。
这里例子中给出了概括的描述：
Router类用于定义和解析路由规则，并将Url映射到Action
History类用于监听URL的变化，和触发Action方法。
1.4 Hash规则
例子中给一些描述：
我们再根据例子看一下：
•http://localhost/index.html // 输出：应用入口方法
•http://localhost/index.html#topic // 输出：渲染列表方法
•http://localhost/index.html#topic/1023 // 输出：渲染详情方法, id为:1023
•http://localhost/index.html#about // 输出：URL错误, 错误信息: about
下面是我们定义的hash规则
routes : {
'' : 'main',
'topic' : 'renderList',
'topic/:id' : 'renderDetail',
'*error' : 'renderError'
}
注重看一下topic/:id和*error这两个规则，经过_routeToRegExp方法会生成什么规则
topic/:id
*error
看一下生成的这两个正则，topic/([^/]+)，这个字符串在生成正则时，会转成
topic\/([^/]+)，这个正则可以匹配topic/后面是一个非/的任意字符(至少要有一个，空格也是可以的)。另外，topic后面的内容用()包裹，可以获取这个子表达式的值，这也是为什么我们可以取到topic/后面的信息了
第二条(.*?)
()是一个子表达式，可以用$1或$&获取，其中.*?，标识忽略优先，或者叫非贪婪。尽可能少的去匹配达到完成任务，但如果一次不匹配，还是要继续匹配，宗旨是尽可能少。
我们如何获取子表达式的匹配内容呢？在_extractParameters方法里
var params = route.exec(fragment).slice(1);//匹配我们生成的正则，这里获取子表达式的信息
1.5 pushState规则
backbone.history还支持pushState方法的URL，pushState是HTML5提供的一种新特性，它能操作当前浏览器的URL(而不是仅仅改变锚点)，同时不会导致页面刷新，从而使单页面，从而使单页面应用使用起来更像一套完整的流程。
HTML5的部分，暂时不做讨论。
1.6 路由相关方法
route方法，navigate方法，stop方法
1.6.1 route
先看route方法，上例子：
router.route('topic/:pageno/:pagesize', 'page', function(pageno, pagesize){
// todo
});
route方法，之前分析过了，上述的例子告诉我们，除了将hash规则和触发函数写在原型上，也可以直接写在实例上。
1.6.2 navigate
先上例子：
router.navigate('topic/1000', {
trigger: true
});
看一下navigate方法：
navigate: function(fragment, options) {
Backbone.history.navigate(fragment, options);
return this;
}
调用的是History的navigate方法
navigate: function(fragment, options) {
if (!History.started) return false;//没有启动，则返回
if (!options || options === true) options = {trigger: !!options};
fragment = this.getFragment(fragment || '');
if (this.fragment === fragment) return;//没有发生变化，则返回,返回刷新无效
this.fragment = fragment;//将定义的hash传入fragment属性中
var url = this.root + fragment;//拼接url
// Don't include a trailing slash on the root.
if (fragment === '' && url !== '/') url = url.slice(0, -1);
// If pushState is available, we use it to set the fragment as a real URL.
if (this._hasPushState) {
this.history[options.replace ? 'replaceState' : 'pushState']({}, document.title, url);
// If hash changes haven't been explicitly disabled, update the hash
// fragment to store history.
} else if (this._wantsHashChange) {
this._updateHash(this.location, fragment, options.replace);//更新hash
if (this.iframe && (fragment !== this.getFragment(this.getHash(this.iframe)))) {
// Opening and closing the iframe tricks IE7 and earlier to push a
// history entry on hash-tag change. When replace is true, we don't
// want this.
if(!options.replace) this.iframe.document.open().close();
this._updateHash(this.iframe.location, fragment, options.replace);
}
// If you've told us that you explicitly don't want fallback hashchange-
// based history, then `navigate` becomes a page refresh.
} else {
return this.location.assign(url);//跳转到该url
}
if (options.trigger) return this.loadUrl(fragment);//设置trigger后，重新执行正则匹配，触发监听事件等，如果不设置，将不会触发相应关联方法和监听事件
}
这个方法大概的作用是这样的，先获取传入的hash，判断是否变化了，如果变化了，先将其更新hash，更新方法如下：
_updateHash: function(location, fragment, replace) {
if (replace) {
var href = location.href.replace(/(javascript:|#).*$/, '');
location.replace(href + '#' + fragment);
} else {
// Some browsers require that `hash` contains a leading #.
location.hash = '#' + fragment;//更新hash
}
}
接下来，你可以设置trigger属性为true，也可以不设置，这就意味着，你是否需要执行loadUrl方法，这个方法帮你执行生成的正则匹配，执行关联的函数，监听的事件等。换言之，如果你不设置的话，将不会触发该一系列事件和函数方法。
1.6.3 stop
还记得我们是通过Backbone.history.start()方法来启动路由监听的，你也可以随时调用Backbone.history.stop()方法来停止监听，看例子：
Backbone.history.stop();
看一下history原型上的stop方法：
stop: function() {
Backbone.$(window).off('popstate', this.checkUrl).off('hashchange', this.checkUrl);
clearInterval(this._checkUrlInterval);
History.started = false;
}
清除事件的清除，清除定时器的清除定时器，最后将History.started置为false，这里为什么会有定时器呢？之前我们留了一个低版本IE的问题，下面我们来看一下
1.7 低版本IE的部分问题
回到history的start方法中：
if (this._hasPushState) {
Backbone.$(window).on('popstate', this.checkUrl);//HTML5
} else if (this._wantsHashChange && ('onhashchange' in window) && !oldIE) {//非老版本IE
Backbone.$(window).on('hashchange', this.checkUrl);//为window绑定hashchange监听事件，事件函数是checkUrl，主要是控制url的变化，
} else if (this._wantsHashChange) {//低版本
this._checkUrlInterval = setInterval(this.checkUrl, this.interval);
}
可以看到，对于不支持onhashchange的浏览器，history会使用定时器去监听它。
注意这些属性名，我们就大致了解了
1._hasPushState，拥有pushState属性
2._wantsHashChange，没有onhashchange事件
以下部分来自http://www.cnblogs.com/rubylouvre/archive/2012/10/24/2730599.html
最后提一提hash值的提取，这里存在两个兼容性问题：
IE6直接用location.hash取hash，可能会取少一部分内容：
比如 http://www.cnblogs.com/rubylouvre#stream/xxxxx?lang=zh_c
ie6 => location.hash = #stream/xxxxx
其他浏览器 => location.hash = #stream/xxxxx?lang=zh_c
firefox 会自作多情对hash进行decodeURIComponent
比如 http://www.cnblogs.com/rubylouvre/#!/home/q={%22thedate%22:%2220121010~20121010%22}
firefox 15 => #!/home/q={"thedate":"20121010~20121010"}
其他浏览器 => #!/home/q={%22thedate%22:%2220121010~20121010%22}
再比如如下代码：
history中的navigate方法
if (this._hasPushState) {
this.history[options.replace ? 'replaceState' : 'pushState']({}, document.title, url);
// If hash changes haven't been explicitly disabled, update the hash
// fragment to store history.
} else if (this._wantsHashChange) {
this._updateHash(this.location, fragment, options.replace);//更新hash
if (this.iframe && (fragment !== this.getFragment(this.getHash(this.iframe)))) {
// Opening and closing the iframe tricks IE7 and earlier to push a
// history entry on hash-tag change. When replace is true, we don't
// want this.
if(!options.replace) this.iframe.document.open().close();
this._updateHash(this.iframe.location, fragment, options.replace);
}
// If you've told us that you explicitly don't want fallback hashchange-
// based history, then `navigate` becomes a page refresh.
} else {
return this.location.assign(url);//跳转到该页
}
关于pushState和replaceState，可以参考http://zhanchaojiang.iteye.com/blog/1462994
默认使用location.assgin完成跳转。不足之处，也欢迎园友们补充，谢谢。
很多时候，读码也是一种旅行，只要一杯茶，一段源码，一个浏览器，剩下的唯有坚持。
身体需要行走，我的精神依旧在路上....
内容不多，时间刚好，以上是我的一点读码体会，如有错误，请指出，大家共通学习。