Flatten ํจ์ ๐ซ
์ฌ๊ฑด
์ด๋ฒ ์ฃผ ๊ณผ์ ์ค ํ๋์๋ flatten ํจ์ ๊ตฌํํ๊ธฐ๋ค.
1
_.flatten(array)
๋ณต์กํจ ์์ด ํด๋น ํจ์๋ ๋ฐฐ์ด์ ์ฒซ ๋ฒ์งธ ๋งค๊ฐ๋ณ์๋ก ๋ฐ๋ ๊ฐ๋จํ ํจ์๋ค. ๊ธฐ๋ฅ ๊ตฌํ ๊ณผ์ ์ ์๊ทธ๋ฌ์ง๋ง.
ํด๋น ํจ์์ ์ค๋ช
๋ํ ๊ฐ๋จํ๋ค.
์๋ฌด๋ฆฌ array์ ์ค์ฒฉ๋ฐฐ์ด์ ๊น์ด๊ฐ ๊น์ด๋ single level๋ก ํํํ ์์ผ์ฃผ๋ ๊ธฐ๋ฅ์ ๊ฐ๊ณ ์๋ ํจ์๋ค.
ํ๋์ ๋ ๋ฒจ๋ง์ ํํํ ์ํค๋ ๊ธฐ๋ฅ ์กฐ์ฐจ ๊ตฌํ์ด ํ๋ค๊ฒ ๋ค ์๊ฐํ์ง๋ง,
์ผ๋ง๋ ๊น๋ ๋ชจ๋ ์ค์ฒฉ ๋ฐฐ์ด์ ํํํ ์ํจ๋ค๋ ๊ฒ์ ๋ง๋งํ๋ค.
์์ฌ์ฝ๋
์ ๊ธฐ๋ฅ ๊ตฌํ์ ์์ํ๊ธฐ์ ์์ ์์ฌ ์ฝ๋๋ถํฐ ์์ฑํด๋ดค๋ค
- ์ฃผ์ด์ง ๋ฐฐ์ด ๊ทธ ์์ฒด๋ฅผ ๊ฑด๋๋ฆฌ๊ธฐ ๋ณด๋ค๋ ์๋ก์ด ๋ฐฐ์ด์ ๋ง๋ ๋ค.
- ๋ฐ๋ณต๋ฌธ์ผ๋ก ๋ฐฐ์ด ๋ด ์ฒซ ๋ฒ์งธ ์ธ๋ฑ์ค๋ถํฐ ๋๊น์ง ์ํํ๋ค.
- ์ํํ๋ ์ค ์กฐ๊ฑด๋ฌธ์ ์ด์ฉํ์ฌ ํด๋น ์ธ๋ฑ์ค๊ฐ ๋ฐฐ์ด์ธ์ง ์๋์ง ํ์ธํ๋ค.
- ๋ฐฐ์ด์ด ์๋๋ผ๋ฉด ๋จ์ํ ํด๋น ๊ฐ์ ์ ๋ฐฐ์ด์ ๋ฃ์ด์ค๋ค.
- ๋ฐฐ์ด์ด๋ผ๋ฉด ํด๋น ๋ฐฐ์ด ๋ด์ ๊ฐ์๋ง ์ ๊ทผํ์ฌ ์ ๋ฐฐ์ด์ ๋ฃ์ด์ค๋ค.
์ด๋ ๊ฒ ์ด 5๋จ๊ณ์ ์์ฌ์ฝ๋๋ก ๊ตฌํํ ๊ธฐ๋ฅ์ ํ๋์ ๋ ๋ฒจ๋ง์ ํํํ ์์ผ์ฃผ๋ ๊ฒ์ด์๋ค.
์์ ๊ฐ๋จํ ๊ธฐ๋ฅ๋ถํฐ ๊ตฌํํ๊ธฐ๋ก ํ๋ค.
์ด๋ฅผ ์ํด์๋ ์ ์์ฌ์ฝ๋๋ฅผ ์กฐ๊ธ ๋ ์ฝ๋์ ์ผ๋ก ๊ตฌ์ฒดํ ํ ํ์๊ฐ ์์๋ค.
- ์ ๋ฐฐ์ด์ ๋ณ์๋ก ์ ์ธํด ํ ๋นํ๊ธฐ,
let result = [ ]
- ๋ฐฐ์ด์ ๊ธธ์ด ๊ตฌํ๊ธฐ,
for
๋ฌธ์ ์ด์ฉํ์ฌ ๋ฐฐ์ด ๊ธธ์ด๊น์ง๋ง ๋ฐ๋ณตํ๊ธฐ if
๋ฌธ์ ์ํด n๋ฒ์งธ ์ธ๋ฑ์ค์ ๊ฐ์ด ๋ฐฐ์ด์ด ์๋๋ผ๋ฉดresult
์push()
ํ๊ธฐ- n๋ฒ์งธ ๊ฐ์ด ๋ฐฐ์ด์ด๋ผ๋ฉด
result
์ n๋ฒ์งธ ์ธ๋ฑ์ค์ ๋ฐฐ์ด๊ณผconcat()
์ผ๋ก ํฉ์ณ ํ๋์ ๋ฐฐ์ด ๋ง๋ค๊ธฐ
์ ์์ฌ์ฝ๋๋ฅผ ์ฝ๋๋ก ๊ตฌํํด๋ณด์.
์ฌ๋ฌ ๊ณ ๋ฏผ๊ณผ ์ฐ์ฌ๊ณก์ ์ด ์์์ง๋ง ๊ตฌํ์ ์ฒซ ์ฑ๊ณตํ๋ ์ฝ๋๋ ์ด๋ ๋ค.
1
2
3
4
5
6
7
8
9
10
11
12
13
function flatten(array) {
let result = [];
for (let i = 0; i < array.length; i++) {
if (Array.isArray(array[i]) === false) {
result.push(array[i]);
}
else if (Array.isArray(array[i])) {
result = result.concat(array[i]);
}
}
return result;
}
์๋ฅผ ์๋ ๋ฐฐ์ด๋ก ์คํํ๊ฒ ๋๋ฉด,
1
2
3
4
5
6
const nestedArray = [
1,
[2],
[3, [[[4]]]],
[[5], [6], [7, 8, 9, [10], [[11]], 12, 13, [14], 15]],
];
1
2
// ๊ฒฐ๊ณผ๊ฐ
[1, 2, 3, [[[4]]], [5], [6], [7, 8, 9, [10], [[11]], 12, 13, [14], 15]]
์ ์ฒ๋ผ ํ์ธต์ ์ค์ฒฉ๋ฐฐ์ด์ด ํํํ๋ ๋ฐฐ์ด์ด ๋ ๊ฒ์ ํ์ธํ ์ ์์๋ค.
๋ถ์
์ ์ฝ๋๋ฅผ ๋ฒ ์ด์ค๋ก ๋ณธ๋ ๊ธฐ๋ฅ์ ๊ตฌํํ ์ ์์๊น?
๋ฐฐ์ด ๊น์ด์ ๋ฒ์๊ฐ ์ ํด์ ธ ์์ง ์๊ณ ์์ ๋ณ๋ก ๋ค ๋ค๋ฅผํ
๋ฐ ์ด๋ป๊ฒ ๋ฒ์๋ฅผ ์ ํด์ผํ ๊น?
ํด๋ต์ ๋ ๋๊น์ง๋ง ๋ฐ๋ณตํ๊ธฐ๋ค.
๋ง์ด ์ฝ์ง, ์ ๋ฐฉ๋ฒ์ ์ฌ์ฉํ๋ ค๋ฉด ์ด๋ป๊ฒ ํด์ผ ๋ ๊น?
์ง์ง ํด๋ต์ ๋ฆฌ์์น ๊ณผ์ ๋ชฉ๋ก์ ์์๋ค.
๊ทธ๊ฒ์ ์ฌ๊ทํจ์์๋ค.
์ฌ๊ท ํจ์ ๊ตฌํ ์ ์ฃผ์์ฌํญ, ์คํ ํ๋ฆ
์ฌ๊ทํจ์์ ์๋ฆฌ๋ ์ด๋ฌํ๋ค.
1
2
3
4
5
6
7
8
9
function recursive(num) {
if (num <= 0) {
return console.log('ํ์ถ ์กฐ๊ฑด์ ๊ฑธ๋ ค ์ฌ๊ทํจ์ ์ข
๋ฃ.');
}
console.log(num);
num--;
recursive(num);
}
recursive(5);
๊ธฐ๋ณธ ๊ตฌ์กฐ๋ ํจ์ ๋ด์์ ๋ณธ์ธ์ ํธ์ถํ๋ ์๋ํ ๋ฐ๊ฐ ์๋ฃ๋๋ฉด ์ข ๋ฃ๋๊ฒ๋ ์กฐ๊ฑด๋ฌธ์ ๊ฑฐ๋ ๊ฒ์ด์๋ค.
๋ฐ์
์ ์ฌ๊ทํจ์๋ฅผ ๋ด ์์ฌ์ฝ๋์ ์ ์ฉ์ํค๋ฉด ์ด๋จ๊น?
๋จผ์ ์์ฌ์ฝ๋๋ฅผ ์จ๋ณด์.
๋ผ๋๋ ๊ธฐ์กด์ ๋ฐฐ์ด ํ ์ธต ํํํ ์ฝ๋์ ๊ฐ์๋ค.
- ์ ๋ฐฐ์ด
result
๋ง๋ค๊ธฐ - ๋ฐฐ์ด์ ๊ธธ์ด๊น์ง ๋ฐ๋ณต๋ฌธ์ผ๋ก ์ํํ๊ธฐ
- ๋ง์ฝ ๋ฐฐ์ด์ด ์๋๋ผ๋ฉด
push()
๋กresult
์ ๋จ์ ์ถ๊ฐํ๊ธฐ - ๋ฐฐ์ด์ด๋ผ๋ฉด ํด๋น ๋ฐฐ์ด๊ณผ
result
์concat()
์ผ๋ก ํฉ์น๊ธฐ - ๋ฐฐ์ด ๊ธธ์ด๊น์ง ๋๋ฌํ์ฌ ๋ฐ๋ณต๋ฌธ์ด ๋ฉ์ถ๋ฉด ํ์ธต ํํํ๋
result
๋ฐฐ์ด ์์ฑ result
๋ฐฐ์ด์ ๋ฐ๋ณต๋ฌธ์ผ๋ก ์ํํ๊ธฐ- ๋ฐฐ์ด ๋ด ๋ฐฐ์ด์ด ์๋ค๋ฉด
result
๋ฐฐ์ด์flatten
ํจ์์ ๋ฃ์ด ์ฌ๊ทํธ์ถ ํ๊ธฐ
์ฌ๋ฌ ์ค์์ ์๋ฌ๋ค์ ๊ฑธ์ณ ์ป์ด๋ธ ๊ฒฐ๊ณผ๋ ์ด๊ฑฐ์๋ค.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
_.flatten = function unpack(nestedArray) {
let result = [];
for (let i = 0; i < nestedArray.length; i++) {
if (Array.isArray(nestedArray[i]) === false) {
result.push(nestedArray[i]);
}
else if (Array.isArray(nestedArray[i])) {
result = result.concat(nestedArray[i]);
}
}
for (let j in result) {
if (Array.isArray(result[j]))
unpack(result);
}
return result;
};
์ ์ฝ๋๋ก์จ ์๋ฒฝํ flatten์ ๊ธฐ๋ฅ์ ๊ตฌํํ..
์ผ๋ฉด ์ข์๊ฒ ์ง๋ง ๋น์ฐํ๊ฒ๋ ์คํ ๊ฒฐ๊ณผ๋ ์๋ํ๋ ๊ฒฐ๊ณผ์ ์กฐ๊ธ ๋น๋๊ฐ ์ ๋๋ ์๋์๋ค.
๋ฌธ์ ์ง๋ฉด
๊ฒฐ๊ณผ๋ ์ด๋ฌํ๋ค.
์ฐ์ธก์ result์์ ๋ณด์ด๋ ๋ฐ์ ๊ฐ์ด ์์ฐจ์ ์ผ๋ก ๋ฐ๋ณต๋ฌธ์ ์ํด ๋ฐ๋ณต๋๋ฉฐ ์ฌ๊ทํจ์๋ก ๋ฐฐ์ด์ด ์์ผ๋ฉด result
์ ๊ทธ ๋ฐฐ์ด์ ๋ค์๊ธ ํฉ์ณ์ฃผ๋ฉฐ ํํํ๋ฅผ ์งํ๋์๋ค.
๊ทธ๋ฆฌ๊ณ ๋ง์นจ๋ด ๋ชจ๋ ์ค์ฒฉ๋ฐฐ์ด์ด ์ฌ๋ผ์ง ํํ๋ก ๋จ์ผ ๋ ๋ฒจ์ ๋ฐฐ์ด์ด result
์ด ๋ด๊ธฐ๋ ๊ฒ์ ํ์ธํ๋ค.
๊ทธ๋ ๊ฒ result
๋ ๋ฐํ๋ฌธ์ ๋ง๋ ๊ฒฐ๊ณผ๋ฅผ ๋ฐํํ๊ธฐ๋ง ํ๋ฉด ๋๋๋ฐ ์ฝ๋๊ฐ ์๋ชป๋๊ฑด์ง result
๋ฐฐ์ด์ ๋ค์ ์ฌ๋ฌ ์ค์ฒฉ๋ฐฐ์ด์ ๊ฐ์ง ์ฑ ์ฝ๋๋ฅผ ๋ฐ๋ณตํ๊ธฐ ์์ํ๋ค..
๊ทธ๋ ๊ฒ ์๋ง์ง์ฐฝ์ผ๋ก ์ฝ๋๊ฐ ๋ฐ๋ณต๋๋ค๊ฐ ์ฌ๋ฌ ์ค์ฒฉ๋ฐฐ์ด์ ๊ฐ์ง ์ฑ๋ก ๊ฒฐ๊ณผ๊ฐ ๋์๋ค.
์ง๋ฌธ
์ง๋ฌธ์ ๋ด์ฉ์ ๊ฐ๋จํ๋ค.
ํด๋น ์ฝ๋๋ก ๋๋ฒ๊น
์ ์์ฐจ๋ก ์งํํ๋ฉฐ ๋ฌธ์ ๊ฐ ๋๋ ํฌ์ธํธ๋ฅผ ์ฐพ์ ๋์ฐ์ง๋ง
๋ช
ํํ๊ฒ ์ด๋์๋ถํฐ ์๋ชป ๋์๋๊ฐ๋ฅผ ์ฐพ์ ์ ์์๋ ๋๋ ํด๋น ์ฝ๋๋ฅผ ๋ฉํ ๋ถ๊ป
์ค์๊ฐ์ผ๋ก ์์ฐํ๋ฉฐ ์ด๋์๋ถํฐ ์ด๋ป๊ฒ ์๋ชป๋๋์ง๋ฅผ ์ฌ์ญค๋ณด์๋ค.
๋ฉํ ๋ถ์ ๋ต์ ์ด๋ฌํ๋ค.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
_.flatten = function unpack(nestedArray) {
let result = [];
for (let i = 0; i < nestedArray.length; i++) {
if (Array.isArray(nestedArray[i]) === false) {
result.push(nestedArray[i]);
}
else if (Array.isArray(nestedArray[i])) {
result = result.concat(nestedArray[i]);
}
}
for (let j in result) {
if (Array.isArray(result[j]))
unpack(result);
}
return result;
};
์ ํ์ด๋ผ์ดํธ ๋ ์์ญ ์์ ๋ฐ๋ณต๋ฌธ์ ๋ง์น๊ณ ํ๋ฒ์ ํํํ๋ฅผ ๊ฑฐ์น ๋ฐฐ์ด์ ํ์ด๋ผ์ดํธ ๋ ์ฝ๋๋ฅผ ๋ง๋๋ฉด์
๋ฌธ์ ๊ฐ ๋ฐ์ํ๋ค. ๊ณผ์ ์ ์ด๋ ๋ค.
- ํ์ธต ํํํ๋ ๋ฐฐ์ด์ ๋ฐ๋ณต๋ฌธ์ผ๋ก ๋๋ค.
- j๋ฒ ์งธ์ ๊ฐ์ผ๋ก ๋ฐฐ์ด์ ๋ง๋ ๋๊น์ง ์งํํ๋ค.
- ๋ฐฐ์ด์ ๋ง๋๊ฒ ๋๋ฉด ์ฌ๊ทํ๋ค.
- ๋ฐ๋ณต๋ฌธ์ j๋ฒ์งธ๊น์ง ์งํํ๊ณ ์ผ์ ์ ์ง๋๋ค.
- ์ฌ๊ท๋ฅผ ์งํํ๊ณ ํ์ธต ๋ ํํํ๋ ๋ฐฐ์ด์ ๋ง๋ ๋ค.
- ํด๋น ๋ฐฐ์ด๋ก ๋ฐ์ ํ์ด๋ผ์ดํธ ๋ฐ๋ณต๋ฌธ์ ๋ง๋ 0๋ฒ์งธ๋ถํฐ ๋ค์ ๋ฐฐ์ด์ธ๊ฐ ์๋๊ฐ๋ฅผ ํ์ธํ๋ค.
- ๋ ๋ค๋ฅธ j ๋ฒ์งธ์์ ๋ฐฐ์ด์ ๋ง๋๋ค.
- ์ 3 - 7๋ฒ์ด ๋ฐ๋ณต๋๋ค.
์ด๋ ๊ฒ ์ ๊ณผ์ ์ ๊ฑฐ์น๋ฉด์ ๋งค๋ฒ ๋ฐ๋ณต๋ฌธ์ ๋ง๋ ๋๋ง๋ค ์ผ์ ์ ์ง๊ฐ ๋์ด ๋ง์ ์งํ๋์ง ์์๋ ๋ฐ๋ณต๋ฌธ์ด ํ๋ฒ ์์ ํ ํํํ๋ฅผ ๊ฑฐ์น๊ณ ๋์์ผ ๋ค์ ์งํ๋๋ ๊ฒ์ด์๋ค.
์ด๋ ์ฝ์คํ์์ ์งํ๋๋ค๊ฐ ๋ค๋ฅธ ํธ์ถ๋ฌธ์ ๋ง๋ ํธ์ถ๋ฌธ์ ์คํ ์ปจํ
์คํธ ์์ด๊ณ ๋ ์์ด๋ฉฐ FILO๊ฐ ๋์๋ ๊ฒ์ด๋ค.
๋ฉํ ๋ถ๊ป์ ์ฌ๊ทํจ์์ ์ดํด๋๋ฅผ ์กฐ๊ธ ๋ ๋ํ๋๊ฒ ํด๋น ์ฝ๋์ ๊ตฌํ์ ๋์์ด ๋ ๊ฑฐ๋ผ๊ณ ํ์
จ๋ค.
์๋๊ฐ ์ฌ๊ทํจ์์ ๋ํ ๋งํฌ
์ฌ๊ทํจ์ 3๋จ๊ณ ์์ฑ๋ฒ
ํผ๋๋ฐฑ ์ ๋ฆฌ
์ฌ๊ทํจ์๋ฅผ ๊ณต๋ถํ๊ณ ๋์
๋จผ์ ๋ ์๊ฐ์ ์ ํ์ด๋ผ์ดํธ ๋ ์ฝ๋๋ฅผ ๊ณ ์น๋ ๊ฒ๋ณด๋ค๋ ํด๋น ์ฝ๋์์ ๋ฌธ์ ๊ฐ ๋ฐ์ํ๋ ์ญ์ ํ๋ ๊ฒ์ด์๋ค.
ํด๋น ์ฝ๋๋ฅผ ์ญ์ ํ๋ ค๋ฉด ๋์ ์ ์ด๋ค ์ฝ๋๋ฅผ ์จ์ผ๋ ๊น?
๋ต์ ์ ๋ง ๊ฐ๋จํ๋ค.
์กฐ๊ฑด๋ฌธ ๋ด์ ์ฌ๊ทํจ์๋ฅผ ๋ฃ๋ ๊ฒ์ด์๋ค.
๊ทธ ์ธ์ ์์ ์ฌํญ์ผ๋ก๋ ๋จผ์
๋ฐ๋ณต๋ฌธ์ผ๋ก ์ธ๋ฑ์ค์ ์ ๊ทผํ๋ ๋ฐฉ์๋ณด๋ค ๊ทธ ์์ฒด์ ์์๋ฅผ ์ํํ๊ธฐ ์ํด forโฆof
๋ฅผ ์ฐ๊ธฐ๋ก ํ๋ค.
๊ทธ๋ฆฌ๊ณ ํท๊ฐ๋ฆผ์ ๋ฐฉ์งํ๊ธฐ ์ํด ๋ฐ๋ณต๋ฌธ์ผ ๋์ ์กฐ๊ฑด์ if
๋ฌธ์ ๋ฃ๊ธฐ๋ก ํ๋ค.
๊ทธ๋ฆฌ๊ณ ๋ฐ๋์ ์กฐ๊ฑด์ ๊ฐ๋จํ๊ฒ else
๋ง์ ์ฌ์ฉํ๋ค.
1
2
3
4
5
6
7
8
9
10
11
12
13
_.flatten = function unpack(nestedArray) {
let result = [];
for (let item of nestedArray) {
if (Array.isArray(item)) {
result = result.concat(flatten(item));
}
else {
result.push(item)
}
}
return result;
};
๋๋ง์ ๊ฒฐ๊ณผ
์ ์ฝ๋๋ก ์์ ๋ฅผ ์คํ์์ผ ๋ณด์๋ค.
๋๋์ด ์ํ๋ ๊ฒฐ๊ณผ์ธ ์น ๋ค ํํํ ๋ ๋ฐฐ์ด์ ๋ง์ดํ ์ ์์๋ค.