Backbone.js 0.9.2 소스코드 주석 중국어번역버전_기본지식

// Backbone.js 0.9.2

 

// (c) 2010-2012 Jeremy Ashkenas, DocumentCloud Inc.

// 백본은 MIT 라이선스에 따라 자유롭게 배포될 수 있습니다.

// 모든 세부 사항 및 문서는 다음을 참조하세요.

// http://backbonejs.org

(기능() {

 

  // 브라우저에서는 창 객체로 표시되고 Node.js에서는 전역 객체로 표시되는 전역 객체를 생성합니다.

  var 루트 = 이것;

 

  // 덮어쓰기 전 "Backbone" 변수의 값을 저장합니다.

  // 이름 충돌이 있거나 사양을 고려하는 경우 Backbone.noConstrict() 메서드를 사용하여 변수가 Backbone에 의해 점유되기 전의 값을 복원하고 이름 변경을 위해 Backbone 객체를 반환할 수 있습니다.

  var PreviousBackbone = root.Backbone;

 

  //Array.prototype의 슬라이스 및 스플라이스 메소드를 호출을 위한 로컬 변수에 캐시합니다.

  var 슬라이스 = Array.prototype.slice;

  var splice = Array.prototype.splice;

 

  var 백본;

  if( 내보내기 유형 !== '정의되지 않음') {

    백본 = 수출;

  } 또 다른 {

    백본 = 루트.백본 = {};

  }

 

  //백본 버전 정의

  백본.VERSION = '0.9.2';

 

  // 서버 환경에서 Underscore를 자동으로 가져옵니다. Backbone의 일부 메소드는 Underscore에 의존하거나 상속받습니다.

  var _ = 루트._;

  if(!_ && ( typeof 필요 !== '정의되지 않음'))

    _ = require('밑줄');

 

  // 타사 라이브러리를 보기(View), 이벤트 처리 및 서버 데이터와의 동기화(sync) 중에 라이브러리의 메소드를 호출하는 데 사용되는 통합 변수 "$"로 정의합니다.

  // 지원되는 라이브러리에는 jQuery, Zepto 등이 있습니다. 구문은 동일하지만 Zepto가 모바일 개발에 더 적합합니다. 주로 Webkit 핵심 브라우저를 대상으로 합니다.

  // Backbone에서 사용하기 위해 jQuery와 유사한 구문으로 사용자 정의 라이브러리를 사용자 정의할 수도 있습니다(때로는 jQuery 또는 Zepto보다 가벼운 사용자 정의 버전이 필요할 수 있음)

  // 여기에 정의된 "$"는 지역 변수이므로 Backbone 프레임워크 외부의 타사 라이브러리를 정상적으로 사용하는 데에는 영향을 미치지 않습니다.

  var $ = root.jQuery || root.Zepto ||

 

  // 타사 라이브러리를 수동으로 설정

  // Backbone을 가져오기 전에 타사 라이브러리를 가져오지 않은 경우 setDomLibrary 메소드를 통해 "$" 지역 변수를 설정할 수 있습니다.

  // setDomLibrary 메소드는 Backbone에서 사용자 정의 라이브러리를 동적으로 가져오는 데에도 일반적으로 사용됩니다.

  Backbone.setDomLibrary = 함수(lib) {

    $ = 라이브러리;

  };

  //"Backbone" 이후 프레임워크 이름 지정을 포기하고 일반적으로 이름 지정 충돌을 피하거나 이름 지정 방법을 표준화하는 데 사용되는 Backbone 개체를 반환합니다.

  // 예를 들어:

  // var bk = Backbone.noConstrict(); // "Backbone" 명명을 취소하고 Backbone 객체를 bk 변수에 저장합니다.

  // console.log(Backbone); // 이 변수는 더 이상 Backbone 객체에 접근할 수 없으며 Backbone이 정의되기 전의 값으로 복원됩니다.

  // var MyBackbone = bk; // 그리고 bk는 Backbone 객체를 저장하고 이름을 MyBackbone으로 바꿉니다.

  Backbone.noConstrict = function() {

    root.Backbone = 이전백본;

    이거 돌려줘;

  };

  // REST를 지원하지 않는 브라우저의 경우 Backbone.emulateHTTP = true로 설정할 수 있습니다.

  // 서버 요청은 POST 모드로 전송되며 작업 이름을 식별하기 위해 _method 매개 변수가 데이터에 추가되고 X-HTTP-Method-Override 헤더 정보도 전송됩니다.

  Backbone.emulateHTTP = 거짓;

 

  // application/json 인코딩을 지원하지 않는 브라우저의 경우 Backbone.emulateJSON = true로 설정할 수 있습니다.

  //요청 유형을 application/x-www-form-urlencoded로 설정하고 호환성을 위해 모델 매개변수에 데이터를 배치합니다.

  Backbone.emulateJSON = 거짓;

 

  // 사용자 정의 이벤트와 관련된 Backbone.Events

  // ------------------

 

  // eventSplitter는 여러 이벤트를 처리할 때 이벤트 이름에 대한 구문 분석 규칙을 지정합니다.

  var eventSplitter = /s /;

 

  // 사용자 정의 이벤트 관리자

  // 이벤트 관련 메소드를 객체에 바인딩하여 해당 객체에 커스텀 이벤트를 추가, 삭제, 트리거할 수 있습니다.

  var 이벤트 = Backbone.Events = {

 

    // 사용자 정의 이벤트와 콜백 함수를 현재 객체에 바인딩합니다.

    //콜백 함수의 컨텍스트 개체는 지정된 컨텍스트입니다. 컨텍스트가 설정되지 않은 경우 컨텍스트 개체는 기본적으로 현재 바인딩된 이벤트의 개체로 설정됩니다.

    // 이 메소드는 DOM Level2의 addEventListener 메소드와 유사합니다.

    // 이벤트를 사용하면 공백, 탭 등의 공백 문자로 구분된 여러 이벤트 이름을 지정할 수 있습니다.

    // 이벤트 이름이 "all"인 경우, 트리거 메소드를 호출하여 이벤트가 트리거되면 "all" 이벤트에 바인딩된 모든 콜백 함수가 호출됩니다.

    on : 함수(이벤트, 콜백, 컨텍스트) {

      //일부 함수에서 사용되는 지역 변수 정의

      var 호출, 이벤트, 노드, 꼬리, 목록;

      //콜백 함수를 설정해야 합니다.

      if(!콜백)

        이거 돌려줘;

      // eventSplitter를 통해 이벤트 이름을 구문 분석하고, 분할을 사용하여 여러 이벤트 이름을 배열로 분할합니다.

      // 일반적으로 여러 이벤트 이름을 지정하려면 공백 문자를 사용합니다.

      이벤트 = events.split(eventSplitter);

      // 호출은 현재 객체에 바인딩된 이벤트 및 콜백 함수 목록을 기록합니다.

      호출 = this._callbacks || (this._callbacks = {});

 

      // 이벤트 이름 목록을 반복하고 처음부터 끝까지 이벤트 이름을 이벤트 변수에 저장합니다.

      while(이벤트 = events.shift()) {

        // 이벤트에 바인딩된 콜백 함수를 가져옵니다.

        // 목록은 단일 이벤트 이름에 바인딩된 콜백 함수 목록을 저장합니다.

        // 함수 목록은 배열로 저장되지 않고, 여러 객체의 다음 속성을 통해 순차적으로 연관됩니다.

        /**数据格式如:

         * {

         * 꼬리: {객체},

         *   다음: {

         * 콜백: {함수},

         * 컨텍스트: {객체},

         *     다음: {

         * 콜백: {함수},

         * 컨텍스트: {객체},

         * 다음: {객체}

         * }

         * }

         * }*/

        // 목록의 각 수준에 있는 다음 객체는 콜백 이벤트와 관련된 정보(함수 본문, 컨텍스트 및 다음 콜백 이벤트)를 저장합니다.

        // 이벤트 목록의 최상위 수준에는 마지막으로 바인딩된 콜백 이벤트의 식별자를 저장하는 tail 개체가 저장됩니다(마지막 콜백 이벤트의 다음 개체와 동일한 개체).

        // tail 식별자를 통해 콜백 목록을 순회하면 마지막 콜백 함수에 도달했음을 알 수 있습니다.

        목록 = 통화[이벤트];

        // 노드 변수는 이 콜백 함수와 관련된 정보를 기록하는 데 사용됩니다.

        //tail은 마지막으로 바인딩된 콜백 함수의 식별자만 저장합니다.

        // 따라서 콜백 함수가 이전에 바인딩된 경우 이전 tail을 노드에 객체로 할당한 다음 tail에 대한 새 객체 식별자를 생성합니다.

        // 이전 콜백의 tail 객체에 이 콜백 이벤트를 추가하는 이유는 콜백 함수 목록의 객체 계층 구조를 바인딩 순서대로 정렬하기 위함입니다. (최근 바인딩된 이벤트는 맨 아래에 배치됩니다.)

        노드 = 목록 ? 목록.꼬리: {};

        node.next = 꼬리 = {};

        //이 콜백의 함수 본문과 컨텍스트 정보를 기록합니다.

        node.context = 컨텍스트;

        node.callback = 콜백;

        //현재 이벤트의 콜백 목록을 재조립합니다. 이 콜백 이벤트가 목록에 추가되었습니다.

        통화[이벤트] = {

          꼬리: 꼬리,

          다음 : 목록 ? list.next : 노드

        };

      }

      // 메소드 체인 호출을 용이하게 하기 위해 현재 객체를 반환합니다.

      이거 돌려줘;

    },

    // 객체에 바인딩된 이벤트나 콜백 함수를 제거합니다. 이벤트, 콜백, 컨텍스트를 통해 삭제해야 하는 이벤트나 콜백 함수를 필터링할 수 있습니다.

    // - 컨텍스트가 비어 있으면 콜백에 지정된 모든 함수를 제거합니다.

    // - 콜백이 비어 있으면 이벤트의 모든 콜백 함수를 제거합니다.

    // - 이벤트가 비어 있으나 콜백이나 컨텍스트가 지정된 경우 콜백이나 컨텍스트에 지정된 콜백 함수를 제거합니다. (이벤트 이름은 구분되지 않습니다.)

    // - 매개변수가 전달되지 않으면 객체에 바인딩된 모든 이벤트와 콜백 함수를 제거합니다.

    off : 함수(이벤트, 콜백, 컨텍스트) {

      var 이벤트, 호출, 노드, 테일, cb, ctx;

 

      // 이벤트가 없거나 *모든* 이벤트를 제거합니다.

      //현재 객체에는 바인딩된 이벤트가 없습니다.

      if(!( 통화 = this._callbacks))

        반품;

      // 매개변수가 지정되지 않은 경우 모든 이벤트 및 콜백 함수를 제거합니다(_callbacks 속성 제거).

      if(!(이벤트 || 콜백 || 컨텍스트)) {

        this._callbacks 삭제;

        이거 돌려줘;

      }

 

      // 제거해야 할 이벤트 목록을 구문 분석합니다.

      // - 이벤트가 지정되면 eventSplitter에 따라 이벤트 이름이 구문 분석됩니다.

      // - 이벤트가 지정되지 않은 경우 바인딩된 모든 이벤트의 이름 목록을 구문 분석합니다.

      이벤트 = 이벤트 ? events.split(eventSplitter) : _.keys(calls);

 

      // 루프 이벤트 이름 목록

      while(이벤트 = events.shift()) {

        // 목록에서 현재 이벤트 객체를 제거하고 노드 변수에 캐시합니다.

        노드 = 호출[이벤트];

        통화 삭제[이벤트];

        // 현재 이벤트 객체가 존재하지 않는 경우(또는 제거 필터 조건이 지정되지 않은 경우 현재 이벤트 및 모든 콜백 함수가 제거되는 것으로 간주) 이 작업을 종료합니다(이전 단계에서 이벤트 객체가 제거되었습니다) )

        if(!노드 || !(콜백 || 컨텍스트))

          계속하다;

        // 표시된 콜백을 생략하고 새 목록을 만듭니다.

        // 콜백 함수나 컨텍스트 필터 조건에 따라 새로운 이벤트 객체를 조립하고 리바인드합니다.

        꼬리 = node.tail;

        // 이벤트의 모든 콜백 객체를 순회합니다.

        while(( node = node.next) !== tail) {

          cb = node.callback;

          ctx = node.context;

          // 콜백 함수와 파라미터에 있는 context를 기반으로 콜백 함수를 필터링하고, 필터링 조건에 맞지 않는 콜백 함수를 이벤트에 다시 바인딩합니다. (위에서 이벤트의 콜백 함수를 모두 제거했기 때문입니다.)

          if((콜백 && cb !== 콜백) || (컨텍스트 && ctx !== 컨텍스트)) {

            this.on(이벤트, cb, ctx);

          }

        }

      }

 

      이거 돌려줘;

    },

    // 정의된 하나 이상의 이벤트를 트리거하고 바인딩된 콜백 함수 목록을 순서대로 실행합니다.

    트리거 : 함수(이벤트) {

      var 이벤트, 노드, 호출, 꼬리, 인수, 모두, 나머지;

      //현재 객체에는 바인딩된 이벤트가 없습니다.

      if(!( 통화 = this._callbacks))

        이거 돌려줘;

      // 콜백 함수 목록에 바인딩된 "모든" 이벤트 목록을 가져옵니다.

      모두 = 통화.모두;

      // eventSplitter 규칙에 따라 배열로 트리거되어야 하는 이벤트 이름을 구문 분석합니다.

      이벤트 = events.split(eventSplitter);

      // 두 번째부터 트리거의 매개변수를 나머지 변수에 기록하고, 이는 차례로 콜백 함수에 전달됩니다.

      나머지 = Slice.call(인수, 1);

 

      // 트리거되어야 하는 이벤트 목록을 반복합니다.

      while(이벤트 = events.shift()) {

        // 여기의 노드 변수는 현재 이벤트의 모든 콜백 함수 목록을 기록합니다.

        if( 노드 = 호출[이벤트]) {

          //tail 변수는 마지막 바인딩 이벤트의 개체 ID를 기록합니다.

          꼬리 = node.tail;

          //노드 변수의 값은 이벤트 바인딩 순서에 따라 바인딩된 단일 콜백 이벤트 객체에 순차적으로 할당됩니다.

          // 마지막으로 바인딩된 이벤트의 next 속성은 tail과 동일한 객체를 참조하며, 이는 목록의 끝에 도달했는지 판단하는 기준으로 사용됩니다.

          while(( node = node.next) !== tail) {

            // 바인딩된 모든 이벤트를 실행하고 트리거 호출 시 매개변수를 콜백 함수에 전달합니다.

            node.callback.apply(node.context || this, 나머지);

          }

        }

        // all 변수는 바인딩 중 'all' 이벤트를 기록합니다. 즉, 어떤 이벤트가 호출되면 'all' 이벤트에 포함된 콜백 함수가 실행됩니다.

        // - "all" 이벤트의 콜백 함수는 바인딩 순서와 관계없이 현재 이벤트의 모든 콜백 함수 목록이 실행된 후 순차적으로 실행됩니다.

        // - "all" 이벤트는 일반 이벤트가 발생할 때 자동으로 호출되어야 합니다. "all" 이벤트가 강제로 트리거되면 해당 이벤트의 콜백 함수가 두 번 실행됩니다.

        if(노드 ​​= 모두) {

          꼬리 = node.tail;

          //일반 이벤트의 콜백 함수 호출과 다른 점은 all 이벤트는 현재 호출된 이벤트 이름을 콜백 함수의 첫 번째 매개변수로 전달한다는 점입니다.

          args = [이벤트].concat(rest);

          // "all" 이벤트의 콜백 함수 목록을 탐색하고 실행합니다.

          while(( node = node.next) !== tail) {

            node.callback.apply(node.context || this, args);

          }

        }

      }

 

      이거 돌려줘;

    }

  };

 

  // 이전 버전의 Backbone과의 호환성을 위한 바인딩 이벤트 및 릴리스 이벤트에 대한 별칭

  Events.bind = 이벤트.온;

  Events.unbind = Events.off;

 

  // Backbone.Model 데이터 객체 모델

  //-------------

 

  // Model은 Backbone의 모든 데이터 객체 모델의 기본 클래스로, 데이터 모델을 생성하는 데 사용됩니다.

  // @param {Object} 속성은 모델 생성 시 초기화 데이터를 지정합니다.

  // @param {Object} 옵션

  /*** @format 옵션

   * {

   * 구문 분석: {부울},

   * 컬렉션: {컬렉션}

   * }*/

  var Model = Backbone.Model = function(속성, 옵션) {

    // defaults 변수는 모델의 기본 데이터를 저장하는 데 사용됩니다.

    var 기본값;

    // 속성 매개변수가 지정되지 않은 경우 속성을 빈 객체로 설정합니다.

    속성 || (속성 = {});

    //속성 기본 데이터의 구문 분석 방법을 설정합니다. 예를 들어 기본 데이터는 서버에서 가져옵니다(또는 원본 데이터는 XML 형식임). 설정된 메서드에 필요한 데이터 형식과 호환되도록 구문 분석합니다. 메소드를 사용하여 구문 분석할 수 있습니다.

    if(옵션 && options.parse)

      속성 = this.parse(속성);

    if( defaults = getValue(this, 'defaults')) {

      // 모델이 정의될 때 기본값 데이터를 설정하면 초기화 데이터는 기본값 및 속성 매개변수와 병합된 데이터를 사용합니다. (속성의 데이터는 기본값의 동일한 이름으로 데이터를 덮어씁니다.)

      속성 = _.extend({}, 기본값, 속성);

    }

    // 모델이 속한 Collection 객체를 명시적으로 지정합니다. (모델을 컬렉션에 추가하기 위해 Collection의 add, push 등의 메소드를 호출하면 모델이 속한 Collection 객체가 자동으로 설정됩니다.)

    if(옵션 && options.collection)

      this.collection = 옵션.collection;

    //attributes 속성은 현재 모델의 JSON 객체화된 데이터를 저장하며 모델 생성 시 기본적으로 비어 있습니다.

    this.attributes = {};

    // 이스케이프 메소드를 통해 처리된 데이터를 캐시할 _escapedAttributes 캐시 객체를 정의합니다.

    this._escapedAttributes = {};

    // 각 모델에 대한 고유 식별자를 구성합니다.

    this.cid = _.uniqueId('c');

    //데이터 상태를 기록하는 데 사용되는 일련의 객체를 정의합니다. 구체적인 의미는 객체 정의 시 주석을 참조하세요.

    this.changed = {};

    this._silent = {};

    this._pending = {};

    // 인스턴스 생성 시 초기화 데이터를 설정합니다. 자동 매개변수를 처음 사용하면 변경 이벤트가 발생하지 않습니다.

    this.set(속성, {

      침묵 : 사실

    });

    // 초기화 데이터가 위에서 설정되었습니다. 변경된 상태, _silent, _pending 개체가 여기에서 다시 초기화되었을 수 있습니다.

    this.changed = {};

    this._silent = {};

    this._pending = {};

    // _previousAttributes 변수는 모델 데이터의 복사본을 저장합니다.

    //change 이벤트에서 모델 데이터가 변경되기 전의 상태를 가져오는 데 사용됩니다. 이전 상태의 데이터는 이전 또는 이전 속성 메소드를 통해 가져올 수 있습니다.

    this._previousAttributes = _.clone(this.attributes);

    //초기화 메소드 호출

    this.initialize.apply(this, 인수);

  };

  // 모델 프로토타입에 대한 일련의 속성과 메서드를 정의하려면 확장 메서드를 사용하세요.

  _.extend(Model.prototype, 이벤트, {

 

    //변경된 속성은 set 메소드가 호출될 때마다 변경된 데이터의 키 컬렉션을 기록합니다.

    변경됨: null,

 

    // // 자동 속성이 지정되면 변경 이벤트가 발생하지 않으며, 다음 변경 이벤트가 발생할 때까지 변경된 데이터가 기록됩니다.

    // _silent 속성은 자동 사용 시 변경된 데이터를 기록하는 데 사용됩니다.

    _silent : null,

 

    _보류 중 : null,

 

    // 각 모델의 고유 식별 속성(기본값은 "id", id 속성 이름은 idAttribute를 수정하여 사용자 정의 가능)

    // 데이터 설정 시 id 속성이 포함된 경우 해당 id가 모델의 id보다 우선 적용됩니다.

    // ID는 컬렉션에서 모델을 찾고 식별하는 데 사용됩니다. 백엔드 인터페이스와 통신할 때 ID는 레코드의 식별자로도 사용됩니다.

    id속성: 'id',

 

    // 모델 초기화 메소드, 모델 구축 후 자동 호출

    초기화 : 함수() {

    },

    // 현재 모델의 데이터 복사본을 반환합니다(JSON 개체 형식).

    toJSON : 함수(옵션) {

      return _.clone(this.attributes);

    },

    //attr 속성 이름에 따라 모델의 데이터 값을 가져옵니다.

    get : 함수(속성) {

      return this.attributes[attr];

    },

    //attr 속성 이름에 따라 모델의 데이터 값을 얻습니다. 데이터 값에 포함된 HTML 특수 문자는 & &lt >

    // _.escape 메소드를 통해 구현됨

    탈출 : 함수(속성) {

      varhtml;

      // _escapedAttributes 캐시 객체에서 데이터를 찾고, 데이터가 캐시된 경우 직접 반환합니다.

      if(html = this._escapedAttributes[attr])

        HTML을 반환;

      // _escapedAttributes 캐시 객체에서 데이터를 찾을 수 없습니다.

      // 그런 다음 먼저 모델에서 데이터를 가져옵니다.

      var val = this.get(attr);

      // _.escape 메서드를 사용하여 데이터의 HTML을 엔터티로 변환하고 다음에 쉽게 검색할 수 있도록 _escapedAttributes 개체에 캐시합니다.

      return this._escapedAttributes[attr] = _.escape(val == null ? '' : '' val);

    },

    // 모델에 특정 속성이 존재하는지 확인합니다. 해당 속성의 값을 Boolean 유형으로 변환하여 값이 false인 경우 존재하지 않는 것으로 간주합니다.

    // 값이 false, null, 정의되지 않음, 0, NaN 또는 빈 문자열인 경우 false로 변환됩니다.

    있음 : 함수(속성) {

      return this.get(attr) != null;

    },

    //모델에 데이터를 설정합니다. 키 값이 없으면 새 속성으로 모델에 추가됩니다. 키 값이 이미 있으면 새 값으로 수정됩니다.

    설정 : 함수(키, 값, 옵션) {

      // attrs 변수에 설정해야 하는 데이터 객체를 기록합니다.

      var 속성, 속성, 발;

 

      // 매개변수 형식은 키-값 개체 형식을 허용하거나 키 및 값 매개변수를 통해 별도의 설정을 허용합니다.

      // key가 객체인 경우 객체 형태로 설정된 것으로 간주하고, 두 번째 매개변수는 옵션 매개변수로 간주한다.

      if(_.isObject(key) || 키 == null) {

        속성 = 키;

        옵션 = 가치;

      } 또 다른 {

        // 키와 값의 두 매개변수를 별도로 설정하고 데이터를 attrs 객체에 넣어 통합 처리합니다.

        속성 = {};

        attrs[키] = 값;

      }

 

      // 옵션 구성 항목은 객체여야 합니다. 옵션이 설정되지 않은 경우 기본값은 빈 객체입니다.

      옵션 || (옵션 = {});

      // 매개변수가 설정되지 않은 경우 아무 작업도 수행되지 않습니다.

      if(!attrs)

        이거 돌려줘;

      // 설정되는 데이터 객체가 Model 클래스의 인스턴스에 속하는 경우 Model 객체의 데이터 객체 속성을 attrs에 할당합니다.

      // 일반적으로 이 작업은 한 Model 개체에서 다른 Model 개체로 데이터를 복사할 때 수행됩니다.

      if(모델 인스턴스 속성)

        attrs = attrs.attributes;

      // 옵션 구성 객체에 unset 속성이 설정된 경우 attrs 데이터 객체의 모든 속성을 정의되지 않음으로 재설정합니다.

      // 일반적으로 한 Model 객체에서 다른 Model 객체로 데이터를 복사할 때 이 작업을 수행하는데, 값은 복사하지 않고 Model 내부의 데이터만 복사하면 됩니다.

      if(options.unset)

        for(속성 속의 속성)

        속성[속성] =

        무효 0;

 

      //현재 데이터를 검증하고, 검증에 실패하면 실행을 중지합니다.

      if(!this._validate(속성, 옵션))

        거짓을 반환;

 

      // 설정된 id 속성 이름이 데이터 컬렉션에 포함된 경우 해당 id를 모델의 id 속성에 덮어씁니다.

      // id 속성명을 커스터마이징한 후 모델의 id 속성에 접근할 때 해당 id에 올바르게 접근할 수 있도록 하기 위한 것입니다.

      if(attrs의 this.idAttribute)

        this.id = attrs[this.idAttribute];

 

      var 변경 = options.changes = {};

      // 이제 현재 모델의 데이터 객체를 기록합니다.

      var now = this.attributes;

      // escaped는 현재 모델에서 escape로 캐시된 데이터를 기록합니다.

      var escaped = this._escapedAttributes;

      // prev는 모델의 데이터가 변경되기 전의 값을 기록합니다.

      var prev = this._previousAttributes ||

 

      // 설정해야 하는 데이터 객체를 탐색합니다.

      for(attr in attrs) {

        // attr은 현재 속성 이름을 저장하고, val은 현재 속성 값을 저장합니다.

        값 = 속성[속성];

 

        // 현재 데이터가 모델에 없거나, 변경되었거나, 옵션에 unset 속성 삭제가 지정된 경우 _escapedAttributes의 데이터로 대체된 데이터를 삭제합니다.

        if(!_.isEqual(now[attr], val) || (options.unset && _.has(now, attr))) {

          // 이스케이프를 통해 캐시된 데이터만 삭제합니다. 이는 캐시에 있는 데이터가 모델의 실제 데이터와 동기화되도록 하기 위한 것입니다.

          삭제 이스케이프됨[attr];

          // 자동 속성이 지정되면 이 set 메소드 호출에 의해 변경 이벤트가 발생하지 않으므로 변경된 데이터가 _silent 속성에 기록되므로 다음에 변경 이벤트가 발생할 때 이벤트 청취 기능이 수행됩니다. 데이터가 변경되었음을 알립니다.

          // 자동 속성이 지정되지 않은 경우 변경 속성의 현재 데이터를 변경된 상태로 직접 설정합니다.

          (options.silent ? this._silent : 변경)[attr] = true;

        }

 

        // 옵션에 unset이 설정되어 있으면 모델에서 데이터(키 포함)를 삭제합니다.

        // unset 속성을 지정하지 않으면 신규 또는 수정된 데이터가 추가되는 것으로 간주하여 모델의 데이터 객체에 새로운 데이터가 추가됩니다.

        옵션.설정 해제?

        지금 삭제[attr] : 지금[attr] = val;

 

        // 모델의 데이터가 새 데이터와 일치하지 않으면 데이터가 변경되었음을 의미합니다.

        if(!_.isEqual(prev[attr], val) || (_.has(now, attr) != _.has(prev, attr))) {

          // 변경된 속성에 현재 속성의 변경된 상태를 기록합니다.

          this.changed[attr] = 발;

          if(!options.silent)

            this._pending[attr] = true;

        } 또 다른 {

          // 데이터가 변경되지 않은 경우 변경된 속성에서 변경된 상태를 제거합니다.

          이것을 삭제하세요.변경됨[attr];

          이것을 삭제하세요._pending[attr];

        }

      }

 

      // 변경 이벤트에 바인딩된 함수를 트리거하는 변경 메서드를 호출합니다.

      if(!options.silent)

        this.change(옵션);

      이거 돌려줘;

    },

    //현재 모델에서 지정된 데이터를 삭제합니다. (속성도 동시에 삭제됩니다.)

    unset : 함수(속성, 옵션) {

      (옵션 || (옵션 = {})).unset = true;

      // options.unset 구성 항목을 통해 삭제 작업을 수행하도록 set 메소드에 알립니다.

      return this.set(attr, null, options);

    },

    // 현재 모델의 모든 데이터와 속성을 지웁니다.

    클리어 : 기능(옵션) {

      (옵션 || (옵션 = {})).unset = true;

      // 현재 모델의 속성 복사본을 복제하고, options.unset 구성 항목을 통해 삭제 작업을 수행하도록 set 메서드에 지시합니다.

      return this.set(_.clone(this.attributes), options);

    },

    // 서버에서 기본 모델 데이터를 가져옵니다. 데이터를 가져온 후 set 메소드를 사용하여 데이터를 모델에 채웁니다. 따라서 가져온 데이터가 현재 모델의 데이터와 일치하지 않으면 변경 이벤트가 트리거됩니다. .

    가져오기 : 함수(옵션) {

      // options가 새 객체인지 확인한 다음 options의 속성을 변경합니다.

      옵션 = 옵션 ? _.clone(옵션) : {};

      var 모델 = 이것;

      // 옵션에서 데이터를 성공적으로 얻은 후 사용자 정의 콜백 함수를 지정할 수 있습니다.

      var 성공 = options.success;

      // 데이터를 성공적으로 가져오면 데이터를 입력하고 사용자 정의 성공 콜백 함수를 호출합니다.

      options.success = function(resp, 상태, xhr) {

        // 서버가 반환한 데이터를 파싱 메소드를 통해 변환

        // 변환된 데이터를 set 메소드를 통해 모델에 채워서 변경 이벤트가 발생하도록 합니다. (데이터가 변경될 때)

        // 데이터를 채울 때 유효성 검사에 실패하면 사용자 정의 성공 콜백 함수가 호출되지 않습니다.

        if(!model.set(model.parse(resp, xhr), 옵션))

          거짓을 반환;

        //사용자 정의 성공 콜백 함수 호출

        만약(성공)

          성공(모델, 담당자);

      };

      // 요청에 오류가 발생하면 WrapError를 통해 오류 이벤트를 처리합니다.

      options.error = Backbone.wrapError(options.error, 모델, 옵션);

      // 서버에서 데이터를 가져오기 위해 동기화 메소드를 호출합니다.

      return (this.sync || Backbone.sync).call(this, 'read', this, options);

    },

    //모델의 데이터를 서버에 저장

    저장 : 함수(키, 값, 옵션) {

      // attrs는 서버에 저장해야 하는 데이터 객체를 저장합니다.

      var 속성, 현재;

 

      //단일 속성 키 설정 지원: value

      // 객체 형태의 {key: value} 일괄 설정 방법 지원

      if(_.isObject(key) || 키 == null) {

        // 키가 객체인 경우 객체 메소드를 통해 설정되는 것으로 간주됩니다.

        // 이때 두 번째 매개변수는 옵션으로 간주됩니다.

        속성 = 키;

        옵션 = 가치;

      }또 다른 {

        // 단일 속성이 key:value 형식으로 설정된 경우 attrs를 직접 설정합니다.

        속성 = {};

        attrs[키] = 값;

      }

      // 구성 객체는 새로운 객체여야 합니다.

      옵션 = 옵션 ? _.clone(옵션) : {};

 

      // 옵션에 대기 옵션이 설정되어 있으면 변경된 데이터를 미리 검증하여 서버가 새로운 데이터에 응답하지 않거나 응답이 실패하는 경우 로컬 데이터를 수정 전 상태로 복원합니다.

      // wait 옵션이 설정되지 않은 경우 서버 설정 성공 여부와 관계없이 로컬 데이터는 최신 상태로 수정됩니다.

      if(options.wait) {

        // 저장해야 할 데이터를 미리 확인한다

        if(!this._validate(속성, 옵션))

          거짓을 반환;

        //현재 모델에 데이터를 기록하며, 데이터를 서버로 전송한 후 복원하는 데 사용됩니다.

        // 서버 응답이 실패하거나 데이터가 반환되지 않는 경우 수정 전 상태를 유지할 수 있습니다.

        현재 = _.clone(this.attributes);

      }

 

      // SilentOptions는 옵션 개체에 자동을 추가합니다(데이터 확인 없음).

      // 위에서 데이터가 검증되었으므로 wait 파라미터 사용 시 SilentOptions 구성 항목을 사용합니다.

      // wait 매개변수가 설정되지 않은 경우 원래 옵션 구성 항목이 계속 사용됩니다.

      var SilentOptions = _.extend({}, 옵션, {

        침묵 : 사실

      });

      // 가장 최근에 수정된 데이터를 모델에 저장하여, 모델 데이터를 sync 메소드로 얻어 서버에 저장할 수 있도록 합니다.

      if(attrs && !this.set(attrs, options.wait ? SilentOptions : options)) {

        거짓을 반환;

      }

 

      var 모델 = 이것;

      // 옵션에서 데이터를 성공적으로 저장한 후 사용자 정의 콜백 함수를 지정할 수 있습니다.

      var 성공 = options.success;

      //서버가 성공적으로 응답한 후 성공 실행

      options.success = function(resp, 상태, xhr) {

        // 서버 응답의 최신 상태 데이터를 가져옵니다.

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

        // wait 매개변수를 사용하면 수정된 데이터 상태가 먼저 모델에 직접 설정됩니다.

        if(options.wait) {

          옵션 삭제.잠깐;

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

        }

        //최신 데이터 상태를 모델에 설정

        // set 메소드 호출 시 검증에 실패하면 커스텀 성공 콜백 함수가 호출되지 않습니다.

        if(!model.set(serverAttrs, 옵션))

          거짓을 반환;

        만약(성공) {

          //응답이 성공한 후 맞춤형 성공 콜백 함수를 호출합니다.

          성공(모델, 담당자);

        } 또 다른 {

          // 사용자 정의 콜백이 지정되지 않은 경우 기본적으로 동기화 이벤트가 트리거됩니다.

          model.trigger('sync', 모델, resp, 옵션);

        }

      };

      // 요청에 오류가 발생하면 WrapError를 통해 오류 이벤트를 처리합니다.

      options.error = Backbone.wrapError(options.error, 모델, 옵션);

      //모델의 데이터를 서버에 저장

      // 현재 모델이 새로 생성된 모델(id 없음)이면 create 메소드(new)를 사용하고, 그렇지 않으면 update 메소드(modified)로 간주합니다.

      var 메소드 = this.isNew() ? '생성': '업데이트';

      var xhr = (this.sync || Backbone.sync).call(this, 메소드, this, 옵션);

      // options.wait가 설정되어 있으면 데이터를 수정 전 상태로 복원합니다.

      // 저장된 요청은 현재 응답을 받지 못했기 때문에 응답이 실패할 경우 모델은 수정 전 상태를 유지하게 되며, 서버가 성공적으로 응답하면 모델 내의 데이터는 성공 시 최신 상태로 설정됩니다. .

      if(옵션.기다림)

        this.set(current, SilentOptions);

      xhr을 반환합니다.

    },

    //모델 삭제, 모델이 속한 컬렉션에서 모델이 삭제됩니다.

    // 클라이언트에서 모델이 생성된 경우 클라이언트에서 직접 삭제합니다.

    // 모델 데이터가 서버에 동시에 존재할 경우, 서버측 데이터도 동시에 삭제됩니다.

    파괴 : 기능(옵션) {

      // 구성 항목은 새로운 객체여야 합니다.

      옵션 = 옵션 ? _.clone(옵션) : {};

      var 모델 = 이것;

      // 옵션에서 데이터가 성공적으로 삭제된 후 사용자 정의 콜백 함수를 지정할 수 있습니다.

      var 성공 = options.success;

      // 데이터 삭제를 위해 성공적으로 호출되면 소멸 이벤트가 트리거됩니다. 모델이 컬렉션에 존재하는 경우 컬렉션은 소멸 이벤트를 수신하고 트리거될 때 컬렉션에서 모델을 제거합니다.

      // 모델 삭제 시 모델 안의 데이터가 지워지지 않은 상태인데, 해당 모델이 컬렉션에서 제거되었기 때문에 해당 모델에 대한 참조가 어디에도 없으면 자동으로 메모리에서 해제됩니다.

      // 모델 삭제 시 모델 객체의 참조 변수를 null로 설정하는 것을 권장합니다.

      var TriggerDestroy = 함수() {

        model.trigger('파괴', 모델, model.collection, 옵션);

      };

      // 모델이 클라이언트에서 새로 생성한 모델인 경우, TriggerDestroy를 직접 호출하여 컬렉션에서 해당 모델을 제거합니다.

      if(this.isNew()) {

        TriggerDestroy();

        거짓을 반환;

      }// 서버에서 데이터 삭제가 성공한 경우

      options.success = 함수(resp) {

        // 옵션 객체에 대기 항목이 구성되어 있으면 서버 데이터가 성공적으로 삭제된 후 로컬 메모리에 있는 모델 데이터가 삭제된다는 의미입니다.

        // 서버 응답이 실패하면 로컬 데이터는 삭제되지 않습니다.

        if(옵션.기다림)

          TriggerDestroy();

        만약(성공) {

          //사용자 정의 성공 콜백 함수 호출

          성공(모델, 담당자);

        } 또 다른 {

          // 커스텀 콜백이 없으면 기본적으로 동기화 이벤트가 트리거됩니다.

          model.trigger('sync', 모델, resp, 옵션);

        }

      };

      // 요청에 오류가 발생하면 WrapError를 통해 오류 이벤트를 처리합니다.

      options.error = Backbone.wrapError(options.error, 모델, 옵션);

      //동기화 메소드를 통해 데이터 삭제 요청을 보냅니다.

      var xhr = (this.sync || Backbone.sync).call(this, '삭제', this, 옵션);

      // 옵션 객체에 대기 항목이 구성되어 있지 않으면 로컬 데이터를 먼저 삭제한 후 서버 데이터를 삭제하라는 요청을 보냅니다.

      // 이때, 서버 삭제 성공 여부와 상관없이 로컬 모델 데이터는 삭제된 상태입니다.

      if(!options.wait)

        TriggerDestroy();

      xhr을 반환합니다.

    },

    // 서버 인터페이스에서 모델에 해당하는 URL을 가져옵니다. save, fetch, destroy 및 기타 메소드를 호출하여 서버와 상호작용할 때 이 메소드를 사용하여 URL을 가져옵니다.

    // 생성된 URL은 "PATHINFO" 모드와 유사합니다. 서버에는 모델 작업을 위한 URL이 하나만 있습니다. 수정 및 삭제 작업의 경우 쉽게 식별할 수 있도록 모델 ID가 URL에 추가됩니다.

    // 모델에 urlRoot가 정의된 경우 서버 인터페이스는 [urlRoot/id] 형식이어야 합니다.

    // 모델이 속한 컬렉션이 url 메서드나 속성을 정의하는 경우 컬렉션에서 url 형식을 사용합니다: [collection.url/id]

    // 서버 URL에 액세스할 때 모델 ID가 URL에 추가되어 서버가 레코드를 쉽게 식별할 수 있으므로 모델의 ID는 서버 레코드와 일치해야 합니다.

    // 모델이나 컬렉션의 URL을 얻을 수 없으면 urlError 메서드가 호출되고 예외가 발생합니다.

    // 서버 인터페이스가 "PATHINFO"에 따라 구성되지 않은 경우 url 메서드를 오버로드하여 서버와 원활한 상호 작용을 구현할 수 있습니다.

    URL : 함수() {

      //서버에 해당하는 URL 경로를 정의합니다.

      var base = getValue(this, 'urlRoot') || getValue(this.collection, 'url') ||

      // 현재 모델이 클라이언트에서 새로 생성한 모델인 경우 id 속성이 없고, 서버 url이 base를 직접 사용합니다.

      if(this.isNew())

        반환 기지;

      // 현재 모델에 id 속성이 있는 경우 save 또는 destroy 메소드가 호출될 수 있으며 모델의 id가 기본에 추가됩니다.

      //다음은 base의 마지막 문자가 "/"인지, 생성된 URL 형식이 [base/id]인지 확인합니다.

      return base (base.charAt(base.length - 1) == '/' ? '' : '/') encodeURIComponent(this.id);

    },

    // 서버에서 가져온 데이터를 파싱하고 set 메서드로 파싱할 수 있는 모델 데이터를 반환하기 위해 파싱 메소드를 사용합니다.

    // 일반적으로 서버와의 원활한 연결을 구축하기 위해 서버에서 반환하는 데이터를 기반으로 구문 분석 메서드가 오버로드됩니다.

    // 서버가 반환한 데이터 구조가 set 메소드에서 요구하는 데이터 구조와 일치하지 않는 경우(예: 서버가 XML 형식의 데이터를 반환하는 경우) 변환에 구문 분석 메소드를 사용할 수 있습니다.

    구문 분석 : 함수(resp, xhr) {

      반환 응답;

    },

    // 현재 모델과 동일한 데이터로 새 모델을 생성합니다.

    복제 : 함수() {

      새로운 this.constructor(this.attributes)를 반환합니다.

    },

    // 현재 모델이 클라이언트가 생성한 새로운 모델인지 확인

    // 확인 방법은 모델에 ID 식별자가 있는지 여부에 따라 결정됩니다. 클라이언트가 만든 새 모델에는 ID 식별자가 없습니다.

    // 따라서 서버가 응답하는 모델 데이터에는 id 식별자가 포함되어야 합니다. 식별자의 속성 이름은 기본적으로 "id"로 설정됩니다. idAttribute 속성을 수정하여 식별자를 맞춤 설정할 수도 있습니다.

    isNew : 함수() {

      return this.id == null;

    },

    // 데이터가 업데이트될 때 변경 이벤트 바인딩을 트리거하는 함수

    // set 메소드 호출 시 자동으로 변경 메소드가 호출됩니다. set 메소드 호출 시 자동 구성이 지정된 경우에는 변경 메소드를 수동으로 호출해야 합니다.

    변경 : 기능(옵션) {

      // 옵션은 객체여야 합니다.

      옵션 || ( 옵션 = {});

      // 이와 관련된 로직에 문제가 있습니다._변경

      // this._changing은 메서드 끝에서 false로 설정되므로 메서드 위의 변경 변수 값은 항상 false입니다(처음은 정의되지 않음).

      // 작성자의 원래 의도는 이 변수를 사용하여 변경 메서드가 실행되었는지 여부를 나타내는 것이어야 합니다. 이 메서드는 실행 시 다른 스크립트를 차단하므로 브라우저 측의 단일 스레드 스크립트에는 의미가 없습니다.

      // 변경하면 마지막 실행 상태를 가져옵니다. 마지막 스크립트가 실행되지 않은 경우 값은 true입니다.

      var 변경 = this._changing;

      //플래그 실행을 시작합니다. 실행 중 값은 항상 true입니다. 실행 후에는 this._changing이 false로 수정됩니다.

      this._changing = true;

 

      //이 변경 사항 이외의 데이터 상태를 _pending 개체에 추가합니다.

      for(this._silent의 var 속성)

      this._pending[attr] = true;

 

      // 변경 객체에는 현재 데이터에 대해 변경 이벤트가 마지막으로 실행된 이후 변경된 모든 데이터가 포함됩니다.

      // 이전에 자동을 사용하여 변경 이벤트가 트리거되지 않은 경우 이번에는 변경 객체에 배치됩니다.

      var 변경 = _.extend({}, options.changes, this._silent);

      //_silent 객체 재설정

      this._silent = {};

      // 변경 객체를 탐색하고 각 속성에 대해 별도의 변경 이벤트를 트리거합니다.

      for(변경 사항의 var 속성) {

        // Model 객체, 속성 값, 구성 항목을 이벤트 수신 함수에 매개변수로 전달합니다.

        this.trigger('change:' attr, this, this.get(attr), options);

      }

 

      //메소드가 실행 중이면 실행을 중지합니다.

      만약(변경)

        이거 돌려줘;

 

      // 변경 이벤트를 트리거합니다. 데이터가 변경된 후 "change:property" 이벤트와 "change" 이벤트가 차례로 트리거됩니다.

      while(!_.isEmpty(this._pending)) {

        this._pending = {};

        // 변경 이벤트를 트리거하고 모델 인스턴스 및 구성 항목을 매개변수로 청취 함수에 전달합니다.

        this.trigger('change', this, options);

        // 변경된 객체의 데이터를 순회하고 변경된 데이터의 상태를 차례로 변경된 항목에서 제거합니다.

        // 이후 데이터 상태를 확인하기 위해 hasChanged를 호출하면 false(변경되지 않음)가 반환됩니다.

        for(this.changed의 var 속성) {

          if(this._pending[attr] || this._silent[attr])

            계속하다;

          //변경된 데이터의 상태를 제거합니다.

          이것을 삭제하세요.변경됨[attr];

        }

        // 변경 이벤트가 실행된 후 _previousAttributes 속성은 현재 모델의 최신 데이터 복사본을 기록합니다.

        // 따라서 데이터의 이전 상태를 가져와야 하는 경우 일반적으로 트리거된 변경 이벤트의 이전 또는 이전 속성 메서드를 통해서만 가져올 수 있습니다.

        this._previousAttributes = _.clone(this.attributes);

      }

 

      //실행 완료 플래그

      this._changing = false;

      이거 돌려줘;

    },

    // 마지막 변경 이벤트가 실행된 이후 특정 데이터가 변경되었는지 확인합니다.

    /*** 일반적으로 다음과 같이 변경 이벤트에서 이전 또는 이전 속성 메서드와 함께 사용됩니다.

     * if(model.hasChanged('attr')) {

     * var attrPrev = model.previous('attr');

     * }*/

    hasChanged : 함수(attr) {

      if(!arguments.length)

        return !_.isEmpty(this.changed);

      return _.has(this.changed, attr);

    },

    // 현재 모델의 데이터 컬렉션과 마지막 데이터에서 변경된 데이터를 가져옵니다.

    // (일반적으로 자동 속성 사용 시에는 변경 메소드가 호출되지 않으므로 변경된 속성에 데이터가 임시 저장됩니다. 마지막 데이터는 이전 속성 메소드를 통해 얻을 수 있습니다.)

    // diff 세트가 전달되면 마지막 모델 데이터가 diff 세트의 데이터와 비교되어 일치하지 않는 데이터 세트가 반환됩니다.

    // 비교 결과 차이가 없으면 false를 반환

    변경된 속성: 함수(diff) {

      // diff를 지정하지 않으면 이전 상태에서 변경된 현재 모델의 데이터 컬렉션이 반환됩니다. 이러한 데이터는 변경된 속성에 저장되어 있으므로 변경된 컬렉션의 복사본이 반환됩니다.

      if(!차이점)

        return this.hasChanged() ? _.clone(this.changed) : false;

      // 비교해야 할 diff 세트를 지정하고 마지막 데이터와 diff 세트의 비교 결과를 반환합니다.

      //이전 변수는 이전 상태의 모델 데이터를 저장합니다.

      var val, 변경됨 = false, old = this._previousAttributes;

      // diff 컬렉션을 탐색하고 각 항목을 이전 상태 컬렉션과 비교합니다.

      for(diff의 var 속성) {

        // 비교 결과가 일치하지 않는 데이터를 변경된 변수에 임시 저장

        if(_.isEqual(old[attr], ( val = diff[attr])))

          계속하다;

        (변경됨 || (변경됨 = {}))[attr] = val;

      }

      // 비교 결과를 반환

      반품이 변경되었습니다.

    },

    // 모델에 의해 발생된 변경 이벤트에서 속성이 변경되기 전의 이전 상태의 데이터를 획득하는데, 이는 일반적으로 데이터 비교나 롤백에 사용됩니다.

    // 이 메소드는 일반적으로 변경 이벤트에서 호출됩니다. 변경 이벤트가 트리거된 후 _previousAttributes 속성은 최신 데이터를 저장합니다.

    이전 : 함수(속성) {

      // attr은 이전 상태를 가져오는 데 필요한 속성 이름을 지정합니다.

      if(!arguments.length || !this._previousAttributes)

        null을 반환;

      return this._previousAttributes[attr];

    },

    // 모델이 변경 이벤트를 트리거하면 모든 속성의 이전 상태에 대한 데이터 수집을 얻습니다.

    // 이 메소드는 이전() 메소드와 유사하며 일반적으로 변경 이벤트에서 호출되며 데이터 비교 또는 롤백에 사용됩니다.

    이전 속성: function() {

      // 이전 상태의 데이터 객체를 새 객체로 복제하고 반환합니다.

      return _.clone(this._previousAttributes);

    },

    // 현재 모델이 유효한 상태인지 확인하는 것만 가능합니다.

    // 자동 변경을 사용하는 경우 *invalid* 상태가 됩니다.

    // 현재 모델의 데이터가 유효성 검사 메서드로 검증 가능한지 확인합니다. 호출하기 전에 유효성 검사 메서드가 정의되어 있는지 확인하세요.

    isValid : 함수() {

      return !this.validate(this.attributes);

    },

    // 데이터 검증 메소드는 설정, 저장, 추가 및 기타 데이터 업데이트 메소드를 호출할 때 자동으로 실행됩니다.

    // 검증에 실패하면 모델 객체의 "error" 이벤트가 발생합니다. 옵션에 오류 처리 함수가 지정되어 있으면 options.error 함수만 실행됩니다.

    // @param {Object}는 모델의 객체화된 데이터를 저장하는 데이터 모델의 속성을 나타냅니다.

    // @param {Object} 옵션 구성 항목

    // @return {Boolean} 확인에 성공하면 true를 반환하고, 실패하면 false를 반환합니다.

    _validate : 함수(속성, 옵션) {

      // set, save, add 등의 데이터 업데이트 메소드를 호출할 때 options.silent 속성을 설정하면 검증이 무시됩니다.

      // 모델에 유효성 검사 메서드가 추가되지 않은 경우 유효성 검사가 무시됩니다.

      if(options.silent || !this.validate)

        사실을 반환;

      // 객체의 모든 속성 값을 가져와 검증을 위해 검증 메소드에 넣습니다.

      //검증 방법에는 모델의 데이터 수집 및 구성 개체인 두 개의 매개 변수가 포함됩니다. 검증에 성공하면 데이터가 반환되지 않습니다(기본값은 정의되지 않음). 검증에 실패하면 오류 정보가 포함된 데이터가 반환됩니다. .

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

      var error = this.validate(attrs, options);

      //확인 통과

      만약(!오류)

        사실을 반환;

      // 확인 실패

      // 구성 개체에 오류 오류 처리 방법이 설정된 경우 이 메서드를 호출하고 오류 데이터 및 구성 개체를 이 메서드에 전달합니다.

      if(옵션 && options.error) {

        options.error(this, 오류, 옵션);

      } 또 다른 {

        // 오류 이벤트 리스너가 모델에 바인딩된 경우 바인딩 이벤트가 트리거됩니다.

        this.trigger('error', this, error, options);

      }

      //반품 확인 실패 식별

      거짓을 반환;

    }

  });

 

  // Backbone.Collection 데이터 모델 컬렉션 관련

  //------

 

  // 컬렉션은 동일한 클래스의 일련의 데이터 모델을 저장하고 모델을 작동하기 위한 관련 메서드를 제공합니다.

  var Collection = Backbone.Collection = function(모델, 옵션) {

    //구성 객체

    옵션 || (옵션 = {});

    //구성 매개변수에서 컬렉션의 모델 클래스를 설정합니다.

    if(옵션.모델)

      this.model = 옵션.모델;

    // comparator 속성이 설정되면 컬렉션의 데이터는 comparator 메소드의 정렬 알고리즘에 따라 정렬됩니다. (add 메소드에서 자동으로 호출됩니다.)

    if(옵션.비교기)

      this.comparator = 옵션.comparator;

    //인스턴스화 시 컬렉션의 내부 상태를 재설정합니다. (첫 번째 호출은 정의 상태로 이해될 수 있습니다.)

    this._reset();

    // 사용자 정의 초기화 메소드를 호출합니다. 필요한 경우 일반적으로 초기화 메소드가 오버로드됩니다.

    this.initialize.apply(this, 인수);

    // 모델 데이터가 지정된 경우 재설정 메서드를 호출하여 컬렉션에 데이터를 추가합니다.

    // 처음 호출될 때 자동 매개변수가 설정되므로 "reset" 이벤트가 트리거되지 않습니다.

    if(모델)

      this.reset(모델, {

        침묵 : 사실,

        구문 분석 : 옵션.parse

      });

  };

  // 확장 메소드를 통해 컬렉션 클래스의 프로토타입 메소드를 정의합니다.

  _.extend(Collection.prototype, 이벤트, {

 

    // 컬렉션의 모델 클래스를 정의합니다. 모델 클래스는 Backbone.Model의 하위 클래스여야 합니다.

    // 컬렉션 관련 메소드(add, create 등) 사용 시 데이터 객체 전달이 허용됩니다. 컬렉션 메소드는 정의된 모델 클래스에 따라 해당 인스턴스를 자동으로 생성합니다.

    //컬렉션에 저장된 데이터 모델은 모두 동일한 모델 클래스의 인스턴스여야 합니다.

    모델 : 모델,

 

    // 초기화 메서드, 이 메서드는 컬렉션 인스턴스가 생성된 후 자동으로 호출됩니다.

    // 이 메서드는 일반적으로 컬렉션 클래스를 정의할 때 오버로드됩니다.

    초기화 : 함수() {

    },

    // 컬렉션에 있는 각 모델의 데이터 객체를 포함하는 배열을 반환합니다.

    toJSON : 함수(옵션) {

      // Undersocre의 map 메소드를 사용하여 컬렉션의 각 모델에 대한 toJSON 결과 배열을 구성하고 반환합니다.

      return this.map(함수(모델) {

        // 각 모델 객체의 toJSON 메소드를 차례로 호출합니다. 이 메소드는 기본적으로 모델의 데이터 객체(복사본)를 반환합니다.

        // 문자열이나 다른 형식을 반환해야 하는 경우 toJSON 메서드를 오버로드할 수 있습니다.

        return model.toJSON(옵션);

      });

    },

    //하나 이상의 모델 객체를 컬렉션에 추가합니다.

    // "add" 이벤트는 기본적으로 발생합니다. 옵션에 자동 속성이 설정된 경우 이 이벤트 발생을 끌 수 있습니다.

    // 전달된 모델은 하나 또는 일련의 모델 개체(Model 클래스의 인스턴스)일 수 있습니다. 모델 속성이 컬렉션에 설정된 경우 데이터 개체(예: {name: 'test'})가 허용됩니다. 모델이 가리키는 모델 객체로 데이터 객체를 자동으로 인스턴스화합니다.

    추가 : 기능(모델, 옵션) {

      //지역변수 정의

      var i, 인덱스, 길이, 모델, cid, id, cids = {}, ids = {}, dups = [];

      옵션 || (옵션 = {});

      // 모델은 배열이어야 하며, 하나의 모델만 전달된 경우 배열로 변환합니다.

      models = _.isArray(models) ? models.slice() : [모델];

 

      // 추가해야 할 모델 목록을 순회하는 동안 다음 작업이 수행됩니다.

      // - 데이터 객체를 모델 객체로 변환

      // - 모델과 컬렉션 사이에 참조를 설정합니다.

      // - 유효하지 않은 모델과 중복된 모델을 기록하고 나중에 필터링합니다.

      for( i = 0, 길이 = models.length; i