parseInt()
Baseline
Widely available
This feature is well established and works across many devices and browser versions. Itโs been available across browsers since โจ2015๋ 7์โฉ.
parseInt() ํจ์๋ ๋ฌธ์์ด ์ธ์๋ฅผ ํ์ฑํ์ฌ ํน์ ์ง์(์์ ์ง๋ฒ ์ฒด๊ณ์์ ๊ธฐ์ค์ด ๋๋ ๊ฐ)์ ์ ์๋ฅผ ๋ฐํํฉ๋๋ค.
์๋ํด ๋ณด๊ธฐ
console.log(parseInt("123"));
// 123 (default base-10)
console.log(parseInt("123", 10));
// 123 (explicitly specify base-10)
console.log(parseInt(" 123 "));
// 123 (whitespace is ignored)
console.log(parseInt("077"));
// 77 (leading zeros are ignored)
console.log(parseInt("1.9"));
// 1 (decimal part is truncated)
console.log(parseInt("ff", 16));
// 255 (lower-case hexadecimal)
console.log(parseInt("0xFF", 16));
// 255 (upper-case hexadecimal with "0x" prefix)
console.log(parseInt("xyz"));
// NaN (input can't be converted to an integer)
๊ตฌ๋ฌธ
parseInt(string);
parseInt(string, radix);
๋งค๊ฐ๋ณ์
string-
ํ์ฑํ ๊ฐ์ ๋๋ค. ๋ฌธ์์ด์ด ์๋ ๊ฒฝ์ฐ
ToString์ถ์ ์ฐ์ฐ์ ์ฌ์ฉํด ๋ฌธ์์ด๋ก ๋ณํํฉ๋๋ค. ๋ฌธ์์ด์ ์ ํ ๊ณต๋ฐฑ์ ๋ฌด์ํฉ๋๋ค. radixOptional-
string์ ์ง์๋ฅผ ๋ํ๋ด๋2๋ถํฐ36๊น์ง์ ์ ์์ ๋๋ค. ์ฃผ์ํ์ธ์. ๊ธฐ๋ณธ ๊ฐ์ด10์ด ์๋๋๋ค!Number์๋ฃํ์ด ์๋ ๊ฒฝ์ฐNumber๋ก ๋ณํํฉ๋๋ค.๊ฒฝ๊ณ :
radix๋ฅผ ์๋ตํ ๊ฒฝ์ฐ ๋ฐ์ํ๋ ์ผ์ ๋ํด์๋ ์๋ ์ค๋ช ์์ ์์ธํ ์์๋ณผ ์ ์์ต๋๋ค.
๋ฐํ ๊ฐ
์ฃผ์ด์ง string์์ ํ์ฑํ ์ ์์
๋๋ค.
๋ค์๊ณผ ๊ฐ์ ๊ฒฝ์ฐ์๋ NaN์ ๋ฐํํฉ๋๋ค.
radix๊ฐ 2๋ณด๋ค ์๊ฑฐ๋ 36๋ณด๋ค ํฐ ๊ฒฝ์ฐ.- ๊ณต๋ฐฑ์ด ์๋ ์ฒซ ๋ฌธ์๋ฅผ ์ซ์๋ก ๋ณํํ ์ ์๋ ๊ฒฝ์ฐ.
์ค๋ช
parseInt ํจ์๋ ์ฒซ ๋ฒ์งธ ์ธ์๋ฅผ ๋ฌธ์์ด๋ก ๋ณํํ๊ณ , ๊ทธ ๊ฐ์ ํ์ฑํ์ฌ ์ ์๋ NaN์ ๋ฐํํฉ๋๋ค.
NaN์ ๋ฐํํ ๊ฒ์ด ์๋๋ฉด, parseInt๋ ์ฒซ ๋ฒ์งธ ์ธ์๋ฅผ ์ง์ ํ radix ์ง์๋ก ํํํ ์ ์๋ฅผ ๋ฐํํฉ๋๋ค. ์๋ฅผ ๋ค์ด radix๊ฐ 10์ธ ๊ฒฝ์ฐ 10์ง์, 8์ธ ๊ฒฝ์ฐ๋ 8์ง์, 16์ธ ๊ฒฝ์ฐ 16์ง์ ๋ฑ๋ฑ์ผ๋ก ๋ณํํฉ๋๋ค.
radix๊ฐ 10์ ์ด๊ณผํ๋ ๊ฒฝ์ฐ, ์๋ฌธ ์ํ๋ฒณ์ด 9๋ณด๋ค ํฐ ์ซ์๋ฅผ ๋ํ๋
๋๋ค. ์ฆ, 16์ง์์์๋ A๋ถํฐ F๊น์ง๋ฅผ ์ฌ์ฉํฉ๋๋ค.
๋ง์ฝ parseInt ํจ์๊ฐ ์ง์ ํ radix์์์ ์ซ์๊ฐ ์๋ ๋ฌธ์๋ฅผ ๋ง์ฃผ์น๋ ๊ฒฝ์ฐ ํด๋น ๋ฌธ์ ์ด์ ๊น์ง์ ๋ฌธ์๋ง ์ฌ์ฉํด ํ์ฑํ๋ฉฐ ๋ฌธ์ ์ ๋ฌธ์์ ๊ทธ ์ดํ๋ ๋ชจ๋ ๋ฌด์ํฉ๋๋ค. parseInt๋ ์ ์ ๊ฐ์ ๋ฐํํ๊ธฐ ์ํด ์์์ ์ดํ ๊ฐ์ ์๋ผ๋
๋๋ค. ์ ํ ๋ฐ ํํ ๊ณต๋ฐฑ์ ํ์ฉ๋ฉ๋๋ค.
์ผ๋ถ ์ซ์๋ 6.022e23(6.022 ร 10^23)์ฒ๋ผ ๋ฌธ์์ด ํํ์ e ๋ฌธ์๋ฅผ ์ฌ์ฉํ๊ธฐ ๋๋ฌธ์, parseInt๋ฅผ ๋งค์ฐ ํฌ๊ฑฐ๋๋งค์ฐ ์์ ์ซ์์ ์์์ ์ดํ ๊ฐ์ ์๋ฅด๊ธฐ ์ํด ์ฌ์ฉํ๋ฉด ์๊ธฐ์น ๋ชปํ ๊ฒฐ๊ณผ๊ฐ ๋ฐ์ํ ์ ์์ต๋๋ค. parseInt๋ฅผ Math.floor()์ ๋์ฒดํ์ผ๋ก ์ฌ์ฉํด์๋ ์๋ฉ๋๋ค.
parseInt๋ ์์ ๋ถํธ +์ ์์ ๋ถํธ -๋ฅผ ์ธ์ํฉ๋๋ค. ๋ถํธ ์ธ์์ ์ ํํ ๊ณต๋ฐฑ์ ์ ๊ฑฐํ ํ ์ฒซ ๋ฒ์งธ ๋จ๊ณ๋ก์ ์ํ๋๋ฉฐ, ๋ถํธ๋ฅผ ์ฐพ์ ์ ์์ผ๋ฉด ์๊ณ ๋ฆฌ์ฆ์ ๋ค์ ๋จ๊ณ๋ก ๋์ด๊ฐ๋๋ค. ๋ถํธ๋ฅผ ์ฐพ์ ๊ฒฝ์ฐ ๋ถํธ๋ฅผ ์ ๊ฑฐํ๊ณ , ๋๋จธ์ง ๋ฌธ์์ด์ ๋ํด ์ซ์ ํ์ฑ์ ์งํํฉ๋๋ค.
์ง์ ์ธ์๋ก ์ง์ ํ ๊ฐ์ (ํ์ํ ๊ฒฝ์ฐ) ์ซ์๋ก ๋ณํ๋ฉ๋๋ค. ๋ณํ ํ์ ๊ฐ์ด 0, NaN, Infinity ์ค ํ๋(undefined๋ NaN์ผ๋ก ๋ณํ)๋ผ๋ฉด JavaScript๋ ๋ค์์ ๊ฐ์ ํฉ๋๋ค.
- ์
๋ ฅ ๊ฐ์ด "
0x" ๋๋ "0X"(0๊ณผ ๋/์๋ฌธ์ X)๋ก ์์ํ๋ ๊ฒฝ์ฐradix๋ฅผ16์ผ๋ก ๊ฐ์ฃผํ์ฌ ๋๋จธ์ง ๋ฌธ์์ด์ 16์ง์๋ก ํ์ฑํฉ๋๋ค. - ์
๋ ฅ ๊ฐ์ด ๊ทธ ์ธ์ ๋ค๋ฅธ ๊ฐ์ผ๋ก ์์ํ๋ฉด
radix๋10(10์ง์)์ ๋๋ค.
์ด์ธ์ ์ง์ ๊ฐ์ด [2, 36]์ ๋ฒ์๋ฅผ ๋ฒ์ด๋๋ ๊ฒฝ์ฐ parseInt๊ฐ NaN์ ๋ฐํํฉ๋๋ค.
NaN ๊ฐ์ ๋ชจ๋ ์ง์์์ ์ซ์๊ฐ ์๋๋๋ค. parseInt์ ๊ฒฐ๊ณผ๊ฐ NaN์ธ์ง ํ์ธํ๋ ค๋ฉด isNaN์ ์ฌ์ฉํ์ธ์. NaN์ ์ฐ์ ์ฐ์ฐ์ ์ฌ์ฉํ๋ฉด ์ฐ์ฐ ๊ฒฐ๊ณผ ์ญ์ NaN์ด ๋ฉ๋๋ค.
์ซ์๋ฅผ ํน์ ์ง์์ ๋ฌธ์์ด ๋ฆฌํฐ๋ด๋ก ๋ณํํ๋ ค๋ฉด number.toString(radix)๋ฅผ ์ฌ์ฉํ์ธ์.
์ง์ ์๋ 8์ง์ ํด์
2021๋ ์ ๊ธฐ์ค์ผ๋ก, ๋ค์ ๋ด์ฉ์ ์ต๊ทผ ๊ตฌํ์ฒด์ ํด๋นํ์ง ์์ต๋๋ค. ์ฃผ์ํ์ธ์.
ECMAScript 3๋ถํฐ ์ด๋ฏธ ๊ถ์ฅ๋์ง ์์์์๋ ๋ถ๊ตฌํ๊ณ , ๋ง์ ECMAScript 3 ๊ตฌํ์ฒด๋ 0์ผ๋ก ์์ํ๋ ์ซ์ํ ๋ฌธ์์ด์ 8์ง์๋ก ํด์ํ์ต๋๋ค. ๋ค์ ์ฝ๋๋ 8์ง์ ๊ฒฐ๊ณผ๋ฅผ ๋ผ ์๋ ์๊ณ , 10์ง์ ๊ฒฐ๊ณผ๋ฅผ ๋ผ ์๋ ์์์ต๋๋ค.
parseInt("0e0"); // 0
parseInt("08"); // 0, '8'์ 8์ง์ ์ซ์๊ฐ ์๋๊ธฐ ๋๋ฌธ
ECMAScript 5 ๋ช
์ธ๋ parseInt ๊ตฌํ์ด 0์ผ๋ก ์์ํ๋ ๋ฌธ์์ด์ 8์ง์๋ก ํด์ํ๋ ๊ฒ์ ๊ธ์งํ์ต๋๋ค. 2021๋
์์ ์์ ๋ง์ ๊ตฌํ์ฒด๊ฐ ์ด ๋์์ ์ ์ฉํ์ต๋๋ค.
parseInt("0e0"); // 0
parseInt("08"); // 8
๋ ์๊ฒฉํ ํ์ฑ ํจ์
๊ฐํน ์ ์๋ฅผ ํ์ฑํ ์ ์๋ ๋ ์๊ฒฉํ ๋ฐฉ๋ฒ์ด ํ์ํ ๋๊ฐ ์์ต๋๋ค. ์ ๊ทํํ์์ด ๋์์ด ๋ ์ ์์ต๋๋ค.
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
์์
>parseInt ์ฌ์ฉํ๊ธฐ
๋ค์์ ๋ชจ๋ 15๋ฅผ ๋ฐํํฉ๋๋ค.
parseInt("0xF", 16);
parseInt("F", 16);
parseInt("17", 8);
parseInt("015", 10); // parseInt('015', 8)์ด์๋ค๋ฉด 13์ ๋ฐํ
parseInt(15.99, 10);
parseInt("15,123", 10);
parseInt("FXX123", 16);
parseInt("1111", 2);
parseInt("15 * 3", 10);
parseInt("15e2", 10);
parseInt("15px", 10);
parseInt("12", 13);
๋ค์์ ๋ชจ๋ NaN์ ๋ฐํํฉ๋๋ค.
parseInt("Hello", 8); // ์ซ์๊ฐ ์ ํ ์๋
parseInt("546", 2); // 0๊ณผ 1์ ์ ์ธํ ์ซ์๋ 2์ง๋ฒ์์ ์ ํจํ์ง ์์
๋ค์์ ๋ชจ๋ -15๋ฅผ ๋ฐํํฉ๋๋ค.
parseInt("-F", 16);
parseInt("-0F", 16);
parseInt("-0XF", 16);
parseInt(-15.1, 10);
parseInt("-17", 8);
parseInt("-15", 10);
parseInt("-1111", 2);
parseInt("-15e1", 10);
parseInt("-12", 13);
๋ค์์ ๋ชจ๋ 4๋ฅผ ๋ฐํํฉ๋๋ค.
parseInt(4.7, 10);
parseInt(4.7 * 1e22, 10); // ๋งค์ฐ ํฐ ์ซ์๊ฐ 4๊ฐ ๋จ
parseInt(0.00000000000434, 10); // ๋งค์ฐ ์์ ์ซ์๊ฐ 4๊ฐ ๋จ
์ซ์๊ฐ 1e+21์ ์ด๊ณผํ๊ฑฐ๋ 1e-7 ๋ฏธ๋ง์ธ ๊ฒฝ์ฐ 10์ง์์์ 1์ ๋ฐํํฉ๋๋ค.
parseInt(0.0000001, 10);
parseInt(0.000000123, 10);
parseInt(1e-7, 10);
parseInt(1000000000000000000000, 10);
parseInt(123000000000000000000000, 10);
parseInt(1e21, 10);
๋ค์์ 224๋ฅผ ๋ฐํํฉ๋๋ค.
parseInt("0e0", 16);
BigInt ๊ฐ์ ์ ํ๋๋ฅผ ์์ต๋๋ค.
parseInt("900719925474099267n");
// 900719925474099300
parseInt๋ ์ซ์ ๊ตฌ๋ถ ๊ธฐํธ์ ํจ๊ป ์ฌ์ฉํ ์ ์์ต๋๋ค.
parseInt("123_456");
// 123
์ง์๋ 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
๋ช ์ธ
| Specification |
|---|
| ECMAScriptยฎ 2026 Languageย Specification> # sec-parseint-string-radix> |