์ฝ๋ฉํ
์คํธ ์๊ณ ๋ฆฌ์ฆ ๋ฌธ์ ๋ฅผ ํ๋ค๋ณด๋ฉด, array.sort() ํจ์๋ฅผ ์์ฃผ ์ฌ์ฉํ๊ฒ ๋๋๋ฐ, ์ฐ๋ค๋ณด๋ฉด ๋งค์ฐ ์ ์ฉํ๊ณ ๋ค์ํ๊ฒ ์์ฉ ๊ฐ๋ฅํ ๊ฑธ ๋๋ ์ ์๋ค.
๋ฌธ๋ ์ ๋๋ก ์๊ณ ์ฐ๊ธฐ๋ณด๋จ "์ด๋ฌ๋ฉด ์ค๋ฆ์ฐจ์, ์ด๋ฌ๋ฉด ๋ด๋ฆผ์ฐจ์" ์ด๋ ๊ฒ ์๊ธฐ์์ผ๋ก ์ฌ์ฉํ๊ณ ์๋ค๋ ๊ฑธ ๋๊ผ๋ค.
๋ฐ๋ผ์ ์๋ฐ์คํฌ๋ฆฝํธ์ sort๋ฅผ ์ ๋ฆฌํ๋ ๊ธ์ ์ฐ๋ ค๊ณ ํ๋ค. ์ ์ ๋ฆฌ ํ์ผ๋ ์ฝ์ด๋ณด๊ณ ๋์์ด ๋์ผ๋ฉด ์ข๊ฒ ๋ ๋ฐ๋์ด๋ค!
๊ตฌ๋ฌธ๋ถํฐ ๋ณด์

compareFunction์ ์๋ต์ด ๊ฐ๋ฅํ๋ฉฐ, ์๋ตํ ์์๋ ๋ฐฐ์ด ๊ฐ ์์๋ฅผ string์ผ๋ก ์ฒ๋ฆฌํ๊ณ , ๊ฐ ๋ฌธ์์ ์ ๋์ฝ๋ ๊ฐ์ ๋ฐ๋ผ ์ ๋ ฌ๋๋ค.
๋ค์ ์์๋ฅผ ๋ณด๋ฉด ๋ฐ๋ก ์ดํด๊ฐ ๋ ๊ฒ์ด๋ค.

๋ง์ฝ, compareFunction์ ๋ฃ์ด์ฃผ๋ฉด, ์ด ํจ์์ ๋ฐํ๊ฐ์ ๋ฐ๋ผ ์ ๋ ฌ๋๋ค.

๋ถ๋ช
๋๋ค ์ค๋ฆ์ฐจ์ ์ ๋ ฌ์ ํ๋๋ฐ compareFunction์ ์กด์ฌ ์ ๋ฌด์ ๋ฐ๋ผ ๋ค๋ฅธ ๊ฒฐ๊ณผ๊ฐ ๋์์์ ์ ์์๋ค.
๊ทธ๋ฌ๋ฉด compareFunction ๋ ๋ญ๋?
mdn ๊ณต์ ์ฌ์ดํธ์ ์ฌ๋ฌ ์๋ฃ๋ฅผ ์ ๋ฆฌํ๋ฉด ๋ค์๊ณผ ๊ฐ๋ค.
compareFunction์ด ์ ๊ณต์ด ๋๋ฉด, compareFunction์ ๋ฐํ๊ฐ์ ์ด์ฉํ๊ธฐ ์์ํ๋ค.
๋ฐฐ์ด์ ์์ 2๊ฐ๋ฅผ ์ ๋ฌ ๋ฐ๊ณ , compareFunction์ด ๋ฐํํ๋ ๊ฐ์ ๊ธฐ์ค์ผ๋ก ์ ๋ ฌํ๋ค.
๊ทธ๋ฆฌ๊ณ ๋ฐํ๊ฐ์, ์์, ์์, 0 ๋ฑ 3๊ฐ์ง๋ก ๊ตฌ๋ถํ๋ค.
์์์ผ ๋ : b๊ฐ a๋ณด๋ค ์์ ์์ด์ผํ๋ค.
์์์ผ ๋ : a๊ฐ b๋ณด๋ค ์์ ์์ด์ผํ๋ค.
0์ผ ๋: a์ b์ ์์๋ฅผ ๋ฐ๊พธ์ง ์๋๋ค.
์ด์ mdn์ ๋์์๋ ์ค๋ฆ์ฐจ์ ์ ๋ ฌ ๊ธฐ๋ณธํ์์ด ์ดํด๊ฐ ๋ ๊ฒ์ด๋ค.
์์, ์์, 0 ์ ๋ฐ๋ผ ๋ฐํ๊ฐ์ ๊ณ ์ ํด ๋จ์ ๋ฟ์ด๋ค.
function compare(a, b) {
if (a < b, ์ฆ a - b๊ฐ ์์์ผ ๋) {
return -1;
}
if (a > b, ์ฆ a - b๊ฐ ์์์ผ ๋) {
return 1;
}
//a = b, ์ฆ a์ b๊ฐ ๊ฐ์ ๋
return 0;
}
array.sort(compare);
์)
[5,2,3] ๋ฐฐ์ด์ด ์ฃผ์ด ์ก๋ค๊ณ ํด๋ณด์
ํ์ฌ ๋ฐฐ์ด: [5, 2, 3]
5์ 2๋ฅผ ๋น๊ต -> 5 - 2 = ์์ -> 1๋ฐํ -> b๊ฐ a๋ณด๋ค ์์ ์์ด์ผํ๋ค. -> 5, 2 ์๋ฆฌ ๋ฐ๊พธ๊ธฐ
ํ์ฌ ๋ฐฐ์ด: [2, 5, 3]
2์ 3์ ๋น๊ต -> 2 - 3 = ์์ -> -1๋ฐํ -> a๊ฐ b๋ณด๋ค ์์ ์์ด์ผํ๋ค. -> ์๋ฆฌ ๊ทธ๋๋ก
ํ์ฌ ๋ฐฐ์ด: [2, 5, 3]
5์ 3์ ๋น๊ต -> 5 - 3 = ์์ -> 1๋ฐํ -> b๊ฐ a๋ณด๋ค ์์ ์์ด์ผํ๋ค. -> 5, 3 ์๋ฆฌ ๋ฐ๊พธ๊ธฐ
ํ์ฌ ๋ฐฐ์ด: [2, 3, 5]
์ด๋ฐ ์์ผ๋ก ์ ๋ ฌ์ด ์๋ฃ๋๋ค.
๋ฌผ๋ก a์ b๋ฅผ ๋น๊ตํ๋ ์์๋ ์ค์ js๋์๊ณผ ๋ค๋ฅผ ์ ์์ง๋ง, ์ดํดํ๊ธฐ ์ฌ์ด ์์๋ฅผ ๋ค์ด ๋ณด์๋ค.
์ด๋ฐ ํ ๋๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ํด์ ํ์๋๊ฒ ๋ฐ๋ก ์ฐ๋ฆฌ๊ฐ ์ซ์๋ฅผ ์ ๋ ฌ ํ ๋ ์ฌ์ฉํ๋ ํ์์ด๋ค.
array.sort((a, b) => a - b);
๋ด๋ฆผ์ฐจ์ ์ ๋ ฌ์ ํ๊ณ ์ถ๋ค๋ฉด a - b๋ฅผ b - a๋ก ๋ฐ๊พธ์ด ์คํํ๋ฉด ๋๋ค.
*์ด๋ฌ๋ฉด ์์์ ์์์ ์กฐ๊ฑด์ด ๋ฐ์ ๋๊ธฐ ๋๋ฌธ์ ๋ด๋ฆผ์ฐจ์ ์ ๋ ฌ์ด ๋๋ค.
array.sort((a, b) => b - a);
๊ฒฐ๋ก
ํต์ฌ์, ์ธ ๊ฐ์ง ์ข
๋ฅ์ ๋ฐํ๊ฐ์ ๋ฐ๋ผ ์๋ฆฌ๋ฅผ ๋ฐ๊ฟ์ง ๋ง์ง ๊ฒฐ์ ์ ํ๋ ๊ฒ์ด์๋ค.
sort()ํจ์์ ์๊ฐ๋ณต์ก๋๋ O(nlogn)์ผ๋ก ๋ณํฉ์ ๋ ฌ๊ณผ ์ ์ฌํ๋คํ๋๋ฐ, ๋น๊ตํ๋ ๊ณผ์ ์ ์์ด์ ์์ฒญ๋ ์๊ณ ๋ฆฌ์ฆ์ ์ฌ์ฉํ์ง ์์์๊น ๋ผ๋ ๊ฐ์ธ์ ์ธ ์ถ์ธก์ํด๋ณธ๋ค.
๋ค์ ๊ธ์์๋ sort()์ ๋ ฌ์ ์์ฉํ๋ ๋ฐฉ๋ฒ์ ์์๋ณด์!
'๐ฅ๏ธ Language > Vanila Javascript' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
JS ๋งต, ์ (0) | 2023.05.14 |
---|---|
์ ๊ทํํ์(regex) ์ ๋ฆฌ (0) | 2023.03.02 |
ํ์ดํ ํจ์์์์ ๋ฆฌํด ์๋ต ๊ฐ๋จํ ์ดํดํ๊ธฐ (0) | 2023.03.01 |
์๊ณ ๊ฐ์ ๋ก์ปฌ ์คํ ๋ฆฌ์ง(localStorage), ์ค์ํ ํน์ง (0) | 2023.02.25 |