JavaScript์์ Number ๊ฐ์ฒด๋ ์ซ์ ๊ด๋ จ ์์ ์ ์ฒ๋ฆฌํ๋ ์ค์ํ ๊ธฐ๋ฅ์ ์ ๊ณตํฉ๋๋ค. ์ด ๊ฐ์ฒด์๋ ์ซ์๋ฅผ ๋ค๋ฃจ๊ธฐ ์ํ ๋ค์ํ ์ซ์ ์์ฑ(Number Properties)์ด ํฌํจ๋์ด ์์ผ๋ฉฐ, ์ด ์์ฑ๋ค์ JavaScript์์ ์ซ์์ ๊ด๋ จ๋ ํ๊ณ์ ์์๊ฐ์ ์ ์ํฉ๋๋ค. ์ด ๊ธ์์๋ ์์ฃผ ์ฌ์ฉ๋๋ JavaScript ์ซ์ ์์ฑ๊ณผ ๊ทธ ํ์ฉ ๋ฐฉ๋ฒ์ ์์๋ณด๊ฒ ์ต๋๋ค.
JavaScript์ ์ฃผ์ ์ซ์ ์์ฑ
JavaScript์์ ์ซ์ ๊ด๋ จ ์์ฑ๋ค์ Number
๊ฐ์ฒด์ ์ํด ์์ผ๋ฉฐ, ์ผ๋ฐ์ ์ผ๋ก ์ต๋๊ฐ, ์ต์๊ฐ, ๋ฌดํ๋ ๋ฑ์ ์ ์ํฉ๋๋ค. ์ด๋ฌํ ์์ฑ๋ค์ ๊ฐ์ ์ง์ ๋ณ๊ฒฝํ ์ ์์ผ๋ฉฐ, ์์๋ก ์ ์๋์ด ์์ต๋๋ค.
1. Number.MAX_VALUE
: JavaScript์์ ํํํ ์ ์๋ ๊ฐ์ฅ ํฐ ์ซ์
Number.MAX_VALUE
์์ฑ์ JavaScript์์ ํํํ ์ ์๋ ๊ฐ์ฅ ํฐ ์ซ์๋ฅผ ๋ํ๋
๋๋ค. ์ด ๊ฐ์ ๋๋ ์ซ์๋ ๋ฌดํ๋(Infinity
)๋ก ์ทจ๊ธ๋ฉ๋๋ค.
console.log(Number.MAX_VALUE); // ๊ฒฐ๊ณผ: 1.7976931348623157e+308
let bigNumber = Number.MAX_VALUE * 2;
console.log(bigNumber); // ๊ฒฐ๊ณผ: Infinity (๋ฌดํ๋)
์ ์ฝ๋์์ Number.MAX_VALUE
๋ JavaScript์์ ๋ค๋ฃฐ ์ ์๋ ์ต๋ ์ ๋ฐ๋๋ฅผ ๊ฐ์ง ์ซ์์
๋๋ค. ์ด ๊ฐ์ ์ด๊ณผํ๋ฉด ์ซ์๋ ๋ฌดํ๋๋ก ์ฒ๋ฆฌ๋ฉ๋๋ค.
2. Number.MIN_VALUE
: JavaScript์์ ํํํ ์ ์๋ ๊ฐ์ฅ ์์ ์์
Number.MIN_VALUE
์์ฑ์ JavaScript์์ ํํํ ์ ์๋ ๊ฐ์ฅ ์์ ์์(0์ ๊ฐ์ฅ ๊ฐ๊น์ด ์์)๋ฅผ ๋ํ๋
๋๋ค. ์์๋ ํฌํจ๋์ง ์์ต๋๋ค.
console.log(Number.MIN_VALUE); // ๊ฒฐ๊ณผ: 5e-324
let smallerNumber = Number.MIN_VALUE / 2;
console.log(smallerNumber); // ๊ฒฐ๊ณผ: 0
Number.MIN_VALUE
๋ 0๋ณด๋ค ํฐ ๊ฐ์ฅ ์์ ์์๋ฅผ ๋ํ๋ด๋ฉฐ, ์ด ๊ฐ์ ๋๋๋ฉด 0์ ๊ฐ๊น์์ง๋๋ค.
3. Number.POSITIVE_INFINITY
: ์์ ๋ฌดํ๋
Number.POSITIVE_INFINITY
๋ ์์ ๋ฌดํ๋๋ฅผ ๋ํ๋ด๋ ๊ฐ์
๋๋ค. ๋งค์ฐ ํฐ ์ซ์๋ฅผ ๊ณ์ฐํ ๋, ๊ทธ ๊ฒฐ๊ณผ๊ฐ Number.MAX_VALUE
๋ฅผ ์ด๊ณผํ๋ฉด ๋ฌดํ๋ ๊ฐ์ด ๋ฐํ๋ฉ๋๋ค.
let positiveInfinity = Number.POSITIVE_INFINITY;
console.log(positiveInfinity); // ๊ฒฐ๊ณผ: Infinity
console.log(1 / 0); // ๊ฒฐ๊ณผ: Infinity (์์ ๋ฌดํ๋)
JavaScript์์ 0์ผ๋ก ๋๋๋ ๊ฒฝ์ฐ์๋ POSITIVE_INFINITY
๊ฐ ๋ฐํ๋ฉ๋๋ค.
4. Number.NEGATIVE_INFINITY
: ์์ ๋ฌดํ๋
Number.NEGATIVE_INFINITY
๋ ์์ ๋ฌดํ๋๋ฅผ ๋ํ๋
๋๋ค. ๋งค์ฐ ์์ ๊ฐ์ด Number.MIN_VALUE
๋ณด๋ค ๋ ์์์ง๋ฉด ์์ ๋ฌดํ๋๊ฐ ๋ฐํ๋ฉ๋๋ค.
let negativeInfinity = Number.NEGATIVE_INFINITY;
console.log(negativeInfinity); // ๊ฒฐ๊ณผ: -Infinity
console.log(-1 / 0); // ๊ฒฐ๊ณผ: -Infinity (์์ ๋ฌดํ๋)
์์๋ฅผ 0์ผ๋ก ๋๋๋ฉด NEGATIVE_INFINITY
๊ฐ ๋ฐํ๋ฉ๋๋ค.
5. Number.NaN
: ์ซ์๊ฐ ์๋ (Not-a-Number)
Number.NaN
์์ฑ์ ์ซ์๊ฐ ์๋ ๊ฐ(Not-a-Number)์ ๋ํ๋
๋๋ค. ์ด ๊ฐ์ ์ซ์ ์ฐ์ฐ์์ ์ ํจํ์ง ์์ ๊ฒฐ๊ณผ๊ฐ ๋ฐ์ํ ๋ ๋ฐํ๋ฉ๋๋ค.
let invalidResult = 0 / "Hello";
console.log(invalidResult); // ๊ฒฐ๊ณผ: NaN
console.log(Number.NaN); // ๊ฒฐ๊ณผ: NaN
์๋ชป๋ ์ฐ์ฐ์ด๋ ๋ณํ์ ์๋ํ ๊ฒฝ์ฐ NaN
๊ฐ์ด ๋ฐํ๋๋ฉฐ, ์ด ๊ฐ์ ์ฒดํฌํ๋ ค๋ฉด isNaN()
ํจ์๋ฅผ ์ฌ์ฉํ ์ ์์ต๋๋ค.
์ซ์ ์์ฑ ํ์ฉ ์์
๋ค์์ ์ซ์ ์์ฑ์ ํ์ฉํ์ฌ ํน์ ์ซ์๊ฐ ์ ํจํ์ง ๋๋ ์์ ํ์ง ํ์ธํ๋ ๊ฐ๋จํ ์์์ ๋๋ค.
์ซ์ ๋ฒ์ ๊ฒ์ฌ
function checkNumberRange(num) {
if (num > Number.MAX_VALUE) {
return "๋ฌดํ๋์ ๋๋ฌํ์ต๋๋ค!";
} else if (num < Number.MIN_VALUE && num > 0) {
return "0์ ๊ฐ๊น์ต๋๋ค!";
} else {
return "์์ ํ ๋ฒ์์ ์ซ์์
๋๋ค.";
}
}
console.log(checkNumberRange(1.8e+308)); // ๊ฒฐ๊ณผ: "๋ฌดํ๋์ ๋๋ฌํ์ต๋๋ค!"
console.log(checkNumberRange(5e-325)); // ๊ฒฐ๊ณผ: "0์ ๊ฐ๊น์ต๋๋ค!"
console.log(checkNumberRange(1000)); // ๊ฒฐ๊ณผ: "์์ ํ ๋ฒ์์ ์ซ์์
๋๋ค."
์ ์ฝ๋์์๋ Number.MAX_VALUE
์ Number.MIN_VALUE
๋ฅผ ์ฌ์ฉํ์ฌ ํน์ ์ซ์๊ฐ ์์ ํ ๋ฒ์ ๋ด์ ์๋์ง๋ฅผ ๊ฒ์ฌํฉ๋๋ค.
NaN ๊ฐ ๊ฒ์ฌ
function checkIfNaN(value) {
if (isNaN(value)) {
return "์ด ๊ฐ์ ์ซ์๊ฐ ์๋๋๋ค.";
} else {
return "์ ํจํ ์ซ์์
๋๋ค.";
}
}
console.log(checkIfNaN(100 / "Apple")); // ๊ฒฐ๊ณผ: "์ด ๊ฐ์ ์ซ์๊ฐ ์๋๋๋ค."
console.log(checkIfNaN(100)); // ๊ฒฐ๊ณผ: "์ ํจํ ์ซ์์
๋๋ค."
isNaN()
ํจ์๋ฅผ ์ฌ์ฉํ์ฌ ๊ฐ์ด ์ ํจํ ์ซ์์ธ์ง, ๋๋ NaN
์ธ์ง๋ฅผ ํ์ธํ ์ ์์ต๋๋ค.
๊ฒฐ๋ก
JavaScript์ Number
์์ฑ๋ค์ ์ซ์ ์์
์์ ์ค์ํ ์ญํ ์ ํฉ๋๋ค. MAX_VALUE
์ MIN_VALUE
๋ ์ซ์์ ์ต๋ ๋ฐ ์ต์ ํ๊ณ๋ฅผ ์ ์ํ๊ณ , POSITIVE_INFINITY
์ NEGATIVE_INFINITY
๋ ๋ฌดํ๋๋ฅผ ๋ค๋ฃจ๋ฉฐ, NaN
์ ์ ํจํ์ง ์์ ์ซ์ ์ฐ์ฐ ๊ฒฐ๊ณผ๋ฅผ ๋ํ๋
๋๋ค. ์ด๋ฌํ ์์ฑ๋ค์ ์ ํ์ฉํ๋ฉด ์ซ์์ ๊ด๋ จ๋ ์์
์ ๋์ฑ ์์ ํ๊ณ ํจ๊ณผ์ ์ผ๋ก ์ฒ๋ฆฌํ ์ ์์ต๋๋ค.
JavaScript์ ์ซ์ ์์ฑ๋ค์ ํ๋ก์ ํธ์์ ํ์ฉํ์ฌ ๋ณต์กํ ์ซ์ ์์ ์ ํจ๊ณผ์ ์ผ๋ก ์ฒ๋ฆฌํด๋ณด์ธ์!
๋๊ธ ์ฐ๊ธฐ