temp-helper-linqjs 0.2.2 → 0.2.3

package/linq-module.js

@@ -1,32 +1,77 @@
 /**
  * Array 프로토타입 확장 - LINQ 스타일 메서드
+ * C# LINQ와 유사한 쿼리 메서드를 JavaScript Array에 추가합니다.
  * @module helper-linqjs
+ * @version 0.2.1
+ * @author WooYoung
+ * @license MIT
  */
 
 (function() {
   'use strict';
 
-  // 필터링
+  /**
+   * 조건을 만족하는 요소를 필터링합니다.
+   * @function Where
+   * @memberof Array.prototype
+   * @param {Function} predicate - 필터링 조건 함수 (true를 반환하는 요소만 포함)
+   * @returns {Array} 필터링된 새로운 배열
+   * @example
+   * [1, 2, 3, 4].Where(x => x > 2) // [3, 4]
+   */
   Array.prototype.Where = function(predicate) {
     return this.filter(predicate);
   };
 
-  // 변환
+  /**
+   * 배열의 각 요소를 변환합니다.
+   * @function Select
+   * @memberof Array.prototype
+   * @param {Function} selector - 변환 함수
+   * @returns {Array} 변환된 새로운 배열
+   * @example
+   * [1, 2, 3].Select(x => x * 2) // [2, 4, 6]
+   */
   Array.prototype.Select = function(selector) {
     return this.map(selector);
   };
 
-  // 처음 N개 가져오기
+  /**
+   * 배열의 처음 N개 요소를 추출합니다.
+   * @function Take
+   * @memberof Array.prototype
+   * @param {number} count - 추출할 요소의 개수
+   * @returns {Array} 처음 count개의 요소로 구성된 배열
+   * @example
+   * [1, 2, 3, 4, 5].Take(3) // [1, 2, 3]
+   */
   Array.prototype.Take = function(count) {
     return this.slice(0, count);
   };
 
-  // 처음 N개 스킵
+  /**
+   * 배열의 처음 N개 요소를 제외합니다.
+   * @function Skip
+   * @memberof Array.prototype
+   * @param {number} count - 제외할 요소의 개수
+   * @returns {Array} count개 이후의 요소로 구성된 배열
+   * @example
+   * [1, 2, 3, 4, 5].Skip(2) // [3, 4, 5]
+   */
   Array.prototype.Skip = function(count) {
     return this.slice(count);
   };
 
-  // 오름차순 정렬
+  /**
+   * 배열을 오름차순으로 정렬합니다.
+   * @function OrderBy
+   * @memberof Array.prototype
+   * @param {Function} selector - 정렬 기준을 결정하는 함수
+   * @returns {Array} 정렬된 배열
+   * @example
+   * [3, 1, 2].OrderBy(x => x) // [1, 2, 3]
+   * [{val: 3}, {val: 1}].OrderBy(x => x.val) // [{val: 1}, {val: 3}]
+   */
   Array.prototype.OrderBy = function(selector) {
     return this.sort((a, b) => {
       const valA = selector(a);
@@ -37,7 +82,15 @@
     });
   };
 
-  // 내림차순 정렬
+  /**
+   * 배열을 내림차순으로 정렬합니다.
+   * @function OrderByDescending
+   * @memberof Array.prototype
+   * @param {Function} selector - 정렬 기준을 결정하는 함수
+   * @returns {Array} 내림차순으로 정렬된 배열
+   * @example
+   * [1, 2, 3].OrderByDescending(x => x) // [3, 2, 1]
+   */
   Array.prototype.OrderByDescending = function(selector) {
     return this.sort((a, b) => {
       const valA = selector(a);
@@ -48,7 +101,16 @@
     });
   };
 
-  // 중복 제거
+  /**
+   * 중복된 요소를 제거합니다.
+   * @function Distinct
+   * @memberof Array.prototype
+   * @param {Function} [selector=x => x] - 중복 판별 기준 함수 (기본값: 요소 자체)
+   * @returns {Array} 중복이 제거된 배열
+   * @example
+   * [1, 1, 2, 2, 3].Distinct() // [1, 2, 3]
+   * [{id: 1}, {id: 1}, {id: 2}].Distinct(x => x.id) // [{id: 1}, {id: 2}]
+   */
   Array.prototype.Distinct = function(selector = x => x) {
     const seen = new Set();
     return this.filter(item => {
@@ -59,7 +121,16 @@
     });
   };
 
-  // 그룹화
+  /**
+   * 배열을 지정된 키로 그룹화합니다.
+   * @function GroupBy
+   * @memberof Array.prototype
+   * @param {Function} selector - 그룹화 키를 결정하는 함수
+   * @returns {Array<Object>} { key, values } 객체 배열
+   * @example
+   * [1, 2, 3, 4].GroupBy(x => x % 2)
+   * // [{ key: 1, values: [1, 3] }, { key: 0, values: [2, 4] }]
+   */
   Array.prototype.GroupBy = function(selector) {
     const groups = new Map();
     this.forEach(item => {
@@ -72,7 +143,18 @@
     return Array.from(groups, ([key, values]) => ({ key, values }));
   };
 
-  // 조인
+  /**
+   * 두 배열을 조인합니다. (SQL INNER JOIN과 유사)
+   * @function Join
+   * @memberof Array.prototype
+   * @param {Array} other - 조인할 배열
+   * @param {Function} outerKey - 현재 배열의 키 선택 함수
+   * @param {Function} innerKey - 다른 배열의 키 선택 함수
+   * @param {Function} selector - 조인 결과를 구성하는 함수
+   * @returns {Array} 조인된 결과 배열
+   * @example
+   * [1, 2].Join([2, 3], x => x, y => y, (x, y) => x + y) // [4]
+   */
   Array.prototype.Join = function(other, outerKey, innerKey, selector) {
     const innerMap = new Map();
     other.forEach(item => {
@@ -90,7 +172,17 @@
     });
   };
 
-  // 첫 번째 요소
+  /**
+   * 첫 번째 요소를 반환합니다.
+   * @function First
+   * @memberof Array.prototype
+   * @param {Function} [predicate=null] - 조건 함수 (선택사항)
+   * @returns {*} 첫 번째 요소 (또는 조건을 만족하는 첫 요소)
+   * @throws {Error} 배열이 비어있거나 조건을 만족하는 요소가 없을 경우
+   * @example
+   * [1, 2, 3].First() // 1
+   * [1, 2, 3].First(x => x > 2) // 3
+   */
   Array.prototype.First = function(predicate = null) {
     if (predicate) {
       return this.find(predicate);
@@ -98,7 +190,17 @@
     return this[0];
   };
 
-  // 마지막 요소
+  /**
+   * 마지막 요소를 반환합니다.
+   * @function Last
+   * @memberof Array.prototype
+   * @param {Function} [predicate=null] - 조건 함수 (선택사항)
+   * @returns {*} 마지막 요소 (또는 조건을 만족하는 마지막 요소)
+   * @throws {Error} 배열이 비어있거나 조건을 만족하는 요소가 없을 경우
+   * @example
+   * [1, 2, 3].Last() // 3
+   * [1, 2, 3].Last(x => x < 3) // 2
+   */
   Array.prototype.Last = function(predicate = null) {
     if (predicate) {
       const arr = this.filter(predicate);
@@ -107,7 +209,16 @@
     return this[this.length - 1];
   };
 
-  // 개수
+  /**
+   * 배열의 요소 개수를 반환합니다.
+   * @function Count
+   * @memberof Array.prototype
+   * @param {Function} [predicate=null] - 조건 함수 (선택사항)
+   * @returns {number} 요소 개수 (또는 조건을 만족하는 요소 개수)
+   * @example
+   * [1, 2, 3, 4].Count() // 4
+   * [1, 2, 3, 4].Count(x => x > 2) // 2
+   */
   Array.prototype.Count = function(predicate = null) {
     if (predicate) {
       return this.filter(predicate).length;
@@ -115,7 +226,17 @@
     return this.length;
   };
 
-  // 조건을 만족하는 요소가 있는지
+  /**
+   * 조건을 만족하는 요소가 있는지 확인합니다.
+   * @function Any
+   * @memberof Array.prototype
+   * @param {Function} [predicate=null] - 조건 함수 (선택사항)
+   * @returns {boolean} 조건을 만족하는 요소가 있으면 true
+   * @example
+   * [1, 2, 3].Any() // true
+   * [1, 2, 3].Any(x => x > 2) // true
+   * [1, 2, 3].Any(x => x > 10) // false
+   */
   Array.prototype.Any = function(predicate = null) {
     if (predicate) {
       return this.some(predicate);
@@ -123,33 +244,87 @@
     return this.length > 0;
   };
 
-  // 모든 요소가 조건을 만족하는지
+  /**
+   * 모든 요소가 조건을 만족하는지 확인합니다.
+   * @function All
+   * @memberof Array.prototype
+   * @param {Function} predicate - 조건 함수
+   * @returns {boolean} 모든 요소가 조건을 만족하면 true
+   * @example
+   * [1, 2, 3].All(x => x > 0) // true
+   * [1, 2, 3].All(x => x > 2) // false
+   */
   Array.prototype.All = function(predicate) {
     return this.every(predicate);
   };
 
-  // 합계
+  /**
+   * 배열 요소의 합계를 계산합니다.
+   * @function Sum
+   * @memberof Array.prototype
+   * @param {Function} [selector=x => x] - 요소 선택 함수 (기본값: 요소 자체)
+   * @returns {number} 합계
+   * @example
+   * [1, 2, 3, 4].Sum() // 10
+   * [{val: 1}, {val: 2}].Sum(x => x.val) // 3
+   */
   Array.prototype.Sum = function(selector = x => x) {
     return this.reduce((acc, item) => acc + selector(item), 0);
   };
 
-  // 평균
+  /**
+   * 배열 요소의 평균을 계산합니다.
+   * @function Average
+   * @memberof Array.prototype
+   * @param {Function} [selector=x => x] - 요소 선택 함수 (기본값: 요소 자체)
+   * @returns {number} 평균 (빈 배열은 0 반환)
+   * @example
+   * [1, 2, 3, 4].Average() // 2.5
+   * [{val: 1}, {val: 3}].Average(x => x.val) // 2
+   */
   Array.prototype.Average = function(selector = x => x) {
     if (this.length === 0) return 0;
     return this.Sum(selector) / this.length;
   };
 
-  // 최댓값
+  /**
+   * 배열에서 최댓값을 반환합니다.
+   * @function Max
+   * @memberof Array.prototype
+   * @param {Function} [selector=x => x] - 요소 선택 함수 (기본값: 요소 자체)
+   * @returns {number} 최댓값
+   * @example
+   * [1, 2, 3, 4].Max() // 4
+   * [{val: 1}, {val: 5}].Max(x => x.val) // 5
+   */
   Array.prototype.Max = function(selector = x => x) {
     return Math.max(...this.map(selector));
   };
 
-  // 최솟값
+  /**
+   * 배열에서 최솟값을 반환합니다.
+   * @function Min
+   * @memberof Array.prototype
+   * @param {Function} [selector=x => x] - 요소 선택 함수 (기본값: 요소 자체)
+   * @returns {number} 최솟값
+   * @example
+   * [1, 2, 3, 4].Min() // 1
+   * [{val: 5}, {val: 2}].Min(x => x.val) // 2
+   */
   Array.prototype.Min = function(selector = x => x) {
     return Math.min(...this.map(selector));
   };
 
-  // 조건에 따라 분할
+  /**
+   * 배열을 조건에 따라 두 그룹으로 분할합니다.
+   * @function Partition
+   * @memberof Array.prototype
+   * @param {Function} predicate - 분할 조건 함수
+   * @returns {Array<Array>} [조건을 만족하는 요소 배열, 만족하지 않는 요소 배열]
+   * @example
+   * [1, 2, 3, 4].Partition(x => x % 2 === 0)
+   * // [[2, 4], [1, 3]]
+   */
   Array.prototype.Partition = function(predicate) {
     const trueArr = [];
     const falseArr = [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "temp-helper-linqjs",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "description": "Array 프로토타입 확장 - LINQ 스타일 메서드",
   "main": "linq-module.js",
   "license": "SEE LICENSE IN LICENSE",