2025. 8. 21. 02:02ใFront-end/JavaScript

๋ชฉ์ฐจ
1. ์ซ์ํ
1-1. e๋ก 10 ๊ฑฐ๋ญ์ ๊ณฑ
1-2. 16์ง์, 2์ง์, 8์ง์
1-3. toString(base)
1-4. ์ด๋ฆผ์ ๊ตฌํ๊ธฐ (rounding)
1-5. ๋ถ์ ํํ ๊ณ์ฐ
1-6. isNaN๊ณผ isFinite
1-7. parseInt์ parseFloat
2. Math์ ๋ฉ์๋๋ค
1. ์ซ์ํ
1. e๋ก 10 ๊ฑฐ๋ญ์ ๊ณฑ
0์ด ๋ง์ ์ซ์๋ค์ ์ ๋ ฅํ๋ ๋ฐฉ๋ฒ๋ค์ด ์๋ค.
// en : 10์ n ๊ฑฐ๋ญ์ ๊ณฑ
alert( 1e3 === 1 * 1000 ); // true
alert( 1.23e6 === 1.23 * 1000000 ); // true
alert( 1e-6 === 0.000001 ); // true
2. 16์ง์, 2์ง์, 8์ง์
์ ๋์ฌ 0x๋ก 16์ง์๋ฅผ, 0b๋ก 2์ง์๋ฅผ, 0o๋ก 8์ง์๋ฅผ ๋ํ๋ผ ์ ์๋ค.
// 16์ง์
alert( 0xff ); // 255
// 2์ง์์ 8์ง์
let a = 0b11111111; // 255์ 2์ง์
let b = 0o377; // 255์ 8์ง์
alert( a == b );
์ด ์ธ์ ์ง๋ฒ์ parseInt๋ฅผ ์ฌ์ฉํ๋ค.
3. toString(base)
num.toString(base) ๋ฉ์๋๋ base ์ง๋ฒ์ผ๋ก num์ ํํํ ํ, ์ด๋ฅผ ๋ฌธ์ํ์ผ๋ก ๋ณํํด ๋ฐํํ๋ค.
base๋ 2 ~36๊น์ง ์ธ ์ ์์ผ๋ฉฐ, ๊ธฐ๋ณธ๊ฐ์ 10์ด๋ค.
let num = 255;
alert( num.toString(16) ); // ff
alert( num.toString(2) ); // 11111111
alert( 123456..toString(36) ); // 2n9c
- base=2 : ๋นํธ ์ฐ์ฐ ๋๋ฒ๊น ์ ์ฃผ๋ก ์ฐ์ธ๋ค. ์ซ์๋ 0 ๋๋ 1์ด ๋๋ค.
- base=16 : 16์ง์ ์, ๋ฌธ์ ์ธ์ฝ๋ฉ ๋ฑ์ ํํํ ๋ ์ฌ์ฉํ๋ค. ์ซ์๋ 0 ~ 9, 10์ด์์ ์๋ A ~ F๊ฐ ๋๋ค.
- base=36 : 0..9, A..Z๋ฅผ ์ฌ์ฉํด ์ซ์๋ฅผ ํํํ๋ค.
- ๋ณ์๊ฐ ์๋ ์ซ์๋ฅผ ๋์์ผ๋ก ํธ์ถํ๋ค๋ฉด ์ ์ ๋ ๊ฐ .. ๋ถ์ฌ์ผํ๋ค. ( ํน์ (123).toString(36)๋ ๊ฐ๋ฅ )
4. ์ด๋ฆผ์ ๊ตฌํ๊ธฐ (rounding)
์ด๋ฆผ์ ๊ด๋ จ ๋ด์ฅ ํจ์ ๋ช ๊ฐ์ง๋ฅผ ๋ณด์.
- Math.floor
์์์ ์ฒซ์งธ ์๋ฆฌ์์ ๋ฒ๋ฆผ - Math.ceil
์์์ ์ฒซ์งธ ์๋ฆฌ์์ ์ฌ๋ฆผ - Math.round
์์์ ์ฒซ์งธ ์๋ฆฌ์์ ๋ฐ์ฌ๋ฆผ - Math.trunc
์์๋ถ๋ฅผ ๋ฌด์
์์ ๋ด์ฅ ํจ์๋ค๋ก๋ ์ฒซ์งธ ์๋ฆฌ์ ๋ํ ์ด๋ฆผ์๋ง ์ฐ์ฐ์ด ๋์๋ค.
์์์ 2 ์ด์์ ์๋ฅผ ๊ธฐ์ค์ผ๋ก ์ด๋ฆผ์๋ฅผ ๊ตฌํ ๋์ ๊ฒฝ์ฐ๋ฅผ ๋ณด์.
- ๊ณฑํ๊ณ ๋๋๊ธฐ
์ํ๋ ์๋ฆฟ์๋งํผ 10์ ๊ฑฐ๋ญ์ ๊ณฑ์ ๊ณฑํ๊ณ → ์ํ๋ ๋ด์ฅ ํจ์ ์ฌ์ฉ → ๊ณฑํ๋งํผ ๋๋๊ธฐ - toFixed(n) ์ฌ์ฉ
์์์ n๋ฒ์งธ ์๊น์ง์ ์ด๋ฆผ์๋ฅผ ๊ตฌํ ํ(์ฌ๋ฆผ/๋ฒ๋ฆผ), ์ด๋ฅผ ๋ฌธ์ํ์ผ๋ก ๋ฐํํด์ค๋ค.
let num = 1.23456
alert( Math.floor(num * 100) / 100 ); // ๊ณฑํ๊ณ ๋๋๊ธฐ
let num1 = 12.34;
let num2 = 12.26;
alert( num.toFixed(1) ); // "12.3"
alert( num.toFixed(1) ); // "12.4"
5. ๋ถ์ ํํ ๊ณ์ฐ
์์์ ์ ๊ณ์ฐ/๋น๊ต๋ฅผ ํ๋ฉด ์ ๋ฐ๋ ์์ค(loss of precision)์ด ๋ฐ์ํ ์ ์๋ค.
alert( 0.1 + 0.2 == 0.3 ); // false
alert( 0.1 + 0.2 ); // 0.30000000000000004
์ซ์๋ ์ด์ง์๋ก ๋ณํ๋์ด ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ ์ ์ฅ๋๋๋ฐ,
10์ง์์์ 1/3์ด ๋ฌดํ ์์ 0.3333...์ด ๋๋ฏ, 2์ง์์์ 2์ ๊ฑฐ๋ญ์ ๊ณฑ์ด ์๋ ๊ฐ์ ๋ฌดํ ์์๊ฐ ๋๊ธฐ ๋๋ฌธ์ด๋ค.
๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ ค๋ฉด toFixed()๊ฐ์ ๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ฉด๋๋ค.
let sum = 0.1 + 0.2;
alert( sum.toFixed(2) ); // 0.30
let sum = 0.1 + 0.2;
alert( +sum.toFixed(2) ); // 0.3
6. isNaN๊ณผ isFinite
Infinity, -Infinity, NaN ์ด ์ธ ๊ฐ์ ์ซ์ํ์ด์ง๋ง ์ ์์ ์ธ ์ซ์๊ฐ ์๋๊ธฐ์ ์ ์์ ์ธ ์ซ์์ ๊ตฌ๋ถํ๊ธฐ ์ํ ํจ์๊ฐ ์๋ค.
- isNaN(value) : ์ธ์๋ฅผ ์ซ์๋ก ๋ณํํ์ฌ NaN์ด๋ฉด true๋ฅผ ๋ฐํ
- isFinite(value) : ์ธ์๋ฅผ ์ซ์๋ก ๋ณํํ์ฌ NaN/Infinity/-Infinity๊ฐ ์๋ ๊ฒฝ์ฐ true๋ฅผ ๋ฐํ
alert( isNaN(NaN) ); // true
alert( isNaN("str") ); // true
alert( isFinite("15") ); // true
alert( isFinite("str") ); // false (NaN)
alert( isFinite("Infinity) ); // false (Infinity)
let num = +prompt("์ซ์๋ฅผ ์
๋ ฅํ์ธ์: ", '');
alert( isFinite(num));
7. parseInt์ parseFloat
๋ถ๊ฐ๋ฅํ ๋๊น์ง ๋ฌธ์์ด์์ ์ซ์๋ฅผ ์ฝ๋๋ค.
์ฝ๋ ๋์ค ์ค๋ฅ๊ฐ ๋ฐ์ํ๋ฉด ์ด๋ฏธ ์์ง๋ ์ซ์๋ฅผ ๋ฐํํ๋ค.
์ซ์ ๋ค์ ๋จ์๊ฐ ๋ถ์ ๊ฒฝ์ฐ, ์ซ์๋ง ์ถ์ถํ๊ธฐ ์ข์ ํจ์๋ค.
๋ ๋ฒ์งธ ์ธ์ ์ง์(16, 2, 8, ...)๋ฅผ ์ ํ์ ์ผ๋ก ๋ฃ์ ์ ์๋ค.
alert( parseInt('100px') ); // 100
alert( parseFloat('12.5em') ); // 12.5
alert( parseInt('12.3') ); // 12 (์ ์๋ถ๋ง ๋ฐํ)
alert( parseFloat('12.3.4') ); // 12.3 (์์์ ํ์๋ฆฌ์์ ๋ฉ์ถค)
alert( parseInt('a123') ); // NaN (a๊ฐ ์ซ์๊ฐ ์๋๋ฏ๋ก ๋ฉ์ถค
2. Math์ ๋ฉ์๋
Math ๊ฐ์ฒด์ ๋ฉ์๋๋ก ๋ค์ํ ์ฐ์ฐ๋ค์ ํ ์ ์๋ค.
- Math.random()
0๊ณผ 1 ์ฌ์ด์ ๋์๋ฅผ ๋ฐํ - Math.max(a, b, c, ...) / Math.min(a, b, c, ...)
์ธ์ ์ค ์ต๋/์ต์๊ฐ์ ๋ฐํ - Math.pow(n, power)
n์ power๋ฒ ๊ฑฐ๋ญ์ ๊ณฑํ ๊ฐ์ ๋ฐํ - Math.sqrt(x)
x์ ์ ๊ณฑ๊ทผ์ ๋ฆฌํด - Math.abs(x)
x์ ์ ๋๊ฐ์ ๋ฆฌํด
์ฐธ๊ณ
'Front-end > JavaScript' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
| ์ค์ฝํ์ ํธ์ด์คํ ํํค์น๊ธฐ (0) | 2025.08.23 |
|---|---|
| B22 : ๋ฌธ์์ด ์ฌํ (4) | 2025.08.21 |
| B20 : ๋ฐฐ์ด (2) | 2025.08.21 |
| B19 : ๋ฉํผ ๊ฐ์ฒด๋ก ์์ํ์ ๋ฉ์๋ ์ฐ๊ธฐ (0) | 2025.08.21 |
| B18 : Date ๊ฐ์ฒด (0) | 2025.08.20 |
GitHub