
JavaScript ๋ฐฐ์ด(Array)์ ๋ฐ์ ๊ณผ ์ฑ๋ฅ์ ๋ํด์ ์์ธํ ์์๋ณด๊ธฐ
์ด ํฌ์คํ ์ 2017๋ 9์ 2์ผ์ Paul Shan์ด ์์ฑํ Diving deep into JavaScript array - evolution & performance๋ฅผ ๋ฒ์ญํ ๊ธ์ ๋๋ค.
ํฌ์คํ ์ ์์ํ๊ธฐ ์ ์ ์ด ํฌ์คํ ์ JavaScript ๋ฐฐ์ด์ ๊ตฌ๋ฌธ์ ๊ดํ ๊ฒ์ ์๋ ค์ฃผ๊ฑฐ๋ ์์ ๋ฅผ ๋ณด์ฌ์ฃผ๋ ๋ฑ์ ๊ธฐ๋ณธ์ ์ธ ๋ด์ฉ์ ์๋๋ผ๊ณ ๋จผ์ ์๊ธฐํด๋๊ณ ์ถ๋ค. ์ด ํฌ์คํ ์์๋ ๋ฉ๋ชจ๋ฆฌ ํํ, ์ต์ ํ, ๊ตฌ๋ฌธ์ ๋ฐ๋ผ ๋ฌ๋ผ์ง๋ ๋์์ ์ฐจ์ด, ์ฑ๋ฅ ๋ฐ ์ต๊ทผ์ JavaScript ๋ฐฐ์ด์ด ์ด๋ป๊ฒ ๋ฐ์ ํ๋์ง์ ๊ดํด์๋ง ์ค๋ช ํ ๊ฒ์ด๋ค.
ํ์๊ฐ JavaScript๋ฅผ ์ฒ์ ์์ํ์ ๋ ํ์๋ ์ด๋ฏธ C, C++, C# ๋ฑ์ ์ธ์ด์ ์ต์ํ ์ํ์๋ค. ๊ทธ๋์ ๋ค๋ฅธ C/C++ ๊ฐ๋ฐ์๋ค์ฒ๋ผ JavaScript์์ ์ฒซ ๋ง๋จ์ด ๊ทธ๋ฆฌ ์ข์ง๋ ๋ชปํ๋ค.
๊ทธ ์ค ํ์๊ฐ JavaScript๋ฅผ ์ข์ํ์ง ์์๋ ๊ฐ์ฅ ํฐ ์ด์ ๋, ๋ฐ๋ก ๋ฐฐ์ด
์ด๋ค. JavaScript์ ๋ฐฐ์ด์ Hash Map์ด๋ Dictionary๋ก ๊ตฌํ๋์๊ณ ์ฐ์์ ์ด์ง ์๊ธฐ ๋๋ฌธ์ ํ์๋ ์ด ์ธ์ด๊ฐ ๋ฐฐ์ด์ ์ ๋๋ก ๊ตฌํํ ์๋ ์๋ B๊ธ ์ธ์ด๋ผ๊ณ ์๊ฐํ๋ค. ๊ทธ๋ฌ๋ ๊ทธ ์ดํ JavaScript์ ๋ํ ํ์์ ์ดํด๋๋ ๋ง์ด ๋ฌ๋ผ์ก๋ค.
(์ญ์ฃผ) ๊ธฐ์กด ์ธ์ด์์ ๊ตฌํํ๋ ๋ฐฐ์ด์ ์์ฑ ์์ ํน์ ๋ฒ์์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ํ ๋นํ๊ณ ์ฐ์์ ์ผ๋ก ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ์ง๋ง JavaScript๋ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ๋ฏธ๋ฆฌ ํ ๋นํด๋์ง ์๊ณ ๋์ ํ ๋นํ๋ฏ๋ก ์ฐ์์ ์ผ๋ก ์์๊ฐ ์ ์ฅ๋์ง ์๋๋ค. ๋ฆฌ์คํธ์ ๋์ผํ ๋ฐฉ์.
JavaScript์ ๋ฐฐ์ด์ด ์ค์ ๋ก๋ ๋ฐฐ์ด์ด ์๋ ์ด์
์๋ฐ์คํฌ๋ฆฝํธ์ ๊ดํ ์ค๋ช
๋ค์ ์์ํ๊ธฐ ์ ์ ๋ฐฐ์ด
์ด ๋ฌด์์ธ์ง๋ถํฐ ์ค๋ช
์ ๋จผ์ ํด์ผํ ๊ฒ ๊ฐ๋ค.
๋ฐฐ์ด์ ์ฐ์์ ์ธ ๋ฉ๋ชจ๋ฆฌ ๋ก์ผ์ด์
๋ค์ ๋ฌถ์์ ์ฌ์ฉํ์ฌ ๊ฐ์ ์ ์ฅํ๋ ๋ฐ ์ฌ์ฉ๋๋ค. ์ฌ๊ธฐ์ ์ค์ํ ํฌ์ธํธ๋ ์ฐ์์ฑ(continuous)
๊ณผ ์ธ์ ์ฑ(contiguous)
์ด๋ผ๋ ๋จ์ด์ด๋ค.

์ ๊ทธ๋ฆผ์ ๋ฐฐ์ด์ ๋ฉ๋ชจ๋ฆฌ ์ํ์ ์์๋ฅผ ํํํ ๊ฒ์ด๋ค. ์ด ๋ฐฐ์ด์ 4 bit๋ก ์ด๋ฃจ์ด์ง 4๊ฐ์ ๋ธ๋ก์ ๊ฐ์ง๊ณ ์๊ณ ์ด 16 bit์ ๋ฉ๋ชจ๋ฆฌ ๋ธ๋ก์ ์ฌ์ฉํ๊ณ ์๋ค.
์ด์ ํ์๊ฐ tinyInt arr[4];
๋ฅผ ์ ์ธํ๊ณ 1201
๋ถํฐ ์์ํด์ ์ด ๋ฉ๋ชจ๋ฆฌ ๋ธ๋ก๋ค์ ํฌ์ฐฉํ๋ค๊ณ ๊ฐ์ ํด๋ณด์. ์ด์ ํ์๊ฐ ์ด๋ค ํฌ์ธํธ๋ก๋ถํฐ a[2]
๋ฅผ ์ฝ์ผ๋ ค๊ณ ํ๋ค๋ฉด a[2]
์ ๋ฉ๋ชจ๋ฆฌ ์ฃผ์๋ฅผ ์ฐพ๊ธฐ ์ํ ๊ฐ๋จํ ์ํ ๊ณ์ฐ์ด ์ด๋ฃจ์ด์ง๋ค. 1201 + (2 x 4)
์ ๊ฐ์ ์์ผ๋ก 1209
์ ์ฃผ์๋ฅผ ๋ฐ๋ก ์ฐธ์กฐํ ์ ์๋ค.
์ญ์ฃผ: ๋ฉ๋ชจ๋ฆฌ ์์ ์ฃผ์ + (์ฐพ๊ณ ์ ํ๋ ์ธ๋ฑ์ค x ํ ๋ธ๋ก์ ํ ๋น๋ ๋ฉ๋ชจ๋ฆฌ ๋ธ๋ก ๊ฐ์)๋ก ๊ณ์ฐํ ๊ฒ์ด๋ค. ๋ฐฐ์ด์ ์ด๋ ๊ฒ ์ํ๋ ์์์ ๋ฐ๋ก ์ ๊ทผํ ์ ์๋ค.

JavaScript์์์ ๋ฐฐ์ด์ Hash Map์ด๋ค. ์ด๊ฒ์ ๋ค์ํ ์๋ฃ ๊ตฌ์กฐ๋ฅผ ์ฌ์ฉํด์ ๊ตฌํ๋ ์ ์๊ณ , ๊ทธ ์ค ํ๋๊ฐ ๋ฐ๋ก Linked List์ด๋ค. ๋ง์ฝ JavaScript ๋ด์์ ์ฐ๋ฆฌ๊ฐ var arr = new Array(4);
๋ก ๋ฐฐ์ด์ ์ ์ธํ๋ฉด ์ด ๋ฐฐ์ด์ ์๋จ์ ๊ทธ๋ฆผ๊ณผ ๊ฐ์ ๊ตฌ์กฐ๋ฅผ ์์ฑํ๋ค. ๋ฐ๋ผ์ ๋ง์ฝ ์ฐ๋ฆฌ๊ฐ a[2]
๋ฅผ ์ฝ๊ณ ์ถ๋ค๋ฉด ๋ฌด์กฐ๊ฑด 1201
๋ถํฐ ํ์ํด๋๊ฐ๋ฉด์ a[2]
๋ฅผ ์ฐพ์๋๊ฐ์ผ ํ๋ค๋ ๊ฒ์ด๋ค.
์ด๊ฒ์ด ๋ฐ๋ก JavaScript์ ๋ฐฐ์ด๊ณผ ์ง์ง ๋ฐฐ์ด์ด ๋ค๋ฅธ ์ ์ด๋ค. ๋ถ๋ช ํ JavaScript์ ๋ฐฐ์ด์ ํ์ํ๋ ๊ฒ์ ์๋์ Linked List ํ์๋ณด๋ค๋ ๊ณ์ฐ์ด ์ ๋ค. ๊ทธ๋ฌ๋ ๋ฐฐ์ด์ ๊ธธ์ด๊ฐ ๊ธธ์ด์ง์๋ก ์ธ์์ด ๊ณ ๋ฌํ์ง๋ ๊ฑด ๋๊ฐ๋ค.
JavaSciprt ๋ฐฐ์ด์ ๋ฐ์
์์ ์๋ ์น๊ตฌ๊ฐ ์ปดํจํฐ์ 256MB ์ง๋ฆฌ ๋จ์ ์ฌ์ฉํ๋ค๊ณ ํ๋ฉด ๋ถ๋ฌ์์ ๋๋ผ๋ ์์ ๋ ์์์ง๋ง ์์ฆ์ ๋ณดํต 8GB ์ ๋์ ๋จ์ ์ฌ์ฉํ๋ค.
์ด์ ๋น์ทํ๊ฒ JavaScript ๋ํ ๋ง์ ๋ฐ์ ์ ์ด๋ฃจ์๋ค. V8, SpiderMonkey, TC39, ์ฆ๊ฐํ๊ณ ์๋ ์น ์ฌ์ฉ์๋ค์ ํผ๋๋ ๋ ธ๋ ฅ์ผ๋ก ์ธํด JavaScript๋ ์ ์ธ๊ณ์ ํ์ ์์๊ฐ ๋์๋ค. ์ด๋ ๊ฒ ๊ฑฐ๋ํ ์ ์ ๋ฒ ์ด์ค๋ฅผ ๊ฐ์ง๊ณ ์๋ค๋ฉด ๋ถ๋ช ํ ์ฑ๋ฅ ํฅ์ ๋ํ ํ์ํ๋ค.
์ต๊ทผ์ JavaScript ์์ง์ ๋ชจ๋ ์์๊ฐ ๋์ผํ ํ์ ์ ๊ฐ์ง๊ณ ์๋ ๋ฐฐ์ด์ธ ๊ฒฝ์ฐ ์ฐ์์ ์ผ๋ก ๋ฉ๋ชจ๋ฆฌ๋ฅผ ํ ๋นํ๋ค. ํ๋ฅญํ ํ๋ก๊ทธ๋๋จธ๋ ํญ์ ๋ฐฐ์ด์ ๋์ผํ ํ์ ์ผ๋ก ์ฌ์ฉํ๋ฉฐ JIT(Just in Time) ์ปดํ์ผ๋ฌ๋ ์ด๋ฐ ๋ฐฐ์ด์ ๋ํด์ C ์ปดํ์ผ๋ฌ์ ๊ฐ์ ๋ฐฐ์ด ๊ณ์ฐ์ ์ํํ๋ค.
๊ทธ๋ฌ๋ ์ด๋ฐ ๋์ผํ ํ์
๋ฐฐ์ด์ ๋ค๋ฅธ ํ์
์ ์์๋ฅผ ์ฝ์
ํ๋ ค๊ณ ํ ๋ JIT๋ ์ ์ฒด ๋ฐฐ์ด์ ๊ตฌ์กฐ๋ฅผ ํด์ ํ๊ณ ๋ค์ ์์ ์ ๋ฐฐ์ด์ฒ๋ผ ๋น์ฐ์์ ์ธ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ํ ๋นํ๋ค. ์ฆ, ๋ง์ฝ ์ฐ๋ฆฌ๊ฐ ์ฝ๋๋ฅผ ์ ๋๋ก ์์ฑํ๋ค๋ฉด JavaScript์ Array
๊ฐ์ฒด๋ ์ค์ ๋ฐฐ์ด์ฒ๋ผ ์๋ํ๋ค๋ ๊ฒ์ด๋ค. ์ด๋ ๋ชจ๋ JS ๊ฐ๋ฐ์๋ค์๊ฒ๋ ์ ๋ง ์ข์ ์ผ์ด๋ค.
์ด์ ๋ํด์ ๋ฐฐ์ด์ ES2015 ๋๋ ES6๋ฅผ ํตํด์ ๋์ฑ ๋ฐ์ ํ๋ค. TC39 ์์ํ๋ JavaScript์ ํ์ดํ๋ ๋ฐฐ์ด์ ์ถ๊ฐํ๊ธฐ๋ก ๊ฒฐ์ ํ๊ณ ๊ทธ๋์ ์ฐ๋ฆฌ๋ ArrayBuffer
๋ฅผ ์ฌ์ฉํ ์ ์๊ฒ ๋์๋ค.
ArrayBuffer
๋ ์ธ์ ํ ๋ฉ๋ชจ๋ฆฌ ๋ธ๋ก์ ์ ๊ณตํ๊ณ ์ฐ๋ฆฌ๊ฐ ๊ทธ๊ฒ์ ๋ง์๋๋ก ๋ค๋ฃฐ ์ ์๊ฒ ํด์ค๋ค. ๊ทธ๋ฌ๋ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์ง์ ๋ค๋ฃจ๋ ๊ฒ์ ๋งค์ฐ Low Level์ด๊ณ ๋ ๋๋ฌด ๋ณต์กํ๊ธฐ ๋๋ฌธ์ ์ฐ๋ฆฌ๋ View๋ผ๋ ๊ฒ์ ํตํด์ ArrayBuffer๋ฅผ ๋ค๋ฃจ๊ฒ ๋๋ค. ์ด๋ฏธ ๋ช๊ฐ์ง View๋ฅผ ์ฌ์ฉํ ์ ์๊ณ ๋์ค์๋ ๋ ์ถ๊ฐ๋ ์์ ์ด๋ค.
var buffer = new ArrayBuffer(8);
var view = new Int32Array(buffer);
view[0] = 100;
๋ง์ฝ ๋น์ ์ด Int32Array
์ ๊ฐ์ Typed Array์ ๋ํด์ ๋ ์๊ณ ์ถ๋ค๋ฉด MDN Documentation๋ฅผ ์ฐธ๊ณ ํ๊ธฐ ๋ฐ๋๋ค.
ํ์ดํ๋ ๋ฐฐ์ด์ ๊ต์ฅํ ํจ์จ์ ์ด๋ค. ํ์ดํ๋ ๋ฐฐ์ด์ WebGL์ ์ฌ์ฉํ๋ ์ฌ๋๋ค์ด ์ผ๋ฐ ๋ฐฐ์ด๋ก๋ ๋ฐ์ด๋๋ฆฌ ๋ฐ์ดํฐ๋ฅผ ํจ๊ณผ์ ์ผ๋ก ์ฒ๋ฆฌํ ์ ์๋ ์์ฒญ๋ ์ฑ๋ฅ ๋ฌธ์ ์ ์ง๋ฉดํ๊ธฐ ๋๋ฌธ์ ์์ฒญํด์ ๋์ ๋ ๊ฐ์ฒด์ด๋ค.(์ญ์ฃผ: ThreeJS๋ ๋ด๋ถ์ ์ผ๋ก๋ ์ ๋ถ Typed Array๋ฅผ ์ฌ์ฉ ์ค์ด๊ณ , ์ฑ๋ฅ ์ฐจ์ด ๋ํ ๋ชธ์ผ๋ก ๋๊ปด์ง ์ ๋๋ก ํ์ฐํ๋ค.) ๋ํ ์ฐ๋ฆฌ๋ SharedArrayBuffer๋ฅผ ์ฌ์ฉํ์ฌ ์ฌ๋ฌ ๊ฐ์ Web Worker๊ฐ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ๊ณต์ ํ์ฌ ์ฑ๋ฅ์ ๋์ด์ฌ๋ฆด ์๋ ์๋ค.
๋๋์ง ์์๊ฐ? JavaScript์ ๋ฐฐ์ด์ ๊ฐ๋จํ Hash Map์์ ์์ํด์ ์ด์ ๋ SharedArrayBuffer
๊น์ง ๋ค๋ฃจ๊ณ ์๋ค.
์ผ๋ฐ ๋ฐฐ์ด vs ํ์ดํ๋ ๋ฐฐ์ด - ์ฑ๋ฅ ๋น๊ต
์ฐ๋ฆฌ๋ JavaScript ๋ฐฐ์ด์ ๋ฐ์ ์ ๋ํด์ ์ด์ผ๊ธฐ ํ๋ค. ์ด์ ์ต๊ทผ์ ๋ฐฐ์ด์ด ์ผ๋ง๋ ์ข์์ง ํ์ธํด๋ณด์. ํ์๋ Mac๊ณผ Node.js 8.4.0
ํ๊ฒฝ์์ ๋ช ๊ฐ์ ์์ ํ
์คํธ๋ฅผ ํด๋ณด์๋ค.
์ผ๋ฐ ๋ฐฐ์ด โ ์ฝ์
var LIMIT = 10000000;
var arr = new Array(LIMIT);
console.time("Array insertion time");
for (var i = 0; i < LIMIT; i++) {
arr[i] = i;
}
console.timeEnd("Array insertion time");
์ํ ์๊ฐ: 55ms
ํ์ดํ๋ ๋ฐฐ์ด โ ์ฝ์
var LIMIT = 10000000;
var buffer = new ArrayBuffer(LIMIT * 4);
var arr = new Int32Array(buffer);
console.time("ArrayBuffer insertion time");
for (var i = 0; i < LIMIT; i++) {
arr[i] = i;
}
console.timeEnd("ArrayBuffer insertion time");
์ํ ์๊ฐ: 52ms
์โฆ? ์์ ์ ์ ํต์ ์ธ ๋ฐฐ์ด๊ณผ ์ต๊ทผ ๋ฐฐ์ด์ ์ฑ๋ฅ์ด ๋น์ทํ๋ฐ์โฆ?
Nope. ํ์๋ ์์ฆ์ ์ปดํ์ผ๋ฌ๋ ๋๋ํ๊ธฐ๋๋ฌธ์ ๊ฐ์ ํ์
์ ๊ฐ์ง ๋ฐฐ์ด์ ๋ด๋ถ์ ์ผ๋ก ์ฐ์์ ์ธ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ๊ฐ์ง ๋ฐฐ์ด๋ก ๋ณํํ๋ค๋ ๊ฒ์ ์ค๋ช
ํ๋ค. ์ด๊ฒ ๋ฐ๋ก ์ฒซ๋ฒ์งธ ์์์์ ๋ฐ์ํ ์ผ์ด๋ค. ํ์๋ new Array(LIMIT)
์ ์ฌ์ฉํ์ง๋ง ๋ด๋ถ์ ์ผ๋ก๋ ์ฐ์์ ์ธ ๋ฉ๋ชจ๋ฆฌ ํ ๋น์ ๊ฐ์ง ํ๋์ ์ธ ๋ฐฐ์ด์ ์ ์งํ๊ณ ์๋ ๊ฒ์ด๋ค.
์ด์ ์ฒซ๋ฒ์งธ ์์๋ฅผ ์์ ํ์ฌ ๋์ผํ ์๋ฃํ์ ๊ฐ์ง๊ณ ์์ง ์์ ๋ฐฐ์ด๋ก ๋ง๋ค๊ณ ์ฑ๋ฅ ์ฐจ์ด๊ฐ ์๋์ง ์ดํด๋ณด๋๋ก ํ์.
์ผ๋ฐ ๋ฐฐ์ด โ ์ฝ์ (๋์ผํ์ง ์์ ์๋ฃํ)
var LIMIT = 10000000;
var arr = new Array(LIMIT);
arr.push({a: 22});
console.time("Array insertion time");
for (var i = 0; i < LIMIT; i++) {
arr[i] = i;
}
console.timeEnd("Array insertion time");
์ํ ์๊ฐ: 1207ms
์ฌ๊ธฐ์ ํ์๋ 3๋ฒ ๋ผ์ธ์ ์๋ก์ด ํํ์ ์ถ๊ฐํ์ ๋ฟ ๋๋จธ์ง๋ ์ด์ ๊ณผ ์ ๋ถ ๋์ผํ์ง๋ง ์ฑ๋ฅ์ ์ฐจ์ด๊ฐ ๋๊ธฐ ์์ํ๋ค. ๋ฌด๋ ค 22๋ฐฐ
๋๋ ค์ง ๊ฒ์ ํ์ธํ ์ ์๋ค.
์ผ๋ฐ ๋ฐฐ์ด - ์ฝ๊ธฐ
var LIMIT = 10000000;
var arr = new Array(LIMIT);
arr.push({a: 22});
for (var i = 0; i < LIMIT; i++) {
arr[i] = i;
}
var p;
console.time("Array read time");
for (var i = 0; i < LIMIT; i++) {
//arr[i] = i;
p = arr[i];
}
console.timeEnd("Array read time");
์ํ ์๊ฐ: 196ms
Typed Array - read
var LIMIT = 10000000;
var buffer = new ArrayBuffer(LIMIT * 4);
var arr = new Int32Array(buffer);
console.time("ArrayBuffer insertion time");
for (var i = 0; i < LIMIT; i++) {
arr[i] = i;
}
console.time("ArrayBuffer read time");
for (var i = 0; i < LIMIT; i++) {
var p = arr[i];
}
console.timeEnd("ArrayBuffer read time");
์ํ ์๊ฐ: 27ms
๊ฒฐ๋ก
JavaScript์ ํ์ดํ๋ ๋ฐฐ์ด์ด ์ถ๊ฐ๋ ๊ฒ์ ์๋ํ ์ฒซ ๋ฐ๊ฑธ์์ด๋ค. Int8Array
, Uint8Array
, Uint8ClampedArray
, Int16Array
, Uint16Array
, Int32Array
, Uint32Array
, Float32Array
, Float64Array
๋ฑ์ ๋ค์ดํฐ๋ธ ๋ฐ์ดํธ ์์๋ก ์ด๋ฃจ์ด์ง ๋ทฐ๋ฅผ ์ ๊ณตํ๊ณ , ๋ ์ฌ๋ฌ๋ถ์ด ์ง์ DataView
๋ฅผ ์ฌ์ฉํ์ฌ ์ปค์คํ
๋ทฐ๋ฅผ ๋ง๋ค ์๋ ์๋ค. ์์ผ๋ก ArrayBuffer๋ฅผ ์ฌ์ฉํ๊ธฐ ์ํด ๋ ๋ง์ DataView ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ค์ด ํ์ฑํ๋๊ธฐ๋ฅผ ๋ฐ๋๋ค.
JavaScript์ ๋ฐฐ์ด์ด ์ด๋ ๊ฒ ๊ฐ์ ๋ ๊ฒ์ ์ข์ ์ผ์ด๋ค. ์ด์ JavaScript์ ๋ฐฐ์ด์ ๋น ๋ฅด๊ณ ํจ์จ์ ์ด๋ฉฐ ๊ฐ๋ ฅํ๊ณ ๋๋ํ๊ฒ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ํ ๋นํ ์ ์๊ฒ ๋ ๊ฒ์ด๋ค.
- JavaScript
- ์๋ฐ์คํฌ๋ฆฝํธ
- ์ฑ๋ฅ ์ต์ ํ
- ๋ฐฐ์ด
- Array
- ์ฐ์ํ ๋น
- ๋น์ฐ์ํ ๋น
- ์๋ฃ๊ตฌ์กฐ
- ๊ธฐ์ ๋ฉด์
- ํฌ์ธํฐ
- ๋ฉ๋ชจ๋ฆฌ๊ตฌ์กฐ
๊ด๋ จ ํฌ์คํ ๋ณด๋ฌ๊ฐ๊ธฐ

JavaScript์ ํจ๊ป ํด์ํ ์ด๋ธ์ ํํค์ณ๋ณด์
ํ๋ก๊ทธ๋๋ฐ/์๊ณ ๋ฆฌ์ฆ
์ต์ ๊ฐ๊ณผ ์ต๋ ๊ฐ์ ๋น ๋ฅด๊ฒ ์ฐพ์ ์ ์๊ฒ ๋์์ฃผ๋ ํ(Heap)
ํ๋ก๊ทธ๋๋ฐ/์๊ณ ๋ฆฌ์ฆ
JavaScript์ let๊ณผ const, ๊ทธ๋ฆฌ๊ณ TDZ
ํ๋ก๊ทธ๋๋ฐ/์๋ฐ์คํฌ๋ฆฝํธ![[JS ํ๋กํ ํ์
] ํ๋กํ ํ์
์ ์ฌ์ฉํ์ฌ ์์ํ๊ธฐ [JS ํ๋กํ ํ์
] ํ๋กํ ํ์
์ ์ฌ์ฉํ์ฌ ์์ํ๊ธฐ](/static/ffc88c93a54f1c5d1783f61478e57588/4e277/thumbnail.png)
[JS ํ๋กํ ํ์ ] ํ๋กํ ํ์ ์ ์ฌ์ฉํ์ฌ ์์ํ๊ธฐ
ํ๋ก๊ทธ๋๋ฐ/์๋ฐ์คํฌ๋ฆฝํธ![[JS ํ๋กํ ํ์
] ์๋ฐ์คํฌ๋ฆฝํธ์ ํ๋กํ ํ์
ํ์ด๋ณด๊ธฐ [JS ํ๋กํ ํ์
] ์๋ฐ์คํฌ๋ฆฝํธ์ ํ๋กํ ํ์
ํ์ด๋ณด๊ธฐ](/static/c4c3f4bd82adfc1f6422180eedbd4fb0/4e277/thumbnail.png)
[JS ํ๋กํ ํ์ ] ์๋ฐ์คํฌ๋ฆฝํธ์ ํ๋กํ ํ์ ํ์ด๋ณด๊ธฐ
ํ๋ก๊ทธ๋๋ฐ/์๋ฐ์คํฌ๋ฆฝํธ