// /pattern/flags
/* flags(组合): 
    1. m(multiple)多行匹配
    2. i(ignore) 忽略大小写
    3. g(global) 全局匹配
*/
var regx = /ab+c/g;

// new RegExp('pattern','flags')
// flags 同上

var regx = new RegExp("ab+c");
var regex = new RegExp(/^[a-zA-Z]+[0-9]*\W?_$, "gi");

var s = 'you love me and I love you';
var pattern = /you/;
var ans = pattern.test(s);
console.log(ans); // true

var rex = new RegExp("d(b+)d", "g");
var arr = rex.exec("cdbbdbsbz");

var s = 'you love me and I love you';
var pattern = /you/;
var ans = s.search(pattern);
console.log(ans);  // 0

var s = 'you love me and I love you';
console.log(s.match(/you/));    // ["you", index: 0, input: "you love me and I love you"]
console.log(s.match(/you/g));   // ["you", "you"]

var s = 'you love me and I love you';
console.log(s.replace('you', 'zichi')); // zichi love me and I love you
console.log(s.replace(/you/, 'zichi')); // zichi love me and I love you
console.log(s.replace(/you/g, 'zichi'));    // zichi love me and I love zichi

var s = 'I love you';
var pattern = /love/;
var ans = s.replace(pattern, '$`' + '$&' + "$'");
console.log(ans); // I I love you you

//交换 Doe,John ->> John,Doe
var name = "Doe, John";
name.replace(/(\w+)\s*, \s*(\w+)/, "$2 $1");//John,Doe

//首字母大写
name = 'aaa bbb ccc';
uw=name.replace(/\b\w+\b/g, function(word){
  return word.substring(0,1).toUpperCase()+word.substring(1);}
  );

"<%= name %><%- aaa%><%ccc%>".replace(/<%-([\s\S]+?)%>|<%=([\s\S]+?)%>|<%([\s\S]+?)%>|$/g,function(){
console.log(arguments);
});

/<%-([\s\S]+?)%>|<%=([\s\S]+?)%>|<%([\s\S]+?)%>|$/g.exec("<%= name %><%- aaa%><%ccc%>");


//每次function接收的参数和执行exec的方法的内容一样,但是有点区别
//执行exec返回的是一个数组，[匹配到的字符串，子表达式匹配到的字符串1，子表达式2匹配的到字符串,....,子表示n匹配的字符串]，属性包括,input 元字符串,index 匹配到的字符串的起始索引

var s = 'you love me and I love you';
var pattern = 'and';
var ans = s.split(pattern);
console.log(ans);   // ["you love me ", " I love you"]

var str = 'cat10,bat20,kat30';
var patten = /\w(at)\d+/;
var arr = str.match(patten);
arr[0] <=> ['cat10']
arr[1] <=> ['at']

var arr = patten.exec(str);
arr[0] <=> ['cat10']
arr[1] <=> ['at']

//示例1：

var str = 'cat,bat,kat';
var patten = /at/g;
str.match(patten);  //['at', 'at', 'at']
patten.exec(str);  //['at']


//示例2：

var str = 'cat,bat,kat';
var patten = /\w+/g;
str.match(patten);  //['cat', 'bat', 'kat']

//第一次调用
patten.exec(str);  //['cat']
//第二次调用
patten.exec(str);  //['bat']
//第三次调用
patten.exec(str);  //['kat']

var str = 'cat10,bat20,kat30';
var patten = /\w(at)\d+/g;
var arr = str.match(patten);  //['cat10', 'bat20', 'kat30']
var arr = patten.exec(str);
arr[0] <=> ['cat10']
arr[1] <=> ['at']

 String str="abcaxc";
 Patter p="ab*c";

 // underscore代码
  // By default, Underscore uses ERB-style template delimiters, change the
  // following template settings to use alternative delimiters.
  _.templateSettings = {
    evaluate: /<%([\s\S]+?)%>/g,
    interpolate: /<%=([\s\S]+?)%>/g,
    escape: /<%-([\s\S]+?)%>/g
  };

  // When customizing `templateSettings`, if you don't want to define an
  // interpolation, evaluation or escaping regex, we need one that is
  // guaranteed not to match.
  var noMatch = /(.)^/;

  // Certain characters need to be escaped so that they can be put into a
  // string literal.
  var escapes = {
    "'": "'",
    '\\': '\\',//
    '\r': 'r',//回车
    '\n': 'n',//换行
    '\u2028': 'u2028',//行分隔符
    '\u2029': 'u2029'//段落分隔符
  };

  var escapeRegExp = /\\|'|\r|\n|\u2028|\u2029/g;

  var escapeChar = function(match) {
    return '\\' + escapes[match];
  };

  // JavaScript micro-templating, similar to John Resig's implementation.
  // Underscore templating handles arbitrary delimiters, preserves whitespace,
  // and correctly escapes quotes within interpolated code.
  // NB: `oldSettings` only exists for backwards compatibility.
  _.template = function(text, settings, oldSettings) {
    if (!settings && oldSettings) settings = oldSettings;
    settings = _.defaults({}, settings, _.templateSettings);

    // Combine delimiters into one regular expression via alternation.
    var matcher = RegExp([
      (settings.escape || noMatch).source,
      (settings.interpolate || noMatch).source,
      (settings.evaluate || noMatch).source
    ].join('|') + '|$', 'g');

    // Compile the template source, escaping string literals appropriately.
    var index = 0;
    var source = "__p+='";
    // 匹配的组
    text.replace(matcher, function(match, escape, interpolate, evaluate, offset) {

      //replace function args
      source += text.slice(index, offset).replace(escapeRegExp, escapeChar);
      index = offset + match.length;

      if (escape) {
        source += "'+\n((__t=(" + escape + "))==null?'':_.escape(__t))+\n'";
      } else if (interpolate) {
        source += "'+\n((__t=(" + interpolate + "))==null?'':__t)+\n'";
      } else if (evaluate) {
        source += "';\n" + evaluate + "\n__p+='";
      }

      // Adobe VMs need the match returned to produce the correct offset.
      return match;
    });
    source += "';\n";

    // If a variable is not specified, place data values in local scope.
    if (!settings.variable) source = 'with(obj||{}){\n' + source + '}\n';

    source = "var __t,__p='',__j=Array.prototype.join," +
      "print=function(){__p+=__j.call(arguments,'');};\n" +
      source + 'return __p;\n';

    var render;
    try {
      render = new Function(settings.variable || 'obj', '_', source);
    } catch (e) {
      e.source = source;
      throw e;
    }

    var template = function(data) {
      return render.call(this, data, _);
    };

    // Provide the compiled source as a convenience for precompilation.
    var argument = settings.variable || 'obj';
    template.source = 'function(' + argument + '){\n' + source + '}';

    return template;
  };

var Book = (function(){
    //只在创建类的时候初始化一次
    //私有的静态属性
    var numberOfBook = 0;
    
    //私有的静态方法
    /*
     私用属性和静态方法，可以用"_"的方式标记；但是仍然无法避免被覆盖；
     通过闭包实现则不会被覆盖；
    */
    function checkISBN(){
    
    }
    //constuctor 返回构造方法
    return function(newIsbn,newTitle,newAuthor){
        //私有属性
        var isbn,title,author;
        //创建属性的访问器
        this.setIsbn = function(newIsbn){
            if(!checkISBN(newIsbn)){
                throw new Error("isbn format is error!!");
            }
            isbn = newIsbn;
        }
        this.getIsbn = function(){
            return isbn;
        }
        this.setTitle = function(newTitle){
            title = newTitle;
        }
        this.getTitle = function(){
            return title;
        }
        this.setAuthor = function(newAuthor){
            author = newAuthor;
        }
        this.getAuthor = function(){
            return author;
        }
        //初始化动作
        numberOfBook++;
        this.setIsbn(newIsbn);
        this.setTitle(newTitle);
        this.setAuthor(newAuthor);
        
    }
})();
//公开的静态方法
Book.covertToTitleCase = function(){
    
}
//公开的非私有方法
Book.prototype = {
    display:function(){
        
    }
}

function extend(subClass,supClass){
    var F = function(){};
    F.prototype =  supClass.prototype;
    //subClass.prototype= new F().__proto__ = supClass.prototype
    subClass.prototype = new F();
    subClass.subClass =  supClass.prototype;
    
    if(supClass.prototype.constructor == Object.prototype.constructor){
        supClass.prototype.constructor = supClass;
    }
}

function clone(object){
    function F(){};
    F.prototype = object;
    return new F;
}

function Mixin(){};
Mixin.prototype={
    serialize:function(){
        
    }
}

  function augment(rc,gc){
        if(arguments[2]){//继承指定的方法
            for(var i=2,len=arguments.length;i<len;i++){
                rc.prototype[arguments[i]] = gc.prototype[arguments[i]];
            }
        }else{
            for(var pro in gc.prototype){
                if(!rc.prototype[pro]){
                    rc.prototype[pro] = gc.prototype[pro];
                }
            }
        }
    }

var fs = require("fs");
fs.readFile("./a.json",function(err,data){
    fs.readFile("./b.json",function(err,data){
        ....
    });        
});

var readFile = require('fs-readfile-promise');

readFile(fileA)
.then(function(data){
  console.log(data.toString());
})
.then(function(){
  return readFile(fileB);
})
.then(function(data){
  console.log(data.toString());
})
.catch(function(err) {
  console.log(err);
});

function Promise(fn) {
    var state = 'pending',
        value = null,
        callbacks = [];

    this.then = function (onFulfilled, onRejected) {
        return new Promise(function (resolve, reject) {
            handle({
                onFulfilled: onFulfilled || null,
                onRejected: onRejected || null,
                resolve: resolve,
                reject: reject
            });
        });
    };
    //增加异常处理
    function handle(callback) {
        if (state === 'pending') {
            callbacks.push(callback);
            return;
        }

        var cb = state === 'fulfilled' ? callback.onFulfilled : callback.onRejected,
            ret;
        if (cb === null) {
            cb = state === 'fulfilled' ? callback.resolve : callback.reject;
            cb(value);
            return;
        }
        try {
            ret = cb(value);
            callback.resolve(ret);
        } catch (e) {
            callback.reject(e);
        }
    }

    function resolve(newValue) {
        if (newValue && (typeof newValue === 'object' || typeof newValue === 'function')) {
            var then = newValue.then;
            if (typeof then === 'function') {
                then.call(newValue, resolve, reject);
                return;
            }
        }
        state = 'fulfilled';
        value = newValue;
        execute();
    }

    function reject(reason) {
        state = 'rejected';
        value = reason;
        execute();
    }

    function execute() {
        setTimeout(function () {
            callbacks.forEach(function (callback) {
                handle(callback);
            });
        }, 0);
    }

    fn(resolve, reject);
}

function asnycJob() {
  // ...其他代码
  var f = yield readFile(fileA);
  // ...其他代码
}

//定义
function* gen(x){
  var y = yield x + 2;
  return y;
}

//执行
var g = gen(1);
g.next() // { value: 3, done: false }
g.next() // { value: undefined, done: true }

var fetch = require('node-fetch');

function* gen(){
  var url = 'https://api.github.com/users/github';
  var result = yield fetch(url);
  console.log(result.bio);
}

//执行
var g = gen();
var result = g.next();

//返回的是promise对象
result.value.then(function(data){
  return data.json();
}).then(function(data){
  g.next(data);
});

fn(x+5)
//形参的两种求值策略
//1. 传值时的调用

f(x + 5)
// 传值调用时，等同于
f(6)

//2. 传名时调用

f(x + 5)
// 传名调用时，等同于
(x + 5) * 2

// 正常版本的readFile（多参数版本）
fs.readFile(fileName, callback);

// Thunk版本的readFile（单参数版本）
var readFileThunk = Thunk(fileName);
readFileThunk(callback);

var Thunk = function (fileName){
 return function (callback){
   return fs.readFile(fileName, callback); 
 };
};

var Thunk = function(fn){
  return function (){
    var args = Array.prototype.slice.call(arguments);
    return function (callback){
      args.push(callback);
      return fn.apply(this, args);
    }
  };
};

var readFileThunk = Thunk(fs.readFile);
//readFileTrunk(fileA) 并没有执行而是返回一个函数
readFileThunk(fileA)(callback);

function thunkify(fn){
  return function(){
    var args = new Array(arguments.length);
    var ctx = this;

    for(var i = 0; i < args.length; ++i) {
      args[i] = arguments[i];
    }

    return function(done){
      var called;

      args.push(function(){
        if (called) return;
        called = true;
        done.apply(null, arguments);
      });

      try {
        fn.apply(ctx, args);
      } catch (err) {
        done(err);
      }
    }
  }
};

//它的源码主要多了一个检查机制，变量 called 确保回调函数只运行一次。这样的设计与下文的 Generator 函数相关.

var fs = require('fs');
var thunkify = require('thunkify');
var readFile = thunkify(fs.readFile);

var gen = function* (){
  var r1 = yield readFile('/etc/fstab');
  console.log(r1.toString());
  var r2 = yield readFile('/etc/shells');
  console.log(r2.toString());
};

//手动执行
var g = gen();

var r1 = g.next();
r1.value(function(err, data){
  if (err) throw err;
  var r2 = g.next(data);
  r2.value(function(err, data){
    if (err) throw err;
    g.next(data);
  });
});

//基于trunk函数的自动执行器
function run(fn) {
  var gen = fn();

  function next(err, data) {
    var result = gen.next(data);
    if (result.done) return;
    result.value(next);
  }

  next();
}

run(gen);

/*
函数 gen 封装了 n 个异步的读取文件操作，只要执行 run 函数，这些操作就会自动完成。这样一来，异步操作不仅可以写得像同步操作，而且一行代码就可以执行
*/

/*

Thunk 函数并不是 Generator 函数自动执行的唯一方案。因为自动执行的关键是，必须有一种机制，自动控制 Generator 函数的流程，接收和交还程序的执行权。回调函数可以做到这一点，Promise 对象也可以做到这一点

*/

var gen = function* (){
  var f1 = yield readFile('/etc/fstab');
  var f2 = yield readFile('/etc/shells');
  console.log(f1.toString());
  console.log(f2.toString());
};

//co 函数库可以让你不用编写 Generator 函数的执行器。

var co = require('co');
co(gen);

//co 函数返回一个 Promise 对象，因此可以用 then 方法添加回调函数。

co(gen).then(function (){
  console.log('Generator 函数执行完成');
})

// 数组的写法
co(function* () {
  var res = yield [
    Promise.resolve(1),
    Promise.resolve(2)
  ];
  console.log(res); 
}).catch(onerror);

// 对象的写法
co(function* () {
  var res = yield {
    1: Promise.resolve(1),
    2: Promise.resolve(2),
  };
  console.log(res); 
}).catch(onerror);

var fs = require('fs');

var readFile = function (fileName){
  return new Promise(function (resolve, reject){
    fs.readFile(fileName, function(error, data){
      if (error) reject(error);
      resolve(data);
    });
  });
};

var gen = function* (){
  var f1 = yield readFile('/etc/fstab');
  var f2 = yield readFile('/etc/shells');
  console.log(f1.toString());
  console.log(f2.toString());
};

var asyncReadFile = async function (){
  var f1 = await readFile('/etc/fstab');
  var f2 = await readFile('/etc/shells');
  console.log(f1.toString());
  console.log(f2.toString());
};

var result = asyncReadFile();

 var obj = {
   a:1,
   b:2
 }
 obj.a

Foo function(a,b){
    this.a = a;
    this.b = b;
}
Foo.prototype.say = function(){
    
}
var foo = new Foo(1,2);
foo.a;
foo.a;

var obj = Objct.create({
    a:1,
    b:1,
    say:function(){
        
    }
});

obj.a;
obj.say();

 function new(func){
    var o = {};
    ret.__proto__= func.prototype;
    var ret = func.call(o,arguments);
    return typeof ret === 'object'? ret : obj;
 }
 

//设 L instanceof R 
//通过判断
 L.__proto__.__proto__ ..... === R.prototype ？
//最终返回true or false

Function instanceof Object // true 
Object instanceof Function // true 
Function instanceof Function //true
Object instanceof Object // true
Number instanceof Number //false

//实现Function.prototype.bind 的Polyfill

//扩展Function原型
if (!Function.prototype.bind) {
    Function.prototype.bind = function (oThis) {
        if (typeof this !== "function") {
            // closest thing possible to the ECMAScript 5
            // internal IsCallable function
            throw new TypeError("Function.prototype.bind - what is trying to be bound is not callable");
        }

        var aArgs = Array.prototype.slice.call(arguments, 1),
            fToBind = this,
            fNOP = function () {},
            fBound = function () {//fBound继承自this
                return fToBind.apply(this instanceof fNOP
                        ? this
                        : oThis || this,
                    aArgs.concat(Array.prototype.slice.call(arguments)));
            };

        fNOP.prototype = this.prototype;
        fBound.prototype = new fNOP();

        return fBound;
    };
}
//非扩展方式实现
function bind(func,context,arg){
    if(typeof func !== "function") throw new TypeError("Bind must be called on a function");
    var args = Array.prototype.slice.call(arguments,2),
        Cort = function(){},
        bound = function (){
            //非构造函数方式
            if(!(this instanceof func)){
                return func.apply(context||this,args.concat(arguments));
            }
            //构造函数方式
            Cort.prototype = func.prototype;
            //this.__proto__ ==  bound.prototype.__proto__ = new FONP.__proto__ = FONP.prototype = func.prototype
            //this instaceof func  --> true;
            bound.protype = new Cort();
            func.apply(this instanceof func?this:context||this,args.concat(arguments));
        };
    return bound;
}

var n = "other";
var mod = {
    n:"mod",
    sayName:function(){
        console.log(this.n);
    }
}
var sayName = mod.sayName;
sayName();//this.n==>window.n  other

// 创建一个新函数，将"this"绑定到mod对象
var sayName1 = mod.sayName.bind(mod);
sayName1();//mod

function list() {
  return Array.prototype.slice.call(arguments);
}

var list1 = list(1, 2, 3); // [1, 2, 3]

// Create a function with a preset leading argument
var leadingThirtysevenList = list.bind(undefined, 37);

var list2 = leadingThirtysevenList(); // [37]
var list3 = leadingThirtysevenList(1, 2, 3); // [37, 1, 2, 3]

var a =1;
var obj={
    a:10,
    timer:function(){
    
        setTimeout(function(){
            console.log(this.a);
        },1000);
    }
};
obj.timer();//1 此时this指向window

//bing解决
function LateBloomer() {
  this.petalCount = Math.ceil(Math.random() * 12) + 1;
}

// Declare bloom after a delay of 1 second
LateBloomer.prototype.bloom = function() {
  window.setTimeout(this.declare.bind(this), 1000);
};

LateBloomer.prototype.declare = function() {
  console.log('I am a beautiful flower with ' +
    this.petalCount + ' petals!');
};

var flower = new LateBloomer();
flower.bloom();  // 一秒钟后, 调用'declare'方法

function Point(x, y) {
  this.x = x;
  this.y = y;
}

Point.prototype.toString = function() { 
  return this.x + ',' + this.y; 
};

var p = new Point(1, 2);
p.toString(); // '1,2'

var emptyObj = {};
var YAxisPoint = Point.bind(emptyObj, 0/*x*/);
// 以下这行代码在 polyfill 不支持,
// 在原生的bind方法运行没问题:
//(译注：polyfill的bind方法如果加上把bind的第一个参数，即新绑定的this执行Object()来包装为对象，Object(null)则是{}，那么也可以支持)
var YAxisPoint = Point.bind(null, 0/*x*/);

var axisPoint = new YAxisPoint(5);
axisPoint.toString(); // '0,5'

axisPoint instanceof Point; // true
axisPoint instanceof YAxisPoint; // true
new Point(17, 42) instanceof YAxisPoint; // true

// 仍然能作为一个普通函数来调用
// (即使通常来说这个不是被期望发生的)
YAxisPoint(13);

emptyObj.x + ',' + emptyObj.y;   //  '0,13'

var slice = Array.prototype.slice;
slice.apply(arguments);

//bind
var unboundSlice = Array.prototype.slice;
var slice = Function.prototype.call.bind(unboundSlice);
slice(arguments);

  // Naked function reference for surrogate-prototype-swapping.
  var Ctor = function(){};
  //不定参转换
  var restArgs = function(func, startIndex) {
    //TODO:func.length 返回的是形参的数量
    //TODO:arguments返回的是实参的数量

    startIndex = startIndex == null ? func.length - 1 : +startIndex;
    return function() {

      var length = Math.max(arguments.length - startIndex, 0),//返回参数的长度 - 开始的索引  默认是0
          rest = Array(length),//构造restArgs的容器
          index = 0;
      for (; index < length; index++) {
        rest[index] = arguments[index + startIndex];
      }
      switch (startIndex) {
        case 0: return func.call(this, rest);
        case 1: return func.call(this, arguments[0], rest);
        case 2: return func.call(this, arguments[0], arguments[1], rest);
      }
      var args = Array(startIndex + 1);
      for (index = 0; index < startIndex; index++) {
        args[index] = arguments[index];
      }
      args[startIndex] = rest;
      return func.apply(this, args);
    };
  };
  
  //实现继承
  var baseCreate = function(prototype) {
    if (!_.isObject(prototype)) return {};
    if (nativeCreate) return nativeCreate(prototype);//Object.create
    Ctor.prototype = prototype;
    var result = new Ctor;
    Ctor.prototype = null;
    return result;
  };
  //executeBound
  var executeBound = function(sourceFunc, boundFunc, context, callingContext, args) {
    //非构造函数方式
   //return executeBound(func, bound, context, this, args.concat(callArgs));

    if (!(callingContext instanceof boundFunc)) return sourceFunc.apply(context, args);

    //构造函数方式
    var self = baseCreate(sourceFunc.prototype);
    var result = sourceFunc.apply(self, args);
    if (_.isObject(result)) return result;//obj
    return self;
  };
  
  //bind实现
  _.bind = restArgs(function(func, context, args) {
    if (!_.isFunction(func)) throw new TypeError('Bind must be called on a function');
    var bound = restArgs(function(callArgs) {
      return executeBound(func, bound, context, this, args.concat(callArgs));
    });
    return bound;
  });

//偏函数实现
  // Partially apply a function by creating a version that has had some of its
  // arguments pre-filled, without changing its dynamic `this` context. _ acts
  // as a placeholder by default, allowing any combination of arguments to be
  // pre-filled. Set `_.partial.placeholder` for a custom placeholder argument.
  _.partial = restArgs(function(func, boundArgs) {
    var placeholder = _.partial.placeholder;
    var bound = function() {
      var position = 0, length = boundArgs.length;
      var args = Array(length);
      for (var i = 0; i < length; i++) {
        args[i] = boundArgs[i] === placeholder ? arguments[position++] : boundArgs[i];
      }
      while (position < arguments.length) args.push(arguments[position++]);
      return executeBound(func, bound, this, this, args);
    };
    return bound;
  });

  _.partial.placeholder = _;

  // Bind a number of an object's methods to that object. Remaining arguments
  // are the method names to be bound. Useful for ensuring that all callbacks
  // defined on an object belong to it.
  _.bindAll = restArgs(function(obj, keys) {
    keys = flatten(keys, false, false);
    var index = keys.length;
    if (index < 1) throw new Error('bindAll must be passed function names');
    while (index--) {
      var key = keys[index];
      obj[key] = _.bind(obj[key], obj);
    }
  });

 
 (function(factory){
    //UMD包装    
 })(function(root, Backbone, _, $){
    var previousBackbone = root.Backbone;
    Backbone.$ = $;

    Backbone.noConflict = function() {
        root.Backbone = previousBackbone;
        return this;
    };
    
    //Events
    var Events = {};
    _.extend(Backbone,Events);
    
    //Model
    var Model = Backbone.Model = function(){}
    _.extend(Model.prototype,Events,{});
    
    //Collection
    var Collection = Backbone.Collection = function(){}
    _.extend(Collection.prototype,Events,{});
    
    //View
    var View = Backbone.View = function(){}
    _.extend(View.prototype,Events,{});
    
    //sync
    Backbone.sync = function(method, model, options){};
    
    //Router
    var Router = Backbone.Router = function(){}
    _.extend(Router.prototype,Events,{});
    
    //History
    var History = Backbone.History = function() {}
    
    //Helper
    var extend = function(protoProps, staticProps){}
    Model.extend = Collection.extend = Router.extend = View.extend = History.extend = extend;
    
    var urlError = function() {};
    var wrapError = function(model, options) {};
    
    
    return Backbone;
 });
 

/*
 * 绑定事件
 * this.on("event"||"event1 event2",function(){}||{event1:fn1,event2:fn2});
 */
Events.on = function(name, callback, context) {
    return internalOn(this, name, callback, context);
}

Events.bind = Events.on;

// 解除绑定
// Remove one or many callbacks. If `context` is null, removes all
// callbacks with that function. If `callback` is null, removes all
// callbacks for the event. If `name` is null, removes all bound
// callbacks for all events.
Events.off = function(name, callback, context) {
    if (!this._events) return this;
    this._events = eventsApi(offApi, this._events, name, callback, {
      context: context,
      listeners: this._listeners
    });
    return this;
  };

  // Inversion-of-control versions of `on`. Tell *this* object to listen to
  // an event in another object... keeping track of what it's listening to
  // for easier unbinding later.
  Events.listenTo = function(obj, name, callback) {
}

// Tell this object to stop listening to either specific events ... or
  // to every object it's currently listening to.
  Events.stopListening = function(obj, name, callback) {
    var listeningTo = this._listeningTo;
    if (!listeningTo) return this;

    var ids = obj ? [obj._listenId] : _.keys(listeningTo);

    for (var i = 0; i < ids.length; i++) {
      var listening = listeningTo[ids[i]];

      // If listening doesn't exist, this object is not currently
      // listening to obj. Break out early.
      if (!listening) break;

      listening.obj.off(name, callback, this);
    }

    return this;
  };

// Extract attributes and options.
// 扩展的属性操作
// unset 是否删除属性
// silent 是否触发chang事件
      
//递归调用做了处理
// You might be wondering why there's a `while` loop here. Changes can
// be recursively nested within `"change"` events.
// 变化可以递归嵌套在“改变”的事件。
// 处理在set调用期间,再次调用set的这种递归调用

events:{
    "click .name":function(){
        
    },
    "keypress .input":"show"
}
this.show = function(){}

  // Backbone Views are almost more convention than they are actual code. A View
  // is simply a JavaScript object that represents a logical chunk of UI in the
  // DOM. This might be a single item, an entire list, a sidebar or panel, or
  // even the surrounding frame which wraps your whole app. Defining a chunk of
  // UI as a **View** allows you to define your DOM events declaratively, without
  // having to worry about render order ... and makes it easy for the view to
  // react to specific changes in the state of your models.

  // Creating a Backbone.View creates its initial element outside of the DOM,
  // if an existing element is not provided...
  var View = Backbone.View = function(options) {
  
      
  }；
  // Cached regex to split keys for `delegate`.
  var delegateEventSplitter = /^(\S+)\s*(.*)$/;

  // List of view options to be set as properties.
  // 限定options指定的属性
  var viewOptions = ['model', 'collection', 'el', 'id', 'attributes', 'className', 'tagName', 'events'];
  //注意，tagName className 和el的区别
 

// Backbone.sync
  // -------------

  // Override this function to change the manner in which Backbone persists
  // models to the server. You will be passed the type of request, and the
  // model in question. By default, makes a RESTful Ajax request
  // to the model's `url()`. Some possible customizations could be:
  //
  // * Use `setTimeout` to batch rapid-fire updates into a single request.
  // * Send up the models as XML instead of JSON.
  // * Persist models via WebSockets instead of Ajax.
  //
  // Turn on `Backbone.emulateHTTP` in order to send `PUT` and `DELETE` requests
  // as `POST`, with a `_method` parameter containing the true HTTP method,
  // as well as all requests with the body as `application/x-www-form-urlencoded`
  // instead of `application/json` with the model in a param named `model`.
  // Useful when interfacing with server-side languages like **PHP** that make
  // it difficult to read the body of `PUT` requests.
   Backbone.sync = function(method, model, options) {
    };
      // Map from CRUD to HTTP for our default `Backbone.sync` implementation.
  //同步方法，对应的mothod操作      
  var methodMap = {
    'create': 'POST',
    'update': 'PUT',
    'patch': 'PATCH',
    'delete': 'DELETE',
    'read': 'GET'
  };

  // Set the default implementation of `Backbone.ajax` to proxy through to `$`.
  // Override this if you'd like to use a different library.
  Backbone.ajax = function() {
    return Backbone.$.ajax.apply(Backbone.$, arguments);
  };

/* 

初始化参数，routes 将带参数的 URLs 映射到路由实例的方法上（或只是直接的函数定义，如果你喜欢），这与 View（视图） 的 events hash（事件键值对） 非常类似。 路由可以包含参数， :param，它在斜线之间匹配 URL 组件。 路由也支持通配符， *splat，可以匹配多个 URL 组件。 路由的可选部分放在括号中(/:optional)。

举个例子，路由 "search/:query/p:page" 能匹配#search/obama/p2 , 这里传入了 "obama" 和 "2" 到路由对应的动作中去了。

路由 "file/*path"可以匹配 #file/nested/folder/file.txt，这时传入动作的参数为 "nested/folder/file.txt"。

路由 "docs/:section(/:subsection)"可以匹配#docs/faq 和 #docs/faq/installing，第一种情况，传入 "faq" 到路由对应的动作中去， 第二种情况，传入"faq" 和 "installing" 到路由对应的动作中去。

结尾的斜杠会被当作URL的一部分， 访问时会被（正确地）当作一个独立的路由。 docs 和 docs/将触发不同的回调。 如果你不能避免产生这两种类型的URLs时， 你可以定义一个"docs(/)"来匹配捕捉这两种情况。

当访问者点击浏览器后退按钮，或者输入 URL ，如果匹配一个路由，此时会触发一个基于动作名称的 event， 其它对象可以监听这个路由并接收到通知。 下面的示例中，用户访问 #help/uploading 将从路由中触发 route:help 事件。

routes: {
  "help/:page":         "help",
  "download/*path":     "download",
  "folder/:name":       "openFolder",
  "folder/:name-:mode": "openFolder"
}
router.on("route:help", function(page) {
  ...
});

*/

//核心方法

/*为路由对象手动创建路由，route 参数可以是 routing string（路由字符串） 或 正则表达式。 每个捕捉到的被传入的路由或正则表达式，都将作为参数传入回调函数（callback）。 一旦路由匹配， name 参数会触发 "route:name" 事件。如果callback参数省略 router[name]将被用来代替。 后来添加的路由可以覆盖先前声明的路由。
*/
route: function(route, name, callback) {
  return this;
},
/*
每当你达到你的应用的一个点时，你想保存为一个URL，  可以调用navigate以更新的URL。 如果您也想调用路由功能， 设置trigger选项设置为true。 无需在浏览器的历史记录创建条目来更新URL，  设置 replace选项设置为true。
*/
execute: function(callback, args, name) {
  if (callback) callback.apply(this, args);
},
// Simple proxy to `Backbone.history` to save a fragment into the history.
/*
这种方法在路由内部被调用，  每当路由和其相应的callback匹配时被执行。 覆盖它来执行自定义解析或包装路由， 例如， 在传递他们给你的路由回调之前解析查询字符串，像这样：
var Router = Backbone.Router.extend({
  execute: function(callback, args) {
    args.push(parseQueryString(args.pop()));
    if (callback) callback.apply(this, args);
  }
});
*/
navigate: function(fragment, options) {
  Backbone.history.navigate(fragment, options);
  return this;
},

// Backbone.History
  // ----------------

  // Handles cross-browser history management, based on either
  // [pushState](http://diveintohtml5.info/history.html) and real URLs, or
  // [onhashchange](https://developer.mozilla.org/en-US/docs/DOM/window.onhashchange)
  // and URL fragments. If the browser supports neither (old IE, natch),
  // falls back to polling.
  var History = Backbone.History = function() {
  }

  //实现了一个继承
  // Helper function to correctly set up the prototype chain for subclasses.
  // Similar to `goog.inherits`, but uses a hash of prototype properties and
  // class properties to be extended.
  var extend = function(protoProps, staticProps) {
    var parent = this;
    var child;

    // The constructor function for the new subclass is either defined by you
    // (the "constructor" property in your `extend` definition), or defaulted
    // by us to simply call the parent constructor.
    if (protoProps && _.has(protoProps, 'constructor')) {
      child = protoProps.constructor;
    } else {
      child = function(){ return parent.apply(this, arguments); };
    }

    // Add static properties to the constructor function, if supplied.
    _.extend(child, parent, staticProps);

    // Set the prototype chain to inherit from `parent`, without calling
    // `parent`'s constructor function and add the prototype properties.
    child.prototype = _.create(parent.prototype, protoProps);
    child.prototype.constructor = child;

    // Set a convenience property in case the parent's prototype is needed
    // later.
    child.__super__ = parent.prototype;

    return child;
  };

var Interface = function(name,methods){
    if(arguments.length!=2){
        throw new Error("Interface constructor called with "+
        arguments.length +" arguments,but expected exactly 2");
    }    
    this.name = name;
    this.methods = [];
    for(var i=0,len=methods.length;i<len;i++){
        if(type methods[i]!="string"){
            throw new Error("Interface constructor expects method names 
            to be passed in as a string");
        }
        this.methods.push(method[i]);
    }
}

//static class method

Interface.ensureImplements = function(obj){
    if(arguments.length<2){
        throw new Error("Function Interface.ensureImplements called witdh
        "+arguments.length+"arguments ,but expected at least 2");
    }
    for(var i = 1,len = arguments.length;i<len;i++){
        var interface = arguments[i];
        if(interface.constructor !== Interface){
            throw new Error("Function interface,ensureImplemnts expects 
            arguments two and above-to be instances of Interface");
        }
        for(var j=0,methodslen = interface.methods.length;j<methodsLen;j++){
            var method = interface.methods[j];
            if(!object[method] || typeof object[mthod] !=="function"){
                throw new Error("Function interface.ensureImplements:object does not implement the "+ interface.name +" interface.mthod "+method+"was not found.");
            }
        }
        
    }
}