์ค๋๋ถํฐ ๋ค์ ์์ฑํด๋ณด๋ TIL~๐ฅ
์ด์ฌ์ผ๋ก ๋์๊ฐ ๋ชจ๋ ์ฒ์์ด๋ ๋ง์๊ฐ์ง์ผ๋ก ๋ค์ ์์ํด ^_^
โ๏ธ ์ค๋ ๋ฐฐ์ด ๊ฒ
์ฌ๊ท ํจ์๋?
์ฌ๊ท ํจ์์ ๋ํด ๋ฐฐ์ ๋ค!
์ํ ์๊ฐ์๋ ์์ฃผ ๋ฃ๋ ๋จ์ด ‘์ฌ๊ท’… ์ ๋๋ก ์๊ณ ์ถ์ง ์์์ ๋ ๋ ๊ฐ๊ณ ๊ท ๋ง๊ณ ๋ฌด์ํ๋ ๋จ์ด์๋๋ฐ ใ ใ ใ ์๊ณ ๋ฆฌ์ฆ ๊ณต๋ถ๋ฅผ ์ํด ์ค๋ ๋๋์ด ๊ทธ ๋๊ณผ ๊ท๋ฅผ ์คํํ๋ค..
์ฌ๊ท๋? ์๋์ ์๋ฆฌ๋ก ๋๋์๊ฐ๊ฑฐ๋ ๋๋์์ค๋ ๊ฒ์ผ๋ก, ํ๋ก๊ทธ๋๋ฐ์์๋ ํจ์ ๋ด๋ถ์์ ๋ณธ์ธ์ ๋ค์ ํธ์ถํ๋ ๋ฐฉ๋ฒ์ผ๋ก ์ฌ๊ท๋ฅผ ์ฌ์ฉํ๋ค.
๊ฒฐ๊ตญ ๊ณ์ํด์ ์๊ธฐ ์์ ์ ํธ์ถํ๋ ํจ์๊ฐ ์ฌ๊ท ํจ์์ด๋ค!
์ฌ๊ท๋ก ๋ฌธ์ ํด๊ฒฐํ๋ ์์
- ๋ฌธ์ ๋ฅผ ์๊ฒ ์ชผ๊ฐ๊ธฐ
- ๋ฌธ์ ๋ฅผ ๊ฐ์ฅ ์์ ๋จ์๋ก ์ชผ๊ฐ๊ธฐ
- ๋ฌธ์ ํด๊ฒฐํ๊ธฐ
์๋ฅผ ๋ค์ด, ์ ๋ ฅ ๋ฐ์ ์ซ์ num๋ถํฐ 1๊น์ง์ ์ซ์๋ฅผ ๋ชจ๋ ํฉํ๋ ํจ์ sumTo(num)์ ์์ฑํ๋ค๋ฉด!
์ฒซ์งธ๋ก,
sumTo(5) === 5 + 4 + 3 + 2 + 1 === 5 + sumTo(4)
sumTo(4) === 4 + 3 + 2 + 1 === 4 + sumTo(3)
sumTo(3) === 3 + 2 + 1 === 3 + sumTo(2)
sumTo(2) === 2 + 1 === 2 + sumTo(1);
sumTo(1) === 1
sumTo(num)์ ์์ ๊ฐ์ ๋จ์์ ํน์ฑ์ ๊ฐ๊ฒ ๋๋ค.
๋์งธ๋ก, ์ ๋ฌธ์ ๋ฅผ ๊ฐ์ฅ ์์ ๋จ์๋ก ์ชผ๊ฐ๊ฒ ๋๋ค๋ฉด, sumTo(1) === 1์ด ๋๋ค.
์ ์งธ๋ก, ์ด๊ฒ์ ํด๊ฒฐํด ์ฝ๋๋ก ๋ณํํด์ฃผ๋ฉด
function sumTo(num) {
// num์ด 1์ดํ์ผ ๋ num์ ๋ฆฌํด (num์ด 0์ผ ๊ฒฝ์ฐ๋ฅผ ๋๋น)
if (num <= 1) return num;
// num + ๋๋จธ์ง ๊ฐ์ ๋ํ๋ sumTo ํจ์
return num + sumTo(num-1);
}
์์ ๊ฐ์ ์ฌ๊ท ํจ์๋ฅผ ๋ง๋ค์ด๋ผ ์ ์๋ค.
๊ทธ๋ ๋ค๋ฉด ์ฌ๊ท ํจ์๋ ์ธ์ ์ฐ๋์?
- ์ฃผ์ด์ง ๋ฌธ์ ๋ฅผ ๋น์ทํ ๊ตฌ์กฐ์ ๋ ์์ ๋ฌธ์ ๋ก ๋๋ ์ ์์ ๋
- ์ค์ฒฉ๋ ๋ฐ๋ณต๋ฌธ์ด ๋ง๊ฑฐ๋ ๋ฐ๋ณต๋ฌธ์ ์ค์ฒฉ ํ์๋ฅผ ์์ธกํ๊ธฐ ์ด๋ ค์ธ ๋
- ๋ฐ๋ณต๋ฌธ์ผ๋ก ์์ฑ๋ ์ฝ๋๋ฅผ ๋ ๊ฐ๊ฒฐํ๊ณ ์ดํดํ๊ธฐ ์ฝ๊ฒ ์์ฑํ ๋
์ฌ์ฉํ ์ ์๋ค!
์ฌ๊ท์ ์ผ๋ก ์ฌ๊ณ ํ๋ ๋ฐฉ๋ฒ
- ์ ๋ ฅ๊ฐ๊ณผ ์ถ๋ ฅ๊ฐ์ ์ ํ๊ธฐ
- ๋ฌธ์ ๋ฅผ ์ชผ๊ฐ๊ณ ๊ฒฝ์ฐ์ ์ ๋๋๊ธฐ
- base case ์๊ฐํ๊ธฐ
- recursive case ์๊ฐํ๊ธฐ
- ์ฝ๋ ๊ตฌํํ๊ธฐ
๐ ์๋กญ๊ฒ ์๊ฒ ๋ ๊ฒ
๊ตฌ์กฐ ๋ถํด ํ ๋น๊ณผ ์คํ๋ ๋ ๋ฌธ๋ฒ์ ํ์ฉ
const arr = [1, 2, 3, 4];
๋ผ๋ ๋ฐฐ์ด์ด ์กด์ฌํ๋ค๋ฉด,
const [head, ...tail] = arr;
// ์ฐธ๊ณ ๋ก [...head, tail]๊ณผ ๊ฐ์ ํํ๋ก๋ ์ฌ์ฉ์ด ๋ถ๊ฐ๋ฅํ๋ค๊ณ ํ๋ค.
๋ฅผ ์ ์ธํ ๊ฒฝ์ฐ,
head // arr[0] === 1
tail // arr.slice(1) === [2, 3, 4]
์ด๋ค!
Array.prototype.flat();
์ฝํ๋ฆฟ 15๋ฒ ๋ฌธ์ ๋ก, ์ ๋ ฅ๋ฐ์ ๋ค์ฐจ์ ๋ฐฐ์ด์ ๋ชจ๋ ์์๋ฅผ 1์ฐจ์ ๋ฐฐ์ด์ ์์๋ก ๋ง๋ค์ด์ฃผ๋ ๊ฒ์ ์ฌ๊ท ํจ์๋ก ๋ง๋๋ ๋ฌธ์ ๊ฐ ์์๋ค.
์ค๋์ ๋ฌด์กฐ๊ฑด ์ฌ๊ท ํจ์๋ฅผ ์ด์ฉํด์ ๋ค์ฐจ์ ๋ฐฐ์ด์ 1์ฐจ์ ๋ฐฐ์ด๋ก ๋ฐ๊ฟ์ฃผ์ด์ผ ํ์ง๋ง, ์ฌ์ค JS ๋ด์ฅํจ์์ธ flat()์ ์ฌ์ฉํด์ฃผ๋ฉด ์์ฃผ ์ฌ์์ง๋ค.. flat()์ ์ค์ฒฉ ๋ฐฐ์ด์ ํํํ ํด์ฃผ๊ณ , ๋ฐฐ์ด์ ๊ตฌ๋ฉ๊น์ง ์ ๊ฑฐํด์ค๋ค! ๊ฐ ๋ฉ์๋
const arr = [1, 2, [3, 4, [5, 6]]];
// arr.flat([depth]] depth ๊น์ด๋งํผ ํํํํด์ฃผ๊ณ ๊ธฐ๋ณธ๊ฐ์ 1์ด๋ค.
arr.flat(); // [1, 2, 3, 4, [5, 6]]
arr.flat(1); // [1, 2, 3, 4, [5, 6]]
arr.flat(2); // [1, 2, 3, 4, 5, 6]
arr.flat(Infinity); // [1, 2, 3, 4, 5, 6]
const arr2 = [1, 2, 3, ,4];
arr2.flat(); // [1, 2, 3, 4]
๐ ์ด๋ ค์ ๋ ๊ฒ
์ผ์ฐจ์์ ์ธ ์ฌ๊ณ ๋ฅผ ์๊ตฌํ๋ ๊ฒ๋ค..
์๋ฅผ ๋ค๋ฉด ํผ๋ณด๋์น ์์ด์ด๋ผ๋๊ฐ, ๋ชจ๋ ์์์ ํฉ ๊ตฌํ๊ธฐ ๋ฑ๋ฑ.. ๋ค์ฐจ์์ ๋ฐฐ์ด์ ์ฌ์ฉํ์ง ์๋ ๊ฐ์ฒด๋ค์ ์ ๊ทผํ๊ธฐ๊ฐ ์ฌ์ ์ง๋ง
๋ฌธ์ ํ๋ฐ์ ๊ฐ์ฒด ์์ ๊ฐ์ฒด, ๋ค์ฐจ์ ๋ฐฐ์ด ๋ฑ์ ํ์ฉํ๋ ๋ฌธ์ ๋ฅผ ๋ณด๋ ์ฝ์ง ์์๋ค..ใ ใ
์ฌ๊ท ํจ์ ๋ด๋ถ์์๋ for๋ฌธ์ ์ฌ์ฉํด์ผ ํ๊ณ , ๊ทธ ์์์ ๋ ๋ฆฌํด ์กฐ๊ฑด์ ์ ๋๋ก ๊ฑธ์ด์ฃผ์ด์ผ ์ํ๋ ๊ฐ์ ๋ฐํ๋ฐ์ ์ ์๋ ๊ฒ์ด ๋๋ฌด๋๋ฌด ์ด๋ ค์ ๋ค..
โจ ๋๋์
์ฌ๊ท ํจ์๋ฅผ ์ง์ ๋ง๋ค์ด๋ณด๋ฉด์ ๋๋ ๊ฒ์ base case๋ฅผ ์ ์ค์ ํด์ค์ผ ํ๋ ๊ฒ ๊ฐ๋ค๋ ๊ฒ์ด๋ค.
base case๋ ๊ฒฐ๊ตญ ์ฌ๊ท ํจ์๋ฅผ ํ์ถํ๊ธฐ ์ํ ์กฐ๊ฑด๋ฌธ์ด๊ธฐ ๋๋ฌธ์ ํ์ถ ์กฐ๊ฑด์ด ์ ๋๋ก ์์ฑ๋์ง ์์ผ๋ฉด ๋ฌดํ ๋ฃจํ์ ๋น ์ง ์๋ ์๊ณ … ๊ธฐ๋๊ฐ๊ณผ ๋ค๋ฅธ ๊ฐ์ด ๋์ค๋ ๊ฒฝ์ฐ๋ ์๊ณ …
๋ฌผ๋ก recursive case๋ ์ ์์ฑํด์ฃผ์ด์ผ ํ์ง๋ง, ํ์ด๋๊ณผ ๋ฌธ์ ๋ฅผ ํ์ด๋ณด๊ณ ๋ ์๊ฐ์ผ๋ก๋ base case์ ์ค์ ์ด ์ข ๋ ์ค์ํด๋ณด์๋ค!
๊ทธ๋ฆฌ๊ณ ๋ค์ฐจ์์ผ๋ก ๋ค์ด๊ฐ๋ ์๊ฐ ๋จธ๋ฆฌ๊ฐ ๋ง์ ์๋ค์ด์.. ์ค๋ ํ์๋ ๋ฌธ์ ๋ฅผ ๋ค์ ํ์ด๋ณด๋ ๊ฒ๋ ์ค์ํ ๊ฒ ๊ฐ๋ค ๐
'๐ถ FE 41๊ธฐ > Daily' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
๐ฐ [221024 TIL] For the users, by the users, of the usersโฆ (0) | 2022.10.24 |
---|---|
๐ฐ [221021 TIL] DOMํฉ์ฑ ~!! (0) | 2022.10.21 |
๐ฐ [SEB FE 41๊ธฐ] ํ๋ฃจ ์ผ๊ธฐ - 22.09.30 (0) | 2022.09.30 |
๐ฐ [SEB FE 41๊ธฐ] ํ๋ฃจ ์ผ๊ธฐ - 22.09.29 (0) | 2022.09.29 |
๐ฐ [SEB FE 41๊ธฐ] ํ๋ฃจ ์ผ๊ธฐ - 22.09.28 (0) | 2022.09.28 |