๋ฐฐ์ด์ ์ฌ๋ฌ ๊ฐ์ ๊ฐ์ ์์ฐจ์ ์ผ๋ก ๋์ดํ ์๋ฃ๊ตฌ์กฐ๋ค.
๋ฐฐ์ด์ ์ฌ์ฉ ๋น๋๊ฐ ๋งค์ฐ ๋์ ๊ฐ์ฅ ๊ธฐ๋ณธ์ ์ธ ์๋ฃ๊ตฌ์กฐ๋ค. ๋ฐฐ์ด์ ์ฌ์ฉ ๋น๋๊ฐ ๋์ผ๋ฏ๋ก ๋ฅ์ํ๊ฒ ๋ค๋ฃฐ ์ ์๋ค๋ฉด ์ฝ๋ฉ์ ๋งค์ฐ ๋์์ด ๋๋ค.const arr = ['apple', 'banana', 'orange'];
๋ฐฐ์ด์ด ๊ฐ์ง๊ณ ์๋ ๊ฐ์
์์
๋ผ๊ณ ๋ถ๋ฅธ๋ค. ์์๊ฐ์ ๋ฌผ๋ก ๊ฐ์ฒด, ํจ์, ๋ฐฐ์ด ๋ฑ ์๋ฐ์คํฌ๋ฆฝํธ์์ ๊ฐ์ผ๋ก ์ธ์ ํ๋ ๋ชจ๋ ๊ฒ์ ๋ฐฐ์ด์ ์์๊ฐ ๋ ์ ์๋ค.
๋ฐฐ์ด์ ์์์๋ ๋ฐฐ์ด์์ ์์ ์ ์์น๋ฅผ ๋ํ๋ด๋ 0 ์ด์์ ์ ์์ธ์ธ๋ฑ์ค
๋ฅผ ๊ฐ๋๋ค.
๋ฐฐ์ด์ ์์์ ๊ฐ์, ๋ฐฐ์ด์ ๊ธธ์ด๋ฅผ ๋ํ๋ด๋ lengthํ๋กํผํฐ๋ฅผ ๊ฐ๋๋คarr.lenghth // 3
์๋ฐ์คํฌ๋ฆฝํธ์ ๋ฐฐ์ด์ด๋ผ๋ ํ์ ์ ์กด์ฌํ์ง ์๋๋ฐ
๋ฐฐ์ด์ ๊ฐ์ฒด ํ์
์ด๋ค.
๊ตฌ๋ถ | ๊ฐ์ฒด | ๋ฐฐ์ด |
---|---|---|
๊ตฌ์กฐ | ํ๋กํผํฐ ํค์ ํ๋กํผํฐ ๊ฐ | ์ธ๋ฑ์ค์ ์์ผ |
๊ฐ์ ์ฐธ์กฐ | ํ๋กํผํฐ ํค | ์ธ๋ฑ์ค |
๊ฐ์ ์์ | X | O |
length ํ๋กํผํฐ | X | O |
์ผ๋ฐ ๊ฐ์ฒด์ ๋ฐฐ์ด์ ๊ตฌ๋ถํ๋ ๊ฐ์ฅ ๋ช
ํํ ์ฐจ์ด๋ "๊ฐ์ ์์"
์ "lenghth ํ๋กํผํฐ"
๋ค
๋ฐฐ์ด์ ์ฅ์
๊ฐ์ ์์์ length ํ๋กํผํฐ๋ฅผ ๊ฐ๊ธฐ ๋๋ฌธ์ ๊ฐ๋ฅ
์๋ฃ๊ตฌ์กฐ์์ ๋งํ๋ ๋ฐฐ์ด์ ๋์ผํ ํฌ๊ธฐ์ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ด ๋นํ์์ด ์ฐ์์ ์ผ๋ก ๋์ด๋ ์๋ฃ๊ตฌ์กฐ๋ฅผ ๋งํ๋ค. ๋ฐฐ์ด์ ์์๋ ํ๋์ ๋ฐ์ดํฐ ํ์ ์ผ๋ก ํต์ผ๋์ด ์์ผ๋ฉฐ ์๋ก ์ฐ์์ ์ผ๋ก ์ธ์ ํด ์๋ค. ์ด๋ฌํ ๋ฐฐ์ด์ ๋ฐ์ง ๋ฐฐ์ด์ด๋ผ ํ๋ค.
์๋ฐ์คํฌ๋ฆฝํธ์ ๋ฐฐ์ด์ ์ผ๋ฐ์ ์ธ ์๋ฏธ์ ๋ฐฐ์ด๊ณผ ๋ค๋ฅด๋ค.
์ฆ, ๋ฐฐ์ด์ ์์๋ฅผ ์ํ ๊ฐ๊ฐ์ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ ๋์ผํ ํฌ๊ธฐ๋ฅผ ๊ฐ์ง ์์๋ ๋๋ฉฐ, ์ฐ์์ ์ผ๋ก ์ด์ด์ ธ ์์ง ์์ ์๋ ์๋ค. ๋ฐฐ์ด์ ์์๊ฐ ์ฐ์์ ์ผ๋ก ์ด์ด์ ธ ์์ง ์๋ ๋ฐฐ์ด์ ํฌ์ ๋ฐฐ์ด์ด๋ผ ํ๋ค.
์๋ฐ์คํฌ๋ฆฝํธ์ ๋ฐฐ์ด์ ์ผ๋ฐ์ ์ธ ๋ฐฐ์ด์ ๋์์ ํ๋ด ๋ธ ํน์ํ ๊ฐ์ฒด๋ค.
โ๏ธ ์ผ๋ฐ์ ์ธ ๋ฐฐ์ด๊ณผ ์๋ฐ์คํฌ๋ฆฝํธ ๋ฐฐ์ด์ ์ฅ๋จ์
length ํ๋กํผํฐ๋ ์์์ ๊ฐ์, ์ฆ ๋ฐฐ์ด์ ๊ธธ์ด๋ฅผ ๋ํ๋ด๋ 0 ์ด์์ ์ ์๋ฅผ ๊ฐ์ผ๋ก ๊ฐ๋๋ค. length ํ๋กํผํฐ์ ๊ฐ์ ๋ฐฐ์ด์ผ ๊ฒฝ์ฐ 0์ด๋ฉฐ, ๋น ๋ฐฐ์ด์ด ์๋ ๊ฒฝ์ฐ ๊ฐ์ฅ ํฐ ์ธ๋ฑ์ค์ 1์ ๋ํ ๊ฒ๊ณผ ๊ฐ๋ค.
๋ฐฐ์ด์ ์์๊ฐ ์ฐ์์ ์ผ๋ก ์์นํ์ง ์๊ณ ์ผ๋ถ๊ฐ ๋น์ด ์๋ ๋ฐฐ์ด์ ํฌ์ ๋ฐฐ์ด์ด๋ผ ํ๋ค. ํฌ์ ๋ฐฐ์ด์ length์ ๋ฐฐ์ด ์์์ ๊ฐ์๊ฐ ์ผ์นํ์ง ์๋๋ค. ํฌ์ ๋ฐฐ์ด์ length๋ ํฌ์ ๋ฐฐ์ด์ ์ค์ ์์ ๊ฐ์๋ณด๋ค ์ธ์ ๋ ํฌ๋ค. ํฌ์ ๋ฐฐ์ด์ ์ฌ์ฉํ์ง ์๋ ๊ฒ์ด ์ข์.
๋ฐฐ์ด์๋ ๊ฐ์ ํ์
์ ์์๋ฅผ ์ฐ์์ ์ผ๋ก ์์น์ํค๋ ๊ฒ์ด ์ต์ ์ด๋ค
๋ฐฐ์ด ๋ฆฌํฐ๋ด์ 0๊ฐ ์ด์์ ์์๋ฅผ ์ผํ๋ก ๊ตฌ๋ถํ์ฌ ๋๊ดํธ([])๋ก ๋ฌถ๋๋ค. ๋ฐฐ์ด ๋ฆฌํฐ๋ด์ ๊ฐ์ฒด ๋ฆฌํฐ๋ด๊ณผ ๋ฌ๋ฆฌ ํ๋กํผํฐ ํค๊ฐ ์๊ณ ๊ฐ๋ง ์กด์ฌ.
const arr = [1,2,3];
console.log(arr.length); // 3
Object ์์ฑ์ ํจ์๋ฅผ ํตํด ๊ฐ์ฒด๋ฅผ ์์ฑํ ์ ์๋ฏ์ด Array ์์ฑ์ ํจ์๋ฅผ ํตํด ๋ฐฐ์ด์ ์์ฑํ ์๋ ์๋ค. Array ์์ฑ์ ํจ์๋ ์ ๋ฌ๋ ์ธ์์ ๊ฐ์์ ๋ฐ๋ผ ๋ค๋ฅด๊ฒ ๋์ํ๋ฏ๋ก ์ฃผ์๊ฐ ํ์
ES6์์ ๋์
๋ Array.of ๋ฉ์๋๋ ์ ๋ฌ๋ ์ธ์๋ฅผ ์์๋ก ๊ฐ๋ ๋ฐฐ์ด์ ์์ฑ
, Array ์์ฑ์ ํจ์์ ๋ค๋ฅด๊ฒ ์ ๋ฌ๋ ์ธ์๊ฐ 1๊ฐ์ด๊ณ ์ซ์์ด๋๋ผ๋ ์ธ์๋ฅผ ์์๋ก ๊ฐ๋ ๋ฐฐ์ด์ ์์ฑ
// ์ ๋ฌ๋ ์ธ์๊ฐ 1๊ฐ์ด๊ณ ์ซ์์ด๋๋ผ๋ ์ธ์๋ฅผ ์์๋ก ๊ฐ๋ ๋ฐฐ์ด์ ์์ฑ
Array.of(1); // [1]
Array.of(1,2,3); // [1,2,3]
Array.of('string'); // ['string']
ES6์์ ๋์ ๋ Array.from ๋ฉ์๋๋ ์ ์ฌ ๋ฐฐ์ด ๊ฐ์ฒด ๋๋ ์ดํฐ๋ฌ๋ธ ๊ฐ์ฒด๋ฅผ ์ธ์๋ก ์ ๋ฌ๋ฐ์ ๋ฐฐ์ด๋ก ๋ฐํํ์ฌ ๋ฐํ
// ์ ์ฌ ๋ฐฐ์ด ๊ฐ์ฒด๋ฅผ ๋ณํํ์ฌ ๋ฐฐ์ด์ ์์ฑํ๋ค.
Array.from({length: 2, 0: 'a', 1: 'b'}); // ['a','b']
// ์ดํฐ๋ฌ๋ธ์ ๋ณํํ์ฌ ๋ฐฐ์ด์ ์์ฑํ๋ค. ๋ฌธ์์ด์ ์ดํฐ๋ฌ๋ธ์ด๋ค.
Array.from('Hello'); // ['H','e','l','l','o']
๐ ์ ์ฌ ๋ฐฐ์ด ๊ฐ์ฒด์ ์ดํฐ๋ฌ๋ธ ๊ฐ์ฒด
์ ์ฌ ๋ฐฐ์ด ๊ฐ์ฒด
๋ ๋ง์น ๋ฐฐ์ด์ฒ๋ผ ์ธ๋ฑ์ค๋ก ํ๋กํผํฐ ๊ฐ์ ์ ๊ทผํ ์ ์๊ณ length ํ๋กํผํฐ๋ฅผ ๊ฐ๋ ๊ฐ์ฒด๋ฅผ ๋งํ๋ค. ์ ์ฌ ๋ฐฐ์ด ๊ฐ์ฒด๋ ๋ง์น ๋ฐฐ์ด์ฒ๋ผ for ๋ฌธ์ผ๋ก ์ํํ ์๋ ์๋ค.
์ดํฐ๋ฌ๋ธ ๊ฐ์ฒด
๋ Symbol.iterator ๋ฉ์๋๋ฅผ ๊ตฌํํ์ฌ for...of ๋ฌธ์ผ๋ก ์ํํ ์ ์์ผ๋ฉฐ, ์คํ๋ ๋ ๋ฌธ๋ฒ๊ณผ ๋ฐฐ์ด ๋์คํธ๋ญ์ฒ๋ง ํ ๋น์ ๋์์ผ๋ก ์ฌ์ฉํ ์ ์๋ ๊ฐ์ฒด๋ฅผ ๋งํ๋ค.
๋ฐฐ์ด์ ์์๋ฅผ ์ฐธ์กฐํ ๋์๋ ๋๊ดํธ([]) ํ๊ธฐ๋ฒ
์ ์ฌ์ฉํ๋ค. ๋๊ดํธ ์์๋ ์ธ๋ฑ์ค
๊ฐ ์์ผ ํ๋ค. ์ ์๋ก ํ๊ฐ๋๋ ํํ์์ด๋ผ๋ฉด ์ธ๋ฑ์ค ๋์ ์ฌ์ฉํ ์ ์๋ค
. ์ธ๋ฑ์ค๋ ๊ฐ์ ์ฐธ์กฐํ ์ ์๋ค๋ ์๋ฏธ์์ ๊ฐ์ฒด์ ํ๋กํผํฐ ํค์ ๊ฐ์ ์ญํ
์ ํจ
์กด์ฌํ์ง ์๋ ์์์ ์ ๊ทผํ๋ฉด undefined
๊ฐ ๋ฐํ
๊ฐ์ฒด์ ํ๋กํผํฐ๋ฅผ ๋์ ์ผ๋ก ์ถ๊ฐํ ์ ์๋ ๊ฒ์ฒ๋ผ ๋ฐฐ์ด์๋ ์์๋ฅผ ๋์ ์ผ๋ก ์ถ๊ฐํ ์ ์๋ค. ์กด์ฌํ์ง ์๋ ์ธ๋ฑ์ค๋ฅผ ์ฌ์ฉํด ๊ฐ์ ํ ๋นํ๋ฉด ์๋ก์ด ์์๊ฐ ์ถ๊ฐ. ์ด๋ length ํ๋กํผํฐ ๊ฐ์ ์๋ ๊ฐฑ์
const arr = [0];
// ๋ฐฐ์ด ์์์ ์ถ๊ฐ
arr[1] = 1;
console.log(arr); // [0,1]
console.log(arr.length); // 2
๋ฐฐ์ด์ ์ฌ์ค ๊ฐ์ฒด์ด๊ธฐ ๋๋ฌธ์ ๋ฐฐ์ด์ ํน์ ์์๋ฅผ ์ญ์ ํ๊ธฐ ์ํด delete ์ฐ์ฐ์๋ฅผ ์ฌ์ฉ
ํ ์ ์๋ค. ํฌ์ ๋ฐฐ์ด์ ๋ง๋๋ delete ์ฐ์ฐ์๋ ์ฌ์ฉํ์ง ์๋ ๊ฒ์ด ์ข๋ค.
โ๏ธ Array.prototype.splice ๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ค.
const arr = [1, 2, 3];
// Array.prototype.splice(์ญ์ ๋ฅผ ์์ํ ์ธ๋ฑ์ค, ์ญ์ ํ ์์ ์)
// arr[1]๋ถํฐ 1๊ฐ์ ์์๋ฅผ ์ ๊ฑฐ
arr.splice(1,1);
console.log(arr); // [1,3]
// length ํ๋กํผํฐ๊ฐ ์๋ ๊ฐฑ์ ๋๋ค.
console.log(arr.length); // 2
๋ฐฐ์ด์ ์ฌ์ฉ ๋น๋๊ฐ ๋์ ์๋ฃ๊ตฌ์กฐ์ด๋ฏ๋ก ๋ฐฐ์ด ๋ฉ์๋์ ์ฌ์ฉ๋ฒ์ ์ ์์๋์!
๋ฐฐ์ด ๋ฉ์๋๋ ๊ฒฐ๊ณผ๋ฌผ์๋ฐํํ๋ ํจํด์ด ๋ ๊ฐ์ง
์ด๋ค
1. ๋ฐฐ์ด์๋ ์๋ณธ ๋ฐฐ์ด(๋ฐฐ์ด ๋ฉ์๋๋ฅผ ํธ์ถํ ๋ฐฐ์ด, ์ฆ ๋ฐฐ์ด ๋ฉ์๋์ ๊ตฌํ์ฒด ๋ด๋ถ์์ this๊ฐ ๊ฐ๋ฆฌํค๋ ๊ฐ์ฒด)์ ์ง์ ๋ณ๊ฒฝํ๋ ๋ฉ์๋
2. ์๋ณธ ๋ฐฐ์ด์ ์ง์ ๋ณ๊ฒฝํ์งใ ฃ ์๊ณ ์๋ก์ด ๋ฐฐ์ด์ ์์ฑํ์ฌ ๋ฐํํ๋ ๋ฉ์๋๊ฐ ์๋ค.
const arr = [1];
// push ๋ฉ์๋๋ ์๋ณธ ๋ฐฐ์ด(arr)์ ์ง์ ๋ณ๊ฒฝํ๋ค
arr.push(2);
console.log(arr); // [1,2]
// concat ๋ฉ์๋๋ ์๋ณธ ๋ฐฐ์ด(arr)์ ์ง์ ๋ณ๊ฒฝํ์ง ์๊ณ ์๋ก์ด ๋ฐฐ์ด์ ์์ฑํ์ฌ ๋ฐํํ๋ค.
const result = arr.concat(3);
console.log(arr); // [1,2]
console.log(result); // [1,2,3]
๐ ๊ฐ๊ธ์ ์๋ณธ ๋ฐฐ์ด์ ์ง์ ๋ณ๊ฒฝํ์ง ์๋ ๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ ํธ์ด ์ข๋ค.
Array.isArray ๋ฉ์๋๋ ์ ๋ฌ๋ ์ธ์๊ฐ ๋ฐฐ์ด์ด๋ฉด true, ๋ฐฐ์ด์ด ์๋๋ฉด false๋ฅผ ๋ฐํํ๋ค.
indexOf ๋ฉ์๋๋ ์๋ณธ ๋ฐฐ์ด์์ ์ธ์๋ก ์ ๋ฌ๋ ์์๋ฅผ ๊ฒ์ํ์ฌ ์ธ๋ฑ์ค๋ฅผ ๋ฐํ
- ์๋ณธ ๋ฐฐ์ด์ ์ธ์๋ก ์ ๋ฌํ ์์์ ์ค๋ณต๋๋ ์์๊ฐ ์ฌ๋ฌ ๊ฐ ์๋ค๋ฉด ์ฒซ ๋ฒ์จฐ๋ก ๊ฒ์๋ ์์์ ์ธ๋ฑ์ค๋ฅผ ๋ฐํ
- ์๋ณธ ๋ฐฐ์ด์ ์ธ์๋ก ์ ๋ฌํ ์์๊ฐ ์กด์ฌํ์ง ์์ผ๋ฉด -1์ ๋ฐํ
const arr = [1,2,2,4];
// ๋ฐฐ์ด arr์์ ์์ 2๋ฅผ ๊ฒ์ํ์ฌ ์ฒซ ๋ฒ์ค๋ก ๊ฒ์๋ ์์์ ์ธ๋ฐ์ค๋ฅผ ๋ฐํ
arr.indexOf(2); // 1
indexOf ๋ฉ์๋๋ ๋ฐฐ์ด์ ํน์ ์์๊ฐ ์กด์ฌํ๋์ง ํ์ธํ ๋ ์ ์ฉํ์ง๋ง ES7์์ ๋์
๋ Array.prototype.includes ๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ฉด ๊ฐ๋
์ฑ์ด ๋ ์ข๋ค.
const foods = ['apple', 'banana', 'orange'];
// food ๋ฐฐ์ด์ 'orange' ์์๊ฐ ์กด์ฌํ๋์ง ํ์ธ
if(!foods.includes('orange')) {
// foods ๋ฐฐ์ด์ 'orange' ์์๊ฐ ์กด์ฌํ์ง ์์ผ๋ฉด 'orange' ์์๋ฅผ ์ถ๊ฐ
foods.push('orange')
}
console.log(foods); // ["apple","banana","orange"]
push ๋ฉ์๋๋ ์ธ์๋ก ์ ๋ฌ๋ฐ์ ๋ชจ๋ ๊ฐ์ ์๋ณธ ๋ฐฐ์ด์ ๋ง์ง๋ง ์์๋ก ์ถ๊ฐํ๊ณ ๋ณ๊ฒฝ๋ length ํ๋กํผํฐ ๊ฐ์ ๋ฐํ.
push ๋ฉ์๋๋ ์๋ณธ ๋ฐฐ์ด์ ์ง์ ๋ณ๊ฒฝ
const arr = [1,2] ;
// ์ธ์๋ก ์ ๋ฌ๋ฐ์ ๋ชจ๋ ๊ฐ์ ์๋ณธ ๋ฐฐ์ด arr์ ๋ง์ง๋ง ์์๋ก ์ถ๊ฐํ๊ณ ๋ณ๊ฒฝ๋ length ๊ฐ์ ๋ฐํํ๋ค.
let result = arr.push(3,4);
console.log(result); 4
// push ๋ฉ์๋๋ ์๋ณธ ๋ฐฐ์ด์ ์ง์ ๋ณ๊ฒฝ
console.log(arr); // [1,2,3,4]
push ๋ฉ์๋๋ ์ฑ๋ฅ ๋ฉด์์ ์ข์ง ์๋ค. ๋ง์ง๋ง ์์๋ก ์ถ๊ฐํ ์์๊ฐ ํ๋๋ฟ์ด๋ผ๋ฉด push ๋ฉ์๋๋ฅผ ์ฌ์ฉํ์ง ์๊ณ length ํ๋กํผํฐ
๋ฅผ ์ฌ์ฉํ์ฌ ๋ฐฐ์ด์ ๋ง์ง๋ง์ ์์๋กค ์ง์ ์ถ๊ฐํ ์๋ ์๋ค.
const arr = [1,2];
// arr.push(3)๊ณผ ๋์ผํ ์ฒ๋ฆฌ๋ฅผ ํ๋ค. ์ด ๋ฐฉ๋ฒ์ด push ๋ฉ์๋๋ณด๋ค ๋น ๋ฅด๋ค
arr[arr.length] = 3;
console.log(arr); // [1,2,3]
push๋ณด๋ค ES6์ ์คํ๋ ๋ ๋ฌธ๋ฒ์ ์ฌ์ฉํ๋ ํธ์ด ์ข๋ค.
pop ๋ฉ์๋๋ ์๋ณธ ๋ฐฐ์ด์์ ๋ง์ง๋ง ์์๋ฅผ ์ ๊ฑฐํ๊ณ ์ ๊ฑฐํ ์์๋ฅผ ๋ฐํํ๋ค.
๋ฐฐ์ด์ด ๋น์ด์์ผ๋ฉด undefined๋ฅผ ๋ฐํ.pop๋ฉ์๋๋ ๋ฐฐ์ด์ ์ง์ ๋ณ๊ฒฝ
const arr = [1.2];
// ์๋ณธ ๋ฐฐ์ด์์ ๋ง์ง๋ง ์์๋ฅผ ์ ๊ฑฐํ๊ณ ์ ๊ฑฐํ ์์๋ฅผ ๋ฐํํ๋ค.
let result = arr.pop();
console.log(result); //2
// pop ๋ฉ์๋๋ ์๋ณธ ๋ฐฐ์ด์ ์ง์ ๋ณ๊ฒฝํ๋ค.
console.log(arr); // [1]
๐ ์คํ ์ ๋ฐ์ดํฐ๋ฅผ ๋ง์ง๋ง์ ๋ฐ์ด ๋ฃ๊ณ , ๋ง์ง๋ง์ ๋ฐ์ด ๋ฃ์ ๋ฐ์ดํฐ๋ฅผ ๋จผ์ ๊บผ๋ด๋ ํ์ ์ ์ถ ๋ฐฉ์์ ์๋ฃ๊ตฌ์กฐ๋ค.
์คํ์ ์ธ์ ๋ ๊ฐ์ฅ ๋ง์ง๋ง์ ๋ฐ์ด ๋ฃ์ ์ต์ ๋ฐ์ดํฐ๋ฅผ ๋จผ์ ์ทจ๋ํ๋ค.
์คํ์ ๋ฐ์ดํฐ๋ฅผ ๋ฐ์ด ๋ฃ๋ ๊ฒ์ํธ์
๋ผํ๊ณ ๊บผ๋ด๋ ๊ฒ์ํ
์ด๋ผ๊ณ ํ๋ค.
unshift ๋ฉ์๋๋ ์ธ์๋ก ์ ๋ฌ๋ฐ์ ๋ชจ๋ ๊ฐ์ ์๋ณธ ๋ฐฐ์ด์ ์ ๋์ ์์๋ก ์ถ๊ฐํ๊ณ ๋ณ๊ฒฝ๋ length ํ๋กํผํฐ ๊ฐ์ ๋ฐํ,
unshift ๋ฉ์๋๋ ์๋ณธ ๋ฐฐ์ด์ ์ง์ ๋ณ๊ฒฝ
const arr = [1,2]
// ์ธ์๋ก ์ ๋ฌ๋ฐ์ ๋ชจ๋ ๊ฐ์ ์๋ณธ ๋ฐฐ์ด์ ์ ๋์ ์์๋ก ์ถ๊ฐํ๊ณ ๋ณ๊ฒฝ๋ length ๊ฐ์ ๋ฐํํ๋ค
let result = arr.unshift(3,4);
console.log(result); // 4
// unshift ๋ฉ์๋๋ ์๋ณธ ๋ฐฐ์ด์ ์ง์ ๋ณ๊ฒฝ
console.log(arr); // [1,2,3,4]
unshift ๋ฉ์๋๋ ์๋ณธ ๋ฐฐ์ด์ ์ง์ ๋ณ๊ฒฝํ๋ ๋ถ์ ํจ๊ณผ๊ฐ ์๋ค ๋ฐ๋ผ์ ES6์ ์คํ๋ ๋ ๋ฌธ๋ฒ์ ์ฌ์ฉํ์.
shift ๋ฉ์๋๋ ์๋ณธ ๋ฐฐ์ด์์ ์ฒซ ๋ฒ์งธ ์์๋ฅผ ์ ๊ฑฐํ๊ณ ์ ๊ฑฐํ ์์๋ฅผ ๋ฐํํ๋ค. ์๋ณธ ๋ฐฐ์ด์ด ๋น ๋ฐฐ์ด์ด๋ฉด undefined๋ฅผ ๋ฐํํ๋ค.
shift ๋ฉ์๋๋ ์๋ณธ ๋ฐฐ์ด์ ์ง์ ๋ณ๊ฒฝ
const arr = [1,2]
// ์๋ณธ ๋ฐฐ์ด์์ ์ฒซ ๋ฒ์จฐ ์์๋ฅผ ์ ๊ฑฐํ๊ณ ์ ๊ฑฐํ ์์๋ฅผ ๋ฐํํ๋ค.
let result = arr.shift();
console.log(result); // 1
// shift ๋ฉ์๋๋ ์๋ณธ ๋ฐฐ์ด์ ์ง์ ๋ณ๊ฒฝ
console.log(arr); // [2]
shift ๋ฉ์๋์ push ๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ฉด ํ๋ฅผ ์ฝ๊ฒ ๊ตฌํํ ์ ์๋ค.
๐ ํ๋ ๋ฐ์ดํฐ๋ฅผ ๋ง์ง๋ง์ ๋ฐ์ด ๋ฃ๊ณ , ์ฒ์ ๋ฐ์ดํฐ, ์ฆ ๊ฐ์ฅ ๋จผ์ ๋ฐ์ด ๋ฃ์ ๋ฐ์ดํฐ๋ฅผ ๋จผ์ ๊บผ๋ด๋ ์ ์ ์ ์ถ๋ฐฉ์์ ์๋ฃ๊ตฌ์กฐ๋ค. ์คํ์ ์ธ์ ๋ ๋ง์ง๋ง์ ๋ฐ์ด ๋ฃ์ ์ต์ ๋ฐ์ดํฐ๋ฅผ ์ทจ๋ํ์ง๋ง ํ๋ ์ธ์ ๋ ๋ฐ์ดํฐ๋ฅผ ๋ฐ์ด ๋ฃ์ ์์๋๋ก ์ทจ๋ํจ.
concat ๋ฉ์๋๋ ์ธ์๋ก ์ ๋ฌ๋ ๊ฐ๋ค์ ์๋ณธ ๋ฐฐ์ด์ ๋ง์ง๋ง ์์๋ก ์ถ๊ฐํ
์๋ก์ด ๋ฐฐ์ด
์ ๋ฐํ ์ธ์๋ก ์ ๋ฌํ ๊ฐ์ด ๋ฐฐ์ด์ธ ๊ฒฝ์ฐ ๋ฐฐ์ด์ ํด์ฒดํ์ฌ ์๋ก์ด ๋ฐฐ์ด์ ์์๋ก ์ถ๊ฐํ๋ค.์๋ณธ ๋ฐฐ์ด์ ๋ณ๊ฒฝX
const arr1 = [1,2];
const arr2 = [3.4];
// ๋ฐฐ์ด arr๋ฅผ ์๋ณธ ๋ฐฐ์ด arr1์ ๋ง์ง๋ง ์์๋ก ์ถ๊ฐํ ์๋ก์ด ๋ฐฐ์ด์ ๋ฐํํ๋ค.
// ์ธ์๋ก ์ ๋ฌํ ๊ฐ์ด ๋ฐฐ์ด์ธ ๊ฒฝ์ฐ ๋ฐฐ์ด์ ํด์ฒดํ์ฌ ์๋ก์ด ๋ฐฐ์ด์ ์์๋ก ์ถ๊ฐํ๋ค.
let result = arr1.concat(arr2);
console.log(result); // [1,2,3,4]
// ์ซ์๋ฅผ ์๋ณธ ๋ฐฐ์ด arr1์ ๋ง์ง๋ง ์์๋ก ์ถ๊ฐํ ์๋ก์ด ๋ฐฐ์ด์ ๋ฐํํ๋ค.
result = arr1.concat(3);
console.log(result); // [1,2,3]
// ๋ฐฐ์ด arr2์ ์ซ์๋ฅผ ์๋ณธ ๋ฐฐ์ด arr1์ ๋ง์ง๋ง ์์๋ก ์ถ๊ฐํ ์๋ก์ด ๋ฐฐ์ด์ ๋ฐํ
result = arr1.concat(arr2,5);
console.log(result); // [1,2,3,4,5]
// ์๋ณธ ๋ฐฐ์ด์ ๋ณ๊ฒฝ๋์ง ์๋๋ค.
console.log(arr1); // [1,2]
โญ๏ธโญ๏ธโญ๏ธ๊ทธ๋ฅ ES6์ ์คํ๋ฅด๋ ๋ฌธ๋ฒ์ ์ผ๊ด์ฑ ์๊ฒ ์ฌ์ฉํ์.
์๋ณธ ๋ฐฐ์ด์ ์ค๊ฐ์ ์์๋ฅผ ์ถ๊ฐํ๊ฑฐ๋ ์ค๊ฐ์ ์๋ ์์๋ฅผ ์ ๊ฑฐํ๋ ๊ฒฝ์ฐ splice ๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ค. 3๊ฐ์ ๋งค๊ฐ๋ณ์๊ฐ ์์ผ๋ฉฐ ์๋ณธ ๋ฐฐ์ด์ ์ง์ ๋ณ๊ฒฝ
const arr = [1,2,3,4];
// ์๋ณธ ๋ฐฐ์ด์ ์ธ๋ฑ์ค 1๋ถํฐ 2๊ฐ์ ์์๋ฅผ ์ ๊ฑฐํ๊ณ ๊ทธ ์๋ฆฌ์ ์๋ก์ด ์์ 20, 30์ ์ฝ์
ํ๋ค.
const result = arr.splice(1,2,20,30);
// ์ ๊ฑฐํ ์์๊ฐ ๋ฐฐ์ด๋ก ๋ฐํ๋๋ค.
console.log(result); // [2,3]
// splice ๋ฉ์๋๋ ์๋ณธ ๋ฐฐ์ด์ ์ง์ ๋ณ๊ฒฝํ๋ค.
console.log(arr); // [1,20,30,4]
splice ๋ฉ์๋์ ๋ ๋ฒ์งธ ์ธ์, ์ฆ ์ ๊ฑฐํ ์์์ ๊ฐ์๋ฅผ 0์ผ๋ก ์ง์ ํ๋ฉด ์๋ฌด๋ฐ ์์๋ ์ ๊ฑฐํ์ง ์๊ณ ์๋ก์ด ์์๋ค์ ์ฝ์ ํ๋ค.
const arr = [1,2,3,4]
// ์๋ณธ ๋ฐฐ์ด์ ์ธ๋ฑ์ค 1๋ถํฐ 0๊ฐ์ ์์๋ฅผ ์ ๊ฑฐํ๊ณ ๊ทธ ์๋ฆฌ์ ์๋ก์ด ์์ 100์ ์ฝ์
ํ๋ค.
const result = arr.splice(1,0,100);
// ์๋ณธ ๋ฐฐ์ด์ด ๋ณ๊ฒฝ๋๋ค.
console.log(arr); // [1,100,2,3,4]
// ์ ๊ฑฐํ ์์๊ฐ ๋ฐฐ์ด๋ก ๋ฐํ๋๋ค.
console.log(result); // []
splice ๋ฉ์๋์ ์ธ ๋ฒ์จฐ ์ธ์, ์ฆ ์ ๊ฑฐํ ์์น์ ์ถ๊ฐํ ์์๋ค์ ๋ชฉ๋ก์ ์ ๋ฌํ์ง ์์ผ๋ฉด ์๋ณธ ๋ฐฐ์ด์์ ์ง์ ๋ ์์๋ฅผ ์ ๊ฑฐํ๊ธฐ๋ง ํ๋ค.
const arr = [1,2,3,4]
// ์๋ณธ ๋ฐฐ์ด์ ์ธ๋ฑ์ค 1๋ถํฐ 2๊ฐ์ ์์๋ฅผ ์ ๊ฑฐํ๋ค.
const result = arr.splice(1,2);
// ์๋ณธ ๋ฐฐ์ด์ด ๋ณ๊ฒฝ๋๋ค.
console.log(arr); // [1,4]
// ์ ๊ฑฐํ ์์๊ฐ ๋ฐฐ์ด๋ก ๋ฐํ๋๋ค.
console.log(result); // [2,3]
splice ๋ฉ์๋์ ๋ ๋ฒ์งธ ์ธ์, ์ฆ ์ ๊ฑฐํ ์์์ ๊ฐ์๋ฅผ ์๋ตํ๋ฉด ์ฒซ ๋ฒ์จฐ ์ธ์๋ก ์ ๋ฌ๋ ์์ ์ธ๋ฑ์ค๋ถํฐ ๋ชจ๋ ์์๋ฅผ ์ ๊ฑฐํ๋ค.
const arr = [1,2,3,4]
// ์๋ณธ ๋ฐฐ์ด์ ์ธ๋ฑ์ค 1๋ถํฐ ๋ชจ๋ ์์๋ฅผ ์ ๊ฑฐํ๋ค.
const result = arr.splice(1);
// ์๋ณธ ๋ฐฐ์ด์ด ๋ณ๊ฒฝ๋๋ค.
console.log(arr); // [1]
// ์ ๊ฑฐํ ์์๊ฐ ๋ฐฐ์ด๋ก ๋ฐํ๋๋ค.
console.log(result); // [2,3,4]
๋ฐฐ์ด์์ ํน์ ์์๋ฅผ ์ ๊ฑฐํ๋ ค๋ฉด indexOf ๋ฉ์๋๋ฅผ ํตํด ํน์ ์์์ ์ธ๋ฑ์ค๋ฅผ ์ทจ๋ํ ๋ค์ splice ๋ฉ์๋ฅผ ์ฌ์ฉํ๋ค.
const arr = [1,2,3,4,5]
// ๋ฐฐ์ด array์์ item ์์๋ฅผ ์ ๊ฑฐํ๋ค. item ์์๊ฐ ์ฌ๋ฌ ๊ฐ ์กด์ฌํ๋ฉด ์ฒซ ๋ฒ์งธ ์์๋ง ์ ๊ฑฐํ๋ค.
function remove(array,item) {
// ์ ๊ฑฐํ item ์์์ ์ธ๋ฑ์ค๋ฅผ ์ทจ๋ํ๋ค.
const index = array.indexOf(item);
// ์ ๊ฑฐํ item ์์๊ฐ ์๋ค๋ฉด ์ ๊ฑฐํ๋ค.
if (index !== -1) array.splice(index,1);
return array;
}
console.log(remove(arr,2)); // [1,3,1,2]
console.log(remove(arr,10)); // [1,3,1,2]
filter ๋ฉ์๋๋ฅผ ์ฌ์ฉํ์ฌ ํน์ ์์๋ฅผ ์ ๊ฑฐํ ์๋ ์๋ค. ํ์ง๋ง ํน์ ์์๊ฐ ์ค๋ณต๋ ๊ฒฝ์ฐ ๋ชจ๋ ์ ๊ฑฐ๋จ.
const arr = [1,2,3,1,2];
// ๋ฐฐ์ด array์์ ๋ชจ๋ item ์์๋ฅผ ์ ๊ฑฐํ๋ค.
function removeAll(array,item) {
return array.filter(v => v !== item);
}
console.log(removeAll(arr,2)); // [1,3,1]
slice ๋ฉ์๋๋ ์ธ์๋ก ์ ๋ฌ๋ ๋ฒ์์ ์์๋ค์ ๋ณต์ฌํ์ฌ ๋ฐฐ์ด๋ก ๋ฐํ
ํ๋ค. ์๋ณธ ๋ฐฐ์ด์ ๋ณ๊ฒฝ๋์ง ์๋๋ค. ์ ์ฌํsplice ๋ฉ์๋๋ ์๋ณธ ๋ฐฐ์ด์ ๋ณ๊ฒฝํ๋ฏ๋ก ์ฃผ์
๋ณต์ฌ๋ฅผ ์์ํ ์ธ๋ฑ์ค
๋ค. ์์์ธ ๊ฒฝ์ฐ ๋ฐฐ์ด์ ๋์์์ ์ธ๋ฑ์ค๋ฅผ ๋ํ๋ธ๋ค. ์๋ฅผ ๋ค์ด slice(-2)๋ ๋ฐฐ์ด์ ๋ง์ง๋ง ๋ ๊ฐ์ ์์๋ฅผ ๋ณต์ํ์ฌ ๋ฐฐ์ด๋ก ๋ฐํํ๋ค.๋ณต์ฌ๋ฅผ ์ข
๋ฃํ ์ธ๋ฑ์ค
๋ค. ์ด ์ธ๋ฑ์ค์ ํด๋นํ๋ ์์๋ ๋ณต์ฌ๋์ง ์๋๋ค. end๋ ์๋ต ๊ฐ๋ฅํ๋ฉฐ ์๋ต ์ ๊ธฐ๋ณธ๊ฐ์ length ํ๋กํผํฐ ๊ฐ์ด๋ค.const arr = [1,2,3];
// arr[0]๋ถํฐ arr[1] ์ด์ (arr[1] ๋ฏธํฌํจ)๊น์ง ๋ณต์ฌํ์ฌ ๋ฐํํ๋ค.
arr.slice(0,1) // [1]
// arr[1]๋ถํฐ arr[2] ์ด์ (arr[2] ๋ฏธํฌํจ)๊น์ง ๋ณต์ฌํ์ฌ ๋ฐํํ๋ค.
arr.slice(1,2) // [2]
//์๋ณธ์ ๋ณ๊ฒฝ๋์ง ์๋๋ค.
console.log(arr); // [1,2,3]
slice ๋ฉ์๋๋ ์ฒซ ๋ฒ์จฐ ์ธ์๋ก ์ ๋ฌ๋ฐ์ ์ธ๋ฑ์ค๋ถํฐ ๋ ๋ฒ์จฐ ์ธ์๋ก ์ ๋ฌ๋ฐ์ ์ธ๋ฑ์ค ์ด์ ๊น์ง ์์๋ค์ ๋ณต์ฌํ์ฌ ๋ฐฐ์ด๋ก ๋ฐํํ๋ค.
const arr = [1,2,3]
// arr[1]๋ถํฐ ์ดํ์ ๋ชจ๋ ์์๋ฅผ ๋ณต์ฌํ์ฌ ๋ฐํํ๋ค.
arr.slice(1); // [2,3]
slice ๋ฉ์๋์ ์ฒซ ๋ฒ์จฐ ์ธ์๊ฐ ์์์ธ ๊ฒฝ์ฐ ๋ฐฐ์ด์ ๋์์๋ถํฐ ์์๋ฅผ ๋ณต์ฌํ์ฌ ๋ฐฐ์ด๋ก ๋ฐํ
const arr = [1,2,3]
// ๋ฐฐ์ด์ ๋์์๋ถํฐ ์์๋ฅผ ํ ๊ฐ ๋ณต์ฌํ์ฌ ๋ฐํํ๋.
arr.slice(-1); // [3]
// ๋ฐฐ์ด์ ๋์์๋ถํฐ ์์๋ฅผ ๋ ๊ฐ ๋ณต์ฌํ์ฌ ๋ฐํํ๋ค.
arr.slice(-2); // [2,3]'
slice ๋ฉ์๋์ ์ธ์๋ฅผ ๋ชจ๋ ์๋ตํ๋ฉด ์๋ณธ ๋ฐฐ์ด์ ๋ณต์ฌ๋ณธ์ ์์ฑํ์ฌ ๋ฐํ
const arr = [1,2,3];
// ์ธ์๋ฅผ ๋ชจ๋ ์๋ตํ๋ฉด ์๋ณธ ๋ฐฐ์ด์ ๋ณต์ฌ๋ณธ์ ์์ฑํ์ฌ ๋ฐํํ๋ค.
const copy = arr.slice();
console.log(copy); // [1,2,3]
console.log(copy === arr); // false
์ด๋ ์์ฑ๋ ๋ณต์ฌ๋ณธ์ ์์ ๋ณต์ฌ๋ฅผ ํตํด ์์ฑ
const todos = [
{ id: 1, content: 'HTML', completed: false},
{ id: 2, content: 'HTML', completed: false},
{ id: 3, content: 'HTML', completed: false}
];
// ์์ ๋ณต์ฌ(shallow copy)
const _todos = todos.slice();
// const _todos = [...todos]
// _todo์ todos๋ ์ฐธ์กฐ๊ฐ์ด ๋ค๋ฅธ ๋ณ๊ฐ์ ๊ฐ์ฒด๋ค.
console.log(_todos === todos); // false
// ๋ฐฐ์ด ์์์ ์ฐธ์กฐ๊ฐ์ด ๊ธธ๋ค. ์ฆ, ์์ ๋ณต์ฌ๋์๋ค.
console.log(_todos[0] === todos[0]); // true
Array.form ๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ฉด ๋์ฑ ๊ฐ๋จํ๊ฒ ์ ์ฌ ๋ฐฐ์ด ๊ฐ์ฒด๋ฅผ ๋ฐฐ์ด๋ก ๋ณํํ ์ ์๋ค.
function sum() {
const arr = Array.from(arguments);
console.log(arr); // [1,2,3]
return arr.reduce((pre, cur) => pre + cur, 0);
}
console.log(sum(1,2,3)); // 6
์ดํฐ๋ฌ๋ธ ๊ฐ์ฒด๋ ES6์ ์คํ๋ ๋ ๋ฌธ๋ฒ์ ์ฌ์ฉํ์ฌ ๊ฐ๋จํ๊ฒ ๋ฐฐ์ด๋ก ๋ณํ
function sum() {
// ์ดํฐ๋ฌ๋ธ์ ๋ฐฐ์ด๋ก ๋ฐํ(ES6 ์คํ๋ ๋ ๋ฌธ๋ฒ)
const arr = [...arguments];
console.log(arr); // [1,2,3]
return arr.reduce((pre,cur) => pre + cur, 0);
}
console.log((sum(1,2,3)); // 6
join ๋ฉ์๋๋ ์๋ณธ ๋ฐฐ์ด์ ๋ชจ๋ ์์๋ฅผ ๋ฌธ์์ด๋ก ๋ณํํ ํ, ์ธ์๋ก ์ ๋ฌ๋ฐ์ ๋ฌธ์์ด, ์ฆ ๊ตฌ๋ถ์๋ก ์ฐ๊ฒฐํ ๋ฌธ์์ด์ ๋ฐํํ๋ค. ๊ตฌ๋ถ์๋ ์๋ต ๊ฐ๋ฅํ๋ฉฐ ๊ธฐ๋ณธ ๊ตฌ๋ณธ์๋ ์ฝค๋ง(',')๋ค.
const arr = [1,2,3,4];
// ๊ธฐ๋ณธ ๊ตฌ๋ถ์๋ ์ฝค๋ง๋ค.
// ์๋ณธ ๋ฐฐ์ด arr์ ๋ชจ๋ ์์๋ฅผ ๋ฌธ์์ด๋ก ๋ณํ๋ ํ ๊ธฐ๋ณธ ๊ตฌ๋ถ์๋ก ์ฐ๊ฒฐํ ๋ฌธ์์ด์ ๋ฐํํ๋ค.
arr.join(); // '1,2,3,4';
// ์๋ณธ ๋ฐฐ์ด arr์ ๋ชจ๋ ์์๋ฅผ ๋ฌธ์์ด๋ก ๋ณํํ ํ, ๋น ๋ฌธ์์ด๋ก ์ฐ๊ฒฐํ ๋ฌธ์์ด์ ๋ฐํํ๋ค.
arr.join(''); // '1234'
// ์๋ณธ ๋ฐฐ์ด arr์ ๋ชจ๋ ์์๋ฅผ ๋ฌธ์์ด๋ก ๋ณํํ ํ ๊ตฌ๋ถ์ ':'๋ก ์ฐ๊ฒฐํ ๋ฌธ์์ด์ ๋ฐํํ๋ค.
arr.join(':') // '1:2:3:4'
reverse ๋ฉ์๋๋ ์๋ณธ ๋ฐฐ์ด์ ์์๋ฅผ ๋ฐ๋๋ก ๋ค์ง๋๋ค.
์ด๋ ์๋ณธ ๋ฐฐ์ด์ด ๋ณ๊ฒฝ๋๋ค. ๋ฐํ๊ฐ์ ๋ณ๊ฒฝ๋ ๋ฐฐ์ด์ด๋ค.
const arr = [1,2,3];
const result = arr.reverse();
// reverse ๋ฉ์๋๋ ์๋ณธ ๋ฐฐ์ด์ ์ง์ ๋ณ๊ฒฝํ๋ค.
console.log(arr); // [3,2,1]
// ๋ฐํ๊ฐ์ ๋ณ๊ฒฝ๋ ๋ฐฐ์ด์ด๋ค.
console.log(result); // [3,2,1]
ES6์์ ๋์
๋ fill ๋ฉ์๋๋ ์ธ์๋ก ์ ๋ฌ๋ฐ์ ๊ฐ์ ๋ฐฐ์ด์ ์ฒ์๋ถํฐ ๋๊น์ง ์์๋ก ์ฑ์ด๋ค. ์๋ณธ ๋ฐฐ์ด์ด ๋ณ๊ฒฝ
const arr= [1,2,3]
// ์ธ์๋ก ์ ๋ฌ๋ฐ์ ๊ฐ 0์ ๋ฐฐ์ด์ ์ฒ์๋ถํฐ ๋๊น์ง ์์๋ก ์ฑ์ด๋ค.
arr.fill(0);
// fill ๋ฉ์๋๋ ์๋ณธ ๋ฐฐ์ด์ ์ง์ ๋ณ๊ฒฝํ๋ค.
console.log(arr); // [0,0,0]
๋ ๋ฒ์งธ ์ธ์๋ก ์์ ์ฑ์ฐ๊ธฐ๋ฅผ ์์ํ ์ธ๋ฑ์ค๋ฅผ ์ ๋ฌํ ์ ์๋ค.
์ธ ๋ฒ์งธ ์ธ์๋ก ์์ ์ฑ์ฐ๊ธฐ๋ฅผ ๋ฉ์ถ ์ธ๋ฑ์ค๋ฅผ ์ ๋ฌํ ์ ์๋ค.
fill ๋ฉ์๋๋ก ์์๋ฅผ ์ฑ์ธ ๊ฒฝ์ฐ ๋ชจ๋ ์์๋ฅผ ํ๋์ ๊ฐ๋ง์ผ๋ก ์ฑ์ธ ์๋ฐ์ ์๋ค๋ ๋จ์ ์ด ์๋ค.
Array.from ๋ฉ์๋๋ฅผ ์ฌ์ฉ
ํ๋ฉด ๋ ๋ฒ์จฐ ์ธ์๋ก ์ ๋ฌํ ์ฝ๋ฐฑ ํจ์๋ฅผ ํตํด ์์๊ฐ์ ๋ง๋ค๋ฉด์ ๋ฐฐ์ด์ ์ฑ์ธ ์ ์๋ค.
Array.from ๋ฉ์๋๋ `๋ ๋ฒ์จฐ ์ธ์๋ก ์ ๋ฌํ ์ฝ๋ฐฑ ํจ์์ ์ฒซ ๋ฒ์งธ ์ธ์์ ์ํด ์์ฑ๋ ๋ฐฐ์ด์ ์์๊ฐ๊ณผ ์ธ๋ฑ์ค๋ฅผ ์์ฐจ์ ์ผ๋ก ์ ๋ฌํ๋ฉด์ ํธ์ถํ๊ณ , ์ฝ๋ฐฑ ํจ์์ ๋ฐํ๊ฐ์ผ๋ก ๊ตฌ์ฑ๋ ๋ฐฐ์ด์ ๋ฐํ.
// ์ธ์๋ก ์ ๋ฌ๋ฐ์ ์ ์๋งํผ ์์๋ฅผ ์์ฑํ๊ณ 0๋ถํฐ 1์ฉ ์ฆ๊ฐํ๋ฉด์ ์์๋ฅผ ์ฑ์ด๋ค.
const sequences = (length = 0) => Array.from({ length }. (_, 1) => i);
// const sequences = (length = 0) => Array.from(new Array(length), (_, i) => i);
console.log(sequences(3)); // [0,1,2]
ES7์์ ๋์
๋ includes ๋ฉ์๋๋ ๋ฐฐ์ด ๋ด์ ํน์ ์์๊ฐ ํฌํจ๋์ด ์๋์ง ํ์ธํ์ฌ true ๋๋ false๋ฅผ ๋ฐํ
์ฒซ ๋ฒ์งธ ์ธ์๋ก ๊ฒ์ํ ๋์์ ์ง์ .
const arr = [1,2,3];
// ๋ฐฐ์ด์ ์์ 2๊ฐ ํฌํจ๋์ด ์๋์ง ํ์ธํ๋ค.
arr.includes(2); // true
// ๋ฐฐ์ด์ ์์ 100์ด ํฌํจ๋์ด ์๋์ง ํ์ธํ๋ค.
arr.includes(100); // false
๋ ๋ฒ์จฐ ์ธ์๋ก ๊ฒ์์ ์์ํ ์ธ๋ฑ์ค๋ฅผ ์ ๋ฌ
ํ ์ ์๋ค. ๋ ๋ฒ์จฐ ์ธ์๋ฅผ ์๋ตํ ๊ฒฝ์ฐ ๊ธฐ๋ณธ๊ฐ 0์ด ์ค์ ๋๋ค. ๋ ๋ฒ์งธ ์ธ์์ ์์๋ฅผ ์ ๋ฌํ๋ฉด length ํ๋กํผํฐ ๊ฐ๊ณผ ์์ ์ธ๋ฑ์ค๋ฅผ ํฉ์ฐํ์ฌ(length + index) ๊ฒ์์์ ์ธ๋ฑ์ค๋ฅผ ์ค์ ํ๋ค.
const arr = [1,2,3];
// ๋ฐฐ์ด์ ์์ 1์ด ํฌํจ๋์ด ์๋์ง ์ธ๋ฑ์ค 1๋ถํฐ ํ์ธํ๋ค.
arr.includes(1,1); // false
// ๋ฐฐ์ด์ ์์ 3์ด ํฌํจ๋์ด ์๋์ง ์ธ๋ฑ์ค 2(arr.length - 1)๋ถํฐ ํ์ธํ๋ค.
arr.includes(3,-1); // true
ES10์์ ๋์ ๋ flat ๋ฉ์๋๋ ์ธ์๋ก ์ ๋ฌํ ๊น์ด๋งํผ ์ฌ๊ท์ ์ผ๋ก ๋ฐฐ์ด์ ํํํํ๋ค.
[1, [2,3,4,5]].flat(); // [1,2,3,4,5]
[1,[2,[3,[4]]]].flat(Infinity); // [1,2,3,4]
๊ณ ์ฐจ ํจ์๋ ํจ์๋ฅผ ์ธ์๋ก ์ ๋ฌ๋ฐ๊ฑฐ๋ ํจ์๋ฅผ ๋ฐํํ๋ ํจ์๋ฅผ ๋งํ๋ค.
์๋ฐ์คํฌ๋ฆฝํธ์ ํจ์๋ ์ผ๊ธ ๊ฐ์ฒด์ด๋ฏ๋ก ํจ์๋ฅผ ๊ฐ์ฒ๋ผ ์ธ์๋ก ์ ๋ฌํ ์ ์์ผ๋ฉฐ ๋ฐํํ ์๋ ์๋ค. ๊ณ ์ฐจํจ์๋ ์ธ๋ถ ์ํ์ ๋ณ๊ฒฝ์ด๋ ๊ฐ๋ณ๋ฐ์ดํฐ๋ฅผ ํผํ๊ณ ๋ถ๋ณ์ฑ์ ์งํฅ
ํ๋ ํจ์ํ ํ๋ก๊ทธ๋๋ฐ์ ๊ธฐ๋ฐ์ ๋๊ณ ์๋ค
ํจ์ํ ํ๋ก๊ทธ๋๋ฐ์ ์์ํจ์์ ๋ณด์กฐ ํจ์์ ์กฐํฉ์ ํตํด ๋ก์ง ๋ด์ ์กด์ฌํ๋ ์กฐ๊ฑด๋ฌธ๊ณผ ๋ฐ๋ณต๋ฌธ์ ์ ๊ฑฐํ์ฌ ๋ณต์ก์ฑ์ ํด๊ฒฐํ๊ณ ๋ณ์์ ์ฌ์ฉ์ ์ต์ ํ์ฌ ์ํ ๋ณ๊ฒฝ์ ํผํ๋ ค๋ ํ๋ก๊ทธ๋๋ฐ ํจ๋ฌ๋ค์์ด๋ค.
ํจ์ํ ํ๋ก๊ทธ๋๋ฐ์ ๊ฒฐ๊ตญ ์์ ํจ์๋ฅผ ํตํด ๋ถ์ ํจ๊ณผ๋ฅผ ์ต๋ํ ์ต์ ํ์ฌ ์ค๋ฅ๋ฅผ ํผํ๊ณ ํ๋ก๊ทธ๋จ์ ์์ ์ฑ์ ๋์ด๋ ค๋ ๋
ธ๋ ฅ์ ์ผํ์ด๋ผ๊ณ ๋ ํ ์ ์๋ค.
sort ๋ฉ์๋๋ ๋ฐฐ์ด์ ์์๋ฅผ ์ ๋ ฌ.
์๋ณธ ๋ฐฐ์ด์ ์ง์ ๋ณ๊ฒฝํ์ฌ ์ ๋ ฌ๋ ๋ฐฐ์ด์ ๋ฐํ. sort ๋ฉ์๋๋ ๊ธฐ๋ณธ์ ์ผ๋ก ์ค๋ฆ์ฐจ์์ผ๋ก ์์๋ฅผ ์ ๋ ฌ
const fruits = ['Banana', 'Orange', 'Apple']
// ์ค๋ฆ์ฐจ์ ์ ๋ ฌ
fruits.sort();
// sort ๋ฉ์๋๋ ์๋ณธ ๋ฐฐ์ด์ ์ง์ ๋ณ๊ฒฝํ๋ค.
console.log(fruits); // ['Apple', 'Banana', 'Orange']
ํ๊ธ ๋ฌธ์์ด์ธ ์์๋ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌ
sort ๋ฉ์๋๋ ๊ธฐ๋ณธ์ ์ผ๋ก ์ค๋ฆ์ฐจ์์ผ๋ก ์์๋ฅผ ์ ๋ ฌํ๋ฏ๋ก ๋ด๋ฆผ์ฐจ์์ผ๋ก ์์๋ฅผ ์ ๋ ฌํ๋ ค๋ฉด sort๋ฅผ ์ฌ์ฉํ๋ค revese ๋ฉ์๋๋ฅผ ์ฌ์ฉํ์.
์ซ์ ์์๋ฅผ ์ ๋ ฌํ ๋๋ sort ๋ฉ์๋์ ์ ๋ ฌ ์์๋ฅผ ์ ์ํ๋ ๋น๊ต ํจ์๋ฅผ ์ธ์๋ก ์ ๋ฌํด์ผ ํ๋ค.
const points = [40,100,1,5,2,25,10];
// ์ซ์ ๋ฐฐ์ด์ ์ค๋ฆ์ฐจ์ ์ ๋ ฌ, ๋น๊ต ํจ์์ ๋ฐํ๊ฐ์ด 0๋ณด๋ค ์์ผ๋ฉด a๋ฅผ ์ฐ์ ํ์ฌ ์ ๋ ฌํ๋ค
points.sort((a,b) => a - b);
console.log(points); // [1,2,4,10,25,40,100]
// ์ซ์ ๋ฐฐ์ด์์ ์ต์/์ต๋๊ฐ ์ทจ๋
console.log(points[0], points[points.length - 1]); // 1, 100
// ์ซ์ ๋ฐฐ์ด์ ๋ด๋ฆผ์ฐจ์ ์ ๋ ฌ, ๋น๊ต ํจ์์ ๋ฐํ๊ฐ์ด 0๋ณด๋ค ์์ผ๋ฉด b๋ฅผ ์ฐ์ ํ์ฌ ์ ๋ ฌํ๋ค.
points.sort((a,b) => b - a);
console.log(points); // [100,40,24,10,5,2,1]
๊ฐ์ฒด๋ฅผ ์์๋ก ๊ฐ๋ ๋ฐฐ์ด์ ์ ๋ ฌํ๋ ์
const todos = [
{ id: 4, content: 'Javascript' },
{ id: 1, content: 'HTML' },
{ id: 2, content: 'CSS' }
];
// ๋น๊ต ํจ์, ๋งค๊ฐ๋ณ์ key๋ ํ๋กํผํฐ ํค๋ค.
function compare(key) {
// ํ๋กํผํฐ ๊ฐ์ด ๋ฌธ์์ด์ธ ๊ฒฝ์ฐ - ์ฐ์ ์ฐ์ฐ์ผ๋ก ๋น๊ตํ๋ฉด NaN์ด ๋์ค๋ฏ๋ก ๋น๊ต ์ฐ์ฐ์ ์ฌ์ฉํ๋ค.
// ๋น๊ต ํจ์๋ ์์/์์/0์ ๋ฐํํ๋ฉด ๋๋ฏ๋ก - ์ฐ์ ์ฐ์ฐ ๋์ ๋น๊ต ์ฐ์ฐ์ ์ฌ์ฉํ ์ ์๋ค)
return(a,b) => (a[key] > b[key] ? 1 : (a[key] < b[key] ? -1 : 0));
// id๋ฅผ ๊ธฐ์ค์ผ๋ก ์ค๋ฆ์ฐจ์ ์ ๋ ฌ
todos.sort(compare('id'));
// content๋ฅผ ๊ธฐ์ค์ผ๋ก ์ค๋ฆ์ฐจ์ ์ ๋ ฌ
todos.sort(compare('content');y
forEach ๋ฉ์๋๋ for ๋ฌธ์ ๋์ฒดํ ์ ์๋ ๊ณ ์ฐจ ํจ์๋ค.
const numbers = [1,2,3];
const pows = [];
// forEach ๋ฉ์๋๋ numbers ๋ฐฐ์ด์ ๋ชจ๋ ์์๋ฅผ ์ํํ๋ฉด์ ์ฝ๋ฐฑ ํจ์๋ฅผ ๋ฐ๋ณต ํธ์ถํ๋ค.
numbers.forEach(item => pows.push(item ** 2));
console.log(pows); // [1,4,9]
map ๋ฉ์๋๋ ์์ ์ ํธ์ถํ ๋ฐฐ์ด์ ๋ชจ๋ ์์๋ฅผ ์ํํ๋ฉด์ ์ธ์๋ก ์ ๋ฌ๋ฐ์ ์ฝ๋ฐฑ ํจ์๋ฅผ ๋ฐ๋ณต ํธ์ถํ๋ค. ๊ทธ๋ฆฌ๊ณ ์ฝ๋ฐฑ ํจ์์ ๋ฐํ๊ฐ๋ค๋ก ๊ตฌ์ฑ๋ ์๋ก์ด ๋ฐฐ์ด์ ๋ฐํ. ์๋ณธ ๋ฐฐ์ด์ ๋ณ๊ฒฝ๋์ง ์๋๋ค
const numbers = [1,4,9];
// map ๋ฉ์๋๋ numbers ๋ฐฐ์ด์ ๋ชจ๋ ์์๋ฅผ ์ํํ๋ฉด์ ์ฝ๋ฐฑ ํจ์๋ฅผ ๋ฐ๋ณต ํธ์ถํ๋ค.
// ๊ทธ๋ฆฌ๊ณ ์ฝ๋ฐฑ ํจ์์ ๋ฐํ๊ฐ๋ค๋ก ๊ตฌ์ฑ๋ ์๋ก์ด ๋ฐฐ์ด์ ๋ฐํํ๋ค.
const roots = numbers.map(item => Math.sqrt(item));
// ์ ์ฝ๋๋ ๋ค์๊ณผ ๊ฐ๋ค.
// const roots = numbers.map(Math.sqrt);
// map ๋ฉ์๋๋ ์๋ก์ด ๋ฐฐ์ด์ ๋ฐํํ๋ค.
console.log(roots); // [1,2,3]
// map ๋ฉ์๋๋ ์๋ณธ ๋ฐฐ์ด์ ๋ณ๊ฒฝํ์ง ์๋๋ค.
console.log(numbers); // [1,4,9]
forEach ๋ฉ์๋๋ ์ธ์ ๋ undefined๋ฅผ ๋ฐํํ๊ณ , map ๋ฉ์๋๋ ์ฝ๋ฐฑ ํจ์์ ๋ฐํ๊ฐ๋ค๋ก ๊ตฌ์ฑ๋ ์๋ก์ด ๋ฐฐ์ด์ ๋ฐํํ๋ ์ฐจ์ด๊ฐ ์๋ค.
forEach ๋ฉ์๋๋ ๋จ์ํ ๋ฐ๋ณต๋ฌธ์ ๋์ฒดํ๊ธฐ ์ํ ๊ณ ์ฐจ ํจ์์ด๊ณ , map ๋ฉ์๋๋ ์์๊ฐ์ ๋ค๋ฅธ ๊ฐ์ผ๋ก ๋งคํํ ์๋ก์ด ๋ฐฐ์ด์ ์์ฑํ๊ธฐ ์ํ ๊ณ ์ฐจ ํจ์๋ค.
map ๋งค์๋๊ฐ ์์ฑํ์ฌ ๋ฐํํ๋ ์๋ก์ด ๋ฐฐ์ด์ length ํ๋กํผํฐ ๊ฐ์ map ๋ฉ์๋๋ฅผ ํธ์ถํ ๋ฐฐ์ด์ length ํ๋กํผํฐ ๊ฐ๊ณผ ๋ฐ๋์ ์ผ์นํ๋ค. ์ฆ, map ๋ฉ์๋๋ฅผ ํธ์ถํ ๋ฐฐ์ด๊ณผ map ๋ฉ์๋๊ฐ ์์ฑํ์ฌ ๋ฐํํ ๋ฐฐ์ด์ 1:1 ๋งคํํ๋ค
filter ๋ฉ์๋๋ ์์ ์ ํธ์ถํ ๋ฐฐ์ด์ ๋ชจ๋ ์์๋ฅผ ์ํํ๋ฉด์ ์ธ์๋ก ์ ๋ฌ๋ฐ์ ์ฝ๋ฐฑ ํจ์๋ฅผ ๋ฐ๋ณต ํธ์ถํ๋ค. ๊ทธ๋ฆฌ๊ณ ์ฝ๋ฐฑ ํจ์์ ๋ฐํ๊ฐ์ด true์ธ ์์๋ก๋ง ๊ตฌ์ฑ๋ ์๋ก์ด ๋ฐฐ์ด์ ๋ฐํํ๋ค.
const numbers = [1,2,3,4,5];
// filter ๋ฉ์๋๋ numbers ๋ฐฐ์ด์ ๋ชจ๋ ์์๋ฅผ ์ํํ๋ฉด์ ์ฝ๋ฐฑ ํจ์๋ฅผ ๋ฐ๋ณต ํธ์ถํ๋ค.
// ๊ทธ๋ฆฌ๊ณ ์ฝ๋ฐฑ ํจ์์ ๋ฐํ๊ฐ์ด true์ธ ์์๋ก๋ง ๊ตฌ์ฑ๋ ์๋ก์ด ๋ฐฐ์ด์ ๋ฐํํ๋ค.
// ๋ค์์ ๊ฒฝ์ฐ numbers ๋ฐฐ์ด์์ ํ์์ธ ์์๋ง ํํฐ๋งํ๋ค.(1์ true๋ก ํ๊ฐ๋๋ค)
const odds = numbers.filter(item => item % 2);
console.log(odds); // [1,3,5]
reduce ๋ฉ์๋๋ ์์ ์ ํธ์ถํ ๋ฐฐ์ด์ ๋ชจ๋ ์์๋ฅผ ์ํํ๋ฉฐ ์ธ์๋ก ์ ๋ฌ๋ฐ์ ์ฝ๋ฐฑ ํจ์๋ฅผ ๋ฐ๋ณต ํธ์ถํ๋ค.๊ทธ๋ฆฌ๊ณ ์ฝ๋ฐฑ ํจ์์ ๋ฐํ๊ฐ์ ๋ค์ ์ํ ์์ ์ฝ๋ฐฑ ํจ์์ ์ฒซ ๋ฒ์จฐ ์ธ์๋ก ์ ๋ฌํ๋ฉด์ ์ฝ๋ฐฑ ํจ์๋ฅผ ํธ์ถํ์ฌ ํ๋์ ๊ฒฐ๊ณผ๊ฐ์ ๋ง๋ค์ด ๋ฐํํ๋ค. ์๋ณธ ๋ฐฐ์ด์ ๋ณ๊ฒฝ๋์ง ์๋๋ค.
reduce ๋ฉ์๋๋ ์ฒซ ๋ฒ์จฐ ์ธ์๋ก ์ฝ๋ฐฑ ํจ์, ๋ ๋ฒ์จฐ ์ธ์๋ก ์ด๊ธฐ๊ฐ์ ์ ๋ฌ๋ฐ๋๋ค. reduce ๋ฉ์๋์ ์ฝ๋ฐฑ ํจ์์ใด 4๊ฐ์ ์ธ์, ์ด๊ธฐ๊ฐ ๋๋ ์ฝ๋ฐฑ ํจ์์ ์ด์ ๋ฐํ๊ฐ, reduce ๋ฉ์๋๋ฅผ ํธ์ถํ ๋ฐฐ์ด์ ์์๊ฐ๊ณผ ์ธ๋ฑ์ค, reduce ๋ฉ์๋๋ฅผ ํธ์ถํ ๋ฐฐ์ด ์์ฒด, ์ฆ this๊ฐ ์ ๋ฌ
reduce ๋ฉ์๋๋ ํ๋์ ๊ฒฐ๊ณผ๊ฐ์ ๋ฐํํ๋ค.
ํ๊ท ๊ตฌํ๊ธฐ
const values = [1,2,3,4,5,6];
const average = values.reduce((acc, cur, i, { length }) => {
// ๋ง์ง๋ง ์ํ๊ฐ ์๋๋ฉด ๋์ ๊ฐ์ ๋ฐํํ๊ณ ๋ง์ง๋ง ์ํ๋ฉด ๋์ ๊ฐ์ผ๋ก ํ๊ท ์ ๊ตฌํด ๋ฐํํ๋ค.
return i === length - 1 ? (acc + cur) / length : acc + cur;
}, 0);
console.log(average); // 3.5
์ต๋๊ฐ ๊ตฌํ๊ธฐ
const values = [1,2,3,4,5];
const max = values.reduce((acc,cur) => (acc > cur ? acc : cur), 0);
console.log(max); // 5
์ต๋๊ฐ์ ๊ตฌํ ๋๋ reduce ๋ฉ์๋๋ณด๋ค Math.max ๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ ๋ฐฉ๋ฒ์ด ๋ ์ง๊ด์
const values = [1,2,3,4,5];
const max = Math.max(...values);
// var max = Math.max.apply(null, values);
console.log(max); // 5
์์์ ์ค๋ณต ํ์ ๊ตฌํ๊ธฐ
const fruits = ['banana', 'apple', 'orange', 'orange', 'apple'];
const count = fruits.reduce((acc, cur) => {
// ์ฒซ ๋ฒ์จฐ ์ํ ์ acc๋ ์ด๊ธฐ๊ฐ์ธ {}์ด๊ณ cur์ ์ฒซ ๋ฒ์งธ ์์์ธ 'banana'๋ค.
// ์ด๊ธฐ๊ฐ์ผ๋ก ์ ๋ฌ๋ฐ์ ๋น ๊ฐ์ฒด์ ์์๊ฐ์ธ cur์ ํ๋กํผํฐ ํค๋ก, ์์์ ๊ฐ์๋ฅผ ํ๋กํผํฐ ๊ฐ์ผ๋ก ํ ๋นํ๋ค.
// ๋ง์ฝ ํ๋กํผํฐ ๊ฐ์ด undefined์ด๋ฉด ํ๋กํผํฐ ๊ฐ์ 1๋ก ์ด๊ธฐํํ๋ค
acc[cur] = (acc[cur] || 0) + 1;
return acc;
}, {});
// ์ฝ๋ฐฑ ํจ์๋ ์ด 5๋ฒ ํธ์ถ๋๊ณ ๋ค์๊ณผ ๊ฐ์ด ๊ฒฐ๊ณผ๊ฐ์ ๋ฐํํ๋ค.
console.log(count); { banana: 1, apple: 2, orange: 2}
์ค์ฒฉ ๋ฐฐ์ด ํํํ
const values = [1, [2,3],4,[5,6]];
const flatten = values.reduce((acc, cur) => acc.concat(cur), []);
console.log(flatten); [1,2,3,4,5,6]
flat ๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ ๋ฐฉ๋ฒ์ด ๋ ์ง๊ด์ ์ด๋ค.
์ค๋ณต ์์ ์ ๊ฑฐ
const values = [1,2,1,3,5,4,5,3,4,4,];
const result = values.reduce(
(unique, val, i, _values) =>
// ํ์ฌ ์ํ ์ค์ธ ์์์ ์ธ๋ฑ์ค i๊ฐ val์ ์ธ๋ฐ๊ธ์ ๊ฐ๋ค๋ฉด val์ ์ฒ์ ์ํํ๋ ์์๋ค.
// ํ์ฌ ์ํ ์ค์ธ ์์์ ์ธ๋ฑ์ค i๊ฐ val์ ์ธ๋ฑ์ค์ ๋ค๋ฅด๋ค๋ฉด val์ ์ค๋ณต๋ ์์๋ค.
// ์ฒ์ ์ํํ๋ ์์๋ง ์ด๊ธฐ๊ฐ []๊ฐ ์ ๋ฌ๋ unique ๋ฐฐ์ด์ ๋ด์ ๋ฐํํ๋ฉด ์ค๋ณต๋ ์์๋ ์ ๊ฑฐ๋๋ค.
_values.indexOf(val) === i ? [...unique, val] : unique,
[]
);
console.log(result); // [1,2,3,5,4]
reduce๋ณด๋ค filter ๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ ๋ฐฉ๋ฒ์ด ๋ ์ง๊ด์
์ค๋ณต๋์ง ์๋ ์ ์ผํ ๊ฐ๋ค์ ์งํฉ์ธ Set
์ ์ฌ์ฉํ ์๋ ์๋ค ์ด ๋ฐฉ๋ฒ ์ถ์ฒ
reduce ๋ฉ์๋๋ฅผ ํธ์ถํ ๋๋ ์ธ์ ๋ ์ด๊ธฐ๊ฐ์ ์ ๋ฌํ๋ ๊ฒ์ด ์์ ํ๋ค.
some ๋ฉ์๋๋ ์์ ์ ํธ์ถํ ๋ฐฐ์ด์ ์์๋ฅผ ์ํํ๋ฉด์ ์ธ์๋ก ์ ๋ฌ๋ ์ฝ๋ฐฑ ํจ์๋ฅผ ํธ์ถํ๋ค. some ๋ฉ์๋๋ ์ฝ๋ฐฑ ํจ์์ ๋ฐํ๊ฐ์ด ๋จ ํ ๋ฒ์ด๋ผ๋ ์ฐธ์ด๋ฉด true, ๋ชจ๋ ๊ฑฐ์ง์ด๋ฉด false๋ฅผ ๋ฐํ
some ๋ฉ์๋๋ฅผ ํธ์ถํ ๋ฐฐ์ด์ด ๋น ๋ฐฐ์ด์ธ ๊ฒฝ์ฐ ์ธ์ ๋ false๋ฅผ ๋ฐํํ๋ฏ๋ก ์ฃผ์!
// ๋ฐฐ์ด์ ์์ ์ค 10๋ณด๋ค ํฐ ์์๊ฐ 1๊ฐ ์ด์ ์กด์ฌํ๋์ง ํ์ธ
[5,10,15].some(item => item > 10); // true
// ๋ฐฐ์ด์ ์์ ์ค 0๋ณด๋ค ์์ ์์๊ฐ 1๊ฐ ์ด์ ์กด์ฌํ๋์ง ํ์ธ
[5,10,15].some(item => item < 0); // false
// ๋ฐฐ์ด์ ์์ ์ค 'banana'๊ฐ 1๊ฐ ์ด์ ์กด์ฌํ๋์ง ํ์ธ
['apple', 'banana', 'mango'].some(item => item === 'banana'); // true
// some ๋ฉ์๋๋ฅผ ํธ์ถํ ๋ฐฐ์ด์ด ๋น ๋ฐฐ์ด์ธ ๊ฒฝ์ฐ ์ธ์ ๋ false
[].some(item => item > 3); // false
every ๋ฉ์๋๋ ์์ ์ ํธ์ถํ ๋ฐฐ์ด์ ์์๋ฅผ ์ํํ๋ฉด์ ์ธ์๋ก ์ ๋ฌ๋ ์ฝ๋ฐฑ ํจ์๋ฅผ ํธ์ถ. every ๋ฉ์๋๋ ์ฝ๋ฐฑ ํจ์์ ๋ฐํ๊ฐ์ด ๋ชจ๋ ์ฐธ์ด๋ฉด true, ๋จ ํ ๋ฒ์ด๋ผ๋ ๊ฑฐ์ง์ด๋ฉด false๋ฅผ ๋ฐํ
๋น ๋ฐฐ์ด์ธ ๊ฒฝ์ฐ ์ธ์ ๋ true๋ฅผ ๋ฐํ!
// ๋ฐฐ์ด์ ๋ชจ๋ ์์๊ฐ 3๋ณด๋ค ํฐ์ง ํ์ธ
[5,10,15].every(item => item > 3); // true
// ๋ฐฐ์ด์ ๋ชจ๋ ์์๊ฐ 10๋ณด๋ค ํฐ์ง ํ์ธ
[5,10,15].every(item => item > 10); // false
// every ๋ฉ์๋๋ฅผ ํธ์ถํ ๋ฐฐ์ด์ด ๋น ๋ฐฐ์ด์ธ ๊ฒฝ์ฐ ์ธ์ ๋ true
[].every(item => item > 3); // true
ES6์์ ๋์ ๋ find ๋ฉ์๋๋ ์์ ์ ํธ์ถํ ๋ฐฐ์ด์ ์์๋ฅผ ์ํํ๋ฉด์ ์ธ์๋ก ์ ๋ฌ๋ ์ฝ๋ฐฑ ํจ์๋ฅผ ํธ์ถํ์ฌ ๋ฐํ๊ฐ์ด true์ธ ์ฒซ ๋ฒ์จฐ ์์๋ฅผ ๋ฐํ. true์ธ ์์๊ฐ ์กด์ฌํ์ง ์๋๋ค๋ฉด undefined๋ฅผ ๋ฐํ
const users = [
{ id: 1, name : 'Lee'},
{ id: 2, name : 'Kim'},
{ id: 3, name : 'Choi'},
{ id: 4, name : 'Park'}
];
// id๊ฐ 2์ธ ์ฒซ ๋ฒ์จฐ ์์๋ฅผ ๋ฐํํใท. find ๋ฉ์๋๋ ๋ฐฐ์ด์ด ์๋๋ผ ์์๋ฅผ ๋ฐํํ๋ค.
users.find(user => user.id === 2); {id: 2, name: 'Kim'}
ES6์์ ๋์
๋ findIndex ๋ฉ์๋๋ ์์ ์ ํธ์ถํ ๋ฐฐ์ด์ ์์๋ฅผ ์ํํ๋ฉด์ ์ธ์๋ก ์ ๋ฌ๋ ์ฝ๋ฐฑ ํจ์๋ฅผ ํธ์ถ๋์ฌ ๋ฐํ๊ฐ์ฑ true์ธ ์ฒซ ๋ฒ์จฐ ์์์ ์ธ๋ฑ์ค๋ฅผ ๋ฐํํ๋ค.
์ฝ๋ฐฑ ํจ์์ ๋ฐํ๊ฐ์ด true์ธ ์์๊ฐ ์กด์ฌํ์ง ์๋๋ค๋ฉด -1์ ๋ฐํ
const users = [
{ id: 1, name : 'Lee'},
{ id: 2, name : 'Kim'},
{ id: 3, name : 'Choi'},
{ id: 4, name : 'Park'}
];
// id๊ฐ 2์ธ ์์์ ์ธ๋ฑ์ค๋ฅผ ๊ตฌํ๋ค.
users.findIndex(user => user.id === 2); // 1
// name์ด 'Park'์ธ ์์์ ์ธ๋ฑ์ค๋ฅผ ๊ตฌํ๋ค.
users.findIndex(user => user.name === 'Park'); // 3
// ์์ ๊ฐ์ด ํ๋กํผํฐ ํค์ ํ๋กํผํฐ ๊ฐ์ผ๋ก ์์์ ์ธ๋ฑ์ค๋ฅผ ๊ตฌํ๋ ๊ฒฝ์ฐ ๋ค์๊ณผ ๊ฐ์ด ์ฝ๋ฐฑ ํจ์๋ฅผ ์ถ์ํํ ์ ์๋ค.
function predicate(key, value) {
// key์ value๋ฅผ ๊ธฐ์ตํ๋ ํด๋ก์ ๋ฅผ ๋ฐํ
return item => item[key] === value;
}
// id๊ฐ 2์ธ ์์์ ์ธ๋ฑ์ค๋ฅผ ๊ตฌํ๋ค.
users.finedIndex(predicate('id', 2)); // 1
// name์ด 'Park'์ธ ์์์ ์ธ๋ฑ์ค๋ฅผ ๊ตฌํ๋ค.
users.findIndeX(predicate('name', 'Park')); // 3
ES10์์ ๋์
๋ flatMap ๋ฉ์๋๋ map ๋ฉ์๋๋ฅผ ํตํด ์์ฑ๋ ์๋ก์ด ๋ฐฐ์ด์ ํํํํ๋ค. ์ฆ, map ๋ฉ์๋์ flat ๋ฉ์๋๋ฅผ ์์ฐจ์ ์ผ๋ก ์คํํ๋ ํจ๊ณผ
const arr = ['hello', 'world'];
// map๊ณผ flat์ ์์ฐจ์ ์ผ๋ก ์คํ
arr.map(x => x.split('')).flat();
// ['h', 'e','l','l','o','w','o','r','l','d']
// flatMap์ map์ ํตํด ์์ฑ๋ ์๋ก์ด ๋ฐฐ์ด์ ํํํ
arr.flatMap(x => x.split(''));
// ['h', 'e','l','l','o','w','o','r','l','d']
flatMap ๋ฉ์๋๋ flat ๋ฉ์๋์ฒ๋ผ ์ธ์๋ฅผ ์ ๋ฌํ์ฌ ํํํ ๊น์ด๋ฅผ ์ง์ ํ ์๋ ์๊ณ 1๋จ๊ณ๋ง ํํํํ๋ค.