๐ข 22/05/30 ๋ณต์ต
javascript.info, https://ko.javascript.info/array
์ฐธ๊ณ ์ฌ์ดํธ์ ๋ด์ฉ์ ๊ฐ์ธ์ ์ผ๋ก ๋ณต์ตํ๊ธฐ ํธํ๋๋ก ์ฌ๊ตฌ์ฑํ ๊ธ์ ๋๋ค.
์์ธํ ์ค๋ช ์ ์ฐธ๊ณ ์ฌ์ดํธ๋ฅผ ์ดํด๋ณด์๊ธฐ ๋ฐ๋๋๋ค.
ํค๋ฅผ ์ฌ์ฉํด ์๋ณํ ์ ์๋ ๊ฐ์ ๋ด์ ์ปฌ๋ ์ ์ ๊ฐ์ฒด๋ผ๋ ์๋ฃ๊ตฌ์กฐ๋ฅผ ์ด์ฉํด ์ ์ฅํ๋๋ฐ, ๊ฐ์ฒด๋ง์ผ๋ก๋ ๋ค์ํ ์์ ์ ํ ์ ์์ต๋๋ค.
๊ทธ๋ฐ๋ฐ ๊ฐ๋ฐ์ ์งํํ๋ค ๋ณด๋ฉด ์ฒซ ๋ฒ์งธ ์์, ๋ ๋ฒ์งธ ์์, ์ธ ๋ฒ์งธ ์์ ๋ฑ๊ณผ ๊ฐ์ด ์์๊ฐ ์๋ ์ปฌ๋ ์ ์ด ํ์ํ ๋๊ฐ ์๊ธฐ๊ณค ํฉ๋๋ค. ์ฌ์ฉ์๋ ๋ฌผ๊ฑด, HTML ์์ ๋ชฉ๋ก๊ฐ์ด ์ผ๋ชฉ์์ฐํ๊ฒ ์์๋ฅผ ๋ง๋ค์ด ์ ๋ ฌํ๊ธฐ ์ํด์ ๋ง์ด์ฃ .
์์๊ฐ ์๋ ์ปฌ๋ ์ ์ ๋ค๋ค์ผ ํ ๋ ๊ฐ์ฒด๋ฅผ ์ฌ์ฉํ๋ฉด ์์์ ๊ด๋ จ๋ ๋ฉ์๋๊ฐ ์์ด ๊ทธ๋ค์ง ํธ๋ฆฌํ์ง ์์ต๋๋ค. ๊ฐ์ฒด๋ ํ์์ด ์์๋ฅผ ๊ณ ๋ คํ์ง ์๊ณ ๋ง๋ค์ด์ง ์๋ฃ๊ตฌ์กฐ์ด๊ธฐ ๋๋ฌธ์ ๊ฐ์ฒด๋ฅผ ์ด์ฉํ๋ฉด ์๋ก์ด ํ๋กํผํฐ๋ฅผ ๊ธฐ์กด ํ๋กํผํฐ "์ฌ์ด์" ๋ผ์ ๋ฃ๋ ๊ฒ๋ ๋ถ๊ฐ๋ฅํฉ๋๋ค.
์ด๋ด ๋ ๐ฅ ์์๊ฐ ์๋ ์ปฌ๋ ์ ์ ์ ์ฅํ ๋ ์ฐ๋ ์๋ฃ๊ตฌ์กฐ์ธ ๋ฐฐ์ด์ ์ฌ์ฉํ ์ ์์ต๋๋ค.
์๋ ๋ ๋ฌธ๋ฒ์ ์ฌ์ฉํ๋ฉด ๋น ๋ฐฐ์ด์ ๋ง๋ค ์ ์์ต๋๋ค.
let arr = new Array();
let arr = [];
๋๋ถ๋ถ ๋ ๋ฒ์งธ ๋ฐฉ๋ฒ์ผ๋ก ๋ฐฐ์ด์ ์ ์ธํ๋๋ฐ, ์ด๋ ๋๊ดํธ ์์ ์ด๊ธฐ ์์๋ฅผ ๋ฃ์ด์ฃผ๋ ๊ฒ๋ ๊ฐ๋ฅํฉ๋๋ค.
let fruits = ["์ฌ๊ณผ", "์ค๋ ์ง", "์๋"];
๊ฐ ๋ฐฐ์ด ์์์ 0
๋ถํฐ ์์ํ๋ ์ซ์(์ธ๋ฑ์ค)๊ฐ ๋งค๊ฒจ์ ธ ์์ต๋๋ค. ์ด ์ซ์๋ค์ ๋ฐฐ์ด ๋ด ์์๋ฅผ ๋ํ๋
๋๋ค.
๋ฐฐ์ด ๋ด ํน์ ์์๋ฅผ ์ป๊ณ ์ถ๋ค๋ฉด ๋๊ดํธ ์์ ์์๋ฅผ ๋ํ๋ด๋ ์ซ์์ธ ์ธ๋ฑ์ค๋ฅผ ๋ฃ์ด์ฃผ๋ฉด ๋ฉ๋๋ค.
let fruits = ["์ฌ๊ณผ", "์ค๋ ์ง", "์๋"];
alert( fruits[0] ); // ์ฌ๊ณผ
alert( fruits[1] ); // ์ค๋ ์ง
alert( fruits[2] ); // ์๋
๊ฐ์ ๋ฐฉ๋ฒ์ผ๋ก ์์๋ฅผ ์์ ํ ์ ์์ต๋๋ค.
fruits[2] = "๋ฐฐ"; // ๋ฐฐ์ด์ด ["์ฌ๊ณผ", "์ค๋ ์ง", "๋ฐฐ"]๋ก ๋ฐ๋
์๋ก์ด ์์๋ฅผ ๋ฐฐ์ด์ ์ถ๊ฐํ๋ ๊ฒ๋ ๊ฐ๋ฅํฉ๋๋ค.
fruits[3] = "๋ ๋ชฌ"; // ๋ฐฐ์ด์ด ["์ฌ๊ณผ", "์ค๋ ์ง", "๋ฐฐ", "๋ ๋ชฌ"]์ผ๋ก ๋ฐ๋
length
๋ฅผ ์ฌ์ฉํ๋ฉด ๋ฐฐ์ด์ ๋ด๊ธด ์์๊ฐ ๋ช ๊ฐ์ธ์ง ์์๋ผ ์ ์์ต๋๋ค.
let fruits = ["์ฌ๊ณผ", "์ค๋ ์ง", "์๋"];
alert( fruits.length ); // 3
๐ฅ ๋ฐฐ์ด ์์์ ์๋ฃํ์ ์ ์ฝ์ด ์์ต๋๋ค.
// ์์์ ์ฌ๋ฌ ๊ฐ์ง ์๋ฃํ์ด ์์ฌ ์์ต๋๋ค.
let arr = [ "์ฌ๊ณผ", { name: "์ด๋ณด๋ผ" }, true, function() { alert("์๋
ํ์ธ์."); } ];
// ์ธ๋ฑ์ค๊ฐ 1์ธ ์์(๊ฐ์ฒด)์ name ํ๋กํผํฐ๋ฅผ ์ถ๋ ฅํฉ๋๋ค.
alert( arr[1].name ); // ์ด๋ณด๋ผ
// ์ธ๋ฑ์ค๊ฐ 3์ธ ์์(ํจ์)๋ฅผ ์คํํฉ๋๋ค.
arr[3](); // ์๋
ํ์ธ์.
๋ฐฐ์ด์ ๋ง์ง๋ง ์์๋ ๊ฐ์ฒด์ ๋ง์ฐฌ๊ฐ์ง๋ก ์ผํ๋ก ๋๋ ์ ์์ต๋๋ค.
let fruits = [
"์ฌ๊ณผ",
"์ค๋ ์ง",
"์๋",
];
trailing(๊ธธ๊ฒ ๋์ด์ง๋) ์ผํ๋ฅผ ์ฌ์ฉํ๋ฉด ๋ชจ๋ ์ค์ ์๊น์๊ฐ ์ ์ฌํด์ง๊ธฐ ๋๋ฌธ์ ์์๋ฅผ ๋ฃ๊ฑฐ๋ ๋นผ๊ธฐ๊ฐ ์ฌ์์ง๋๋ค.
ํ(queue)๋ ๋ฐฐ์ด์ ์ฌ์ฉํด ๋ง๋ค ์ ์๋ ๋ํ์ ์ธ ์๋ฃ๊ตฌ์กฐ๋ก, ๋ฐฐ์ด๊ณผ ๋ง์ฐฌ๊ฐ์ง๋ก ์์๊ฐ ์๋ ์ปฌ๋ ์ ์ ์ ์ฅํ๋ ๋ฐ ์ฌ์ฉํฉ๋๋ค. ํ๋ฉด์ ์์ฐจ์ ์ผ๋ก ๋์ธ ๋ฉ์์ง๋ฅผ ๋น์ถํด ๋์ ์๋ฃ ๊ตฌ์กฐ๋ฅผ ๋ง๋ค ๋ ํ๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ฒ๋ผ ํ๋ ์ค๋ฌด์์ ์๋นํ ์์ฃผ ์ฐ์ด๋ ์๋ฃ๊ตฌ์กฐ์ ๋๋ค.
ํ์์ ์ฌ์ฉํ๋ ์ฃผ์ ์ฐ์ฐ์ ์๋์ ๊ฐ์ต๋๋ค.
push
๋งจ ๋์ ์์๋ฅผ ์ถ๊ฐํฉ๋๋ค.
shift
์ ์ผ ์ ์์๋ฅผ ๊บผ๋ด ์ ๊ฑฐํ ํ ๋จ์์๋ ์์๋ค์ ์์ผ๋ก ๋ฐ์ด์ค๋๋ค. ์ด๋ ๊ฒ ํ๋ฉด ๋ ๋ฒ์งธ ์์๊ฐ ์ฒซ ๋ฒ์งธ ์์๊ฐ ๋ฉ๋๋ค.
๋ฐฐ์ด์ ํ ์ด์ธ์ ์คํ(stack)์ด๋ผ ๋ถ๋ฆฌ๋ ์๋ฃ๊ตฌ์กฐ๋ฅผ ๊ตฌํํ ๋๋ ์ฐ์ ๋๋ค. ์คํ์ ํํ ์นด๋ ํ ๋ฒ๊ณผ ๋น๊ต๋ฉ๋๋ค. ์์ฌ์๋ ์นด๋ ๋งจ ์์ ์๋ก์ด ์นด๋๋ฅผ ๋ํด์ฃผ๊ฑฐ๋ ๋นผ๋ ๊ฒ์ฒ๋ผ ์คํ๋ "ํ์ชฝ ๋"์ ์์๋ฅผ ์ง์ด๋ฃ๊ฑฐ๋ ์ถ์ถ ํ ์ ์๊ธฐ ๋๋ฌธ์ ๋๋ค.
์คํ์์ ์ฌ์ฉํ๋ ์ฐ์ฐ์ ์๋์ ๊ฐ์ต๋๋ค.
push
์์๋ฅผ ์คํ ๋์ ์ง์ด๋ฃ์ต๋๋ค.
pop
์คํ ๋ ์์๋ฅผ ์ถ์ถํฉ๋๋ค.
์คํ์ ์ฌ์ฉํ๋ฉด ๊ฐ์ฅ ๋์ค์ ์ง์ด๋ฃ์ ์์๊ฐ ๋จผ์ ๋์ต๋๋ค. ์ด๋ฐ ํน์ง์ ์ค์ฌ์ ํ์ ์ ์ถ(Last-In-First-Out, LIFO)์ด๋ผ๊ณ ๋ถ๋ฆ ๋๋ค. ๋ฐ๋ฉด ํ๋ฅผ ์ฌ์ฉํ๋ฉด ๋จผ์ ์ง์ด๋ฃ์ ์์๊ฐ ๋จผ์ ๋์ค๊ธฐ ๋๋ฌธ์ ํ๋ ์ ์ ์ ์ถ(First-In-First-Out, FIFO) ์๋ฃ๊ตฌ์กฐ๋ผ๊ณ ๋ถ๋ฆ ๋๋ค.
์๋ฐ์คํฌ๋ฆฝํธ ๋ฐฐ์ด์ ์ฌ์ฉํ๋ฉด ํ์ ์คํ ๋ ๋ค๋ฅผ ๋ง๋ค ์ ์์ต๋๋ค. ์ด ์๋ฃ๊ตฌ์กฐ๋ค์ ๋ฐฐ์ด์ ์ฒ์์ด๋ ๋์ ์์๋ฅผ ๋ํ๊ฑฐ๋ ๋นผ๋ ๋ฐ ์ฌ์ฉ๋์ฃ .
์ด๋ ๊ฒ ์ฒ์์ด๋ ๋์ ์์๋ฅผ ๋ํ๊ฑฐ๋ ๋นผ์ฃผ๋ ์ฐ์ฐ์ ์ ๊ณตํ๋ ์๋ฃ๊ตฌ์กฐ๋ฅผ ์ปดํจํฐ ๊ณผํ ๋ถ์ผ์์ ๋ฐํ(deque, Double Ended Queue)๋ผ๊ณ ๋ถ๋ฆ ๋๋ค.
๋ฐฐ์ด ๋ ์์๋ฅผ ์ ๊ฑฐํ๊ณ , ์ ๊ฑฐํ ์์๋ฅผ ๋ฐํํฉ๋๋ค.
let fruits = ["์ฌ๊ณผ", "์ค๋ ์ง", "๋ฐฐ"];
alert( fruits.pop() ); // ๋ฐฐ์ด์์ "๋ฐฐ"๋ฅผ ์ ๊ฑฐํ๊ณ ์ ๊ฑฐ๋ ์์๋ฅผ ์ผ๋ฟ์ฐฝ์ ๋์๋๋ค.
alert( fruits ); // ์ฌ๊ณผ,์ค๋ ์ง
๋ฐฐ์ด ๋์ ์์๋ฅผ ์ถ๊ฐํฉ๋๋ค.
let fruits = ["์ฌ๊ณผ", "์ค๋ ์ง"];
fruits.push("๋ฐฐ");
alert( fruits ); // ์ฌ๊ณผ,์ค๋ ์ง,๋ฐฐ
fruits.push(...)
๋ฅผ ํธ์ถํ๋ ๊ฒ์ fruits[fruits.length] = ...
ํ๋ ๊ฒ๊ณผ ๊ฐ์ ํจ๊ณผ๋ฅผ ๋ณด์
๋๋ค.
๋ฐฐ์ด ์ ์์๋ฅผ ์ ๊ฑฐํ๊ณ , ์ ๊ฑฐํ ์์๋ฅผ ๋ฐํํฉ๋๋ค.
let fruits = ["์ฌ๊ณผ", "์ค๋ ์ง", "๋ฐฐ"];
alert( fruits.shift() ); // ๋ฐฐ์ด์์ "์ฌ๊ณผ"๋ฅผ ์ ๊ฑฐํ๊ณ ์ ๊ฑฐ๋ ์์๋ฅผ ์ผ๋ฟ์ฐฝ์ ๋์๋๋ค.
alert( fruits ); // ์ค๋ ์ง,๋ฐฐ
๋ฐฐ์ด ์์ ์์๋ฅผ ์ถ๊ฐํฉ๋๋ค.
let fruits = ["์ค๋ ์ง", "๋ฐฐ"];
fruits.unshift("์ฌ๊ณผ");
alert( fruits ); // ์ฌ๊ณผ,์ค๋ ์ง,๋ฐฐ
push
์ unshift
๋ ์์ ์ฌ๋ฌ ๊ฐ๋ฅผ ํ ๋ฒ์ ๋ํด์ค ์๋ ์์ต๋๋ค.
let fruits = ["์ฌ๊ณผ"];
fruits.push("์ค๋ ์ง", "๋ฐฐ");
fruits.unshift("ํ์ธ์ ํ", "๋ ๋ชฌ");
// ["ํ์ธ์ ํ", "๋ ๋ชฌ", "์ฌ๊ณผ", "์ค๋ ์ง", "๋ฐฐ"]
alert( fruits );
๐ฅ ๋ฐฐ์ด์ ํน๋ณํ ์ข
๋ฅ์ ๊ฐ์ฒด์
๋๋ค. ๋ฐฐ์ด arr
์ ์์๋ฅผ arr[0]
์ฒ๋ผ ๋๊ดํธ๋ฅผ ์ฌ์ฉํด ์ ๊ทผํ๋ ๋ฐฉ์์ ๊ฐ์ฒด ๋ฌธ๋ฒ์์ ์์ต๋๋ค. ๋ค๋ง ๋ฐฐ์ด์ ํค๊ฐ ์ซ์๋ผ๋ ์ ๋ง ๋ค๋ฆ
๋๋ค.
์ซ์ ํค๋ฅผ ์ฌ์ฉํจ์ผ๋ก์จ ๋ฐฐ์ด์ ๊ฐ์ฒด ๊ธฐ๋ณธ ๊ธฐ๋ฅ ์ด์ธ์๋ ์์๊ฐ ์๋ ์ปฌ๋ ์
์ ์ ์ดํ๊ฒ ํด์ฃผ๋ ํน๋ณํ ๋ฉ์๋๋ฅผ ์ ๊ณตํฉ๋๋ค. length
๋ผ๋ ํ๋กํผํฐ๋ ์ ๊ณตํ์ฃ . ๊ทธ๋ ์ง๋ง ์ด์จ๋ ๋ฐฐ์ด์ ๋ณธ์ง์ ๊ฐ์ฒด์
๋๋ค.
์ด๋ ๊ฒ ๋ฐฐ์ด์ ์๋ฐ์คํฌ๋ฆฝํธ์ ์ผ๊ณฑ ๊ฐ์ง ์์ ์๋ฃํ์ ํด๋นํ์ง ์๊ณ , ์์ ์๋ฃํ์ด ์๋ ๊ฐ์ฒดํ์ ์ํ๊ธฐ ๋๋ฌธ์ ๊ฐ์ฒด์ฒ๋ผ ๋์ํฉ๋๋ค. ๋ฐฐ์ด์ ๊ฐ์ฒด์ ๋ง์ฐฌ๊ฐ์ง๋ก ์ฐธ์กฐ๋ฅผ ํตํด ๋ณต์ฌ๋ฉ๋๋ค.
let fruits = ["๋ฐ๋๋"]
let arr = fruits; // ์ฐธ์กฐ๋ฅผ ๋ณต์ฌํจ(๋ ๋ณ์๊ฐ ๊ฐ์ ๊ฐ์ฒด๋ฅผ ์ฐธ์กฐ)
alert( arr === fruits ); // true
arr.push("๋ฐฐ"); // ์ฐธ์กฐ๋ฅผ ์ด์ฉํด ๋ฐฐ์ด์ ์์ ํฉ๋๋ค.
alert( fruits ); // ๋ฐ๋๋,๋ฐฐ - ์์๊ฐ ๋ ๊ฐ๊ฐ ๋์์ต๋๋ค.
๋ฐฐ์ด์ ๋ฐฐ์ด๋ต๊ฒ ๋ง๋ค์ด์ฃผ๋ ๊ฒ์ ํน์ ๋ด๋ถ ํํ๋ฐฉ์์ ๋๋ค. ์๋ฐ์คํฌ๋ฆฝํธ ์์ง์ ์๋์ชฝ ๊ทธ๋ฆผ์์์ฒ๋ผ ๋ฐฐ์ด์ ์์๋ฅผ ์ธ์ ํ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ ์ฐจ๋ก๋ก ์ ์ฅํด ์ฐ์ฐ ์๋๋ฅผ ๋์ ๋๋ค. ์ด ๋ฐฉ๋ฒ ์ด์ธ์๋ ๋ฐฐ์ด ๊ด๋ จ ์ฐ์ฐ์ ๋ ๋น ๋ฅด๊ฒ ํด์ฃผ๋ ์ต์ ํ ๊ธฐ๋ฒ์ ๋ค์ํฉ๋๋ค.
๊ทธ๋ฐ๋ฐ ๊ฐ๋ฐ์๊ฐ ๋ฐฐ์ด์ "์์๊ฐ ์๋ ์๋ฃ์ ์ปฌ๋ ์ "์ฒ๋ผ ๋ค๋ฃจ์ง ์๊ณ ์ผ๋ฐ ๊ฐ์ฒด์ฒ๋ผ ๋ค๋ฃจ๋ฉด ์ด๋ฐ ๊ธฐ๋ฒ๋ค์ด ์ ๋๋ก ๋์ํ์ง ์์ต๋๋ค.
let fruits = []; // ๋น ๋ฐฐ์ด์ ํ๋ ๋ง๋ญ๋๋ค.
fruits[99999] = 5; // ๋ฐฐ์ด์ ๊ธธ์ด๋ณด๋ค ํจ์ฌ ํฐ ์ซ์๋ฅผ ์ฌ์ฉํด ํ๋กํผํฐ๋ฅผ ๋ง๋ญ๋๋ค.
fruits.age = 25; // ์์์ ์ด๋ฆ์ ์ฌ์ฉํด ํ๋กํผํฐ๋ฅผ ๋ง๋ญ๋๋ค.
๋ฐฐ์ด์ ๊ฐ์ฒด์ด๋ฏ๋ก ์์์ฒ๋ผ ์ํ๋ ํ๋กํผํฐ๋ฅผ ์ถ๊ฐํด๋ ๋ฌธ์ ๊ฐ ๋ฐ์ํ์ง ์์ต๋๋ค.
๊ทธ๋ฐ๋ฐ ์ด๋ ๊ฒ ์ฝ๋๋ฅผ ์์ฑํ๋ฉด ์๋ฐ์คํฌ๋ฆฝํธ ์์ง์ด ๋ฐฐ์ด์ ์ผ๋ฐ ๊ฐ์ฒด์ฒ๋ผ ๋ค๋ฃจ๊ฒ ๋์ด ๋ฐฐ์ด์ ๋ค๋ฃฐ ๋๋ง ์ ์ฉ๋๋ ์ต์ ํ ๊ธฐ๋ฒ์ด ๋์ํ์ง ์์ ๋ฐฐ์ด ํน์ ์ ์ด์ ์ด ์ฌ๋ผ์ง๋๋ค.
์๋ชป๋ ๋ฐฉ๋ฒ์ ์๋ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
๐ arr.test = 5
๊ฐ์ด ์ซ์๊ฐ ์๋ ๊ฐ์ ํ๋กํผํฐ ํค๋ก ์ฌ์ฉํ๋ ๊ฒฝ์ฐ
๐ arr[0]
๊ณผ arr[1000]
๋ง ์ถ๊ฐํ๊ณ ๊ทธ์ฌ์ด์ ์๋ฌด๋ฐ ์์๋ ์๋ ๊ฒฝ์ฐ
๐ arr[1000]
, arr[999]
๊ฐ์ด ์์๋ฅผ ์ญ์์ผ๋ก ์ฑ์ฐ๋ ๊ฒฝ์ฐ
๋ฐฐ์ด์ ์์๊ฐ ์๋ ์๋ฃ๋ฅผ ์ ์ฅํ๋ ์ฉ๋๋ก ๋ง๋ค์ด์ง ํน์ํ ์๋ฃ๊ตฌ์กฐ์
๋๋ค. ๋ฐฐ์ด ๋ด์ฅ ๋ฉ์๋๋ค์ ์ด๋ฐ ์ฉ๋์ ๋ง๊ฒ ๋ง๋ค์ด์ก์ฃ . ์๋ฐ์คํฌ๋ฆฝํธ ์์ง์ ์ด๋ฐ ํน์ฑ์ ๊ณ ๋ คํ์ฌ ๋ฐฐ์ด์ ์ ์คํ๊ฒ ์กฐ์ ํ๊ณ , ์ฒ๋ฆฌํ๋ฏ๋ก ๋ฐฐ์ด์ ์ฌ์ฉํ ๋ ์ด๋ฐ ๋ชฉ์ ์ ๋ง๊ฒ ์ฌ์ฉํด ์ฃผ์๊ธฐ ๋ฐ๋๋๋ค. ์์์ ํค๋ฅผ ์ฌ์ฉํด์ผ ํ๋ค๋ฉด ๋ฐฐ์ด๋ณด๋จ ์ผ๋ฐ ๊ฐ์ฒด {}
๊ฐ ์ ํฉํ ์๋ฃ๊ตฌ์กฐ์ผ ํ๋ฅ ์ด ๋์ต๋๋ค.
push
์ pop
์ ๋น ๋ฅด์ง๋ง shift
์ unshift
๋ ๋๋ฆฝ๋๋ค.
๋ฐฐ์ด ์์ ๋ฌด์ธ๊ฐ๋ฅผ ํด์ฃผ๋ ๋ฉ์๋๊ฐ ๋ฐฐ์ด ๋์ ๋ฌด์ธ๊ฐ๋ฅผ ํด์ฃผ๋ ๋ฉ์๋๋ณด๋ค ๋๋ฆฐ ์ด์ ๋ฅผ ์คํ ํ๋ฆ์ ์ดํด๋ณด๋ฉด์ ์์๋ด
์๋ค.
shift
๋ฉ์๋๋ฅผ ํธ์ถํ ๊ฒ๊ณผ ๋์ผํ ํจ๊ณผ๋ฅผ ๋ณด๋ ค๋ฉด ์ธ๋ฑ์ค๊ฐ 0
์ธ ์์๋ฅผ ์ ๊ฑฐํ๋ ๊ฒ๋ง์ผ๋ก ์ถฉ๋ถํ์ง ์์ต๋๋ค. ์ ๊ฑฐ ๋์์ด ์๋ ๋๋จธ์ง ์์๋ค์ ์ธ๋ฑ์ค๋ฅผ ์์ ํด ์ค์ผ ํ์ฃ .
shift
์ฐ์ฐ์ ์๋ 3๊ฐ์ง ๋์์ ๋ชจ๋ ์ํํด์ผ ์ด๋ค์ง๋๋ค.
๐ ์ธ๋ฑ์ค๊ฐ 0
์ธ ์์๋ฅผ ์ ๊ฑฐํฉ๋๋ค.
๐ ๋ชจ๋ ์์๋ฅผ ์ผ์ชฝ์ผ๋ก ์ด๋์ํต๋๋ค. ์ด๋ ์ธ๋ฑ์ค 1
์ 0
, 2
๋ 1
๋ก ๋ณํฉ๋๋ค.
๐ length
ํ๋กํผํฐ ๊ฐ์ ๊ฐฑ์ ํฉ๋๋ค.
๊ทธ๋ฐ๋ฐ ๋ฐฐ์ด์ ์์๊ฐ ๋ง์ผ๋ฉด ์์๊ฐ ์ด๋ํ๋ ๋ฐ ๊ฑธ๋ฆฌ๋ ์๊ฐ์ด ๊ธธ๊ณ ๋ฉ๋ชจ๋ฆฌ ๊ด๋ จ ์ฐ์ฐ๋ ๋ง์์ง๋๋ค.
unshift
๋ฅผ ์คํํ์ ๋๋ ์ด์ ์ ์ฌํ ์ผ์ด ์ผ์ด๋ฉ๋๋ค. ์์๋ฅผ ๋ฐฐ์ด ์์ ์ถ๊ฐํ๋ ค๋ฉด ์ผ๋จ ๊ธฐ์กด ์์๋ค์ ์ค๋ฅธ์ชฝ์ผ๋ก ์ด๋์์ผ์ผ ํ๋๋ฐ, ์ด๋ ์ธ๋ฑ์ค๋ ๋ฐ๊ฟ์ค์ผ ํฉ๋๋ค.
๊ทธ๋ ๋ค๋ฉด push
๋ pop
์ ์ด๋จ๊น์? ์ด ๋์ ์์ ์ด๋์ ์๋ฐํ์ง ์์ต๋๋ค. pop
๋ฉ์๋๋ก ์์๋ฅผ ๋์์ ์ ๊ฑฐํ๋ ค๋ฉด ๋ง์ง๋ง ์์๋ฅผ ์ ๊ฑฐํ๊ณ length
ํ๋กํผํฐ์ ๊ฐ์ ์ค์ฌ์ฃผ๊ธฐ๋ง ํ๋ฉด ๋์ฃ .
pop
๋ฉ์๋๋ ์์๋ฅผ ์ฎ๊ธฐ์ง ์์ผ๋ฏ๋ก ๊ฐ ์์๋ ๊ธฐ์กด ์ธ๋ฑ์ค๋ฅผ ๊ทธ๋๋ก ์ ์งํฉ๋๋ค. ๋ฐฐ์ด ๋์ ๋ฌด์ธ๊ฐ๋ฅผ ํด์ฃผ๋ ๋ฉ์๋์ ์คํ ์๋๊ฐ ๋น ๋ฅธ ์ด์ ๋ ๋ฐ๋ก ์ฌ๊ธฐ์ ์์ต๋๋ค.
push
๋ฉ์๋๋ฅผ ์ธ ๋๋ ์ ์ฌํ ๋์์ด ์ผ์ด๋๋ฏ๋ก ์๋๊ฐ ๋น ๋ฆ
๋๋ค.
for
๋ฌธ์ ๋ฐฐ์ด์ ์ํํ ๋ ์ฐ๋ ๊ฐ์ฅ ์ค๋๋ ๋ฐฉ๋ฒ์
๋๋ค. ์ํ์์ ์ธ๋ฑ์ค๋ฅผ ์ฌ์ฉํฉ๋๋ค.
let arr = ["์ฌ๊ณผ", "์ค๋ ์ง", "๋ฐฐ"];
for (let i = 0; i < arr.length; i++) {
alert( arr[i] );
}
๋ฐฐ์ด์ ์ ์ฉํ ์ ์๋ ๋ ๋ค๋ฅธ ์ํ ๋ฌธ๋ฒ์ผ๋ก for..of
๊ฐ ์์ต๋๋ค.
let fruits = ["์ฌ๊ณผ", "์ค๋ ์ง", "์๋"];
// ๋ฐฐ์ด ์์๋ฅผ ๋์์ผ๋ก ๋ฐ๋ณต ์์
์ ์ํํฉ๋๋ค.
for (let fruit of fruits) {
alert( fruit );
}
for..of
๋ฅผ ์ฌ์ฉํ๋ฉด ํ์ฌ ์์์ ์ธ๋ฑ์ค๋ ์ป์ ์ ์๊ณ ๊ฐ๋ง ์ป์ ์ ์์ต๋๋ค. ์ด ์ ๋ ๊ธฐ๋ฅ์ด๋ฉด ์ํ๋ ๊ฒ์ ์ถฉ๋ถํ ๊ตฌํํ ์ ์๊ณ ๋ฌธ๋ฒ๋ ์งง๊ธฐ ๋๋ฌธ์ ๋ฐฐ์ด์ ์์๋ฅผ ๋์์ผ๋ก ๋ฐ๋ณต ์์
์ ํ ๋ for..of
๋ฅผ ์ฌ์ฉํด ๋ณด์๊ธฐ ๋ฐ๋๋๋ค.
๋ฐฐ์ด์ ๊ฐ์ฒดํ์ ์ํ๋ฏ๋ก for..in
์ ์ฌ์ฉํ๋ ๊ฒ๋ ๊ฐ๋ฅํฉ๋๋ค.
let arr = ["์ฌ๊ณผ", "์ค๋ ์ง", "๋ฐฐ"];
for (let key in arr) {
alert( arr[key] ); // ์ฌ๊ณผ, ์ค๋ ์ง, ๋ฐฐ
}
๊ทธ๋ฐ๋ฐ for..in
์ ๋ค์๊ณผ ๊ฐ์ ํน์ง์ ์ง๋๊ธฐ ๋๋ฌธ์ ๋ฐฐ์ด์ for..in
์ ์ฌ์ฉํ๋ฉด ๋ฌธ์ ๊ฐ ๋ฐ์ํ๋ฏ๋ก ๋๋๋ก ๋ค๋ฅธ ๋ฐ๋ณต๋ฌธ์ ์ฌ์ฉํ์๊ธธ ๋ฐ๋๋๋ค.
for..in
๋ฐ๋ณต๋ฌธ์ ๋ชจ๋ ํ๋กํผํฐ๋ฅผ ๋์์ผ๋ก ์ํํฉ๋๋ค. ํค๊ฐ ์ซ์๊ฐ ์๋ ํ๋กํผํฐ๋ ์ํ ๋์์ ํฌํจ๋ฉ๋๋ค.
๋ธ๋ผ์ฐ์ ๋ ๊ธฐํ ํธ์คํธ ํ๊ฒฝ์์ ์ฐ์ด๋ ๊ฐ์ฒด ์ค, ๋ฐฐ์ด๊ณผ ์ ์ฌํ ํํ๋ฅผ ๋ณด์ด๋ "์ ์ฌ ๋ฐฐ์ด(array-like)" ๊ฐ์ฒด๊ฐ ์์ต๋๋ค. ์ ์ฌ ๋ฐฐ์ด ๊ฐ์ฒด์ ๋ฐฐ์ด์ฒ๋ผ length
ํ๋กํผํฐ๋ ์๊ณ ์์๋ง๋ค ์ธ๋ฑ์ค๋ ๋ถ์ด ์์ฃ . ๊ทธ๋ฐ๋ฐ ์ฌ๊ธฐ์ ๋ํ์ฌ ์ ์ฌ ๋ฐฐ์ด ๊ฐ์ฒด์ ๋ฐฐ์ด๊ณผ๋ ๋ฌ๋ฆฌ ํค๊ฐ ์ซ์ํ์ด ์๋ ํ๋กํผํฐ์ ๋ฉ์๋๊ฐ ์์ ์ ์์ต๋๋ค. ์ ์ฌ ๋ฐฐ์ด ๊ฐ์ฒด์ for..in
์ ํจ๊ป ์ฌ์ฉํ๋ฉด ์ด ๋ชจ๋ ๊ฒ์ ๋์์ผ๋ก ์ํ๊ฐ ์ด๋ค์ง๋๋ค. ๋ฐ๋ผ์ "ํ์ ์๋" ํ๋กํผํฐ๋ค์ด ๋ฌธ์ ๋ฅผ ์ผ์ผํฌ ๊ฐ๋ฅ์ฑ์ด ์๊น๋๋ค.
for..in
๋ฐ๋ณต๋ฌธ์ ๋ฐฐ์ด์ด ์๋๋ผ ๊ฐ์ฒด์ ํจ๊ป ์ฌ์ฉํ ๋ ์ต์ ํ๋์ด ์์ด์ ๋ฐฐ์ด์ ์ฌ์ฉํ๋ฉด ๊ฐ์ฒด์ ์ฌ์ฉํ๋ ๊ฒ ๋๋น 10~100๋ฐฐ ์ ๋ ๋๋ฆฝ๋๋ค. for..in
๋ฐ๋ณต๋ฌธ์ ์๋๊ฐ ๋์ฒด๋ก ๋น ๋ฅธ ํธ์ด๊ธฐ ๋๋ฌธ์ ๋ณ๋ชฉ ์ง์ ์์๋ง ๋ฌธ์ ๊ฐ ๋๊ธด ํฉ๋๋ค๋ง, for..in
๋ฐ๋ณต๋ฌธ์ ์ฌ์ฉํ ๋ ์ด๋ฐ ์ฐจ์ด๋ฅผ ์๊ณ ์ ์ ํ ๊ณณ์ ์ฌ์ฉํ์๊ธธ ๋ฐ๋๋๋ค.
๊ทธ๋ฌ๋ ๋ฐฐ์ด์ ๋๋๋ก for..in
๋ฅผ ์ฐ์ง ๋ง์ธ์.
๋ฐฐ์ด์ ๋ฌด์ธ๊ฐ ์กฐ์์ ๊ฐํ๋ฉด length
ํ๋กํผํฐ๊ฐ ์๋์ผ๋ก ๊ฐฑ์ ๋ฉ๋๋ค. ๐ฅ length
ํ๋กํผํฐ๋ ๋ฐฐ์ด ๋ด ์์์ ๊ฐ์๊ฐ ์๋๋ผ ๊ฐ์ฅ ํฐ ์ธ๋ฑ์ค์ 1
์ ๋ํ ๊ฐ์
๋๋ค.
๋ฐ๋ผ์ ๋ฐฐ์ด์ ์์๊ฐ ํ๋ ์๊ณ , ์ด ์์์ ์ธ๋ฑ์ค๊ฐ ์์ฃผ ํฐ ์ ์๋ผ๋ฉด ๋ฐฐ์ด์ length
ํ๋กํผํฐ๋ ์์ฃผ ์ปค์ง๋๋ค.
let fruits = [];
fruits[123] = "์ฌ๊ณผ";
alert( fruits.length ); // 124
๋ฐฐ์ด์ ์ด๋ ๊ฒ ์ฌ์ฉํ์ง ์๋๋ก ํฉ์๋ค.
length
ํ๋กํผํฐ์ ๋ ๋ค๋ฅธ ๋
ํนํ ํน์ง ์ค ํ๋๋ ์ฐ๊ธฐ๊ฐ ๊ฐ๋ฅํ๋ค๋ ์ ์
๋๋ค.
length
์ ๊ฐ์ ์๋์ผ๋ก ์ฆ๊ฐ์ํค๋ฉด ์๋ฌด ์ผ๋ ์ผ์ด๋์ง ์์ต๋๋ค. ๊ทธ๋ฐ๋ฐ ๊ฐ์ ๊ฐ์์ํค๋ฉด ๋ฐฐ์ด์ด ์๋ฆฝ๋๋ค. ์งง์์ง ๋ฐฐ์ด์ ๋ค์ ๋๋๋ฆด ์ ์์ต๋๋ค.
let arr = [1, 2, 3, 4, 5];
arr.length = 2; // ์์ 2๊ฐ๋ง ๋จ๊ธฐ๊ณ ์๋ผ๋ด
์๋ค.
alert( arr ); // [1, 2]
arr.length = 5; // ๋ณธ๋ ๊ธธ์ด๋ก ๋๋๋ ค ๋ด
์๋ค.
alert( arr[3] ); // undefined: ์ญ์ ๋ ๊ธฐ์กด ์์๋ค์ด ๋ณต๊ตฌ๋์ง ์์ต๋๋ค.
์ด๋ฐ ํน์ง์ ์ด์ฉํ๋ฉด arr.length = 0;
์ ์ฌ์ฉํด ์์ฃผ ๊ฐ๋จํ๊ฒ ๋ฐฐ์ด์ ๋น์ธ ์ ์์ต๋๋ค.
์์์๋ ์ ์ ์ธ๊ธํ์ง๋ง new Array()
๋ฌธ๋ฒ์ ์ฌ์ฉํด๋ ๋ฐฐ์ด์ ๋ง๋ค ์ ์์ต๋๋ค.
let arr = new Array("์ฌ๊ณผ", "๋ฐฐ", "๊ธฐํ");
๋๊ดํธ []
๋ฅผ ์ฌ์ฉํ๋ฉด ๋ ์งง์ ๋ฌธ๋ฒ์ผ๋ก ๋ฐฐ์ด์ ๋ง๋ค ์ ์๊ธฐ ๋๋ฌธ์ new Array()
๋ ์ ์ฌ์ฉ๋์ง ์๋ ํธ์
๋๋ค. new Array()
์ ๋ค๋ฃจ๊ธฐ ๊น๋ค๋ก์ด ๊ธฐ๋ฅ๋ ์์ด์ ๋์ฑ๋ ๊ทธ๋ ์ต๋๋ค.
์ซ์ํ ์ธ์ ํ๋๋ฅผ ๋ฃ์ด์ new Array
๋ฅผ ํธ์ถํ๋ฉด ๋ฐฐ์ด์ด ๋ง๋ค์ด์ง๋๋ฐ, ์ด ๋ฐฐ์ด์ ์์๊ฐ ์๋ ๋ฐ๋ฉด ๊ธธ์ด๋ ์ธ์์ ๊ฐ์์ง๋๋ค.
์์๋ฅผ ํตํด new Array()
์ ์ด๋ฐ ํน์ง์ด ์ด๋ป๊ฒ ์ค์๋ฅผ ์ ๋ฐํ ์ ์๋์ง ์์๋ด
์๋ค.
let arr = new Array(2); // ์ด๋ ๊ฒ ํ๋ฉด ๋ฐฐ์ด [2]๊ฐ ๋ง๋ค์ด์ง๊น์?
alert( arr[0] ); // undefined๊ฐ ์ถ๋ ฅ๋ฉ๋๋ค. ์์๊ฐ ํ๋๋ ์๋ ๋ฐฐ์ด์ด ๋ง๋ค์ด์ก๋ค์.
alert( arr.length ); // ๊ธธ์ด๋ 2์
๋๋ค.
์ ์์์์ ํ์ธํด ๋ณธ ๊ฒ์ฒ๋ผ new Array(number)
๋ฅผ ์ด์ฉํด ๋ง๋ ๋ฐฐ์ด์ ์์๋ ๋ชจ๋ undefined
์
๋๋ค.
์ด๋ฐ ๋ป๋ฐ์ ์ํฉ์ ๋ง์ฃผ์น์ง ์๊ธฐ ์ํด new Array
์ ๊ธฐ๋ฅ์ ์ ์์ง ์๋ ํ ๋๋ถ๋ถ์ ๊ฐ๋ฐ์๊ฐ ๋๊ดํธ๋ฅผ ์จ์ ๋ฐฐ์ด์ ๋ง๋ญ๋๋ค.
๋๋ ์ ํน์ง์ ์ด์ฉํด์ ๋ฐฐ์ด์ ๋ฉ์๋ ์ค ํ๋์ธ fill
์ ์ด์ฉํด ๋ด๋ถ ์์์ ๊ฐ์ ๋ชจ๋ ํ ๋นํ ํ ํ์ฉํ๊ธฐ๋ ํฉ๋๋ค.
// new Array()์ Array()๋ ๋์ผํ ๋์์ ํฉ๋๋ค.
Array(100).fill().map((_, index) => {
alert( index );
})
[...Array(100)].map((_, index) => {
alert( index );
})
๋ฐฐ์ด ์ญ์ ๋ฐฐ์ด์ ์์๊ฐ ๋ ์ ์์ต๋๋ค. ์ด๋ฐ ๋ฐฐ์ด์ ๊ฐ๋ฆฌ์ผ ๋ค์ฐจ์ ๋ฐฐ์ด(multidimensional array)์ด๋ผ ๋ถ๋ฆ ๋๋ค. ๋ค์ฐจ์ ๋ฐฐ์ด์ ํ๋ ฌ์ ์ ์ฅํ๋ ์ฉ๋๋ก ์ฐ์ ๋๋ค.
let matrix = [
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
];
alert( matrix[1][1] ); // 5, ์ค์ฌ์ ์๋ ์์
๋ฐฐ์ด์ toString
๋ฉ์๋๊ฐ ๊ตฌํ๋์ด ์์ด ์ด๋ฅผ ํธ์ถํ๋ฉด ์์๋ฅผ ์ผํ๋ก ๊ตฌ๋ถํ ๋ฌธ์์ด์ด ๋ฐํ๋ฉ๋๋ค.
let arr = [1, 2, 3];
alert( arr ); // 1,2,3
alert( String(arr) === "1,2,3" ); // true
alert( [] + 1 ); // "1"
alert( [1] + 1 ); // "11"
alert( [1,2] + 1 ); // "1,21"
๋ฐฐ์ด์ Symbol.toPrimitive
๋ valueOf
๋ฉ์๋๊ฐ ์์ต๋๋ค. ๋ฐ๋ผ์ ์ ์์์์ ๋ฌธ์์ด๋ก์ ํ ๋ณํ์ด ์ผ์ด๋ []
๋ ๋น ๋ฌธ์์ด, [1]
์ ๋ฌธ์์ด "1"
, [1,2]
๋ ๋ฌธ์์ด "1,2"
๋ก ๋ณํ๋ฉ๋๋ค.
์ดํญ ๋ง์
์ฐ์ฐ์ "+"
๋ ํผ์ฐ์ฐ์ ์ค ํ๋๊ฐ ๋ฌธ์์ด์ธ ๊ฒฝ์ฐ ๋๋จธ์ง ํผ์ฐ์ฐ์๋ ๋ฌธ์์ด๋ก ๋ณํํฉ๋๋ค. ๋ฐ๋ผ์ ์ ์์๋ ์๋ ์์์ ๋์ผํ๊ฒ ๋์ํฉ๋๋ค.
alert( "" + 1 ); // "1"
alert( "1" + 1 ); // "11"
alert( "1,2" + 1 ); // "1,21"