๐ป ์ซ์์ ๋ฌธ์
1. Number
์๋ฐ์คํฌ๋ฆฝํธ์์๋ ๋ชจ๋ ์ซ์๊ฐ Number
ํ์
์ผ๋ก ํํ๋๋ฉฐ, ์ ์์ ์ค์๋ฅผ ๋ณ๋๋ก ๊ตฌ๋ถํ์ง ์๋๋ค.
์ด๋ C++์ด๋ Java์์ ๊ฐ์ฅ ํฐ ์ฐจ์ด์ ์ค ํ๋๋ก, int
, float
, double
๊ณผ ๊ฐ์ ๋ค์ํ ์ซ์ ํ์
์ด ์กด์ฌํ๋ ์ธ์ด๋ค๊ณผ ๋ฌ๋ฆฌ, ์๋ฐ์คํฌ๋ฆฝํธ์์๋ ๋ชจ๋ ์ซ์๊ฐ 64๋นํธ ๋ถ๋์์์ (IEEE 754) ํ์์ผ๋ก ์ ์ฅ๋๋ค.
์ด๋ก ์ธํด ์ ํ๋ ๋ฌธ์ ๊ฐ ๋ฐ์ํ ์ ์๋ค.
console.log(0.1 + 0.2); // 0.30000000000000004 (๋ถ๋์์์ ์ค์ฐจ)
2. BigInt
BigInt
๋ ๋งค์ฐ ํฐ ์ ์๋ฅผ ๋ค๋ฃฐ ์ ์๋ ์๋ฐ์คํฌ๋ฆฝํธ์ ์๋ฃํ์ผ๋ก, Number
ํ์
๊ณผ๋ ๋ค๋ฅด๊ฒ ์ ํํ ์ ์ ์ฐ์ฐ์ด ๊ฐ๋ฅํ๋ค.
2-1. BigInt์ ๋ด๋ถ ๊ตฌ์กฐ
BigInt
๋ ๊ฐ๋ณ ํฌ๊ธฐ ์ ์๋ฅผ ์ ์ฅํ๊ธฐ ์ํด ๋ฐฐ์ด ๊ธฐ๋ฐ์ ๋ค์ค ์ ๋ฐ๋ ์ ์(Multi-Precision Integer) ๊ตฌ์กฐ๋ฅผ ์ฌ์ฉํ๋ค. ๋ด๋ถ์ ์ผ๋ก ์ฌ๋ฌ ๊ฐ์ ์์ ์ ์(์๋, word)๋ก ๋๋์ด ์ ์ฅ๋๋ฉฐ, ๊ฐ ์๋๋ 32๋นํธ ๋๋ 64๋นํธ ๋จ์๋ก ๊ด๋ฆฌ๋๋ค.
์๋ฅผ ๋ค์ด, 123456789012345678901234567890n
๊ฐ์ ํฐ ์ ์๋ฅผ BigInt
๋ก ์ ์ฅํ๋ฉด:
BigInt(123456789012345678901234567890n)
↓
[ 0x1B69B4BACD05F15A, 0x4F0D28A1 ] (๊ฐ์์ 64๋นํธ ๋ธ๋ก์ผ๋ก ๋ถํ )
๊ฐ ๋ธ๋ก(์๋)์ ๋ฐฐ์ด ํํ๋ก ๊ด๋ฆฌ๋๋ฉฐ, ์ฐ์ฐ ์ ์๋ฆฌ ์ฌ๋ฆผ(Carry Propagation) ๋ฑ์ ์ฒ๋ฆฌ๊ฐ ํ์ํ๋ค.
2-2. BigInt์ ์ฐ์ฐ ๋ฐฉ์
- ๋ง์ (Addition): ์ฌ๋ฌ ๊ฐ์ ์๋๋ฅผ ํ๋์ฉ ๋ํ๋ฉด์ ์๋ฆฌ ์ฌ๋ฆผ์ ์ฒ๋ฆฌํ๋ค.
- ๊ณฑ์ (Multiplication): Karatsuba ๊ณฑ์ ์๊ณ ๋ฆฌ์ฆ ๋๋ FFT ๊ธฐ๋ฐ ๊ณฑ์ ์ ์ฌ์ฉํ ์ ์๋ค.
- ๋นํธ ์ฐ์ฐ(Bitwise Operations) ์ง์ X:
BigInt
๋ ํฌ๊ธฐ๊ฐ ๊ฐ๋ณ์ ์ด๋ฏ๋ก,&
,|
,^
,<<
,>>
๊ฐ์ ๋นํธ ์ฐ์ฐ์๋ฅผ ์ฌ์ฉํ ์ ์๋ค.
2-3. BigInt vs Number
Number (IEEE 754) |
BigInt |
|
---|---|---|
์ต๋ ํฌ๊ธฐ | ±1.8 × 10³โฐโธ | ๋ฉ๋ชจ๋ฆฌ๊ฐ ํ์ฉํ๋ ํ ๋ฌด์ ํ |
์ ์ฅ ๋ฐฉ์ | 64๋นํธ ๋ถ๋์์์ | ๋ฐฐ์ด ๊ธฐ๋ฐ ๋ค์ค ์ ๋ฐ๋ ์ ์ |
์ ํ์ฑ | ํฐ ์ ์ ์ฐ์ฐ ์ ๋ฐ์ฌ๋ฆผ ์ค๋ฅ ๋ฐ์ | ์ ํํ ์ ์ ์ฐ์ฐ ๊ฐ๋ฅ |
์ฐ์ฐ ์๋ | ๋น ๋ฆ | ๋๋ฆผ (ํฐ ์์ผ์๋ก ์ฑ๋ฅ ์ ํ) |
๋นํธ ์ฐ์ฐ ์ง์ | O | X |
3. String
์๋ฐ์คํฌ๋ฆฝํธ์ ๋ฌธ์์ด์ ๋ณ๊ฒฝํ ์ ์๋(immutable) ์ ๋์ฝ๋ ๋ฌธ์๋ค์ ์ํ์ค๋ค.
์ด๋ Java๋ C++์์์ String
๊ณผ ์ ์ฌํ์ง๋ง, JavaScript์์๋ ๋ฌธ์์ด์ด ์์ ๊ฐ(primitive
)์ผ๋ก ์ทจ๊ธ๋๋ค.
3-1. ์์ ๋ฌธ์์ด vs String ๊ฐ์ฒด
์๋ฐ์คํฌ๋ฆฝํธ์์๋ ๋ฌธ์์ด์ด ์์ ๊ฐ์ผ๋ก ๋์ํ์ง๋ง, ๋ฉ์๋๋ฅผ ํธ์ถํ ๋ ์์ String ๊ฐ์ฒด๊ฐ ์์ฑ๋์ด ๋ฉ์๋๋ฅผ ์คํํ ํ ์ฆ์ ์ญ์ ๋๋ค.
let str = "hello";
console.log(str.toUpperCase()); // "HELLO"
console.log(typeof str); // "string" (์ฌ์ ํ ์์ ๊ฐ)
๋ฐ๋ฉด, new String("hello")
๋ก ์์ฑํ๋ฉด ๊ฐ์ฒด๋ก ์ทจ๊ธ๋์ด ๋ฉ์๋ ์คํ ํ์๋ ์ํ๊ฐ ์ ์ง๋๋ค.
let objStr = new String("hello");
console.log(typeof objStr); // "object"
console.log(objStr instanceof String); // true
ํ์ง๋ง, ์์ ๋ฌธ์์ด๊ณผ ๊ฐ์ฒด ๋ฌธ์์ด์ ๋ค๋ฅด๋ฏ๋ก ๋น๊ต ์ ์ฃผ์ํด์ผ ํ๋ค.
console.log("hello" === new String("hello")); // false (ํ์
์ด ๋ค๋ฆ)
3-2. String ๊ฐ์ฒด ์ฌ์ฉ์ ์ง์ํ๋ ์ด์
- ๋นํจ์จ์ ์ธ ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ: ์์ ๋ฌธ์์ด์ ์คํ(stack)์์ ์์ฑ๋์ด string pool (์์ง๋ณ ์์ด ๊ฐ๋ฅ)์ ์ฐธ์กฐํ๋ฉด ๋์ง๋ง,
String
๊ฐ์ฒด๋ ํ(heap)์ ํ๋ฒ๋ ๊ฐ์ฒด๋ก ์ ์ฅ๋๋ฏ๋ก ๋ถํ์ํ ๋ฉ๋ชจ๋ฆฌ ์๋น๊ฐ ๋ฐ์ํ๋ค. - ๋น๊ต ์ฐ์ฐ ์ ํผ๋: ์์ ๋ฌธ์์ด๊ณผ ๊ฐ์ฒด ๋ฌธ์์ด์ ๋น๊ตํ๋ฉด ์์์น ๋ชปํ ๊ฒฐ๊ณผ๊ฐ ๋์ฌ ์ ์๋ค.
- ๋ฌธ์์ด ์กฐ์ ์ ๋น์ผ๊ด์ฑ:
String
๊ฐ์ฒด์ ํ๋กํผํฐ๋ฅผ ์ถ๊ฐํ ์ ์์ง๋ง, ๋ฌธ์์ด ์กฐ์ ์ ์ ์ง๋์ง ์๋๋ค.
let strObj = new String("hello");
strObj.customProp = "test";
console.log(strObj.customProp); // "test"
let strPrim = "hello";
strPrim.customProp = "test";
console.log(strPrim.customProp); // undefined (์์ ๊ฐ์ ํ๋กํผํฐ๋ฅผ ๊ฐ์ง ์ ์์)
3-3. String๊ณผ ๋ฉ๋ชจ๋ฆฌ
- ๊ณต๋ถ๋ฅผ ํ๋ค๋ณด๋ฉด js์์ String์ด ์ด์งธ์ ๋ถ๋ณ์ผ๊ฐ์ ๋ํ ๊ณ ๋ฏผ์ด ์๊ธด๋ค.
- C์์๋ ๋ฌธ์์ด์ ๋ฆฌํฐ๋ด๋ก ์ฌ์ฉํ๋ค๋ฉด ๋ง์ฐฌ๊ฐ์ง๋ก ๋ถ๋ณ์ด์ง๋ง char ๋ฐฐ์ด๋ก ๋ง๋ค์ด์ ์ฌ์ฉํ๊ฑฐ๋, cpp์์๋ string์๋ฃํ์ ์ฌ์ฉํ๋ฉด ์์ ์ด ๊ฐ๋ฅํ๊ธฐ ๋๋ฌธ์ js๋ ์ด๋ฐ ๊ณผ์ ์ด ์ด๋ป๊ฒ ์งํ๋ ์ง ๊ถ๊ธํ๋ค.
let str1 = "Hello";
let str2 = "Hello";
console.log(str1 == str2); //true
- ์ด ๊ฒฝ์ฐ ์คํ(stack)์ str1, str2๊ฐ ๋ง๋ค์ด์ง๋ค.
- ๊ทธ๋ฆฌ๊ณ ํ(heap) ์์ string constant pool ์ด๋ผ๋ string ๋ค์ ์ ์ฅํด ๋๋ ๊ณต๊ฐ์ "hello"๋ผ๋ ๋ฐฐ์ด์ด ์๊ธด๋ค.
- str1๊ณผ str2 ๋ชจ๋ pool ์์ ๋์ผํ ๊ณต๊ฐ์ ๊ฐ๋ฆฌํจ๋ค.
๊ทธ๋ผ ์์์ ์ String ๊ฐ์ฒด๊ฐ ๋ฉ๋ชจ๋ฆฌ์์ ๋นํจ์จ์ ์ผ ์ ์๋์ง ์ดํดํ ์ ์๋ค.
์ฝ๋๋ฅผ ๋จผ์ ๋ณด์๋ฉด
let str1 = new String("John");
let str2 = new String("John");
let str3 = new String("Doe");
console.log(str1 == str2); // false
console.log(str1 == str3); // false
new๋ก ๊ฐ์ฒด๋ฅผ ๋์ ์ผ๋ก ์์ฑํ๋ฉด, str1๊ณผ str2๋ ๊ฐ๊ฐ ๋ค๋ฅธ ๊ฐ์ฒด๋ฅผ ๊ฐ๋ฆฌํค๊ณ ๊ฐ๊ฐ์ ๊ฐ์ฒด ์์์ ๋์ผํ "John"์ด๋ผ๋ ๋ฌธ์์ด์ ๊ฐ๋ฆฌํค๊ณ ์๊ธฐ ๋๋ฌธ์ ๋ค๋ฅธ ๊ฒ์ผ๋ก ์ทจ๊ธํ๋ค.
4. ๊ด๋ จ ๊ฐ๋
์์ ๋ฌธ์์ด์ ๋ฉ๋ชจ๋ฆฌ ๊ตฌ์กฐ
- ์์ ๋ฌธ์์ด์ ์คํ(stack)์๋ง ์ ์ฅ๋จ (๋ณ๊ฒฝ ๋ถ๊ฐ, immutable)
new String()
์ ์ฌ์ฉํ๋ฉด ํ(heap)์๋ ์ ์ฅ๋จ (๊ฐ์ฒด๋ก ์ทจ๊ธ๋จ)- ๋ฌธ์์ด์ ์์ ํ๋ฉด ์๋ก์ด ๋ฌธ์์ด์ด ํ ๋น๋๋ฉฐ, ๊ธฐ์กด ๋ฌธ์์ด์ GC(๊ฐ๋น์ง ์ปฌ๋ ์ )์ ์ํด ์ ๋ฆฌ๋จ
์ธํฐํ๋ฆฌํฐ์ ๋ฌธ์์ด ์ฒ๋ฆฌ ๋ฐฉ์
- ์์ ๋ฌธ์์ด์ด ๋ฉ์๋๋ฅผ ํธ์ถํ๋ฉด, ์๋ฐ์คํฌ๋ฆฝํธ ์์ง์ด ์๋์ผ๋ก
new String(str)
์ ์คํํ์ฌ ์์ ๊ฐ์ฒด๋ฅผ ์์ฑํ๋ค. - ๋ฉ์๋๊ฐ ์คํ๋๊ณ , ๊ฒฐ๊ณผ๊ฐ ๋ฐํ๋ ํ ์์ ๊ฐ์ฒด๋ ์ฆ์ ์ญ์ (GC ์ฒ๋ฆฌ๋จ).
let str = "hello";
str.test = "test"; // ์์ ๊ฐ์ ํ๋กํผํฐ ์ถ๊ฐ ์๋
console.log(str.test); // undefined
- ์์ ๊ฐ์ ํ๋กํผํฐ๋ฅผ ์ถ๊ฐํ ์ ์์ง๋ง, ๋ฉ์๋๋ ์คํ ๊ฐ๋ฅํ ์ด์ ๊ฐ ์ฌ๊ธฐ์ ์์.
๐ ์ฐธ๊ณ ์๋ฃ
'Language > javascript' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
Javascript์ ๊ฐ์ฒด์งํฅ - ์์ (inheritance) (0) | 2025.05.13 |
---|---|
javascript์ prototype๊ณผ __proto__ ์ ๋ฆฌ (1) | 2025.04.27 |
์๋ฐ์คํฌ๋ฆฝํธ ํจ์ ์ ๋ฆฌ (javascript function) (0) | 2025.03.21 |
์๋ฐ์คํฌ๋ฆฝํธ์์ "๊ฐ์ฒด" ์๋ฃํ (0) | 2025.03.19 |