์ค๋์ ์๋ฐ์คํฌ๋ฆฝ์ parseInt() ํจ์์ ๋ํด ๊ณต๋ถํด๋ณด์.
parseInt() ํจ์๋ ๋ฌธ์์ด ์ธ์๋ฅผ ํ์ฑํ์ฌ ํน์ ์ง์์ ์ ์๋ฅผ ๋ฐํํ๋ค.
(ํ์ฑ์ด๋ ๋ฐ์ดํฐ๋ฅผ ๋ถํด ๋ถ์ํด์ ์ํ๋ ํํ๋ก ์กฐ๋ฆฝํ๊ณ ๋ค์ ๋นผ๋ด๋ ํ๋ก๊ทธ๋จ)
๊ตฌ๋ฌธ
parseInt(string);
parseInt(string, radix);
๋งค๊ฐ๋ณ์
string
ํ์ฑํ ๊ฐ์ด๋ค. ๋ฌธ์์ด์ด ์๋ ๊ฒฝ์ฐ toString ์ถ์ ์ฐ์ฐ์ ์ฌ์ฉํด ๋ฌธ์์ด๋ก ๋ณํํ ๊ฒ์ด๋ค. ๋ฌธ์์ด์ ์ ํ ๊ณต๋ฐฑ์ ๋ฌด์ํ๋ค.
radix
string์ ์ง์๋ฅผ ๋ํ๋ด๋ 2๋ถํฐ 36๊น์ง์ ์ ์์ด๋ค. ์ฃผ์! ๊ธฐ๋ณธ ๊ฐ์ด 10์ด ์๋๋ค! Number ์๋ฃํ์ด ์๋ ๊ฒฝ์ฐ Number๋ก ๋ณํํ๋ค.
๋ฐํ ๊ฐ
์ฃผ์ด์ง string์์ ํ์ฑํ ์ ์์ด๋ค. ์๋์ ๊ฐ์ ๊ฒฝ์ฐ์๋ NaN์ ๋ฐํํ๋ค.
- radix๊ฐ 2๋ณด๋ค ์๊ฑฐ๋ 36๋ณด๋ค ํฐ ๊ฒฝ์ฐ.
- ๊ณต๋ฐฑ์ด ์๋ ์ฒซ ๋ฌธ์๋ฅผ ์ซ์๋ก ๋ณํํ ์ ์๋ ๊ฒฝ์ฐ.
์ค๋ช
- parseInt ํจ์๋ ์ฒซ ๋ฒ์งธ ์ธ์๋ฅผ ๋ฌธ์์ด๋ก ๋ณํํ๊ณ , ๊ทธ ๊ฐ์ ํ์ฑํ์ฌ ์ ์๋ NaN์ ๋ฐํํ๋ค.
- NaN์ ๋ฐํํ ๊ฒ์ด ์๋๋ฉด, parseInt๋ ์ฒซ ๋ฒ์งธ ์ธ์๊ฐ ์ง์ ํ radix์ง์๋ก ํํํ ์ ์๋ฅผ ๋ฐํํ๋ค.
์๋ฅผ ๋ค์ด radix๊ฐ 10์ธ ๊ฒฝ์ฐ 10์ง์, 8์ธ ๊ฒฝ์ฐ๋ 8์ง์ ๋ฑ๋ฑ์ผ๋ก ๋ณํํ๋ค. - radix๊ฐ 10์ ์ด๊ณผํ๋ ๊ฒฝ์ฐ, ์๋ฌธ ์ํ๋ฒณ์ด 9๋ณด๋ค ํฐ ์ซ์๋ฅผ ๋ํ๋ธ๋ค. ์ฆ, 16์ง์์์๋ A๋ถํฐ F๊น์ง๋ฅผ ์ฌ์ฉํ๋ค.
- ๋ง์ฝ parseInt ํจ์๊ฐ ์ง์ ํ radix์์ ์ซ์๊ฐ ์๋ ๋ฌธ์๋ฅผ ๋ง์ฃผ์น๋ ๊ฒฝ์ฐ ํด๋น ๋ฌธ์ ์ด์ ๊น์ง์ ๋ฌธ์๋ง ์ฌ์ฉํด ํ์ฑํ๋ฉฐ ๋ฌธ์ ์ ๋ฌธ์์ ๊ทธ ์ดํ๋ ๋ชจ๋ ๋ฌด์ํ๋ค. parseInt๋ ์ ์๊ฐ์ ๋ฐํํ๊ธฐ ์ํด ์์์ ์ดํ ๊ฐ์ ์๋ผ๋ด๊ณ , ์ ํ ๋ฐ ํํ ๊ณต๋ฐฑ์ ํ์ฉ๋๋ค.
- ์ผ๋ถ ์ซ์๋ ๋ฌธ์์ด ํํ์ e ๋ฌธ์๋ฅผ ์ฌ์ฉํ๊ธฐ ๋๋ฌธ์(6.022e23(6.022 × 10^23)์ฒ๋ผ), parseInt๋ฅผ ๋งค์ฐ ํฌ๊ฑฐ๋ ์์ ์ซ์์ ์์์ ์ดํ ๊ฐ์ ์๋ฅด๊ธฐ ์ํด ์ฌ์ฉํ๋ฉด ์๊ธฐ์น ๋ชปํ ๊ฒฐ๊ณผ๊ฐ ๋ฐ์ํ ์ ์๋ค.
๊ทธ๋์ parseInt๋ฅผ Math.floor()์ ๋์ฒดํ์ผ๋ก ์ฌ์ฉํด์๋ ์๋๋ค. - parseInt ๋ ์์ ๋ถํธ(+)์ ์์ ๋ถํธ(-)๋ฅผ ์ธ์ํ๋ค.
๋ถํธ ์ธ์์ ์ ํํ ๊ณต๋ฐฑ์ ์ ๊ฑฐํ ํ ์ฒซ ๋ฒ์งธ ๋จ๊ณ๋ก์ ์ํ๋๋ฉฐ, ๋ถํธ๋ฅผ ์ฐพ์ ์ ์์ผ๋ฉด ์๊ณ ๋ฆฌ์ฆ์ ๋ค์ ๋จ๊ณ๋ก ๋์ด๊ฐ๋ค. ๋ถํธ๋ฅผ ์ฐพ์ ๊ฒฝ์ฐ ๋ถํธ๋ฅผ ์ ๊ฑฐํ๊ณ , ๋๋จธ์ง ๋ฌธ์์ด์ ๋ํด ์ซ์ ํ์ฑ์ ์งํํ๋ค. - ์ ์ ์ธ์๋ก ์ง์ ํ ๊ฐ์ (ํ์ํ ๊ฒฝ์ฐ) ์ซ์๋ก ๋ณํ๋๋ค.
๋ณํ ํ์ ๊ฐ์ด 0, NaN, Infinity ์ค ํ๋(undefined๋ NaN์ผ๋ก ๋ณํ)ํ๋ฉด ์๋ฐ์คํฌ๋ฆฝํธ๋ ๋ค์์ ๊ฐ์ ํ๋ค.
1. ์ ๋ ฅ ๊ฐ์ด "0x" ๋๋ "0X"(0๊ณผ ๋/์๋ฌธ์ X)๋ก ์์ํ๋ ๊ฒฝ์ฐ radix๋ฅผ 16์ผ๋ก ๊ฐ์ฃผ๋ผ์ฌ ๋๋จธ์ง ๋ฌธ์์ด์ 16์ง์๋ก ํ์ฑํ๋ค.
2. ์ ๋ ฅ ๊ฐ์ด ๊ทธ ์ธ์ ๋ค๋ฅธ ๊ฐ์ผ๋ก ์์ํ๋ฉด radix๋ 10(10์ง์)์ด๋ค.
์ด์ธ์ ์ง์ ๊ฐ์ด [2, 36]์ ๋ฒ์๋ฅผ ๋ฒ์ด๋๋ ๊ฒฝ์ฐ parseInt๊ฐ NaN์ ๋ฐํํ๋ค.
์์
// 15 ๋ฐํ
parseInt("0xF", 16);
parseInt("F", 16);
parseInt("17", 8);
parseInt(15.99, 10);
parseInt("1111", 2);
parseInt("15e2", 10);
// NaN ๋ฐํ
parseInt("Hello", 8); // ์ซ์๊ฐ ์ ํ ์๋
parseInt("546", 2); // 0๊ณผ 1์ ์ ์ธํ ์ซ์๋ 2์ง๋ฒ์์ ์ ํจํ์ง ์์
// -15 ๋ฐํ
parseInt("-0F", 16);
parseInt(-15.1, 10);
parseInt("-17", 8);
parseInt("-1111", 2);
parseInt("-15e1", 10);
// 4 ๋ฐํ
parseInt(4.7, 10);
parseInt(4.7 * 1e22, 10); // ๋งค์ฐ ํฐ ์ซ์๊ฐ 4๊ฐ ๋จ
parseInt(0.00000000000434, 10); // ๋งค์ฐ ์์ ์ซ์๊ฐ 4๊ฐ ๋จ
// 1 ๋ฐํ: ์ซ์๊ฐ 1e+21์ ์ด๊ณผํ๊ฑฐ๋ 1e-7 ๋ฏธ๋ง์ด ๊ฒฝ์ฐ
parseInt(0.0000001, 10);
parseInt(1e-7, 10);
parseInt(123000000000000000000000, 10);
์ง์๋ Number๋ก ๋ณํํ๋ค.
const obj = {
valueOf() {
return 8;
},
};
parseInt("11", obj); // 9
obj.valueOf = function () {
return 1;
};
parseInt("11", obj); // NaN
obj.valueOf = function () {
return Infinity;
};
parseInt("11", obj); // 11
๋ ์๊ฒฉํ ํ์ฑ ํจ์
// ์ ๊ท ํํ์ ์ฌ์ฉ
function filterInt(value) {
if (/^[-+]?(\d+|Infinity)$/.test(value)) {
return Number(value);
} else {
return NaN;
}
}
console.log(filterInt("421")); // 421
console.log(filterInt("-421")); // -421
console.log(filterInt("+421")); // 421
console.log(filterInt("Infinity")); // Infinity
console.log(filterInt("421e+0")); // NaN
console.log(filterInt("421hop")); // NaN
console.log(filterInt("hop1.61803398875")); // NaN
console.log(filterInt("1.61803398875")); // NaN
์ฐธ๊ณ
'Frontend ๐ > JavaScript' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[JS] ์๋ฐ์คํฌ๋ฆฝํธ๋ (0) | 2024.07.06 |
---|---|
[JS] for...of ๋ช ๋ น๋ฌธ (2) | 2023.12.04 |
[JS] Constructor(์์ฑ์)๋? (0) | 2023.11.28 |