1.Model

우선 하류를 분석하다.

var myM = Backbone.Model.extend({})//    Model ，myM

>_.keys(myM)

["extend", "__super__"]

>_.keys(Backbone.Model)

["extend"]

>_.isObject(myM.__super__)

true

>_.keys(myM.__super__)

["on", "once", "off", "trigger", "stopListening", "listenTo", "listenToOnce", "bind", "unbind", "changed", "validationError", "idAttribute", "initialize", "toJSON", "sync", "get", "escape", "has", "set", "unset", "clear", "hasChanged", "changedAttributes", "previous", "previousAttributes", "fetch", "save", "destroy", "url", "parse", "clone", "isNew", "isValid", "_validate", "keys", "values", "pairs", "invert", "pick", "omit"]

function (options) {

      options = options ? _.clone(options) : {};

      if (options.parse === void 0) options.parse = true;

      var model = this;

      var success = options.success;

      options.success = function(resp) {

        if (!model.set(model.parse(resp, options), options)) return false;

        if (success) success(model, resp, options);

        model.trigger('sync', model, resp, options);

      };

      wrapError(this, options);

      return this.sync('read', this, options);

    } 

function () {

      return Backbone.sync.apply(this, arguments);

    } 

분석 클래스의 인스턴스입니다.

>m_obj= new myM;

s {cid: "c6", attributes: Object, _changing: false, _previousAttributes: Object, changed: Object…}

>_.isObject(m_obj)

true

>_.keys(m_obj)

["cid", "attributes", "_changing", "_previousAttributes", "changed", "_pending"]

>_.functions(m_obj)

["_validate", "bind", "changedAttributes", "clear", "clone", "constructor", "destroy", "escape", "fetch", "get", "has", "hasChanged", "initialize", "invert", "isNew", "isValid", "keys", "listenTo", "listenToOnce", "off", "omit", "on", "once", "pairs", "parse", "pick", "previous", "previousAttributes", "save", "set", "stopListening", "sync", "toJSON", "trigger", "unbind", "unset", "url", "values"]

>m_obj_funcs = _.functions(m_obj)

base_funcs = _.functions(myM.__super__)

_.filter(base_funcs, function(f){return _.contains(m_obj_funcs,f)})



["_validate", "bind", "changedAttributes", "clear", "clone", "destroy", "escape", "fetch", "get", "has", "hasChanged", "initialize", "invert", "isNew", "isValid", "keys", "listenTo", "listenToOnce", "off", "omit", "on", "once", "pairs", "parse", "pick", "previous", "previousAttributes", "save", "set", "stopListening", "sync", "toJSON", "trigger", "unbind", "unset", "url", "values"]

>_.filter(m_obj_funcs, function(f){return !_.contains(base_funcs,f);})

["constructor"]

>m_obj.constructor

function (){ return parent.apply(this, arguments); } 

등록 정보

>m_obj.set({'name':'tommy','blog':'http://www.cnblogs.com/Tommy-Yu'})

>m_obj.attributes

Object {name: "tommy", blog: "http://www.cnblogs.com/Tommy-Yu"}

>m_obj.set({'name':'joe'})

>m_obj.changed

Object {name: "joe"}

>m_obj._previousAttributes

Object {name: "tommy", blog: "http://www.cnblogs.com/Tommy-Yu"}

함수.

>m_obj.has('name')

true

>m_obj.has('age')

false

>m_obj.get('name')

"tommy"

>m_obj.previousAttributes()

Object {name: "tommy", blog: "http://www.cnblogs.com/Tommy-Yu"}

>m_obj.previous('name')

"tommy"

>m_obj.toJSON()

Object {name: "tommy", blog: "http://www.cnblogs.com/Tommy-Yu"}

>m_obj.keys()

["name", "blog"]

m_obj.values()

["tommy", "http://www.cnblogs.com/Tommy-Yu"]

>m_obj.isNew()

true

function (method, model, options) {

    var type = methodMap[method];



    // Default options, unless specified.

    _.defaults(options || (options = {}), {

      emulateHTTP: Backbone.emulateHTTP,

      emulateJSON: Backbone.emulateJSON

    });



    // Default JSON-request options.

    var params = {type: type, dataType: 'json'};



    // Ensure that we have a URL.

    if (!options.url) {

      params.url = _.result(model, 'url') || urlError();

    }



    // Ensure that we have the appropriate request data.

    if (options.data == null && model && (method === 'create' || method === 'update' || method === 'patch')) {

      params.contentType = 'application/json';

      params.data = JSON.stringify(options.attrs || model.toJSON(options));

    }



    // For older servers, emulate JSON by encoding the request into an HTML-form.

    if (options.emulateJSON) {

      params.contentType = 'application/x-www-form-urlencoded';

      params.data = params.data ? {model: params.data} : {};

    }



    // For older servers, emulate HTTP by mimicking the HTTP method with `_method`

    // And an `X-HTTP-Method-Override` header.

    if (options.emulateHTTP && (type === 'PUT' || type === 'DELETE' || type === 'PATCH')) {

      params.type = 'POST';

      if (options.emulateJSON) params.data._method = type;

      var beforeSend = options.beforeSend;

      options.beforeSend = function(xhr) {

        xhr.setRequestHeader('X-HTTP-Method-Override', type);

        if (beforeSend) return beforeSend.apply(this, arguments);

      };

    }



    // Don't process data on a non-GET request.

    if (params.type !== 'GET' && !options.emulateJSON) {

      params.processData = false;

    }



    // If we're sending a `PATCH` request, and we're in an old Internet Explorer

    // that still has ActiveX enabled by default, override jQuery to use that

    // for XHR instead. Remove this line when jQuery supports `PATCH` on IE8.

    if (params.type === 'PATCH' && noXhrPatch) {

      params.xhr = function() {

        return new ActiveXObject("Microsoft.XMLHTTP");

      };

    }



    // Make the request, allowing the user to override any Ajax options.

    var xhr = options.xhr = Backbone.ajax(_.extend(params, options));

    model.trigger('request', model, xhr, options);

    return xhr;

  } 

function (key, val, options) {

      var attrs, method, xhr, attributes = this.attributes;



      // Handle both `"key", value` and `{key: value}` -style arguments.

      if (key == null || typeof key === 'object') {

        attrs = key;

        options = val;

      } else {

        (attrs = {})[key] = val;//attrs => Object {key: val}

      }



      options = _.extend({validate: true}, options);



      // If we're not waiting and attributes exist, save acts as

      // `set(attr).save(null, opts)` with validation. Otherwise, check if

      // the model will be valid when the attributes, if any, are set.

      if (attrs && !options.wait) {

        if (!this.set(attrs, options)) return false;

      } else {

        if (!this._validate(attrs, options)) return false;

      }



      // Set temporary attributes if `{wait: true}`.

      if (attrs && options.wait) {

        this.attributes = _.extend({}, attributes, attrs);

      }



      // After a successful server-side save, the client is (optionally)

      // updated with the server-side state.

      if (options.parse === void 0) options.parse = true;

      var model = this;

      var success = options.success;

      options.success = function(resp) {

        // Ensure attributes are restored during synchronous saves.

        model.attributes = attributes;

        var serverAttrs = model.parse(resp, options);

        if (options.wait) serverAttrs = _.extend(attrs || {}, serverAttrs);

        if (_.isObject(serverAttrs) && !model.set(serverAttrs, options)) {

          return false;

        }

        if (success) success(model, resp, options);

        model.trigger('sync', model, resp, options);

      };

      wrapError(this, options);



      method = this.isNew() ? 'create' : (options.patch ? 'patch' : 'update');

      if (method === 'patch') options.attrs = attrs;

      xhr = this.sync(method, this, options);



      // Restore attributes.

      if (attrs && options.wait) this.attributes = attributes;



      return xhr;

    } 

function (resp, options) {

return resp;

}