28장 Number

28.1 Number 생성자 함수(28-01)

  • 표준 빌트인 객체인 Number 객체는 생성자 함수 객체다

  • 인수없이 인스턴스 생성시 [[NumberData]] 내부 슬롯에 0을 할당한 Number 래퍼 객체를 생성

const numObj = new Number();
console.log(numObj); // Number {[[PrimitiveValue]]: 0}

28-02

  • ES5에선 [[NumberData]]를 [[PrimitiveValue]]라 불렀다
const numObj = new Number(10);
console.log(numObj); // Number {[[PrimitiveValue]]: 10}

28-03

  • 숫자로 변환 못하는 인수는 NaN으로 생성
let numObj = new Number('10');
console.log(numObj); // Number {[[PrimitiveValue]]: 10}

numObj = new Number('Hello');
console.log(numObj); // Number {[[PrimitiveValue]]: NaN}

28-04

  • new 없이 생성하면 숫자타입으로 변환만 함(앞에서 배움)
// 문자열 타입 => 숫자 타입
Number('0');     // -> 0
Number('-1');    // -> -1
Number('10.53'); // -> 10.53

// 불리언 타입 => 숫자 타입
Number(true);  // -> 1
Number(false); // -> 0

28.2 Number 프로퍼티

28.2.1 Number.EPSILON(28-05)

  • ES6에서 도입된 Number.EPSILON은 1과 1보다 큰 숫자 중에서 가장 작은 숫자와의 차이와 같다
0.1 + 0.2;         // -> 0.30000000000000004
0.1 + 0.2 === 0.3; // -> false

28-06

  • 파이썬에서도 이렇게 엡실론과 비교를 했다
function isEqual(a, b){
  // a와 b를 뺀 값의 절대값이 Number.EPSILON보다 작으면 같은 수로 인정한다.
  return Math.abs(a - b) < Number.EPSILON;
}

isEqual(0.1 + 0.2, 0.3); // -> true

28.2.2 Number.MAX_VALUE(28-07)

  • 자바스크립트에서 표현할 수 있는 가장 큰 양수 값
Number.MAX_VALUE; // -> 1.7976931348623157e+308
Infinity > Number.MAX_VALUE; // -> true

28.2.3 Number.MIN_VALUE(28-08)

  • 가장 작은 양수 값
Number.MIN_VALUE; // -> 5e-324
Number.MIN_VALUE > 0; // -> true

28.2.4 Number.MAX_SAFE_INTEGER(28-09)

  • 가장 큰 정수 값
Number.MAX_SAFE_INTEGER; // -> 9007199254740991

28.2.5 Number.MIN_SAFE_INTEGER(28-10)

  • 가장 작은 정수 값
Number.MIN_SAFE_INTEGER; // -> -9007199254740991

28.2.6 Number.POSITIVE_INFINITY(28-11)

  • 양의 무한대를 나타내는 숫자값 = Infinity
Number.POSITIVE_INFINITY; // -> Infinity

28.2.7 Number.NEGATIVE_INFINITY(28-12)

  • 음의 무한대를 나타내는 숫자값 = -Infinity
Number.NEGATIVE_INFINITY; // -> -Infinity

28.2.8 Number.NaN(28-13)

  • 숫자가 아님을 나타내는 숫자값
Number.NaN; // -> NaN

28.3 Number 메서드

28.3.1 Number.isFinite(28-14)

  • 암묵적 타입변환 하지 않음(그래서 문자는 그냥 false)
// 인수가 정상적인 유한수이면 true를 반환한다.
Number.isFinite(0);                // -> true
Number.isFinite(Number.MAX_VALUE); // -> true
Number.isFinite(Number.MIN_VALUE); // -> true

// 인수가 무한수이면 false를 반환한다.
Number.isFinite(Infinity);  // -> false
Number.isFinite(-Infinity); // -> false

28-15

Number.isFinite(NaN); // -> false

28-16

  • Number.isFinite메서드는 빌트인 전역 함수 isFinite와 차이가 있다
// Number.isFinite는 인수를 숫자로 암묵적 타입 변환하지 않는다.
Number.isFinite(null); // -> false

// isFinite는 인수를 숫자로 암묵적 타입 변환한다. null은 0으로 암묵적 타입 변환된다.
isFinite(null); // -> true

28.3.2 Number.isInteger(28-17)

  • 암묵적 타입변환 하지 않음
// 인수가 정수이면 true를 반환한다.
Number.isInteger(0)     // -> true
Number.isInteger(123)   // -> true
Number.isInteger(-123)  // -> true

// 0.5는 정수가 아니다.
Number.isInteger(0.5)   // -> false
// '123'을 숫자로 암묵적 타입 변환하지 않는다.
Number.isInteger('123') // -> false
// false를 숫자로 암묵적 타입 변환하지 않는다.
Number.isInteger(false) // -> false
// Infinity/-Infinity는 정수가 아니다.
Number.isInteger(Infinity)  // -> false
Number.isInteger(-Infinity) // -> false

28.3.3 Number.isNaN(28-18)

  • 암묵적 타입변환 하지 않음
// 인수가 NaN이면 true를 반환한다.
Number.isNaN(NaN); // -> true

28-19

  • Number.isNaN메서드와 빌트인 전역 함수 isNaN과 차이가 있다
// Number.isNaN은 인수를 숫자로 암묵적 타입 변환하지 않는다.
Number.isNaN(undefined); // -> false

// isNaN은 인수를 숫자로 암묵적 타입 변환한다. undefined는 NaN으로 암묵적 타입 변환된다.
isNaN(undefined); // -> true

28.3.4 Number.isSafeInteger(28-20)

  • 암묵적 타입변환 하지 않음 안전한 정수값은 -(2^53-1) ~ (2^53-1) 사이의 정수값이다
// 0은 안전한 정수이다.
Number.isSafeInteger(0); // -> true
// 1000000000000000은 안전한 정수이다.
Number.isSafeInteger(1000000000000000); // -> true

// 10000000000000001은 안전하지 않다.
Number.isSafeInteger(10000000000000001); // -> false
// 0.5은 정수가 아니다.
Number.isSafeInteger(0.5); // -> false
// '123'을 숫자로 암묵적 타입 변환하지 않는다.
Number.isSafeInteger('123'); // -> false
// false를 숫자로 암묵적 타입 변환하지 않는다.
Number.isSafeInteger(false); // -> false
// Infinity/-Infinity는 정수가 아니다.
Number.isSafeInteger(Infinity); // -> false

28.3.5 Number.prototype.toExponential(28-21)

  • 숫자를 지수 표기법으로 변환하여 문자열로 반환 지수 표기법이란 e앞의 수를 10의 n승을 곱하는 형식으로 나타냄

  • 인수는 표현할 소수점 이하의 자리수를 의미

(77.1234).toExponential();  // -> "7.71234e+1"
(77.1234).toExponential(4); // -> "7.7123e+1"
(77.1234).toExponential(2); // -> "7.71e+1"

28-22

  • 엔진은 숫자 뒤의 .을 부동 소수점 숫자의 소수 구분 기호로 해석
77.toExponential(); // -> SyntaxError: Invalid or unexpected token

28-23

  • 소수점은 당연히 하나만 존재하므로 아래 예시는 부동 소수점으로 잘 해석이 되어서 문제가 없는것
77.1234.toExponential(); // -> "7.71234e+1"

28-24

  • 그룹 연산자()를 사용하길 권장
(77).toExponential(); // -> "7.7e+1"

28-25

  • 다만, 이렇게도 가능(공백이 오면 .을 소수 구분 기호로 해석하지 않음)
77 .toExponential(); // -> "7.7e+1"

28.3.6 Number.prototype.toFixed(28-26)

  • 숫자를 반올림하여 문자열로 반환(소수점 이하) 인수의 기본값은 0
// 소수점 이하 반올림. 인수를 생략하면 기본값 0이 지정된다.
(12345.6789).toFixed(); // -> "12346"
// 소수점 이하 1자리수 유효, 나머지 반올림
(12345.6789).toFixed(1); // -> "12345.7"
// 소수점 이하 2자리수 유효, 나머지 반올림
(12345.6789).toFixed(2); // -> "12345.68"
// 소수점 이하 3자리수 유효, 나머지 반올림
(12345.6789).toFixed(3); // -> "12345.679"

28.3.7 Number.prototype.toPrecision(28-27)

  • 숫자를 반올림하여 문자열로 반환(전체 자리수) 인수의 기본값은 0
// 전체 자리수 유효. 인수를 전달하지 않으면 기본값 0이 전달된다.
(12345.6789).toPrecision(); // -> "12345.6789"
// 전체 1자리수 유효, 나머지 반올림
(12345.6789).toPrecision(1); // -> "1e+4"
// 전체 2자리수 유효, 나머지 반올림
(12345.6789).toPrecision(2); // -> "1.2e+4"
// 전체 6자리수 유효, 나머지 반올림
(12345.6789).toPrecision(6); // -> "12345.7"

28.3.8 Number.prototype.toString(28-28)

  • 숫자를 문자열로 반환 인수의 기본값은 10(10진법을 의미)
// 인수를 생략하면 10진수 문자열을 반환한다.
(10).toString(); // -> "10"
// 2진수 문자열을 반환한다.
(16).toString(2); // -> "10000"
// 8진수 문자열을 반환한다.
(16).toString(8); // -> "20"
// 16진수 문자열을 반환한다.
(16).toString(16); // -> "10"

댓글남기기

참고