[Underscore.js] 언더스코어 배열 관련 함수 정리

UnderscoreJS 배열 관련 함수 정리

언더스코어JS의 배열 관련 함수를 정리해 보았습니다.

언더스코어의 함수들은 함수적인 스타일와 객체지향형 스타일 두가지로 사용이 가능합니다.

_.first([5, 4, 3, 2, 1]) 또는
_([5, 4, 3, 2, 1]).first() 둘 다 사용 가능

참고 URL

https://underscorejs.org/

_.first(array)

배열의 첫번째 요소를 리턴합니다.

_.first([5, 4, 3, 2, 1]);
=> 5

_.initial(array)

배열의 마지막 요소를 제외 후 리턴합니다.

_.initial([5, 4, 3, 2, 1]);
=> [5, 4, 3, 2]

_.last(array)

배열의 마지막 요소를 리턴합니다.

_.last([5, 4, 3, 2, 1]);
=> 1

_.rest(array, [index])

주어진 배열에서 주어진 index 까지의 요소를 제외하고 나머지 값을 가진 배열을 리턴합니다.

//index를 넘기지 않으면 첫번째 요소만 제외
_.rest([5, 4, 3, 2, 1]);
=> [4, 3, 2, 1]
 
 
//첫번째 요소만 제외
_.rest([6, 5, 4, 3, 2, 1], 1);
=> [5, 4, 3, 2, 1]
 
//두번째 요소까지 제외하고 리턴
_.rest([6, 5, 4, 3, 2, 1], 2);
=> [4, 3, 2, 1]
 
//음수를 지정하는 경우 배열의 뒤에서부터 index만큼의 요소를 리턴
_.rest([6, 5, 4, 3, 2, 1], -2);
=> [2, 1]

_.flatten(array, [shallow])

주어진 배열 안의 요소들을 단일레벨의 배열로 병합합니다. 

두번째 인자 shallow에 true를 넘기면 1레벨만 제외한 상태로 병합합니다.

_.flatten([1, [2], [3, [[4]]]]);
=> [1, 2, 3, 4];
 
_.flatten([1, [2], [3, [[4]]]], true);
=> [1, 2, 3, [[4]]];

_.without(array, *values)

주어진 배열에서 특정 값을 제외하고 리턴합니다. 두번째 인자 *values는 가변인자로 여러가지 값을 넘길 수 있습니다.

//0과 1을 제외하고 리턴
_.without([1, 2, 1, 0, 3, 1, 4], 0, 1);
=> [2, 3, 4]

_.union(*arrays)

여러 배열을 하나로 병합합니다. 이때 나중에 병합되는 배열에서 앞선 배열과 중복된 값이 발견되면 무시됩니다.

_.union([1, 2, 3], [101, 2, 1, 10], [2, 1]);
=> [1, 2, 3, 101, 10]

_.intersection(*arrays)

여러 배열들 간의 요소에서 중복되는 교집합을 구합니다.

_.intersection([1, 2, 3], [101, 2, 1, 10], [2, 1]);
=> [1, 2]

_.difference(array, *others)

첫번째 인자로 오는 배열을 기준으로 이후 오는 배열 요소의 차집합을 구합니다.

//1, 2, 3, 4, 5를 기준으로 두번째 인자로 넘어오는 배열의 요소인 5, 2, 10을 제외하고 1, 3, 4를 리턴
_.difference([1, 2, 3, 4, 5], [5, 2, 10]);
=> [1, 3, 4]
 
 
//차집합 연산 대상 배열은 여러개 지정 가능
_.difference([1, 2, 3, 4, 5], [5, 2, 10], [1, 3]); 
=> [4]

_.uniq(array, [isSorted], [iteratee])

배열 안에서 중복되는 값을 제거하고 유일한 값만을 리턴합니다. 두번째 오는 isSorted는 배열이 정렬되어있는지 여부인데, 배열의 크기가 크고 정렬되어 있는경우 true를 입력하면 알고리즘 처리속도가 훨씬 빠릅니다.

_.uniq([1, 2, 1, 4, 1, 3]);
=> [1, 2, 4, 3]

_.zip(*arrays)

주어진 여러 배열들을 각 index에 맞게 한 개씩 값을 조합하여 여러 배열로 묶어 리턴합니다.

예를 들어 주어진 배열이 세 개이고 각 배열당 네 개의 요소가 있다면 length가 4인 배열 세개를 묶어 하나의 배열로 리턴합니다.(설명이 어렵..)

만약 여러배열 중 특정 배열의 경우에만 length가 다를 수 있는데 이럴때에는 요소의 갯수(length)는 가장 큰 배열을 기준으로 하지만 비어있는 자리는 undefined로 채웁니다.

_.zip(['moe', 'larry', 'curly'], [30, 40, 50], [true, false, false]);
=> [["moe", 30, true], ["larry", 40, false], ["curly", 50, false]]
 
_.zip(['moe', 'larry', 'curly', 'kim'], [30, 40, 50, 60], [true, false, false, true], ['a', 'b', 'c', 'd']);
=> [["moe", 30, true, "a"], ["larry", 40, false, "b"], ["curly", 50, false, "c"], ["kim", 60, true, "d"]]
 
_.zip(['moe', 'larry', 'curly'], [30, 40]);
=> [["moe", 30], ["larry", 40], ["curly", undefined]]

_.unzip(array)

바로 앞서 설명한 _.zip()의 반대의 기능을 수행합니다.

_.unzip([["moe", 30, true], ["larry", 40, false], ["curly", 50, false]]);
=> [['moe', 'larry', 'curly'], [30, 40, 50], [true, false, false]]

_.object(key 배열, value 배열) 또는 _.object([key, value] 배열)

두 개의 배열을 넘기면 앞의 배열의 요소들이 key가 되고 뒤의 배열의 요소들이 vlaue가 되어 json객체가 리턴됩니다.

각 요소는 index에 맞춰서 맵핑됩니다. 또한 두개의 length를 가진 배열 여러개를 넘기면 각 배열의 요소가 각자 key, value가 되어 객체가 리턴됩니다.

_.object(['moe', 'larry', 'curly'], [30, 40, 50]);
=> {moe: 30, larry: 40, curly: 50}
 
_.object([['moe', 30], ['larry', 40], ['curly', 50]]);
=> {moe: 30, larry: 40, curly: 50}

_.indexOf(array, value, [isSorted])

첫번째 인자로 주어진 배열에서 두번째로 주어진 값이 몇번째 index(0부터 시작)에 있는지 리턴합니다. 배열 안에 중복된 값이 있는 경우 최초에 발견된 index 리턴. 배열이 정렬 되어 있고 isSorted 값에 true를 주면 2진 탐색을 통해 더욱 빠른 알고리즘 처리가 가능합니다. 발견하지 못한 경우 -1을 리턴합니다.

_.indexOf([1, 2, 3], 2);
=> 1
 
_.indexOf([1, 2, 3, 1, 2, 3], 3);
=> 2

_.lastIndexOf(array, value, [fromIndex])

첫번째 인자로 주어진 배열에서 두번째로 주어진 값이 몇번째 index(0부터 시작)에 있는지 리턴합니다. 배열 안에 중복된 값이 있는 경우 가장 마지막에 발견된 index를리턴합니다.  발견하지 못한 경우 -1을 리턴합니다. 세번째 인자인 fromIndex는 검색 범위를 지정하는 값으로 선택사항입니다.

//3이 몇번 index에 있는지 검색. 가장 마지막에 발견된 3 즉 index값 8을 리턴
_.lastIndexOf([1, 2, 3, 1, 2, 3, 1, 2, 3], 3);
=> 8
 
//4번 요소 이내에서 3이 몇번째 index에 있는지 검색
_.lastIndexOf([1, 2, 3, 1, 2, 3, 1, 2, 3], 3, 4);
=> 2

_.sortedIndex(array, value, [정렬속성])

주어진 배열을 이진탐색 알고리즘을 사용하여, 두번째 인자로 넘긴 값이 몇 번째 index 위치에 들어가야 하는지 리턴합니다.  배열의 요소가 객체인 경우 정렬 기준 속성명을 세번째 인자로 넘길 수 있습니다.

_.sortedIndex([10, 20, 30, 40, 50], 35); //35는 배열의 index 3의 위치에 적당한 값
=> 3
 
var stooges = [{name: 'moe', age: 40}, {name: 'curly', age: 60}];
_.sortedIndex(stooges, {name: 'larry', age: 50}, 'age');
=> 1

_.findIndex(array, predicate)

주어진 배열에서 predicate로 넘겨진 함수의 조건에 만족하는 값의 index를 리턴합니다. 배열의 0번 index부터 한번씩 순회하면서 넘겨진 predicate 함수가 실행되며, 최초로 만족하는 요소의 index를 리턴합니다.

//요소의 값이 12를 초과하는 경우 true
var predic = function(value) { 
    return value > 12;
};
 
//찾지 못한 경우 -1 리턴
_.findIndex([4, 6, 8, 12], predic);
=> -1 
 
//13 즉 arr[4]가 만족하는 값이므로 4 리턴
_.findIndex([4, 6, 7, 12, 13], predic);
=> 4 
 
//조건에 만족하는 값(13)이 두개이지만 최초에 발견된 값의 index를 리턴
_.findIndex([13, 4, 6, 7, 12, 13], predic);
=> 0 

_.findLastIndex(array, predicate)

바로 앞서 설명한  _.findIndex() 함수와 기능이 같지만 조건에 만족하는 요소가 여러개 존재하는 경우 가장 마지막의 index를 리턴합니다.

//요소의 값이 12를 초과하는 경우 true
var predic = function(value) {
    return value > 12;
};
 
//조건에 만족하는 값(13)이 두개이지만 마지막에 발견된 값의 index를 리턴
_.findLastIndex([13, 4, 6, 7, 12, 13], predic);
=> 5
 
 
var users = [{'id': 1, 'name': 'Bob', 'last': 'Brown'},
             {'id': 2, 'name': 'Ted', 'last': 'White'},
             {'id': 3, 'name': 'Frank', 'last': 'James'},
             {'id': 4, 'name': 'Ted', 'last': 'Jones'}];
 
 
//배열의 요소가 객체인 경우 name이 'Ted'인 요소의 index를 다음과 같은 형태로 구할 수 있음.
_.findLastIndex(users, {
  name: 'Ted'
});
 
=> 3

_.range([start], stop, [step])

숫자로 이루어진 배열을 만들어줍니다. start는 최초 시작값이며 stop은 끝값으로 stop - 1 까지 추가됩니다. step은 증감값을 의미합니다.

//기본 시작값은 0이며 stop에 10을 줄 경우 
_.range(10);
=> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
 
//1 ~ (11 - 1)까지 가진 배열
_.range(1, 11);
=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
 
 
//0 ~ (30 - 1)까지 5씩 증가한 값을 가진 배열
_.range(0, 30, 5);
=> [0, 5, 10, 15, 20, 25]
 
 
//음수 배열로 1씩 감소
_.range(0, -10, -1);
=> [0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
 
//빈 배열 생성
_.range(0);
=> []