22. Number 레퍼 객체

https://poiemaweb.com/js-number

Number | PoiemaWeb

 

 

Number 객체는 원시 타입 number를 다룰 때 유용한 프로퍼티와 메소드를 제공하는 레퍼(wrapper) 객체이다.

변수 또는 객체의 프로퍼티가 숫자를 값으로 가지고 있다면 Number 객체의 별도 생성없이 Number 객체의 프로퍼티와 메소드를 사용할 수 있다.

 

var num = 1.5;

console.log(num.toFixed()); // 2

 

위에서 원시 타입을 담고 있는 변수 num이 Number.prototype.toFixed() 메소드를 호출할 수 있는 것은 변수 num의 값이 일시적으로 wrapper객체로 변환되었기 때문이다.

 

-> 1.5는 그냥 숫자인데 어떻게 메소드 같은 함수를 가져다 쓸 수 있냐? 

-> 1.5 의 원시타입이 관련된 wrapper 객체로 변환되고 프로토타입 객체를 공유하여 메소드를 사용할 수 있음. 

-> 당연하게 쓰던 메소드들이 사실은 이런 과정을 거치고 있었음 !!

---

1. Number Constructor
Number 객체는 Number() 생성자 함수를 통해 생성할 수 있다.

var x = new Number(123);

var y = new Number('123');

var z = new Number('str');

console.log(x); // 123

console.log(y); // 123

console.log(z); // NaN

만일 인자가 숫자로 변환될 수 없다면 NaN을 반환한다.

 

 

new 연산자를 사용하면 객체(Object)가 되고

new 연산자를 사용하지 않으면 숫자(number)가 된다.

var x = Number('123');

var y = new Number('123');

console.log(typeof x, x); // number 123

console.log(typeof y, y); // object [Number: 123]

---

 

2. Number Property
정적(static) 프로퍼티로 Number 객체를 생성할 필요없이 Number.propertyName의 형태로 사용한다.

 

 

2.1 Number.EPSILON [ES6]
Number.EPSILON은 JavaScript에서 표현할 수 있는 가장 작은 수이다. 

-> 가장 작은 숫자이며, 숫자간의 간격이기도 하다.

Number.EPSILON은 약 2.2204460492503130808472633361816E-16 또는 2-52이다.

부동소수점 산술 연산 비교는 정확한 값을 기대하기 어렵다. 

정수는 2진법으로 오차없이 저장이 가능하지만,

부동소수점을 표현하는 표준인 IEEE 754은 2진법으로 변환시 무한소수가 되어 미세한 오차가 발생한다.

따라서 부동소수점의 비교는 Number.EPSILON을 사용하여 비교 기능을 갖는 함수를 작성하여야 한다.

console.log(0.1 + 0.2);        // 0.30000000000000004

console.log(0.1 + 0.2 == 0.3); // false!!!

function isEqual(a, b){

  // Math.abs는 절댓값을 반환한다.

  // 즉 a와 b의 차이가 JavaScript에서 표현할 수 있는 가장 작은 수인 Number.EPSILON보다 작으면 같은 수로 인정할 수 있다.

  return Math.abs(a - b) < Number.EPSILON;

}

console.log(isEqual(0.1 + 0.2, 0.3));

 

'두 수의 차'는 최소 Number.EPSILON 이상이여야 한다.

따라서 '두 수의 차' 가 Number.EPSILON 보다 작으면 두 수는 같은것으로 취급한다.

 

컴퓨터상 한계가 있으므로 숫자의 간격이 EPSILON 임

이런 느낌인듯 -> [  ... , -1 , ... , -2EP , -EP , 0 , 0+EP , 0+2EP, ... , 1 , ... ] 

---

2.2 Number.MAX_VALUE [ES1]
자바스크립트에서 사용 가능한 가장 큰 숫자(1.7976931348623157e+308)를 반환한다. 

MAX_VALUE보다 큰 숫자는 Infinity이다.

 

2.3 Number.MIN_VALUE [ES1]
자바스크립트에서 사용 가능한 가장 작은 숫자(5e-324)를 반환한다. 

MIN_VALUE는 0에 가장 가까운 양수 값이다. MIN_VALUE보다 작은 숫자는 0으로 변환된다.

 

Number.MAX_VALUE; // 1.7976931348623157e+308

var maxNum = 10;

maxNum.MAX_VALUE;    // undefined

console.log(Infinity > Number.MAX_VALUE); // true

Number.MIN_VALUE; // 5e-324

var minNum = 10;

minNum.MIN_VALUE;    // undefined

console.log(Number.MIN_VALUE > 0); // true

 

---

 

기타.

console.log(Math.abs(0-Number.MIN_VALUE) < Number.EPSILON);

 

Number.MIN_VALUE가 생각보다 작아보이길래,

두수의 차이가 EPSILON 보다 작으면 같다라는 점을 이용하여 0과 비교하였는데, 

true 로 나오지만.. ? 

이런 용도로 쓰면 안되고, 각각에 대해서 특정 상황에서 사용.

---

2.4 Number.POSITIVE_INFINITY [ES1]

양의 무한대 Infinity를 반환한다.

 

 

2.5 Number.NEGATIVE_INFINITY [ES1]
음의 무한대 -Infinity를 반환한다.

 

Number.POSITIVE_INFINITY // Infinity

var postInf= 10;

postInf.POSITIVE_INFINITY;   // undefined

Number.NEGATIVE_INFINITY // -Infinity

var negaInf = 10;

negaInf.NEGATIVE_INFINITY;   // undefined

 

---

 

2.6 Number.NaN [ES1]
숫자가 아님(Not-a-Number)을 나타내는 숫자값이다. 

Number.NaN 프로퍼티는 window.NaN 프로퍼티와 같다.

console.log(Number('xyz')); // NaN

console.log(1 * 'string');  // NaN

console.log(typeof NaN);    // number

 

---

 

정리

Number.EPSILON : 부동소수점의 두 수가 같은지 확인할때 사용

Number.MAX_VALUE : 자바스크립트에서 가장 큰 숫자 , 테스트 케이스 , 정밀도 

Number.MIN_VALUE : 자바스크립트에서 0에 가장 가까운 수, 테스트 케이스, 정밀도

Number.POSITIVE_INFINITY : 양의 무한대 값

Number.NEGATIVE_INFINITY  : 음의 무한대 값

Number.NaN : Not-a-Number , 숫자가 아님, 타입은 number 

 

---

 

3. Number Method

3.1 Number.isFinite(testValue: number): boolean [ES6]
매개변수에 전달된 값이 정상적인 '유한한 수'인지를 검사하여 그 결과를 Boolean으로 반환한다.

 

전역 함수 isFinite()는 인수를 숫자로 변환하여 검사를 수행하며,

이와 다르게 Number.isFinite()는 인수를 변환하지 않는다.

따라서 숫자가 아닌 인수가 주어졌을 때 반환값은 언제나 false가 된다.

 

Number.isFinite(Infinity)  // false

Number.isFinite(NaN)       // false

Number.isFinite('Hello')   // false

Number.isFinite('2005/12/12')   // false

Number.isFinite(0)         // true

Number.isFinite(2e64)      // true

Number.isFinite(null)      // false. isFinite(null) => true

// Number.isFinite() 와 isFinite() 차이

console.log(Number.isFinite(1)) // true

console.log(Number.isFinite('1')) // false

console.log(isFinite(1)) // true

console.log(isFinite('1')) // true

 

---

 

3.2 Number.isInteger(testValue: number): boolean [ES6]
매개변수에 전달된 값이 정수(Integer)인지 검사하여 그 결과를 Boolean으로 반환한다. 

검사전에 인수를 숫자로 변환하지 않는다.

 

Number.isInteger(123)   //true

Number.isInteger(-123)  //true

Number.isInteger(5-2)   //true

Number.isInteger(0)     //true

Number.isInteger(0.5)   //false

Number.isInteger('123') //false

Number.isInteger(false) //false

Number.isInteger(Infinity)  //false

Number.isInteger(-Infinity) //false

Number.isInteger(0 / 0) //false

 

---

 

3.3 Number.isNaN(testValue: number): boolean [ES6]
매개변수에 전달된 값이 NaN인지를 검사하여 그 결과를 Boolean으로 반환한다.

 

Number.isNaN()는 전역 함수 isNaN()와 차이가 있다.

전역 함수 isNaN()는 인수를 숫자로 변환하여 검사를 수행하지만

Number.isNaN()는 인수를 변환하지 않는다.

따라서 숫자가 아닌 인수가 주어졌을 때 반환값은 언제나 false가 된다.

Number.isNaN(NaN)       // true

Number.isNaN(undefined) // false. undefined → NaN. isNaN(undefined) → true.

Number.isNaN({})        // false. {} → NaN.        isNaN({}) → true.

Number.isNaN('blabla')  // false. 'blabla' → NaN.  isNaN('blabla') → true.

Number.isNaN(true)      // false

Number.isNaN(null)      // false

Number.isNaN(37)        // false

Number.isNaN('37');     // false

Number.isNaN('37.37');  // false

Number.isNaN('');       // false

Number.isNaN(' ');      // false

Number.isNaN(new Date())             // false

Number.isNaN(new Date().toString())  // false. String → NaN. isNaN(String) → true.

 

Number.isNaN은 오직 NaN 만 true 인듯하다.

isNaN 은 String 도 NaN 으로 보는데 조금 햇깔린다. 

 

---

 

3.4 Number.isSafeInteger(testValue: number): boolean [ES6]
매개변수에 전달된 값이 안전한(safe) 정수값인지 검사하여 그 결과를 Boolean으로 반환한다. 

안전한 정수값은 -(2^53 - 1)와 2^53 - 1 사이의 정수값이다. 

검사전에 인수를 숫자로 변환하지 않는다.

Number.isSafeInteger(123)   //true

Number.isSafeInteger(-123)  //true

Number.isSafeInteger(5-2)   //true

Number.isSafeInteger(0)     //true

Number.isSafeInteger(1000000000000000)  // true

Number.isSafeInteger(10000000000000001) // false

Number.isSafeInteger(0.5)   //false

Number.isSafeInteger('123') //false

Number.isSafeInteger(false) //false

Number.isSafeInteger(Infinity)  //false

Number.isSafeInteger(-Infinity) //false

Number.isSafeInteger(0 / 0) //false

6번째를 보면 정수 인데도 false 인것을 확인

 

---

 

3.5 Number.prototype.toExponential(fractionDigits?: number): string [ES3]
대상을 지수 표기법으로 변환하여 문자열로 반환한다. 

지수 표기법이란 매우 큰 숫자를 표기할 때 주로 사용하며 e(Exponent) 앞에 있는 숫자에 10의 n승이 곱하는 형식으로 수를 나타내는 방식이다.

 

 

1234 = 1.234e+3

 

var numObj = 77.1234;

console.log(numObj.toExponential());  // logs 7.71234e+1

console.log(numObj.toExponential(4)); // logs 7.7123e+1

console.log(numObj.toExponential(2)); // logs 7.71e+1

console.log(77.1234.toExponential()); // logs 7.71234e+1

console.log(77.toExponential());      // SyntaxError: Invalid or unexpected token

console.log(77 .toExponential());     // logs 7.7e+1

 

 

정수 리터럴과 함께 메소드를 사용할 경우

 

console.log(77.toExponential()); // SyntaxError: Invalid or unexpected token

console.log(77 .toExponential()); // '7.7e+1'

console.log((77).toExponential()); // '7.7e+1'

 

---

3.6 Number.prototype.toFixed(fractionDigits?: number): string [ES3]
매개변수로 지정된 소숫점자리를 반올림하여 문자열로 반환한다.

var numObj = 12345.6789;

// 소숫점 이하 반올림

console.log(numObj.toFixed());   // '12346'

// 소숫점 이하 1자리수 유효, 나머지 반올림

console.log(numObj.toFixed(1));  // '12345.7'

// 소숫점 이하 2자리수 유효, 나머지 반올림

console.log(numObj.toFixed(2));  // '12345.68'

// 소숫점 이하 3자리수 유효, 나머지 반올림

console.log(numObj.toFixed(3));  // '12345.679'

// 소숫점 이하 6자리수 유효, 나머지 반올림

console.log(numObj.toFixed(6));  // '12345.678900'

 

---

3.7 Number.prototype.toPrecision(precision?: number): string [ES3]
매개변수로 지정된 전체 자릿수까지 유효하도록 나머지 자릿수를 반올림하여 문자열로 반환한다. 지정된 전체 자릿수로 표현할 수 없는 경우 지수 표기법으로 결과를 반환한다.

 

var numObj = 15345.6789;

// 전체자리수 유효

console.log(numObj.toPrecision());   // '12345.6789'

// 전체 1자리수 유효, 나머지 반올림

console.log(numObj.toPrecision(1));  // '2e+4'

// 전체 2자리수 유효, 나머지 반올림

console.log(numObj.toPrecision(2));  // '1.5e+4'

// 전체 3자리수 유효, 나머지 반올림

console.log(numObj.toPrecision(3));  // '1.53e+4'

// 전체 6자리수 유효, 나머지 반올림

console.log(numObj.toPrecision(6));  // '12345.7'

 

---

3.8 Number.prototype.toString(radix?: number): string [ES1]
숫자를 문자열로 변환하여 반환한다.

var count = 10;

console.log(count.toString());   // '10'

console.log((17).toString());    // '17'

console.log(17 .toString());     // '17'

console.log((17.2).toString());  // '17.2'

var x = 16;

console.log(x.toString(2));       // '10000'

console.log(x.toString(8));       // '20'

console.log(x.toString(16));      // '10'

console.log((254).toString(16));  // 'fe'

console.log((-10).toString(2));   // '-1010'

console.log((-0xff).toString(2)); // '-11111111'

 

---

3.9 Number.prototype.valueOf(): number [ES1]
Number 객체의 원시 타입 값(primitive value)을 반환한다.

 

 

let numObj = new Number(10); // Number 객체 생성

let numPrim = 10; // 숫자 리터럴을 이용한 원시 값 생성

console.log(numObj.valueOf()); // 10

console.log(numPrim.valueOf()); // undefined (원시 값은 직접적으로 valueOf() 메서드를 호출할 수 없음)

console.log(typeof numObj) // object

console.log(typeof numObj.valueOf()) // number

console.log(typeof numPrim) // number

console.log(numObj === numPrim); // false (타입이 다름)

console.log(numObj.valueOf() === numPrim); // true (값이 같음)

 

numObj 가 valueOf 를 쓰면 type까지 변해서 numPrim 이 된다.

 

---

 

정리

 

Number.isFinite(testValue: number): 유한한 수이면 true 반환 // cf. isFinite
Number.isInteger(testValue: number): 정수면 true 반환
Number.isNaN(testValue: number): NaN 이면 true 반환 // cf. isNaN
Number.isSafeInteger(testValue: number): 안전한(특정범위) 정수이면 true 반환

  testValue : 테스트 값  

 

Number.prototype.toExponential(fractionDigits?: number) : 지수표기법으로 변환하여 String 반환
Number.prototype.toFixed(fractionDigits?: number): string : 소숫점자리를 반올림하여 String 반환

  fractionDigits : 소숫점 이하 자릿수

Number.prototype.toPrecision(precision?: number): 지정된 전체 자릿수까지 나머지 자릿수를 반올림 String 반환

  precision : 지정 자릿수

Number.prototype.toString([radix?: number]): 숫자를 문자열로 변환하여 String 반환

  radix : 2-36진법, 생략가능

Number.prototype.valueOf(): Object 객체를 원시 타입 number 로 변환 

 

---

 

1.5toFixed() 가 어떻게 작동하는지?

1.5 의 원시타입이 관련된 wrapper 객체로 변환되고 프로토타입 객체를 공유하여 메소드를 사용할 수 있음. 

 

 

아래의 식의 결과는?

 

console.log(0.1 + 0.2 == 0.3)

 

 

부동소수점을 비교시 2진법을 이용하는데, 무한소수가 되어 오차가 발생한다.

Number.EPSILON 를 사용해야한다.

Number.EPSILON 크기가 가장 작은 수로 두 수의 차이가 Number.EPSILON 보다 작으면 같다고 인정

Math.abs((0.1+0.2) - 0.3 ) < Number.EPSILON 이 true 일 경우 두 수는 같음.

 

 

 

 

https://chatgpt.com/