์๋ฐ์คํฌ๋ฆฝํธ ์ดํฐ๋ ์ดํฐ ํฌํผ์ ์ฑ๋ฅ์ ์ผ๊ด ์ฒ๋ฆฌ๋ฅผ ํตํด ์ต์ ํํ๋ ๋ฐฉ๋ฒ์ ์์๋ณด์ธ์. ์๋๋ฅผ ๊ฐ์ ํ๊ณ , ์ค๋ฒํค๋๋ฅผ ์ค์ด๋ฉฐ, ๋ฐ์ดํฐ ์กฐ์์ ํจ์จ์ฑ์ ๋์ผ ์ ์์ต๋๋ค.
์๋ฐ์คํฌ๋ฆฝํธ ์ดํฐ๋ ์ดํฐ ํฌํผ ๋ฐฐ์น ์ฑ๋ฅ: ์ผ๊ด ์ฒ๋ฆฌ ์๋ ์ต์ ํ
์๋ฐ์คํฌ๋ฆฝํธ์ ์ดํฐ๋ ์ดํฐ ํฌํผ(map, filter, reduce, forEach ๋ฑ)๋ ๋ฐฐ์ด์ ํธ๋ฆฌํ๊ณ ๊ฐ๋
์ฑ ๋๊ฒ ์กฐ์ํ๋ ๋ฐฉ๋ฒ์ ์ ๊ณตํฉ๋๋ค. ํ์ง๋ง ๋์ฉ๋ ๋ฐ์ดํฐ์
์ ๋ค๋ฃฐ ๋ ์ด๋ฌํ ํฌํผ๋ค์ ์ฑ๋ฅ์ด ๋ณ๋ชฉ ํ์์ ์์ธ์ด ๋ ์ ์์ต๋๋ค. ์ด๋ฅผ ์ํํ๋ ํจ๊ณผ์ ์ธ ๊ธฐ๋ฒ ์ค ํ๋๊ฐ ์ผ๊ด ์ฒ๋ฆฌ(batch processing)์
๋๋ค. ์ด ๊ธ์์๋ ์ดํฐ๋ ์ดํฐ ํฌํผ๋ฅผ ์ด์ฉํ ์ผ๊ด ์ฒ๋ฆฌ์ ๊ฐ๋
, ์ด์ , ๊ตฌํ ์ ๋ต ๋ฐ ์ฑ๋ฅ ๊ณ ๋ ค ์ฌํญ์ ๋ํด ํ๊ตฌํฉ๋๋ค.
ํ์ค ์ดํฐ๋ ์ดํฐ ํฌํผ์ ์ฑ๋ฅ ๋ฌธ์ ์ดํดํ๊ธฐ
ํ์ค ์ดํฐ๋ ์ดํฐ ํฌํผ๋ ์ฐ์ํ์ง๋ง, ๋์ฉ๋ ๋ฐฐ์ด์ ์ ์ฉ๋ ๋ ์ฑ๋ฅ ํ๊ณ์ ๋ถ๋ชํ ์ ์์ต๋๋ค. ํต์ฌ ๋ฌธ์ ๋ ๊ฐ ์์์ ๋ํด ๊ฐ๋ณ์ ์ธ ์ฐ์ฐ์ด ์ํ๋๋ค๋ ์ ์
๋๋ค. ์๋ฅผ ๋ค์ด, map ์ฐ์ฐ์์๋ ๋ฐฐ์ด์ ๋ชจ๋ ๋จ์ผ ํญ๋ชฉ์ ๋ํด ํจ์๊ฐ ํธ์ถ๋ฉ๋๋ค. ์ด๋ ํนํ ํจ์๊ฐ ๋ณต์กํ ๊ณ์ฐ์ด๋ ์ธ๋ถ API ํธ์ถ์ ํฌํจํ ๋ ์๋นํ ์ค๋ฒํค๋๋ก ์ด์ด์ง ์ ์์ต๋๋ค.
๋ค์ ์๋๋ฆฌ์ค๋ฅผ ๊ณ ๋ คํด ๋ณด๊ฒ ์ต๋๋ค:
const data = Array.from({ length: 100000 }, (_, i) => i);
const transformedData = data.map(item => {
// ๋ณต์กํ ์ฐ์ฐ ์๋ฎฌ๋ ์ด์
let result = item * 2;
for (let j = 0; j < 100; j++) {
result += Math.sqrt(result);
}
return result;
});
์ด ์์ ์์ map ํจ์๋ 100,000๊ฐ์ ์์๋ฅผ ์ํํ๋ฉฐ ๊ฐ ์์์ ๋ํด ๋ค์ ๊ณ์ฐ ์ง์ฝ์ ์ธ ์ฐ์ฐ์ ์ํํฉ๋๋ค. ํจ์๋ฅผ ์ด๋ ๊ฒ ๋ง์ด ํธ์ถํ๋ ๋ฐ์ ๋์ ๋ ์ค๋ฒํค๋๋ ์ ์ฒด ์คํ ์๊ฐ์ ์๋นํ ์ํฅ์ ๋ฏธ์นฉ๋๋ค.
์ผ๊ด ์ฒ๋ฆฌ(Batch Processing)๋ ๋ฌด์์ธ๊ฐ?
์ผ๊ด ์ฒ๋ฆฌ๋ ๋์ฉ๋ ๋ฐ์ดํฐ์ ์ ๋ ์๊ณ ๊ด๋ฆฌํ๊ธฐ ์ฌ์ด ๋ฉ์ด๋ฆฌ(๋ฐฐ์น)๋ก ๋๋๊ณ ๊ฐ ๋ฉ์ด๋ฆฌ๋ฅผ ์์ฐจ์ ์ผ๋ก ์ฒ๋ฆฌํ๋ ๊ฒ์ ํฌํจํฉ๋๋ค. ๊ฐ ์์๋ฅผ ๊ฐ๋ณ์ ์ผ๋ก ์ฒ๋ฆฌํ๋ ๋์ , ์ดํฐ๋ ์ดํฐ ํฌํผ๋ ํ ๋ฒ์ ํ ๋ฌถ์์ ์์๋ค์ ์ฒ๋ฆฌํฉ๋๋ค. ์ด๋ ํจ์ ํธ์ถ๊ณผ ๊ด๋ จ๋ ์ค๋ฒํค๋๋ฅผ ํฌ๊ฒ ์ค์ด๊ณ ์ ๋ฐ์ ์ธ ์ฑ๋ฅ์ ํฅ์์ํฌ ์ ์์ต๋๋ค. ๋ฐฐ์น์ ํฌ๊ธฐ๋ ์ฑ๋ฅ์ ์ง์ ์ ์ธ ์ํฅ์ ๋ฏธ์น๋ฏ๋ก ์ ์คํ๊ฒ ๊ณ ๋ คํด์ผ ํ ์ค์ํ ๋งค๊ฐ๋ณ์์ ๋๋ค. ๋งค์ฐ ์์ ๋ฐฐ์น ํฌ๊ธฐ๋ ํจ์ ํธ์ถ ์ค๋ฒํค๋๋ฅผ ํฌ๊ฒ ์ค์ด์ง ๋ชปํ ์ ์๊ณ , ๋ฐ๋๋ก ๋งค์ฐ ํฐ ๋ฐฐ์น ํฌ๊ธฐ๋ ๋ฉ๋ชจ๋ฆฌ ๋ฌธ์ ๋ฅผ ์ผ์ผํค๊ฑฐ๋ UI ๋ฐ์์ฑ์ ์ํฅ์ ์ค ์ ์์ต๋๋ค.
์ผ๊ด ์ฒ๋ฆฌ์ ์ด์
- ์ค๋ฒํค๋ ๊ฐ์: ์์๋ฅผ ๋ฐฐ์น๋ก ์ฒ๋ฆฌํจ์ผ๋ก์จ ์ดํฐ๋ ์ดํฐ ํฌํผ์ ๋ํ ํจ์ ํธ์ถ ํ์๊ฐ ํฌ๊ฒ ์ค์ด๋ค์ด ๊ด๋ จ ์ค๋ฒํค๋๊ฐ ๋ฎ์์ง๋๋ค.
- ์ฑ๋ฅ ํฅ์: ํนํ CPU ์ง์ฝ์ ์ธ ์ฐ์ฐ์ ๋ค๋ฃฐ ๋ ์ ์ฒด ์คํ ์๊ฐ์ ํฌ๊ฒ ๊ฐ์ ํ ์ ์์ต๋๋ค.
- ๋ฉ๋ชจ๋ฆฌ ๊ด๋ฆฌ: ๋์ฉ๋ ๋ฐ์ดํฐ์ ์ ๋ ์์ ๋ฐฐ์น๋ก ๋๋๋ฉด ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ๋์ ๊ด๋ฆฌํ๋ ๋ฐ ๋์์ด ๋์ด ์ ์ฌ์ ์ธ ๋ฉ๋ชจ๋ฆฌ ๋ถ์กฑ ์ค๋ฅ๋ฅผ ๋ฐฉ์งํ ์ ์์ต๋๋ค.
- ๋์์ฑ ์ ์ฌ๋ ฅ: ๋ฐฐ์น๋ ์ฑ๋ฅ์ ๋์ฑ ๊ฐ์ํํ๊ธฐ ์ํด (์: ์น ์์ปค ์ฌ์ฉ) ๋์์ ์ฒ๋ฆฌ๋ ์ ์์ต๋๋ค. ์ด๋ ๋ฉ์ธ ์ค๋ ๋๋ฅผ ์ฐจ๋จํ๋ฉด ์ฌ์ฉ์ ๊ฒฝํ์ด ์ ํ๋ ์ ์๋ ์น ์ ํ๋ฆฌ์ผ์ด์ ์์ ํนํ ๊ด๋ จ์ด ์์ต๋๋ค.
์ดํฐ๋ ์ดํฐ ํฌํผ๋ก ์ผ๊ด ์ฒ๋ฆฌ ๊ตฌํํ๊ธฐ
๋ค์์ ์๋ฐ์คํฌ๋ฆฝํธ ์ดํฐ๋ ์ดํฐ ํฌํผ๋ก ์ผ๊ด ์ฒ๋ฆฌ๋ฅผ ๊ตฌํํ๋ ๋จ๊ณ๋ณ ๊ฐ์ด๋์ ๋๋ค:
1. ๋ฐฐ์น ์์ฑ ํจ์ ๋ง๋ค๊ธฐ
๋จผ์ , ๋ฐฐ์ด์ ์ง์ ๋ ํฌ๊ธฐ์ ๋ฐฐ์น๋ค๋ก ๋๋๋ ์ ํธ๋ฆฌํฐ ํจ์๋ฅผ ๋ง๋ญ๋๋ค:
function batchArray(array, batchSize) {
const batches = [];
for (let i = 0; i < array.length; i += batchSize) {
batches.push(array.slice(i, i + batchSize));
}
return batches;
}
์ด ํจ์๋ ๋ฐฐ์ด๊ณผ batchSize๋ฅผ ์
๋ ฅ์ผ๋ก ๋ฐ์ ๋ฐฐ์น๋ค์ ๋ฐฐ์ด์ ๋ฐํํฉ๋๋ค.
2. ์ดํฐ๋ ์ดํฐ ํฌํผ์ ํตํฉํ๊ธฐ
๋ค์์ผ๋ก, batchArray ํจ์๋ฅผ ์ดํฐ๋ ์ดํฐ ํฌํผ์ ํตํฉํฉ๋๋ค. ์๋ฅผ ๋ค์ด, ์์์ map ์์ ๋ฅผ ์ผ๊ด ์ฒ๋ฆฌ๋ฅผ ์ฌ์ฉํ๋๋ก ์์ ํด ๋ณด๊ฒ ์ต๋๋ค:
const data = Array.from({ length: 100000 }, (_, i) => i);
const batchSize = 1000; // ๋ค์ํ ๋ฐฐ์น ํฌ๊ธฐ๋ก ์คํํด๋ณด์ธ์
const batchedData = batchArray(data, batchSize);
const transformedData = batchedData.flatMap(batch => {
return batch.map(item => {
// ๋ณต์กํ ์ฐ์ฐ ์๋ฎฌ๋ ์ด์
let result = item * 2;
for (let j = 0; j < 100; j++) {
result += Math.sqrt(result);
}
return result;
});
});
์ด ์์ ๋ ์์ ์์๋ ๋จผ์ ์๋ณธ ๋ฐฐ์ด์ batchArray๋ฅผ ์ฌ์ฉํด ๋ฐฐ์น๋ก ๋๋๋๋ค. ๊ทธ๋ฐ ๋ค์, flatMap ํจ์๊ฐ ๋ฐฐ์น๋ค์ ์ํํ๊ณ , ๊ฐ ๋ฐฐ์น ๋ด์์ map ํจ์๋ฅผ ์ฌ์ฉํด ์์๋ค์ ๋ณํํฉ๋๋ค. flatMap์ ๋ฐฐ์ด์ ๋ฐฐ์ด์ ๋ค์ ๋จ์ผ ๋ฐฐ์ด๋ก ํํํํ๋ ๋ฐ ์ฌ์ฉ๋ฉ๋๋ค.
3. `reduce`๋ฅผ ์ด์ฉํ ์ผ๊ด ์ฒ๋ฆฌ
reduce ์ดํฐ๋ ์ดํฐ ํฌํผ์๋ ๋์ผํ ๋ฐฐ์น ์ ๋ต์ ์ ์ฉํ ์ ์์ต๋๋ค:
const data = Array.from({ length: 100000 }, (_, i) => i);
const batchSize = 1000;
const batchedData = batchArray(data, batchSize);
const sum = batchedData.reduce((accumulator, batch) => {
return accumulator + batch.reduce((batchSum, item) => batchSum + item, 0);
}, 0);
console.log("Sum:", sum);
์ฌ๊ธฐ์๋ ๊ฐ ๋ฐฐ์น๊ฐ reduce๋ฅผ ์ฌ์ฉํ์ฌ ๊ฐ๋ณ์ ์ผ๋ก ํฉ์ฐ๋ ๋ค์, ์ด ์ค๊ฐ ํฉ๊ณ๋ค์ด ์ต์ข
sum์ผ๋ก ๋์ ๋ฉ๋๋ค.
4. `filter`๋ฅผ ์ด์ฉํ ๋ฐฐ์น ์ฒ๋ฆฌ
๋ฐฐ์น ์ฒ๋ฆฌ๋ filter์๋ ์ ์ฉํ ์ ์์ง๋ง, ์์์ ์์๋ ์ ์ง๋์ด์ผ ํฉ๋๋ค. ๋ค์์ ์์ ์
๋๋ค:
const data = Array.from({ length: 100000 }, (_, i) => i);
const batchSize = 1000;
const batchedData = batchArray(data, batchSize);
const filteredData = batchedData.flatMap(batch => {
return batch.filter(item => item % 2 === 0); // ์ง์๋ง ํํฐ๋ง
});
console.log("Filtered Data Length:", filteredData.length);
์ฑ๋ฅ ๊ณ ๋ ค ์ฌํญ ๋ฐ ์ต์ ํ
๋ฐฐ์น ํฌ๊ธฐ ์ต์ ํ
์ฌ๋ฐ๋ฅธ batchSize๋ฅผ ์ ํํ๋ ๊ฒ์ ์ฑ๋ฅ์ ๋งค์ฐ ์ค์ํฉ๋๋ค. ์์ ๋ฐฐ์น ํฌ๊ธฐ๋ ์ค๋ฒํค๋๋ฅผ ํฌ๊ฒ ์ค์ด์ง ๋ชปํ ์ ์๊ณ , ํฐ ๋ฐฐ์น ํฌ๊ธฐ๋ ๋ฉ๋ชจ๋ฆฌ ๋ฌธ์ ๋ก ์ด์ด์ง ์ ์์ต๋๋ค. ํน์ ์ฌ์ฉ ์ฌ๋ก์ ๋ง๋ ์ต์ ์ ๊ฐ์ ์ฐพ๊ธฐ ์ํด ๋ค์ํ ๋ฐฐ์น ํฌ๊ธฐ๋ก ์คํํ๋ ๊ฒ์ด ์ข์ต๋๋ค. ํฌ๋กฌ ๊ฐ๋ฐ์ ๋๊ตฌ์ ์ฑ๋ฅ ํญ๊ณผ ๊ฐ์ ๋๊ตฌ๋ ์ฝ๋๋ฅผ ํ๋กํ์ผ๋งํ๊ณ ์ต์์ ๋ฐฐ์น ํฌ๊ธฐ๋ฅผ ์๋ณํ๋ ๋ฐ ๋งค์ฐ ์ ์ฉํ ์ ์์ต๋๋ค.
๋ฐฐ์น ํฌ๊ธฐ๋ฅผ ๊ฒฐ์ ํ ๋ ๊ณ ๋ คํด์ผ ํ ์์:
- ๋ฉ๋ชจ๋ฆฌ ์ ์ฝ: ํนํ ๋ชจ๋ฐ์ผ ๊ธฐ๊ธฐ์ ๊ฐ์ด ๋ฆฌ์์ค๊ฐ ์ ํ๋ ํ๊ฒฝ์์ ๋ฐฐ์น ํฌ๊ธฐ๊ฐ ์ฌ์ฉ ๊ฐ๋ฅํ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์ด๊ณผํ์ง ์๋๋ก ํด์ผ ํฉ๋๋ค.
- CPU ๋ถํ: ํนํ ๊ณ์ฐ ์ง์ฝ์ ์ธ ์ฐ์ฐ์ ์ํํ ๋ ์์คํ ์ ๊ณผ๋ถํ๊ฐ ๊ฑธ๋ฆฌ์ง ์๋๋ก CPU ์ฌ์ฉ๋์ ๋ชจ๋ํฐ๋งํด์ผ ํฉ๋๋ค.
- ์คํ ์๊ฐ: ๋ค์ํ ๋ฐฐ์น ํฌ๊ธฐ์ ๋ํ ์คํ ์๊ฐ์ ์ธก์ ํ๊ณ ์ค๋ฒํค๋ ๊ฐ์์ ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ๋ ์ฌ์ด์์ ์ต์์ ๊ท ํ์ ์ ๊ณตํ๋ ํฌ๊ธฐ๋ฅผ ์ ํํด์ผ ํฉ๋๋ค.
๋ถํ์ํ ์ฐ์ฐ ํผํ๊ธฐ
์ผ๊ด ์ฒ๋ฆฌ ๋ก์ง ๋ด์์ ๋ถํ์ํ ์ฐ์ฐ์ ๋์ ํ์ง ์๋๋ก ํด์ผ ํฉ๋๋ค. ์์ ๊ฐ์ฒด ์์ฑ์ ์ต์ํํ๊ณ ์ค๋ณต ๊ณ์ฐ์ ํผํ์ธ์. ์ดํฐ๋ ์ดํฐ ํฌํผ ๋ด์ ์ฝ๋๋ฅผ ๊ฐ๋ฅํ ํ ํจ์จ์ ์ผ๋ก ์ต์ ํํ์ธ์.
๋์์ฑ
๋ ํฐ ์ฑ๋ฅ ํฅ์์ ์ํด ์น ์์ปค(Web Worker)๋ฅผ ์ฌ์ฉํ์ฌ ๋ฐฐ์น๋ฅผ ๋์์ ์ฒ๋ฆฌํ๋ ๊ฒ์ ๊ณ ๋ คํด ๋ณด์ธ์. ์ด๋ฅผ ํตํด ๊ณ์ฐ ์ง์ฝ์ ์ธ ์์ ์ ๋ณ๋์ ์ค๋ ๋๋ก ์คํ๋ก๋ํ์ฌ ๋ฉ์ธ ์ค๋ ๋๊ฐ ์ฐจ๋จ๋๋ ๊ฒ์ ๋ฐฉ์งํ๊ณ UI ๋ฐ์์ฑ์ ํฅ์์ํฌ ์ ์์ต๋๋ค. ์น ์์ปค๋ ํ๋ ๋ธ๋ผ์ฐ์ ์ Node.js ํ๊ฒฝ์์ ์ฌ์ฉํ ์ ์์ผ๋ฉฐ, ๋ณ๋ ฌ ์ฒ๋ฆฌ๋ฅผ ์ํ ๊ฐ๋ ฅํ ๋ฉ์ปค๋์ฆ์ ์ ๊ณตํฉ๋๋ค. ์ด ๊ฐ๋ ์ ์๋ฐ์ ์ค๋ ๋, Go์ ๋ฃจํด, ๋๋ ํ์ด์ฌ์ ๋ฉํฐํ๋ก์ธ์ฑ ๋ชจ๋๊ณผ ๊ฐ์ด ๋ค๋ฅธ ์ธ์ด๋ ํ๋ซํผ์ผ๋ก ํ์ฅ๋ ์ ์์ต๋๋ค.
์ค์ ์ฌ๋ก ๋ฐ ์ฌ์ฉ ์
์ด๋ฏธ์ง ์ฒ๋ฆฌ
ํฐ ์ด๋ฏธ์ง์ ํํฐ๋ฅผ ์ ์ฉํด์ผ ํ๋ ์ด๋ฏธ์ง ์ฒ๋ฆฌ ์ ํ๋ฆฌ์ผ์ด์ ์ ์๊ฐํด ๋ณด์ธ์. ๊ฐ ํฝ์ ์ ๊ฐ๋ณ์ ์ผ๋ก ์ฒ๋ฆฌํ๋ ๋์ , ์ด๋ฏธ์ง๋ฅผ ํฝ์ ๋ฐฐ์น๋ก ๋๋๊ณ ์น ์์ปค๋ฅผ ์ฌ์ฉํ์ฌ ๊ฐ ๋ฐฐ์น์ ํํฐ๋ฅผ ๋์์ ์ ์ฉํ ์ ์์ต๋๋ค. ์ด๋ ์ฒ๋ฆฌ ์๊ฐ์ ํฌ๊ฒ ๋จ์ถํ๊ณ ์ ํ๋ฆฌ์ผ์ด์ ์ ๋ฐ์์ฑ์ ํฅ์์ํต๋๋ค.
๋ฐ์ดํฐ ๋ถ์
๋ฐ์ดํฐ ๋ถ์ ์๋๋ฆฌ์ค์์๋ ์ข ์ข ๋์ฉ๋ ๋ฐ์ดํฐ์ ์ ๋ณํํ๊ณ ๋ถ์ํด์ผ ํฉ๋๋ค. ์ผ๊ด ์ฒ๋ฆฌ๋ฅผ ์ฌ์ฉํ์ฌ ๋ฐ์ดํฐ๋ฅผ ๋ ์์ ๋ฉ์ด๋ฆฌ๋ก ์ฒ๋ฆฌํ๋ฉด ํจ์จ์ ์ธ ๋ฉ๋ชจ๋ฆฌ ๊ด๋ฆฌ์ ๋ ๋น ๋ฅธ ์ฒ๋ฆฌ ์๊ฐ์ ์ป์ ์ ์์ต๋๋ค. ์๋ฅผ ๋ค์ด, ๋ก๊ทธ ํ์ผ์ด๋ ๊ธ์ต ๋ฐ์ดํฐ๋ฅผ ๋ถ์ํ ๋ ์ผ๊ด ์ฒ๋ฆฌ ๊ธฐ๋ฒ์ด ์ ์ฉํ ์ ์์ต๋๋ค.
API ์ฐ๋
์ธ๋ถ API์ ์ํธ ์์ฉํ ๋, ์ผ๊ด ์ฒ๋ฆฌ๋ฅผ ์ฌ์ฉํ์ฌ ์ฌ๋ฌ ์์ฒญ์ ๋ณ๋ ฌ๋ก ๋ณด๋ผ ์ ์์ต๋๋ค. ์ด๋ API์์ ๋ฐ์ดํฐ๋ฅผ ๊ฒ์ํ๊ณ ์ฒ๋ฆฌํ๋ ๋ฐ ๊ฑธ๋ฆฌ๋ ์ ์ฒด ์๊ฐ์ ํฌ๊ฒ ์ค์ผ ์ ์์ต๋๋ค. AWS Lambda๋ Azure Functions์ ๊ฐ์ ์๋น์ค๋ ๊ฐ ๋ฐฐ์น์ ๋ํด ๋ณ๋ ฌ๋ก ํธ๋ฆฌ๊ฑฐ๋ ์ ์์ต๋๋ค. API ์๋ ์ ํ์ ์ด๊ณผํ์ง ์๋๋ก ์ฃผ์ํด์ผ ํฉ๋๋ค.
์ฝ๋ ์์ : ์น ์์ปค๋ฅผ ์ด์ฉํ ๋์์ฑ
๋ค์์ ์น ์์ปค๋ก ์ผ๊ด ์ฒ๋ฆฌ๋ฅผ ๊ตฌํํ๋ ๋ฐฉ๋ฒ์ ์์ ์ ๋๋ค:
// ๋ฉ์ธ ์ค๋ ๋
const data = Array.from({ length: 100000 }, (_, i) => i);
const batchSize = 1000;
const batchedData = batchArray(data, batchSize);
const results = [];
let completedBatches = 0;
function processBatch(batch) {
return new Promise((resolve, reject) => {
const worker = new Worker('worker.js'); // ์์ปค ์คํฌ๋ฆฝํธ ๊ฒฝ๋ก
worker.postMessage(batch);
worker.onmessage = (event) => {
results.push(...event.data);
worker.terminate();
resolve();
completedBatches++;
if (completedBatches === batchedData.length) {
console.log("All batches processed. Total Results: ", results.length)
}
};
worker.onerror = (error) => {
reject(error);
};
});
}
async function processAllBatches() {
const promises = batchedData.map(batch => processBatch(batch));
await Promise.all(promises);
console.log('Final Results:', results);
}
processAllBatches();
// worker.js (์น ์์ปค ์คํฌ๋ฆฝํธ)
self.onmessage = (event) => {
const batch = event.data;
const transformedBatch = batch.map(item => {
// ๋ณต์กํ ์ฐ์ฐ ์๋ฎฌ๋ ์ด์
let result = item * 2;
for (let j = 0; j < 100; j++) {
result += Math.sqrt(result);
}
return result;
});
self.postMessage(transformedBatch);
};
์ด ์์ ์์ ๋ฉ์ธ ์ค๋ ๋๋ ๋ฐ์ดํฐ๋ฅผ ๋ฐฐ์น๋ก ๋๋๊ณ ๊ฐ ๋ฐฐ์น์ ๋ํด ์น ์์ปค๋ฅผ ์์ฑํฉ๋๋ค. ์น ์์ปค๋ ๋ฐฐ์น์ ๋ํ ๋ณต์กํ ์ฐ์ฐ์ ์ํํ๊ณ ๊ทธ ๊ฒฐ๊ณผ๋ฅผ ๋ฉ์ธ ์ค๋ ๋๋ก ๋ค์ ๋ณด๋ ๋๋ค. ์ด๋ฅผ ํตํด ๋ฐฐ์น์ ๋ณ๋ ฌ ์ฒ๋ฆฌ๊ฐ ๊ฐ๋ฅํด์ ธ ์ ์ฒด ์คํ ์๊ฐ์ด ํฌ๊ฒ ๋จ์ถ๋ฉ๋๋ค.
๋์ ๊ธฐ๋ฒ ๋ฐ ๊ณ ๋ ค ์ฌํญ
ํธ๋์ค๋์(Transducers)
ํธ๋์ค๋์๋ ์ฌ๋ฌ ์ดํฐ๋ ์ดํฐ ์ฐ์ฐ(map, filter, reduce)์ ๋จ์ผ ํจ์ค๋ก ์ฐ๊ฒฐํ ์ ์๊ฒ ํด์ฃผ๋ ํจ์ํ ํ๋ก๊ทธ๋๋ฐ ๊ธฐ๋ฒ์ ๋๋ค. ์ด๋ ๊ฐ ์ฐ์ฐ ์ฌ์ด์ ์ค๊ฐ ๋ฐฐ์ด ์์ฑ์ ํผํจ์ผ๋ก์จ ์ฑ๋ฅ์ ํฌ๊ฒ ํฅ์์ํฌ ์ ์์ต๋๋ค. ํธ๋์ค๋์๋ ๋ณต์กํ ๋ฐ์ดํฐ ๋ณํ์ ๋ค๋ฃฐ ๋ ํนํ ์ ์ฉํฉ๋๋ค.
์ง์ฐ ํ๊ฐ(Lazy Evaluation)
์ง์ฐ ํ๊ฐ๋ ์ฐ์ฐ ๊ฒฐ๊ณผ๊ฐ ์ค์ ๋ก ํ์ํ ๋๊น์ง ์คํ์ ์ง์ฐ์ํต๋๋ค. ์ด๋ ๋ถํ์ํ ๊ณ์ฐ์ ํผํ๊ฒ ํด์ฃผ๋ฏ๋ก ๋์ฉ๋ ๋ฐ์ดํฐ์ ์ ๋ค๋ฃฐ ๋ ์ ์ฉํ ์ ์์ต๋๋ค. ์ง์ฐ ํ๊ฐ๋ ์ ๋๋ ์ดํฐ๋ Lodash์ ๊ฐ์ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ์ฌ์ฉํ์ฌ ๊ตฌํํ ์ ์์ต๋๋ค.
๋ถ๋ณ ๋ฐ์ดํฐ ๊ตฌ์กฐ
๋ถ๋ณ ๋ฐ์ดํฐ ๊ตฌ์กฐ๋ฅผ ์ฌ์ฉํ๋ ๊ฒ๋ ์ฑ๋ฅ์ ํฅ์์ํฌ ์ ์์ต๋๋ค. ์ด๋ ๋ค๋ฅธ ์ฐ์ฐ ๊ฐ์ ๋ฐ์ดํฐ๋ฅผ ํจ์จ์ ์ผ๋ก ๊ณต์ ํ ์ ์๊ฒ ํด์ค๋๋ค. ๋ถ๋ณ ๋ฐ์ดํฐ ๊ตฌ์กฐ๋ ์ฐ๋ฐ์ ์ธ ์์ ์ ๋ฐฉ์งํ๊ณ ๋๋ฒ๊น ์ ๋จ์ํํ ์ ์์ต๋๋ค. Immutable.js์ ๊ฐ์ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ ์๋ฐ์คํฌ๋ฆฝํธ๋ฅผ ์ํ ๋ถ๋ณ ๋ฐ์ดํฐ ๊ตฌ์กฐ๋ฅผ ์ ๊ณตํฉ๋๋ค.
๊ฒฐ๋ก
์ผ๊ด ์ฒ๋ฆฌ๋ ๋์ฉ๋ ๋ฐ์ดํฐ์ ์ ๋ค๋ฃฐ ๋ ์๋ฐ์คํฌ๋ฆฝํธ ์ดํฐ๋ ์ดํฐ ํฌํผ์ ์ฑ๋ฅ์ ์ต์ ํํ๋ ๊ฐ๋ ฅํ ๊ธฐ๋ฒ์ ๋๋ค. ๋ฐ์ดํฐ๋ฅผ ๋ ์์ ๋ฐฐ์น๋ก ๋๋์ด ์์ฐจ์ ์ผ๋ก ๋๋ ๋์์ ์ฒ๋ฆฌํจ์ผ๋ก์จ ์ค๋ฒํค๋๋ฅผ ํฌ๊ฒ ์ค์ด๊ณ , ์คํ ์๊ฐ์ ๊ฐ์ ํ๋ฉฐ, ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ์ ๋ ํจ๊ณผ์ ์ผ๋ก ๊ด๋ฆฌํ ์ ์์ต๋๋ค. ๋ค์ํ ๋ฐฐ์น ํฌ๊ธฐ๋ก ์คํํ๊ณ ๋ณ๋ ฌ ์ฒ๋ฆฌ๋ฅผ ์ํด ์น ์์ปค ์ฌ์ฉ์ ๊ณ ๋ คํ์ฌ ๋ ํฐ ์ฑ๋ฅ ํฅ์์ ๋ฌ์ฑํ์ธ์. ์ฝ๋๋ฅผ ํ๋กํ์ผ๋งํ๊ณ ๋ค์ํ ์ต์ ํ ๊ธฐ๋ฒ์ ์ํฅ์ ์ธก์ ํ์ฌ ํน์ ์ฌ์ฉ ์ฌ๋ก์ ๊ฐ์ฅ ์ ํฉํ ํด๊ฒฐ์ฑ ์ ์ฐพ๋ ๊ฒ์ ์์ง ๋ง์ธ์. ๋ค๋ฅธ ์ต์ ํ ๊ธฐ๋ฒ๊ณผ ๊ฒฐํฉ๋ ์ผ๊ด ์ฒ๋ฆฌ๋ฅผ ๊ตฌํํ๋ฉด ๋ ํจ์จ์ ์ด๊ณ ๋ฐ์์ฑ์ด ๋ฐ์ด๋ ์๋ฐ์คํฌ๋ฆฝํธ ์ ํ๋ฆฌ์ผ์ด์ ์ ๋ง๋ค ์ ์์ต๋๋ค.
๋ํ, ์ผ๊ด ์ฒ๋ฆฌ๊ฐ ํญ์ *์ต๊ณ ์* ํด๊ฒฐ์ฑ ์ ์๋๋ผ๋ ์ ์ ๊ธฐ์ตํด์ผ ํฉ๋๋ค. ์์ ๋ฐ์ดํฐ์ ์ ๊ฒฝ์ฐ, ๋ฐฐ์น๋ฅผ ์์ฑํ๋ ์ค๋ฒํค๋๊ฐ ์ฑ๋ฅ ํฅ์ ํจ๊ณผ๋ฅผ ์์ํ ์ ์์ต๋๋ค. *์์ ์* ํน์ ๋งฅ๋ฝ์์ ์ฑ๋ฅ์ ํ ์คํธํ๊ณ ์ธก์ ํ์ฌ ์ผ๊ด ์ฒ๋ฆฌ๊ฐ ์ค์ ๋ก ์ ์ตํ์ง ํ๋จํ๋ ๊ฒ์ด ์ค์ํฉ๋๋ค.
๋ง์ง๋ง์ผ๋ก, ์ฝ๋ ๋ณต์ก์ฑ๊ณผ ์ฑ๋ฅ ํฅ์ ์ฌ์ด์ ์ ์ถฉ์ ์ ๊ณ ๋ คํ์ธ์. ์ฑ๋ฅ ์ต์ ํ๋ ์ค์ํ์ง๋ง, ์ฝ๋ ๊ฐ๋ ์ฑ๊ณผ ์ ์ง๋ณด์์ฑ์ ํฌ์ํด์๋ ์ ๋ฉ๋๋ค. ์ ํ๋ฆฌ์ผ์ด์ ์ด ํจ์จ์ ์ด๋ฉด์๋ ์ ์ง๋ณด์ํ๊ธฐ ์ฝ๋๋ก ์ฑ๋ฅ๊ณผ ์ฝ๋ ํ์ง ์ฌ์ด์ ๊ท ํ์ ์ถ๊ตฌํด์ผ ํฉ๋๋ค.