Responsive Advertisement

JavaScript Number Properties: ์ˆซ์ž ์†์„ฑ๊ณผ ํ™œ์šฉ๋ฒ•

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์˜ ์ˆซ์ž ์†์„ฑ๋“ค์„ ํ”„๋กœ์ ํŠธ์—์„œ ํ™œ์šฉํ•˜์—ฌ ๋ณต์žกํ•œ ์ˆซ์ž ์ž‘์—…์„ ํšจ๊ณผ์ ์œผ๋กœ ์ฒ˜๋ฆฌํ•ด๋ณด์„ธ์š”!

๋Œ“๊ธ€ ์“ฐ๊ธฐ