ํ์ค ๋นํธ์ธ ๊ฐ์ฒด์ธ Number๋ ์์ ํ์
์ธ ์ซ์๋ฅผ ๋ค๋ฃฐ ๋ ์ ์ฉํ ํ๋กํผํฐ์ ๋ฉ์๋๋ฅผ ์ ๊ณตํ๋ค.
ํ์ค ๋นํธ์ธ ๊ฐ์ฒด์ธ Number ๊ฐ์ฒด๋ ์์ฑ์ ํจ์ ๊ฐ์ฒด๋ค. ๋ฐ๋ผ์ new ์ฐ์ฐ์์ ํจ๊ผ ํธ์ถํ์ฌ Number ์ธ์คํด์ค๋ฅผ ์์ฑ
ํ ์ ์๋ค.
Number ์์ฑ์ ํจ์์ ์ธ์๋ฅผ ์ ๋ฌํ์ง ์๊ณ new ์ฐ์ฐ์์ ํจ๊ป ํธ์ถํ๋ฉด [[NumberData]] ๋ด๋ถ ์ฌ๋กฏ์ 0์ ํ ๋นํ Number ๋ํผ ๊ฐ์ฒด
๋ฅผ ์์ฑํ๋ค.
const numObj = new Number();
console.log(numObj); // Number {[[PrimitiveValue]]: 0}
Number ์์ฑ์ ํจ์์ ์ธ์๋ก ์ซ์๊ฐ ์๋ ๊ฐ์ ์ ๋ฌํ๋ฉด ์ธ์๋ฅผ ์ซ์๋ก ๊ฐ์ ๋ณํ
new ์ฐ์ฐ์๋ฅผ ์ฌ์ฉํ์ง ์๊ณ Number ์์ฑ์ ํจ์๋ฅผ ํธ์ถํ๋ฉด Number ์ธ์คํด์ค๊ฐ ์๋ ์ซ์๋ฅผ ๋ฐํํ๋ค. ์ด๋ฅผ ์ด์ฉํ์ฌ ๋ช
์์ ์ผ๋ก ํ์
์ ๋ณํํ๊ธฐ๋ ํจ.
// ๋ฌธ์์ด ํ์
=> ์ซ์ ํ์
Number('0'); // 0
Number('-1'); // -1
Number('10.53'); // 10.53
// ๋ถ๋ฆฌ์ธ ํ์
=> ์ซ์ ํ์
Number(true); // 1
Number(false); // 0
ES6์์ ๋์
๋๋ Number.EPSILON์ 1๊ณผ 1๋ณด๋ค ํฐ ์ซ์ ์ค์์ ๊ฐ์ฅ ์์ ์ซ์์์ ์ฐจ์ด์ ๊ฐ๋ค. Number.EPSILON์ ๋ถ๋์์์ ์ผ๋ก ์ธํด ๋ฐ์ํ๋ ์ค์ฐจ๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํด ์ฌ์ฉํ๋ค.
function isEqual(a,b){
// a์ b๋ฅผ ๋บธ ๊ฐ์ ์ ๋๊ฐ์ด Number.EPSILON๋ณด๋ค ์์ผ๋ฉด ๊ฐ์ ์๋ก ์ธ์ ํ๋ค
return Math.abs(a-b) < Number.EPSILON;
}
isEqual(0.1 + 0.2, 0.3); // true
Number.MAX_VALUE๋ ์๋ฐ์คํฌ๋ฆฝํธ์์ ํํํ ์ ์๋ ๊ฐ์ฅ ํฐ ์์ ๊ฐ์ด๋ค. Number.MAX_VALUE๋ณด๋ค ํฐ ์ซ์๋ Infinity๋ค.
Number.MAX_VALUE; // 1.7976931348623157e+308
Infinity > Number.MAX_VALUE; // true
Number.MAX_VALUE๋ ์๋ฐ์คํฌ๋ฆฝํธ์์ ํํํ ์ ์๋ ๊ฐ์ฅ ์์ ์์ ๊ฐ์ด๋ค. Number.MAX_VALUE๋ณด๋ค ์์ ์ซ์๋ 0์ด๋ค.
Number.MIN_VALUE; // 5e-324
Number.MIN_VALUE > 0; // true
Number.MAX_SAFE_INTEGER๋ ์๋ฐ์คํฌ๋ฆฝํธ์์ ์์ ํ๊ฒ ํํํ ์ ์๋ ๊ฐ์ฅ ํฐ ์ ์๊ฐ(9007199254740991์ด๋ค.
Number.MAX_SAFE_INTEGER; // 9007199254740991์ด๋ค
Number.MAX_SAFE_INTEGER๋ ์๋ฐ์คํฌ๋ฆฝํธ์์ ์์ ํ๊ฒ ํํํ ์ ์๋ ๊ฐ์ฅ ์์ ์ ์๊ฐ(-9007199254740991์ด๋ค.
Number.MIN_SAFE_INTEGER; // -9007199254740991์ด๋ค
Number.MIN_POSITIVE_INFINITY๋ ์์ ๋ฌดํ๋๋ฅผ ๋ํ๋ด๋ ์ซ์๊ฐ Infinity์ ๊ฐ๋ค.
Number.POSITIVE_INFINITY // Infinity
Number.MIN_POSITIVE_INFINITY๋ ์์ ๋ฌดํ๋๋ฅผ ๋ํ๋ด๋ ์ซ์๊ฐ Infinity์ ๊ฐ๋ค.
Number.NEGATIVE_INFINITY // -Infinity
Number.NAN์ ์ซ์๊ฐ ์๋์ ๋ํ๋ด๋ ์ซ์๊ฐ์ด๋ค.
Number.NaN; // -NaN
ES6์์ ๋์
๋ Number.isFinite ์ ์ ๋ฉ์๋๋ ์ธ์๋ก ์ ๋ฌ๋ ์ซ์๊ฐ์ด ์ ์์ ์ธ ์ ํ์, Infinity ๋๋ -Infinity๊ฐ ์๋์ง ๊ฒ์ฌํ์ฌ ๊ทธ ๊ฒฐ๊ณผ๋ฅผ ๋ถ๋ฆฌ์ธ ๊ฐ์ผ๋ก ๋ฐํ.
// ์ธ์๊ฐ ์ ์์ ์ธ ์ ํ์์ด๋ฉด 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
์ธ์๊ฐ NaN์ด๋ฉด ์ธ์ ๋ false๋ฅผ ๋ฐํ
Number.isFinite ๋ฉ์๋์ ๋นํธ์ธ ์ ์ญ ํจ์ isFinite์์ ์ฐจ์ด
// Number.isFinite๋ ์ธ์๋ฅผ ์ซ์๋ก ์๋ฌต์ ํ์
๋ณํํ์ง ์๋๋ค.
Number.isFinite(null); // false
// isFinite๋ ์ธ์๋ฅผ ์ซ์๋ก ์๋ฌต์ ํ์
๋ณํํ๋ค. null์ 0์ผ๋ก ์๋ฌต์ ํ์
๋ณํ๋๋ค
isFinite(null); // true
ES6์์ ๋์
๋ Number.isInteger ์ ์ ๋ฉ์๋๋ ์ธ์๋ก ์ ๋ฌ๋ ์ซ์๊ฐ์ด ์ ์์ธ์ง ๊ฒ์ฌํ์ฌ ๊ทธ ๊ฒฐ๊ณผ๋ฅผ ๋ถ๋ฆฌ์ธ ๊ฐ์ผ๋ก ๋ฐํ
ํ๋ค. ๊ฒ์ฌํ๊ธฐ ์ ์ ์ธ์๋ฅผ ์ซ์๋ก ์๋ฌต์ ํ์
๋ณํํ์ง ์์
// ์ธ์๊ฐ ์ ์์ด๋ฉด 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
ES6์์ ๋์ ๋ Number.isNaN ์ ์ ๋ฉ์๋๋ ์ธ์๋ก ์ ๋ฌ๋ ์ซ์๊ฐ์ด NaN์ธ์ง ๊ฒ์ฌํ์ฌ ๊ทธ ๊ฒฐ๊ณผ๋ฅผ ๋ถ๋ฆฌ์ธ ๊ฐ์ผ๋ก ๋ฐํ.
// ์ธ์๊ฐ NaN์ด๋ฉด true๋ฅผ ๋ฐํํ๋ค.
Number.isNaN(NaN); // true
Number.isNaN ๋ฉ์๋์ ๋นํธ์ธ ์ ์ญ ํจ์ isNaN๊ณผ ์ฐจ์ด
// Number.isNaN(undefined); // false
Number.isNaN(undefined); // false
// isFinite๋ ์ธ์๋ฅผ ์ซ์๋ก ์๋ฌต์ ํ์
๋ณํํ๋ค. undefined๋ NaN์ผ๋ก ์๋ฌต์ ํ์
๋ณํ๋๋ค.
isNaN(undefined); // true
ES6์์ ๋์ ๋ Number.isSafeInteger ์ ์ ๋ฉ์๋๋ ์ธ์๋ก ์ ๋ฌ๋ ์ซ์๊ฐ์ด ์์ ํ ์ ์์ธ์ง ๊ฒ์ฌํ์ฌ ๊ทธ ๊ฒฐ๊ณผ๋ฅผ ๋ถ๋ฆฌ์ธ ๊ฐ์ผ๋ก ๋ฐํ
// 0์ ์์ ํ ์ ์๋ค.
Number.isSafeInteger(0); // true
// 10000000000์ ์์ ํ ์ ์๋ค
Number.isSafeInteger(10000000000); // true
// 100000000001์ ์์ ํ์ง ์๋ค.
Number.isSafeInteger(100000000001); // false
// 0.5๋ ์ ์๊ฐ ์๋๋ค.
Number.isSafeInteger(0.5); // false
// '123'์ ์ซ์๋ก ์๋ฌต์ ํ์
๋ณํํ์ง ์๋๋ค.
Number.isSafeInteger('123'); // false
// false๋ฅผ ์ซ์๋ก ์๋ฌต์ ํ์
๋ณํํ์ง ์๋๋ค.
Number.isSafeInteger(false); // false
// Infinity/-Infinity๋ ์ ์๊ฐ ์๋๋ค.
Number.isSafeInteger(Infinity); // false
toExponential ๋ฉ์๋๋ ์ซ์๋ฅผ ์ง์ ํ๊ธฐ๋ฒ์ผ๋ก ๋ณํํ์ฌ ๋ฌธ์์ด๋ก ๋ณํ
(77.1234).toExponential(); // "7.71234e+1"
(77.1234).toExponential(4); // "7.7123e+1"
(77.1234).toExponential(2); // "7.71e+1"
toFixed ๋ฉ์๋๋ ์ซ์๋ฅผ ๋ฐ์ฌ๋ฆผํ์ฌ ๋ฌธ์์ด๋ก ๋ฐํ.
// ์์์ ์ดํ ๋ฐ์ฌ๋ฆผ ์ธ์๋ฅผ ์๋ตํ๋ฉด ๊ธฐ๋ณธ๊ฐ 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"
toPrecision ๋ฉ์๋๋ ์ธ์๋ก ์ ๋ฌ๋ฐ์ ์ ์ฒด ์๋ฆฟ์๊น์ง ์ ํจํ๋๋ก ๋๋จธ์ง ์๋ฆฟ์๋ฅผ ๋ฐ์ฌ๋ฆฌํ์ฌ ๋ฌธ์์ด๋ก ๋ฐํํ๋ค.
// ์ ์ฒด ์๋ฆฟ์ ์ ํจ. ์ธ์๋ฅผ ์๋ตํ๋ฉด ๊ธฐ๋ณธ๊ฐ 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"
toString ๋ฉ์๋๋ ์ซ์๋ฅผ ๋ฌธ์์ด๋ก ๋ณํํ์ฌ ๋ฐํ
// ์ธ์๋ฅผ ์๋ตํ๋ฉด 10์ง์ ๋ฌธ์์ด์ ๋ฐํ
(10).toString(); // 10
// 2์ง์ ๋ฌธ์์ด์ ๋ฐ๋
ธํ
(16).toString(2); // "10000"
// 8์ง์ ๋ฌธ์์ด์ ๋ฐ๋
ธํ
(16).toString(8); // "20"
// 16์ง์ ๋ฌธ์์ด์ ๋ฐ๋
ธํ
(16).toString(16); // "10"