Underscore.js 1.3.3 중국어 주석 번역 지침_기본지식

// Underscore.js 1.3.3

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

// Underscore는 MIT 라이센스에 따라 무료로 배포 가능합니다.

// Underscore의 일부는 Prototype에서 영감을 받거나 차용되었습니다.

// Oliver Steele의 Functional 및 John Resig의 Micro-Templating.

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

// http://documentcloud.github.com/underscore

(기능() {

 

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

  var 루트 = 이것;

 

  //"_"(밑줄 변수)를 덮어쓰기 전의 값을 저장합니다.

  // 이름 충돌이 있거나 사양을 고려하는 경우 _.noConstrict() 메서드를 사용하여 Underscore가 차지하기 전의 "_" 값을 복원하고 이름 변경을 위해 Underscore 개체를 반환할 수 있습니다.

  var 이전Underscore = 루트._;

 

  //내부 공유 및 사용을 위해 빈 객체 상수를 생성합니다.

  var 차단기 = {};

 

  //빠른 호출을 용이하게 하기 위해 내장 객체의 프로토타입 체인을 로컬 변수에 캐시합니다.

  var ArrayProto = Array.prototype, //

  ObjProto = Object.prototype, //

  FuncProto = 함수.프로토타입;

 

  //빠른 호출을 위해 지역 변수에 내장된 객체 프로토타입의 공통 메서드를 캐시합니다.

  var 슬라이스 = ArrayProto.slice, //

  unshift = ArrayProto.unshift, //

  toString = ObjProto.toString, //

  hasOwnProperty = ObjProto.hasOwnProperty;

 

  // 이는 JavaScript 1.6에서 제공되는 몇 가지 새로운 메소드를 정의합니다.

  // 호스트 환경이 이러한 메소드를 지원하는 경우 먼저 호출됩니다. 호스트 환경에서 이를 제공하지 않는 경우 Underscore에 의해 구현됩니다.

  var NativeForEach = ArrayProto.forEach, //

  NativeMap = ArrayProto.map, //

  NativeReduce = ArrayProto.reduce, //

  NativeReduceRight = ArrayProto.reduceRight, //

  NativeFilter = ArrayProto.filter, //

  NativeEvery = ArrayProto.every, //

  NativeSome = ArrayProto.some, //

  NativeIndexOf = ArrayProto.indexOf, //

  NativeLastIndexOf = ArrayProto.lastIndexOf, //

  NativeIsArray = Array.isArray, //

  NativeKeys = Object.keys, //

  NativeBind = FuncProto.bind;

 

  // Underscore 래퍼를 반환하는 개체 스타일 호출 메서드를 만듭니다. 래퍼 개체의 프로토타입에는 Underscore의 모든 메서드가 포함되어 있습니다(DOM 개체를 jQuery 개체로 래핑하는 것과 유사).

  var _ = 함수(obj) {

    // 모든 Underscore 객체는 래퍼 객체를 통해 내부적으로 생성됩니다.

    새로운 래퍼(obj)를 반환합니다.

  };

  // 다른 호스트 환경의 경우 Undersocre의 명명된 변수를 다른 개체에 저장합니다.

  if( typeof imports !== 'undefine') {// Node.js 환경

    if( 모듈 유형 !== '정의되지 않음' && module.exports) {

      내보내기 = module.exports = _;

    }

    수출._ = _;

  } else {//브라우저 환경에서 Underscore라는 이름의 변수가 window 객체에 걸려 있습니다.

    루트['_'] = _;

  }

 

  // 버전 설명

  _.VERSION = '1.3.3';

 

  // 컬렉션 관련 메서드(데이터 및 객체에 대한 일반적인 처리 방법)

  //-------

 

  // 프로세서를 반복하고 컬렉션의 각 요소에 대해 프로세서 메서드를 실행합니다.

  var 각각 = _.each = _.forEach = function(obj, iterator, context) {

    //null 값을 처리하지 않음

    if(obj == null)

      반품;

    if(nativeForEach && obj.forEach === NativeForEach) {

      // 호스트 환경에서 지원하는 경우 JavaScript 1.6에서 제공하는 forEach 메서드가 먼저 호출됩니다.

      obj.forEach(반복자, 컨텍스트);

    } else if(obj.length === obj.length) {

      //<array>의 각 요소에 대해 프로세서 메서드를 실행합니다.

      for(var i = 0, l = obj.length; i 의 각 요소에 대해 프로세서 메서드를 실행합니다.

      for(obj의 var 키) {

        if(_.has(obj, key)) {

          if(iterator.call(context, obj[key], key, obj) === 차단기)

            반품;

        }

      }

    }

  };

  // 반복 프로세서, 각 메소드와의 차이점은 맵이 각 반복의 반환 값을 저장하고 새 배열로 반환한다는 것입니다.

  _.map = _.collect = function(obj, iterator, context) {

    //반환값을 저장하는 데 사용되는 배열

    var 결과 = [];

    if(obj == null)

      결과를 반환합니다.

    // 호스트 환경에서 제공하는 맵 메소드 호출 우선순위를 지정합니다.

    if(nativeMap && obj.map === 기본 맵)

      return obj.map(반복자, 컨텍스트);

    // 컬렉션의 요소를 반복합니다.

    각각(obj, 함수(값, 인덱스, 목록)) {

      // 각 반복의 반환 값을 결과 배열에 저장합니다.

      results[results.length] = iterator.call(컨텍스트, 값, 인덱스, 목록);

    });

    //처리 결과를 반환합니다.

    if(obj.길이 === obj.길이)

      결과.길이 = obj.길이;

    결과를 반환합니다.

  };

  // 컬렉션의 각 요소를 반복 프로세서에 넣고 이 반복의 반환 값을 "메모"로 다음 반복에 전달합니다. 일반적으로 결과를 누적하거나 데이터를 연결하는 데 사용됩니다.

  _.reduce = _.foldl = _.inject = function(obj, iterator, 메모, 컨텍스트) {

    // 매개변수 개수만큼 초기값이 있는지 확인

    var 초기 = 인수.길이 >

    if(obj == null)

      obj = [];

    // 호스트 환경에서 제공하는 축소 메소드 호출 우선순위를 지정합니다.

    if(nativeReduce && obj.reduce === NativeReduce && false) {

      if(컨텍스트)

        iterator = _.bind(반복자, 컨텍스트);

      초기 반환 ? obj.reduce(iterator, memo) : obj.reduce(iterator);

    }

    // 컬렉션의 요소를 반복합니다.

    각각(obj, 함수(값, 인덱스, 목록)) {

      if(!initial) {

        // 초기값이 없으면 첫 번째 요소가 초기값으로 사용되며, 객체 컬렉션이 처리되면 기본값은 첫 번째 속성의 값입니다.

        메모 = 값;

        초기 = 사실;

      } 또 다른 {

        // 처리 결과를 기록하고 결과를 다음 반복으로 전달합니다.

        memo = iterator.call(컨텍스트, 메모, 값, 인덱스, 목록);

      }

    });

    if(!초기)

      throw new TypeError('초기값이 없는 빈 배열 감소');

    메모 반환;

  };

  // 감소와 유사하게 컬렉션의 요소를 반대 방향으로 반복합니다(즉, 마지막 요소에서 시작하여 첫 번째 요소까지).

  _.reduceRight = _.foldr = function(obj, iterator, 메모, 컨텍스트) {

    var 초기 = 인수.길이 >

    if(obj == null)

      obj = [];

    // 호스트 환경에서 제공하는 ReduceRight 메소드 호출 우선순위를 지정합니다.

    if(nativeReduceRight && obj.reduceRight === NativeReduceRight) {

      if(컨텍스트)

        iterator = _.bind(반복자, 컨텍스트);

      초기 반환 ? obj.reduceRight(iterator, memo) : obj.reduceRight(iterator);

    }

    //컬렉션의 요소 순서를 반대로 바꿉니다.

    var reversed = _.toArray(obj).reverse();

    if(컨텍스트 && !초기)

      iterator = _.bind(반복자, 컨텍스트);

    //리듀스 메소드를 통해 데이터 처리

    return 초기 ? _.reduce(reversed, iterator, memo, context) : _.reduce(reversed, iterator);

  };

  // 컬렉션의 요소를 순회하고 프로세서 확인을 통과할 수 있는 첫 번째 요소를 반환합니다.

  _.find = _.Detect = function(obj, iterator, context) {

    // 결과는 검증을 통과할 수 있는 첫 번째 요소를 저장합니다.

    var 결과;

    // any 메소드를 통해 데이터를 탐색하고 검증을 통과한 요소를 기록합니다.

    // (iteration 중 프로세서 반환 상태를 확인하는 경우 여기서는 각각의 메소드를 사용하는 것이 더 적절할 것입니다)

    모든(obj, 함수(값, 인덱스, 목록)) {

      // 프로세서가 반환한 결과를 Boolean 타입으로 변환하여 값이 true이면 현재 요소를 기록하여 반환한다.

      if(iterator.call(context, value, index, list)) {

        결과 = 값;

        사실을 반환;

      }

    });

    결과 반환;

  };

  // find 메소드와 비슷하지만 filter 메소드는 컬렉션의 확인된 모든 요소를 ​​기록합니다.

  _.filter = _.select = function(obj, iterator, context) {

    // 유효성 검사를 통과한 요소의 배열을 저장하는 데 사용됩니다.

    var 결과 = [];

    if(obj == null)

      결과를 반환합니다.

    // 호스트 환경에서 제공하는 필터 메소드를 우선적으로 호출합니다.

    if(nativeFilter && obj.filter === NativeFilter)

      return obj.filter(반복자, 컨텍스트);

    // 컬렉션의 요소를 반복하고 프로세서에서 확인한 요소를 배열에 넣고 반환합니다.

    각각(obj, 함수(값, 인덱스, 목록)) {

      if(iterator.call(컨텍스트, 값, 인덱스, 목록))

        결과[결과.길이] = 값;

    });

    결과를 반환합니다.

  };

  // 필터 메소드의 반대 효과, 즉 프로세서 검증을 통과하지 못한 요소 목록을 반환합니다.

  _.reject = function(obj, iterator, context) {

    var 결과 = [];

    if(obj == null)

      결과를 반환합니다.

    각각(obj, 함수(값, 인덱스, 목록)) {

      if(!iterator.call(컨텍스트, 값, 인덱스, 목록))

        결과[결과.길이] = 값;

    });

    결과를 반환합니다.

  };

  //컬렉션의 모든 요소가 프로세서 확인을 통과할 수 있으면 true를 반환합니다.

  _.every = _.all = function(obj, iterator, context) {

    var 결과 = true;

    if(obj == null)

      결과 반환;

    // 호스트 환경에서 제공하는 모든 메소드를 우선적으로 호출합니다.

    if(nativeEvery && obj.every === NativeEvery)

      return obj.every(반복자, 컨텍스트);

    //컬렉션의 요소를 반복합니다.

    각각(obj, 함수(값, 인덱스, 목록)) {

      // 이는 result = (result && iterator.call(context, value, index, list))로 이해됩니다.

      // 프로세서의 결과가 Boolean 타입으로 변환된 후 참값인지 확인

      if(!( 결과 = 결과 && iterator.call(컨텍스트, 값, 인덱스, 목록)))

        복귀 차단기;

    });

    반환 !!결과;

  };

  // 컬렉션의 요소가 부울 유형으로 변환될 때 참값을 갖는지 확인합니까? 아니면 프로세서에서 처리된 후에 참값을 갖는지 확인합니까?

  var any = _.some = _.any = function(obj, iterator, context) {

    // 프로세서 매개변수가 지정되지 않은 경우 기본 프로세서 함수는 요소 자체를 반환하고 반복 중에 요소를 부울 유형으로 변환하여 참값인지 확인합니다.

    반복자 || ( 반복자 = _.identity);

    var 결과 = 거짓;

    if(obj == null)

      결과 반환;

    // 호스트 환경에서 제공하는 일부 메소드 호출에 우선순위를 부여합니다.

    if(nativeSome && obj.some === NativeSome)

      return obj.some(반복자, 컨텍스트);

    //컬렉션의 요소를 반복합니다.

    각각(obj, 함수(값, 인덱스, 목록)) {

      if(결과 || ( 결과 = iterator.call(컨텍스트, 값, 인덱스, 목록)))

        복귀 차단기;

    });

    반환 !!결과;

  };

  // 컬렉션에 대상 매개변수와 정확히 일치하는 값이 있는지 확인합니다. (데이터 유형도 일치합니다.)

  _.include = _.contains = function(obj, 대상) {

    var 발견 = false;

    if(obj == null)

      반품을 찾았습니다.

    // 호스트 환경에서 제공하는 Array.prototype.indexOf 메서드 호출 우선순위를 지정합니다.

    if(nativeIndexOf && obj.indexOf === NativeIndexOf)

      return obj.indexOf(target) != -1;

    // any 메소드를 통해 컬렉션의 요소를 반복하고 요소의 값과 유형이 대상과 완전히 일치하는지 확인합니다.

    발견 = 모든(obj, 함수(값)) {

      반환 값 === 대상;

    });

    반품을 찾았습니다.

  };

  // 요소의 호출 메서드에 전달될 세 번째 매개변수부터 시작하여 컬렉션에 있는 모든 요소의 동일한 이름의 메서드를 순서대로 호출합니다.

  // 모든 메소드의 처리 결과를 저장하는 배열을 반환

  _.invoke = 함수(obj, 메서드) {

    // 같은 이름의 메소드 호출 시 전달되는 매개변수 (3번째 매개변수부터 시작)

    var args = Slice.call(인수, 2);

    // 각 요소의 메소드를 차례로 호출하고 그 결과를 배열에 담아 반환한다.

    return _.map(obj, function(value) {

      return (_.isFunction(method) ? method || value : value[method]).apply(value, args);

    });

  };

  // 객체 목록으로 구성된 배열을 탐색하고 각 객체의 지정된 속성에 대한 값 목록을 반환합니다.

  _.pluck = function(obj, 키) {

    // 객체에 속성이 존재하지 않는 경우, 정의되지 않음을 반환합니다.

    return _.map(obj, function(value) {

      반환값[키];

    });

  };

  //컬렉션의 최대값을 반환하고, 비교할 수 있는 값이 없으면 정의되지 않은 값을 반환합니다.

  _.max = 함수(obj, 반복자, 컨텍스트) {

    // 컬렉션이 배열이고 프로세서가 사용되지 않는 경우 Math.max를 사용하여 최대값을 얻습니다.

    // 일반적으로 일련의 숫자형 데이터가 배열로 저장됩니다.

    if(!iterator && _.isArray(obj) && obj[0] === obj[0])

      return Math.max.apply(Math, obj);

    // null 값의 경우 음의 무한대를 직접 반환합니다.

    if(!iterator && _.isEmpty(obj))

      반환 -무한대;

    // 임시 개체, 계산은 비교 프로세스 중 최대값을 저장하는 데 사용됩니다(임시).

    변수 결과 = {

      계산 : -무한대

    };

    //컬렉션의 요소를 반복합니다.

    각각(obj, 함수(값, 인덱스, 목록)) {

      // 프로세서 매개변수가 지정된 경우 비교 데이터는 프로세서가 반환한 값이고, 그렇지 않으면 각 순회 중 기본값이 직접 사용됩니다.

      var 계산 = 반복자 ? iterator.call(컨텍스트, 값, 인덱스, 목록) : 값;

      // 비교 값이 이전 값보다 크면 현재 값을 result.value에 넣습니다.

      계산됨 >= 결과.계산됨 && ( 결과 = {

        가치: 가치,

        계산하다 : 계산하다

      });

    });

    // 최대값을 반환합니다.

    결과.값을 반환합니다.

  };

  //세트의 최소값을 반환합니다. 처리 프로세스는 max 메소드와 일치합니다.

  _.min = 함수(obj, 반복자, 컨텍스트) {

    if(!iterator && _.isArray(obj) && obj[0] === obj[0])

      return Math.min.apply(Math, obj);

    if(!iterator && _.isEmpty(obj))

      무한대를 반환합니다.

    변수 결과 = {

      계산됨: 무한대

    };

    각각(obj, 함수(값, 인덱스, 목록)) {

      var 계산 = 반복자 ? iterator.call(컨텍스트, 값, 인덱스, 목록) : 값;

      계산된 

      rand = Math.floor(Math.random() * (색인 1));

      // 섞인 배열의 끝에 무작위로 얻은 요소를 넣습니다.

      섞인[인덱스] = 섞인[랜드];

      //이전에 얻은 난수 위치에 가장 최근의 값을 삽입

      shuffled[rand] = 값;

    });

    // 무작위로 섞인 컬렉션 요소를 저장하는 배열을 반환합니다.

    섞여서 돌아옴;

  };

  // 특정 필드나 값에 따라 컬렉션의 요소를 정렬합니다.

  // Array.prototype.sort 메소드와 비교하여 sortBy 메소드는 객체 정렬을 지원합니다.

  _.sortBy = function(obj, val, context) {

    // val은 객체의 속성이거나 프로세서 함수여야 합니다. 프로세서인 경우 비교해야 하는 데이터를 반환해야 합니다.

    var iterator = _.isFunction(val) ? val : function(obj) {

      반환 객체[발];

    };

    // 호출 순서: _.pluck(_.map().sort());

    // _.map() 메서드를 호출하여 컬렉션을 순회하고 컬렉션의 요소를 값 노드에 넣고 요소에서 비교해야 하는 데이터를 기준 속성에 넣습니다.

    //criteria 속성의 데이터에 따라 컬렉션의 요소를 정렬하려면 sort() 메서드를 호출합니다.

    // pluck을 호출하여 정렬된 객체 컬렉션을 얻고 반환합니다.

    return _.pluck(_.map(obj, function(value, index, list)) {

      반품 {

        가치: 가치,

        기준: iterator.call(컨텍스트, 값, 인덱스, 목록)

      };

    }).sort(함수(왼쪽, 오른쪽) {

      var a = 왼쪽.기준, b = 오른쪽.기준;

      만약(a ===

        무효 0)

        1을 반환합니다.

      만약(b ===

        무효 0)

        -1을 반환합니다.

      a <b>b ?

    }), '값');

  };

  // 프로세서가 반환한 키에 따라 컬렉션의 요소를 여러 배열로 나눕니다.

  _.groupBy = 함수(obj, val) {

    var 결과 = {};

    // val은 그룹화를 위해 프로세서 함수로 변환됩니다. val이 Function 유형 데이터가 아닌 경우 요소 필터링 시 키 값으로 사용됩니다.

    var iterator = _.isFunction(val) ? val : function(obj) {

      반환 객체[발];

    };

    //컬렉션의 요소를 반복합니다.

    각각(obj, 함수(값, 인덱스)) {

      // 프로세서의 반환 값을 키로 사용하고 동일한 키 요소를 새 배열에 넣습니다.

      var key = iterator(값, 인덱스);

      (결과[키] || (결과[키] = [])).push(값);

    });

    // 그룹화된 데이터를 반환합니다.

    결과 반환;

  };

  _.sortedIndex = function(array, obj, iterator) {

    반복자 || ( 반복자 = _.identity);

    var low = 0, high = array.length;

    while(낮음 > 1;

      iterator(array[mid]) = 0;

      });

    });

  };

  // 현재 배열에서 지정된 데이터와 동일하지 않은 차이 데이터를 필터링하고 반환합니다.

  // 이 함수는 일반적으로 배열에서 지정된 데이터를 삭제하고 삭제 후 새 배열을 가져오는 데 사용됩니다.

  // 이 메소드의 기능은 Without와 동일합니다. Without 메소드 매개변수는 데이터가 배열에 포함되는 것을 허용하지 않는 반면, Difference 메소드 매개변수는 배열을 권장합니다(without과 동일한 매개변수를 사용할 수도 있습니다).

  _.차이 = 함수(배열) {

    // 두 번째 매개변수부터 모든 매개변수를 배열로 병합합니다. (1단계만 병합하고, 깊은 병합은 하지 않습니다.)

    // 나머지 변수에는 원본 데이터와 비교하기 위해 이 메서드에서 사용되는 검증 데이터가 저장됩니다.

    var 나머지 = _.platten(slice.call(arguments, 1), true);

    // 병합된 배열 데이터를 필터링합니다. 필터 조건은 현재 배열에 매개변수에 지정된 검증 데이터가 포함되어 있지 않다는 것입니다.

    // 필터 조건에 맞는 데이터를 새로운 배열로 결합하여 반환

    return _.filter(배열, 함수(값) {

      return !_.include(나머지, 값);

    });

  };

  //각 배열의 동일한 위치에 있는 데이터를 새로운 2차원 배열로 반환합니다. 반환되는 배열의 길이는 전달된 매개변수의 최대 배열 길이를 기준으로 합니다. 다른 배열의 공백 위치는 정의되지 않은 상태로 채워집니다.

  // zip 메소드에는 여러 매개변수가 포함되어야 하며 각 매개변수는 배열이어야 합니다.

  _.zip = 함수() {

    //매개변수를 배열로 변환합니다. 이때 args는 2차원 배열입니다.

    var args = Slice.call(인수);

    // 각 배열의 길이를 계산하고 최대 길이 값을 반환합니다.

    var 길이 = _.max(_.pluck(args, '길이'));

    //처리 결과를 저장하는 데 사용되는 최대 길이 값에 따라 새로운 빈 배열을 생성합니다.

    var 결과 = new Array(length);

    //루프의 최대 길이, 각 루프에서 각 배열의 동일한 위치(0부터 순서대로 마지막 위치까지)의 데이터를 얻기 위해 pluck 메소드가 호출됩니다.

    // 얻은 데이터를 새 배열에 저장하고 결과에 넣고 반환합니다.

    for(var i = 0; i = 0; i--) {

        args = [funcs[i].apply(this, args)];

      }

      //마지막 함수 호출의 반환 값을 반환합니다.

      반환 인수[0];

    };

  };

  // 호출 카운터 역할을 하는 함수를 반환합니다. 함수가 회 호출되면(또는 회를 초과하면) func 함수가 실행됩니다.

  // after 메소드는 일반적으로 비동기 카운터로 사용됩니다. 예를 들어 여러 AJAX 요청이 완료된 후 함수를 실행해야 하는 경우 각 AJAX 요청이 완료된 후 after를 사용하여 호출할 수 있습니다.

  _.after = 함수(시간, 함수) {

    // 시간이 지정되지 않거나 유효하지 않은 경우 func가 직접 호출됩니다.

    if(회 를 포함한 HTML 문자열의 특수 문자를 HTML 엔터티로 변환합니다.

  _.escape = 함수(문자열) {

    return ('' 문자열).replace(/&/g, '&').replace(/, '/g, '>').replace(/ "/g, '"').replace(/'/g, ''').replace(///g, '/');

  };

  //객체의 속성을 지정하고 해당 속성에 해당하는 값을 반환합니다. 해당 속성이 함수에 해당하면 함수가 실행되고 결과가 반환됩니다.

  _.result = function(객체, 속성) {

    if(객체 == null)

      null을 반환;

    //객체의 값을 가져옵니다.

    var 값 = 객체[속성];

    // 값이 함수이면 실행하고 반환하고, 그렇지 않으면 직접 반환합니다.

    return _.isFunction(value) ? value.call(object) : 값;

  };

  //Underscore 플러그인을 확장하기 위해 Underscore 객체에 일련의 사용자 정의 메소드를 추가합니다.

  _.mixin = 함수(obj) {

    //obj는 일련의 사용자 정의 메소드를 수집하는 객체입니다. 여기서 객체를 순회하는 방법은 각각을 통해 이루어집니다.

    각각(_.functions(obj), 함수(이름) {

      //객체 기반 호출을 지원하기 위해 addToWrapper 함수를 통해 Underscore에서 만든 객체에 사용자 정의 메서드를 추가합니다.

      // 또한 함수 호출을 지원하기 위해 _ 자체에 메서드를 추가합니다.

      addToWrapper(이름, _[이름] = obj[이름]);

    });

  };

  // 전역적으로 고유한 식별자를 가져옵니다. 식별자는 0부터 시작하여 누적됩니다.

  var idCounter = 0;

  // prefix는 식별자의 접두사를 나타냅니다. 접두사가 지정되지 않으면 식별자가 직접 반환됩니다. 일반적으로 객체 또는 DOM에 대한 고유 ID를 생성하는 데 사용됩니다.

  _.uniqueId = 함수(접두사) {

    var id = idCounter;

    접두사 반환 ? 접두사 id : id;

  };

  // 템플릿 메소드에서 사용되는 템플릿의 구분 기호를 정의합니다.

  _.templateSettings = {

    //JavaScript 실행 코드 구분 기호

    평가 : //g,

    //변수의 구분자를 직접 출력

    보간 : //g,

    //HTML을 문자열로 출력하기 위해 필요한 구분자(특수기호를 문자열 형식으로 변환)

    탈출 : //g

  };

 

  var noMatch = /.^/;

 

  // 이스케이프 객체는 서로 변환해야 하는 특수 기호와 문자열 형식 간의 대응 관계를 기록하고, 둘이 서로 변환될 때 인덱스로 사용됩니다.

  // 먼저 문자열 형식에 따라 특수 문자를 정의합니다.

  var 이스케이프 = {

    '\' : '\',

    "'" : "'",

    'r' : 'r',

    'n' : 'n',

    '티' : '티',

    'u2028' : 'u2028',

    'u2029' : 'u2029'

  };

  // 특수문자열을 모두 순회하고 특수문자를 키로 사용하여 문자열 형태로 기록한다.

  for(이스케이프의 var p)

  이스케이프[이스케이프[p]] = p;

  // 백슬래시, 작은따옴표, 캐리지 리턴, 줄 바꿈, 탭, 줄 구분 기호, 단락 구분 기호 등 템플릿에서 바꿔야 하는 특수 기호를 정의합니다.

  // 문자열의 특수기호를 문자열 형태로 변환할 때 사용

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

  // 문자열 형태의 특수기호를 반전(교체)할 때 사용

  var unescaper = /\(\|'|r|n|t|u2028|u2029)/g;

 

  //문자열의 특수 기호 반전

  // 템플릿에서 실행해야 하는 자바스크립트 소스 코드를 특수 기호로 반전시켜야 합니다. 그렇지 않으면 HTML 엔터티나 문자열 형태로 나타날 경우 구문 오류가 발생합니다.

  var 이스케이프 해제 = 함수(코드) {

    return code.replace(unescaper, function(match, escape) {

      return escapes[escape];

    });

  };

  // 템플릿 문자열에 데이터를 채우는 데 사용되는 밑줄 템플릿 구문 분석 방법

  // 템플릿 구문 분석 프로세스:

  // 1. 템플릿의 특수 기호를 문자열로 변환합니다.

  // 2. 이스케이프 양식 태그를 구문 분석하고 콘텐츠를 HTML 엔터티로 구문 분석합니다.

  // 3. 양식 태그 및 출력 변수를 보간하여 구문 분석합니다.

  // 4. 평가 양식 태그를 구문 분석하고 실행 가능한 JavaScript 코드를 생성합니다.

  // 5. 데이터를 가져온 후 템플릿을 직접 채우고 채워진 문자열을 반환할 수 있는 처리 함수를 생성합니다.

  // 6. 매개변수에 따라 채워진 문자열 또는 처리 함수의 핸들을 반환합니다.

  //------

  //템플릿 본문에서 인수를 통해 두 개의 매개변수, 즉 채우기 데이터(obj라는 이름)와 Underscore 개체(_라는 이름)를 얻을 수 있습니다.

  _.template = function(텍스트, 데이터, 설정) {

    // 템플릿 구성, 구성 항목이 지정되지 않은 경우 templateSettings에 지정된 구성 항목이 사용됩니다.

    설정 = _.defaults(설정 || {}, _.templateSettings);

 

    // 템플릿을 실행 가능한 소스 코드로 구문 분석하기 시작합니다.

    var source = "__p ='" text.replace(escaper, function(match) {

      //특수기호를 문자열 형식으로 변환

      return '\' 이스케이프[일치];

    }).replace(settings.escape || noMatch, function(일치, 코드) {

      // 이스케이프 형식 태그 를 구문 분석하고, _.escape 함수를 통해 변수에 포함된 HTML을 HTML 엔터티로 변환합니다.

      return "' n_.escape(" unescape(code) ") n'";

    }).replace(settings.interpolate || noMatch, function(일치, 코드) {

      // 보간 형식 태그 를 구문 분석하고 템플릿 내용을 다른 문자열과 변수로 연결하면 변수로 출력됩니다.

      return "' n(" unescape(code) ") n'";

    }).replace(settings.evaluate || noMatch, function(일치, 코드) {

      // 평가 형식 태그 를 구문 분석합니다. 실행해야 할 JavaScript 코드는 평가 태그에 저장되며 여기서 끝나며 새 줄에서 JavaScript 구문으로 실행됩니다. 문자열의 시작 부분을 다시 문자로 사용하므로 평가 태그의 JavaScript 코드가 정상적으로 실행될 수 있습니다.

      return "';n" unescape(code) "n;__p ='";

    }) "';N";

    if(!settings.변수)

      소스 = 'with(obj||{}){n' 소스 '}n';

    source = "var __p='';" "var print=function(){__p =Array.prototype.join.call(arguments, '')};n" 소스 "return __p;n";

 

    // 함수를 생성하고, 소스 코드를 함수 실행 본문으로 사용하고, obj 및 Underscore를 함수에 매개변수로 전달합니다.

    var render = new Function(settings.variable || 'obj', '_', source);

    // 템플릿의 채우기 데이터가 지정된 경우 템플릿 내용을 교체하고 교체된 결과를 반환합니다.

    만약(데이터)

      return render(data, _);

    // 채우기 데이터가 지정되지 않은 경우 수신된 데이터를 템플릿으로 바꾸는 함수를 반환합니다.

    // 프로그램에서 동일한 템플릿을 여러 번 채울 경우 첫 번째 호출에서 채우기 데이터를 지정하지 않는 것이 좋습니다. 처리 함수의 참조를 얻은 후 직접 호출하면 작업 효율성이 향상됩니다.

    var 템플릿 = 함수(데이터) {

      return render.call(this, data, _);

    };

    //생성된 소스 코드 문자열을 함수 객체에 추가합니다. 일반적으로 디버깅 및 테스트에 사용됩니다.

    template.source = 'function(' (settings.variable || 'obj') '){n' 소스 '}';

    //채우는 데이터가 지정되지 않은 경우 처리 함수 핸들을 반환합니다.

    반환 템플릿;

  };

  // Underscore 객체의 메소드 체인 작업을 지원합니다. Wrapper.prototype.chain을 참조하세요.

  _.체인 = 함수(obj) {

    return _(obj).chain();

  };

  // Underscore 객체는 관련 메소드를 캡슐화합니다.

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

 

  //원시 데이터를 래핑하기 위한 래퍼 생성

  // 모든 undersocre 객체는 래퍼 함수를 ​​통해 내부적으로 생성되고 캡슐화됩니다.

  //Underscore와 래퍼 사이의 내부 관계:

  // - 내부적으로 _ 변수를 정의하고, _에 Underscore 관련 메소드를 추가하여 _.bind() 등의 함수 호출을 지원할 수 있도록 합니다.

  // - 래퍼 클래스를 내부적으로 정의하고 _의 프로토타입 객체가 래퍼 클래스의 프로토타입을 가리키도록 합니다.

  // - 래퍼 프로토타입에 Underscore 관련 메서드를 추가하면 생성된 _ 객체에 Underscore 메서드가 포함됩니다.

  // - 래퍼 프로토타입에 Array.prototype 관련 메서드를 추가하면 생성된 _ 객체는 Array.prototype의 메서드를 갖게 됩니다.

  // -new _()는 실제로 래퍼() 객체를 생성 및 반환하고, 원래 배열을 _wrapped 변수에 저장하고, 원래 값을 첫 번째 매개변수로 사용하여 해당 메서드를 호출합니다.

  var 래퍼 = function(obj) {

    //원래 데이터는 래핑된 객체의 _wrapped 속성에 저장됩니다.

    this._wrapped = obj;

  };

  // Underscore의 프로토타입 개체가 래퍼의 프로토타입을 가리키도록 하므로 래퍼 프로토타입과 같은 메서드를 추가하면 Underscore 개체도 동일한 메서드를 갖게 됩니다.

  _.prototype = 래퍼.프로토타입;

 

  //객체를 반환합니다. 현재 Underscore가 chain() 메서드를 호출하면(즉, _chain 속성이 true) 래핑된 Underscore 객체가 반환되고, 그렇지 않으면 객체 자체가 반환됩니다.

  // 결과 함수</b></array>