find() ๋ฉ์๋๋ ์ฃผ์ด์ง ํ๋ณ ํจ์๋ฅผ ๋ง์กฑํ๋ ์ฒซ ๋ฒ์งธ ์์์ ๊ฐ์ ๋ฆฌํดํฉ๋๋ค. ๋ง์ฝ ์์ผ๋ฉด undefined๋ฅผ ๋ฆฌํดํฉ๋๋ค.
๊ฐ๋จํ๊ฒ ์ฝ๋๋ก ํ์ธํฉ๋๋ค.
const array1 = [5, 12, 8, 130, 44];
const found = array1.find(element => element > 10);
console.log(found);
๊ฒฐ๊ณผ ๊ฐ: 12
ํ๋ณํจ์๊ฐ ์์๊ฐ 10๋ณด๋ค ํฐ ๊ฐ์ ๋ฐํํ๊ณ ์์ง๋ง find ๋ฉ์๋๋ ์ฒซ ๋ฒ์งธ ์์๋ง์ ๋ฐํํ๊ธฐ ๋๋ฌธ์ 12๋ง ๋ฐํ๋ ๊ฒ์ ํ์ธํ ์ ์์ต๋๋ค.
findIndex() ๋ฉ์๋๋ ์ฃผ์ด์ง ํ๋ณ ํจ์๋ฅผ ๋ง์กฑํ๋ ๋ฐฐ์ด์ ์ฒซ ๋ฒ์งธ ์์์ ๋ํ ์ธ๋ฑ์ค๋ฅผ ๋ฐํํฉ๋๋ค. ๊ทธ๋ ์ง ์๋ค๋ฉด -1๋ฅผ ๋ฐํํฉ๋๋ค.
์ธ๋ฑ์ค๋ฅผ ๋ฐํํ๋ค๋ ๊ฒ์ ํ๋ณ ํจ์์ ๋ง์กฑํ๋ ์ฒซ ๋ฒ์งธ ๊ฐ์ '์์'๋ฅผ ๋ฐํํ๋ค๊ณ ๋ณผ ์ ์์ต๋๋ค.
const array1 = [5, 12, 8, 130, 44];
const isLargeNumber = (element) => element > 13;
console.log(array1.findIndex(isLargeNumber));
๋ค์๊ณผ ๊ฐ์ ์ฝ๋๊ฐ ์์ต๋๋ค. ๋ฐฐ์ด์์ ํ๋ณ ํจ์ isLargeNumber์ ํด๋นํ๋ ์ฒซ ๋ฒ์งธ ์์๊ฐ 130์ ๋๋ค. 130์ index๋ 3์ด๊ธฐ ๋๋ฌธ์ ์ด ์ฝ๋์ ์ฝ์๋ก๊ทธ์๋ '3'์ด ์ถ๋ ฅ๋ ๊ฒ ์ ๋๋ค.
flat() ๋ฉ์๋๋ ๋ชจ๋ ํ์ ๋ฐฐ์ด ์์๋ฅผ ์ง์ ํ ๊น์ด๊น์ง ์ฌ๊ท์ ์ผ๋ก ์ด์ด๋ถ์ธ ์๋ก์ด ๋ฐฐ์ด์ ์์ฑํฉ๋๋ค. ๊น์ด์ default๋ 1์ด๋ฉฐ ๋ฐ๋ก ์ง์ ์ด ๊ฐ๋ฅํฉ๋๋ค.
์ค์ฒฉ ๋ฐฐ์ด ํํํ
const arr1 = [1, 2, [3, 4]];
arr1.flat();
// [1, 2, 3, 4]
const arr2 = [1, 2, [3, 4, [5, 6]]];
arr2.flat();
// [1, 2, 3, 4, [5, 6]]
const arr3 = [1, 2, [3, 4, [5, 6]]];
arr3.flat(2);
// [1, 2, 3, 4, 5, 6]
const arr4 = [1, 2, [3, 4, [5, 6, [7, 8, [9, 10]]]]];
arr4.flat(Infinity);
// [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
๋ฐฐ์ด.flat(๊น์ด ์ง์ )์ ํํ์ด๋ฉฐ ์ง์ ํ ๊น์ด์ ๋ฐ๋ผ ํ์ ๋ฐฐ์ด๋ถํฐ ์ฐจ๋ก๋ก ์ด์ด๋ถํ๊ฒ ๋ฉ๋๋ค. ๋ํ flat์ ๋น์ด์๋ ๋ฐฐ์ด์ ๊ตฌ๋ฉ๋ ์ ๊ฑฐํ๊ฒ ๋ฉ๋๋ค.
flatMap()์ ๊ฐ ์์์ ๋ํด map ์ํ ํ, ๊ฒฐ๊ณผ๋ฅผ ์๋ก์ด ๋ฐฐ์ด๋ก ํํํํฉ๋๋ค. ์ค๋ช ์ด ์ด๋ ค์ ์์ ๋ฅผ ๋ณด๋ฉฐ ํ์ธํฉ๋๋ค.
Map๊ณผ flatMap์ ์ฐจ์ด
let arr1 = [1, 2, 3, 4];
arr1.map(x => [x * 2]);
// [[2], [4], [6], [8]]
arr1.flatMap(x => [x * 2]);
// [2, 4, 6, 8]
// ํ ๋ ๋ฒจ๋ง ํํํ๋จ
arr1.flatMap(x => [[x * 2]]);
// [[2], [4], [6], [8]]
flatMap์ด ๋ช ๋ ๋ฒจ๋ก ํํํ๋ฅผ ํ ์ง์ ๋ฐ๋ผ ๋ฐฐ์ด์ ๋ถ๋ฆฌ๊ฐ ๋ฌ๋ผ์ง ๊ฒ์ ๋ณผ ์ ์์ต๋๋ค.
let arr1 = ["it's Sunny in", "", "California"];
arr1.map(x=>x.split(" "));
// [["it's","Sunny","in"],[""],["California"]]
arr1.flatMap(x => x.split(" "));
// ["it's","Sunny","in","California"]
map() ๋ฉ์๋์ flatMap()๋ฉ์๋์ ์ฐจ์ด๋ฅผ ๋ณผ ์ ์์ต๋๋ค. map์ ํํํ๊ฐ ์ด๋ฃจ์ด ์ง์ง ์๊ณ ๊ณต๋ฐฑ๋ ๋ฐฐ์ด ์์์ค ํ๋๋ก ๊ปด ์์ง๋ง flatMap()์ ํ ๋ฐฐ์ด๋ก ํํํ๊ฐ ์ด๋ฃจ์ด์ ธ ์๋ ๊ฒ์ ํ์ธํ ์ ์์ต๋๋ค.
forEach()๋ฉ์๋๋ ์ฃผ์ด์ง ํจ์๋ฅผ ๋ฐฐ์ด ์์ ๊ฐ๊ฐ์ ๋ํด ์คํํฉ๋๋ค. ๋ฐฐ์ด ์์ ๊ฐ ๊ฐ๊ฐ์ ๋ชจ๋ ๊ฐ์ ๋ฐ๋ก ๋ฐ๋ก ์คํํ๊ฒ ๋ฉ๋๋ค.
const array1 = ['b', 'y', 'e'];
array1.forEach(element => console.log(element));
// expected output: "b"
// expected output: "y"
// expected output: "e"
array1์ ์์๋ค์ด ๊ฐ๊ฐ ๋ฐ๋ก ์ถ๋ ฅ์ด ๋ ๊ฒ์ ํ์ธํ ์ ์์ต๋๋ค.
forEach๋ ๋ฐฐ์ด์ ๋ณํํ์ง ์์ง๋ง ์ฝ๋ฐฑํจ์๊ฐ ๋ณํํ ์๋ ์์ต๋๋ค. forEach๋ ์ฝ๋ฐฑํจ์๋ฅผ ์ค๋ฆ์ฐจ์์ผ๋ก ํ ๋ฒ์ฉ ์คํํ๋ฉฐ ์ญ์ ํ๊ฑฐ๋ ์ด๊ธฐํํ์ง ์์ ์ธ๋ฑ์ค ์์ฑ์ ๋ํด์๋ ์คํํ์ง ์์ต๋๋ค.
const arraySparse = [1,3,,7]
let numCallbackRuns = 0
arraySparse.forEach(function(element){
console.log(element)
numCallbackRuns++
})
console.log("numCallbackRuns: ", numCallbackRuns)
// 1
// 3
// 7
// numCallbackRuns: 3
// 3๊ณผ 9 ์ฌ์ด์ ์๋ ๋ฐฐ์ด์ forEach๊ฐ ์๋ตํ๋ ๊ฒ์ ๋ณผ ์ ์์ต๋๋ค.
ํจ์๋ฅผ ์ดํด๋ณด๋ฉด forEach๊ฐ ๋ฐฐ์ด์ ์ํํ๋ฉฐ ๊ฐ๊ฐ์ ๊ฐ์ ์ถ๋ ฅํ๊ณ ์ํํ ๋๋ง๋ค numCallbackRuns๊ฐ 1์ฉ ์์นํฉ๋๋ค. ํ์ง๋ง ๋ง์ง๋ง์ ์ถ๋ ฅ๋๋ ๊ฐ์ด 3์ธ๊ฒ์ ํ์ธํ์ฌ ๋น์ด์๋ ๋ฐฐ์ด์ forEach๊ฐ ์๋ต์ ํ๊ณ ์ํํ๋ ๊ฒ์ ์ดํด๋ณผ ์ ์์ต๋๋ค.
์ฐ๋ฆฌ๋ ์ด forEach๋ฅผ ์ฌ์ฉํ์ฌ ๋ฐฐ์ด์ ์ํํ ๋ for๋ฌธ ๋์ ๊ฐํธํ๊ฒ forEach๋ฌธ์ผ๋ก ๋์ ํ ์ ์์ ๊ฒ ์ ๋๋ค.
const items = ['item1', 'item2', 'item3'];
const copy = [];
// ์ด์
for (let i=0; i<items.length; i++) {
copy.push(items[i]);
}
// ์ดํ
items.forEach(function(item){
copy.push(item);
});
๊ฐ๋จํ๊ฒ ์ฝ๋ฐฑํจ์๋ก item๋ค์ ๊ฐ๊ฐ copy๋ฐฐ์ด์ ํธ์ฌํ ์ ์์ต๋๋ค.
includes() ๋ฉ์๋๋ ๋ฐฐ์ด์ด ํน์ ์์๋ฅผ ํฌํจํ๊ณ ์๋์ง ํ๋ณํฉ๋๋ค.
const array1 = [1, 2, 3];
console.log(array1.includes(2));
// expected output: true
const pets = ['cat', 'dog', 'bat'];
console.log(pets.includes('cat'));
// expected output: true
console.log(pets.includes('at'));
// expected output: false
includeํจ์์ ๋งค๊ฐ๋ณ์๋ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
arr.includes(valueToFind[, fromIndex])
valueToFind๋ ํ์ํ ์์์ด๊ณ fromIndex๋ ์ด๋์ ๋ถํฐ ๊ฒ์์ ์์ํ ์ง ์ ํ๋ ๋งค๊ฐ๋ณ์ ์ ๋๋ค. ๋ง์ฝ fromIndex๊ฐ ์์์ด๋ฉด ์ ์ฒด ๊ฒ์์ ์์ํ๊ฒ ๋ฉ๋๋ค. fromIndex๊ฐ ๋ฐฐ์ด์ ํฌ๊ธฐ๋ณด๋ค ํฌ๋ฉด false๋ฅผ ๋ฐํํ๊ฒ ๋ฉ๋๋ค. ์์ ๋ฅผ ๋ด ๋๋ค.
[1, 2, 3].includes(2); // true
[1, 2, 3].includes(4); // false
[1, 2, 3].includes(3, 3); // false
[1, 2, 3].includes(3, -1); // true
[1, 2, NaN].includes(NaN); // true
3๋ฒ๊ณผ 4๋ฒ์ ๋ณด๋ฉด 3๋ฒ์ 3์ ๋ฐฐ์ด์์ ํฌํจ๋์ด ์์ง๋ง fromIndex๊ฐ 3์ด๋ฏ๋ก ๋ฐฐ์ด์ ํฌ๊ธฐ๋ณด๋ค ํฌ๋ฏ๋ก false๊ฐ ๋ฆฌํด๋๊ณ 4๋ฒ์ fromIndex๊ฐ -1์ด๊ธฐ ๋๋ฌธ์ ์ ์ญ ๊ฒ์์ ํ๊ฒ ๋์ด 3์ ์ฐพ์ true๊ฐ ๋ฆฌํด๋ ๊ฒ์ ๋ณผ ์ ์์ต๋๋ค.