lodash
- A modern JavaScript utility library delivering modularity, performance, & extras
https://github.com/lodash/lodash
์ข์ utilํจ์ ์ง๋ ๊ฒ์ ๋๋ฌด ํ๋ค๋ค. ๋ฌผ๋ก ๋์๊ฐ๋ ์ฝ๋๋ฅผ ๊ตฌํํ ์๋ ์์ง๋ง.. ์ต์ ํ ๋ ํจ์์ธ์ง ๊ตฌ๋ถํ๊ธฐ๋ ์ด๋ ต๊ณ .. ๋ ์ข์ ํจ์์ธ์ง ๊ตฌ๋ถํ๊ธฐ๋ ์์ง์ ํ๋ ๊ฑฐ ๊ฐ๋ค ๐ฐ
์ด๋ ์ถ์ฒ๋ฐ์ lodash ๐ค
์ ์ฉํ๊ฒ ์ฌ์ฉ๊ฐ๋ฅ ํ ์ ํธ ํจ์ ์คํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ
๋ก ์ฝ๋๋ฅผ ์ ์ง๋ ์ฌ๋๋ค์ด ๊ฐ๊ฒฐํ๊ฒ ๋ง๋ค์ด ๋์ ํจ์์ ์์๋ฅผ ์ง์ ์ฌ์ฉํ ์ ์๋ค! ๋์ ๊ฒฝ์ฐ๋ ํ๋ํ๋ ๋ฏ์ด๋ณด๋ฉฐ ์ฌ๋๋ค์ด ์ ํธํจ์๋ฅผ ์ด๋ป๊ฒ ๋ง๋ค์๋์ง ์๋ฐ์คํฌ๋ฆฝํธ ๋ฌธ๋ฒ์ ์ง์ด๊ฐ๋ ๊ณต๋ถ๋ฅผ ํด๋ณด๋ ค ํ๋ค!
chunk(['a', 'b', 'c', 'd'], 2) // ์ด๋ ๊ฒ ํธ์ถํ๋ฉด
=> [['a', 'b'], ['c', 'd']] // ์๋ ๊ฒ ๊ฐ๊ฐ ๋๊ฐ์ฉ ๋ฌถ์ ๋ฐฐ์ด์ ๋ณด์ฌ์ค๋ค.
chunk(['a', 'b', 'c', 'd'], 3) // ์ด๋ ๊ฒ ํธ์ถํ๋ฉด
=> [['a', 'b', 'c'], ['d']] // 3๊ฐ๊น์ง ํ๋ฐฐ์ด์ ๋ฌถ๊ณ ๋๋จธ์ง๋ ํ ๋ฐฐ์ด์ ๋ฃ์ด์ ๋ณด์ฌ์ค๋ค.
import slice from './slice.js'
import toInteger from './toInteger.js'
function chunk(array, size = 1) {
size = Math.max(toInteger(size), 0)
const length = array == null ? 0 : array.length
if (!length || size < 1) {
return []
}
let index = 0
let resIndex = 0
const result = new Array(Math.ceil(length / size))
while (index < length) {
result[resIndex++] = slice(array, index, (index += size))
}
return result
}
export default chunk
import slice from './slice.js'
import toInteger from './toInteger.js'
@params
๋ก ๋๊ธฐ๋ ํ๋ผ๋ฏธํฐ ์ ๋ณด๋ฅผ ์์ธํ ์ ์ด๋๋๊ฒ์ด ํ์
์ ์๋ก์ ์ฝ๋๋ฅผ ์ดํดํ๋๋ฐ ํฐ ๋์์ด ๋๋ค! ๐ค/**
* Creates an array of elements split into groups the length of `size`.
* If `array` can't be split evenly, the final chunk will be the remaining
* elements.
*
* @since 3.0.0
* @category Array
* @param {Array} array The array to process. <- ์ฒซ๋ฒ์งธ ํ๋ผ๋ฏธํฐ
* @param {number} [size=1] The length of each chunk <- ๋๋ฒ์งธ ํ๋ผ๋ฏธํฐ
* @returns {Array} Returns the new array of chunks. <- ๋ฆฌํด ๊ฐ
*/
// defaualt parameter๋ก ๋๋ฒ์งธ ์ธ์๋ฅผ 1๋ก ๋ฐ๊ณ ์๋ค ์ฆ ์ธ์๋ฅผ ํ๋๋ง ๋๊ธธ๋๋ ์๋์ผ๋ก ํ๋๋ก ์ง์ ๋์ด ์๋ค๋ ๋ป
function chunk(array, size = 1) {
// ๋ฐ์ ์ซ์๊ฐ ์ ์๊ฐ ์๋๊ฒฝ์ฐ, toInteger() ์ ๋ฃ์ด ์ ์๋ก ๋ง๋ค๊ณ ์์ ์ ์์ผ ๊ฒฝ์ฐ , 0์ ๋๊ฒจ์ฃผ์ด ๋๋์ง ์๊ฑฐ๋, 0๋ณด๋ค ํฐ์๋ก ๋๋์ด ์ฃผ๋ ์ญํ ์ ํ๋ค.
size = Math.max(toInteger(size), 0)
// array์ length๋ฅผ ๊ตฌํ๋ ํจ์์ด๊ณ , array๊ฐ ๋น์ด์ ์
๋ ฅ๋์ด null ๊ฐ์ด ๋ค์ด์ค๋ฉด length๋ 0, ์๋๋ฉด array.length๋ฅผ ํตํด ๊ตฌํด์ค๋ค.
const length = array == null ? 0 : array.length
// length ๋ก 0 ์ด ๋ค์ด์์ false์ด๊ฑฐ๋, size ์ ์์๊ฐ ๋ค์ด์์ 0 ์ธ ๊ฒฝ์ฐ์๋ chunk ํจ์๊ฐ ์ ๋๋ก ์๋ํ์ง ์๋ ์ํฉ์ด๋ฏ๋ก ๋น array๋ฅผ ๋ฆฌํดํ๋ค.
// ์ฆ chunk([],2) ํน์ chunk([1,2,3],0) ์ด ๋ค์ด์ค๋ฉด ๋ค []๋ฅผ ๋ฆฌํดํ๋ ๊ตฌ์กฐ์ด๋ค.
if (!length || size < 1) {
return []
}
// ์ค์ chunk๋ฅผ ๊ตฌํ๋ ํจ์
// ์ฒซ index ๊ฐ๊ณผ ๋ฐฐ์ด์ ๋ฐฐ์ด์์ ์ฐ๋ฆฌ๊ฐ ์ํ๋ chunk๋ฅผ ๋ฃ์ ์ ์๋ result index์ index ๊ฐ์ 0์ผ๋ก ์
ํ
ํด์ค๋ค.
let index = 0
let resIndex = 0
// chunck ๋ฐฐ์ด์์ ๋ค์ด๊ฐ ๋ฐฐ์ด์ ๊ธธ์ด๋ฅผ ๊ตฌํด์ฃผ๋ ์ฝ๋ new ์์ฑ์ ํจ์๋ก ๋ฐฐ์ด์ ๊ธธ์ด๋ฅผ ์ํ๋ ์ฌ์ด์ฆ๋งํผ ๊ตฌํด์ ์ฌ๋ฆผํด์ฃผ๋ฉด ์ฐ๋ฆฌ๊ฐ ์ํ๋ ๋ฐฐ์ด์ ๊ธธ์ด๋งํผ์ ์ด์ค ๋ฐฐ์ด์ด ๋ง๋ค์ด ์ง๋ค.
// ์ฆ ์๋ฅผ ๋ค์ด chunck([1,2,3,4,5],2) ๋ฅผ ํ๋ค๋ฉด
const result = new Array(Math.ceil(length / size))
// const result = new Array(Math.ceil(5/2))
// const result = new Array(3)
// const result = [empty ร 3] -> ๊ธธ์ด๊ฐ 3 ์ธ ๋ฐฐ์ด์ด ๋ง๋ค์ด ์ง๊ณ ์๋์ while๋ฌธ์ ๋๋ฉด์ result์ ๊ฐ๊ฐ index์ ์ํ๋ ๊ฐ์ ๋ฃ์ด์ค๋ค.
while (index < length) {
// ์ฌ๊ธฐ์ sliceํจ์๋ ์ผ๋ฐ ์ฌ๋ผ์ด์ค์ ๋ค๋ฅด๊ฒ ์ธ์๋ฅผ 3๊ฐ ๋ฐ์ ์ ์๊ณ , ์ฒซ๋ฒ์งธ ์ธ์๋ก sliceํ๊ณ ์ ํ๋ ๋ฐฐ์ด์ ๋ฃ์ด์ฃผ๊ณ ๋๋จธ์ง๋ start, end์ธ ๊ธฐ๋ณธ sliceํจ์์ ๊ฐ๋ค๊ณ ์๊ฐํ๋ฉด ๋๋ค.
result[resIndex++] = slice(array, index, (index += size))
}
// ์ฆ while ๋ฌธ์ ๋๋๋ง๋ค ์ฒซ๋ฒ์งธ index, ๋๋ฒ์งธ index ์ธ๋ฒ์งธ index์ ์๋์ ๊ฐ์ด ๋ฃ์ด์ฃผ๋ฉด
//result[0] = slice([1,2,3,4,5],0,2) [1,2]
//result[1] = slice([1,2,3,4,5],2,4 )[3,4]
//result[2] = slice([1,2,3,4,5],4,6 ) [5]
//์ ์ฒด result๋ [[1,2],[3,4],[5]] ๊ฐ ๋๋ค.
return result
}
export default chunk
chunk ํจ์ ์คํ์์ค ๋ฏ์ด๋ณด๊ธฐ ๋์!
์ ๋ง ์ ์ตํ๋ค์~!