Set ๊ฐ์ฒด๋ ์ค๋ณต๋์ง ์๋ ์ ์ผํ ๊ฐ๋ค์ ์งํฉ์ด๋ค. Set ๊ฐ์ฒด๋ ๋ฐฐ์ด๊ณผ ์ ์ฌํ์ง๋ง ๋ค์๊ณผ ๊ฐ์ ์ฐจ์ด๊ฐ ์๋ค.
๊ตฌ๋ถ | ๋ฐฐ์ด | Set ๊ฐ์ฒด |
---|---|---|
๋์ผํ ๊ฐ์ ์ค๋ณตํ์ฌ ํํจํ ์ ์๋ค. | O | X |
์์ ์์์ ์๋ฏธ๊ฐ ์๋ค. | O | X |
์ธ๋ฑ์ค๋ก ์์์ ์ ๊ทผํ ์ ์๋ค. | O | X |
Set์ ์ํ์ ์งํฉ์ ๊ตฌํํ๊ธฐ ์ํ ์๋ฃ๊ตฌ์กฐ๋ค.
Set์ ํตํด ๊ต์งํฉ, ํฉ์งํฉ, ์ฐจ์งํฉ, ์ฌ์งํฉ, ๋ฑ์ ๊ตฌํํ ์ ์๋ค.
Set ๊ฐ์ฒด๋ Set ์์ฑ์ ํจ์๋ก ์์ฑํ๋ค. Set ์์ฑ์ ํจ์์ ์ธ์๋ฅผ ์ ๋ฌํ์ง ์์ผ๋ฉด ๋น Set ๊ฐ์ฒด๊ฐ ์์ฑ๋๋ค.
const set = new Set();
console.log(set); // Set(0) {}
Set ์์ฑ์ ํจ์๋ ์ดํฐ๋ฌ๋ธ์ ์ธ์๋ก ์ ๋ฌ๋ฐ์ Set ๊ฐ์ฒด๋ฅผ ์์ฑํ๋ค. ์ด๋ ์ดํฐ๋ฌ๋ธ์ ์ค๋ณต๋ ๊ฐ์ Set ๊ฐ์ฒด์ ์์๋ก ์ ์ฅ๋์ง ์๋๋ค.
์ค๋ณต์ ํ์ฉํ์ง ์๋ Set ๊ฐ์ฒด์ ํน์ฑ์ ํ์ฉํ์ฌ ๋ฐฐ์ด์์ ์ค๋ณต๋ ์์๋ฅผ ์ ๊ฑฐํ ์ ์๋ค.
// ๋ฐฐ์ด์ ์ค๋ณต ์์ ์ ๊ฑฐ
const uniq = array => array.filter((v,i,self) => self.indexOf(v) === i);
console.log(uniq([2,1,2,3,4,3,4])); // [2,1,3,4]
// Set์ ์ฌ์ฉํ ๋ฐฐ์ด์ ์ค๋ณต ์์ ์ ๊ฑฐ
const uniq = array => [...new Set(array)];
console.log(uniq([2,1,2,3,4,3,4]))
Set ๊ฐ์ฒด์ ์์ ๊ฐ์๋ฅผ ํ์ธํ ๋๋ Set.prototype.size ํ๋กํผํฐ๋ฅผ ์ฌ์ฉํ๋ค
const { size } = new Set([1,2,3,3]);
console.log(size); // 3
size ํ๋กํผํฐ๋ setter ํจ์ ์์ด getter ํจ์๋ง ์กด์ฌํ๋ ์ ๊ทผ์ ํ๋กํผํฐ๋ค.
๋ฐ๋ผ์ size ํ๋กํผํฐ์ ์ซ์๋ฅผ ํ ๋นํ์ฌ ๊ฐ์ฒด์ ์์ ๊ฐ์๋ฅผ ๋ณ๊ฒฝํ ์ ์๋ค.
const set = new Set([1,2,3]);
console.log(Object.getOwnPropertyDescriptor(Set.prototype, 'size'));
set.size = 10; // ๋ฌด์๋๋ค
console.log(set.size); // 3
Set ๊ฐ์ฒด์ ์์๋ฅผ ์ถ๊ฐํ ๋๋ Set.prototype.add ๋ฉ์๋๋ฅผ ์ฌ์ฉ
const set = new Set();
console.log(set); // set(0) {}
set.add(1);
console.log(set); // Set(1) {1}
add ๋ฉ์๋๋ ์๋ก์ด ์์๊ฐ ์ถ๊ฐ๋ Set ๊ฐ์ฒด๋ฅผ ๋ฐํํ๋ค. add ๋ฉ์๋๋ฅผ ์ฐ์์ ์ผ๋ก ํธ์ถํ ์ ์๋ค.
Set ๊ฐ์ฒด์ ์ค๋ณต๋ ์์์ ์ถ๊ฐ๋ ํ์ฉ๋์ง ์๋๋ค.
์ด๋ ์๋ฌ๊ฐ ๋ฐ์ํ์ง๋ ์๊ณ ๋ฌด์๋๋ค.
์ผ์น ๋น๊ต ์ฐ์ฐ์ ===์ ์ฌ์ฉํ๋ฉด NaN๊ณผ NaN์ ๋ค๋ฅด๋ค๊ณ ํ๊ฐํ๋ค. ํ์ง๋ง Set ๊ฐ์ฒด๋ NaN๊ณผ NaN์ ๊ฐ๋ค๊ณ ํ๊ฐํ์ฌ ์ค๋ณต ์ถ๊ฐ๋ฅผ ํ์ฉํ์ง ์๋๋ค.
Set ๊ฐ์ฒด๋ ๊ฐ์ฒด๋ ๋ฐฐ์ด๊ณผ ๊ฐ์ด ์๋ฐ์คํฌ๋ฆฝํธ์ ๋ชจ๋ ๊ฐ์ ์์๋ก ์ ์ฅ
ํ ์ ์์.
Set ๊ฐ์ฒด์ ํน์ ์์๊ฐ ์กด์ฌํ๋์ง ํ์ธํ๋ ค๋ฉดSet.prototype.has ๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ค. has ๋ฉ์๋๋ ํน์ ์์์ ์กด์ฌ ์ฌ๋ถ๋ฅผ ๋ํ๋ด๋ ๋ถ๋ฆฌ์ธ ๊ฐ์ ๋ฐํํ๋ค.
const set = new Set([1,2,3]);
console.log(set.has(2)); // true
console.log(set.has(4)); // false
Set ๊ฐ์ฒด์ ํน์ ์์๋ฅผ ์ญ์ ํ๋ ค๋ฉด Set.prototype.delete ๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ค.
delete ๋ฉ์๋๋ ์ญ์ ์ฑ๊ณต ์ฌ๋ถ๋ฅผ ๋ํ๋ด๋ ๋ถ๋ฆฌ์ธ ๊ฐ์ ๋ฐํ
ํ๋ค.
delete ๋ฉ์๋์๋ ์ธ๋ฑ์ค๊ฐ ์๋๋ผ ์ญ์ ํ๋ ค๋ ์์๊ฐ์ ์ธ์๋ก ์ ๋ฌ
Set ๊ฐ์ฒด๋ ์์์ ์๋ฏธ๊ฐ ์๋ค. ๋ค์ ๋งํด ๋ฐฐ์ด๊ณผ ๊ฐ์ด ์ธ๋ฑ์ค๋ฅผ ๊ฐ์ง ์๋๋ค.
const set = new Set([1,2,3]);
// ์์ 2๋ฅผ ์ญ์ ํ๋ค.
set.delete(2);
console.log(set); // Set(2) {1,3}
// ์์ 1์ ์ญ์ ํ๋ค.
set.delete(1);
console.log(set); // Set(1) {3}
์กด์ฌํ์ง ์๋ Set ๊ฐ์ฒด์ ์์๋ฅผ ์ญ์ ํ๋ ค ํ๋ฉด ์๋ฌ ์์ด ๋ฌด์๋๋ค.
add ๋ฉ์๋์ ๋ฌ๋ฆฌ ์ฐ์์ ์ผ๋ก ํธ์ถ ํ ์ ์๋ค.
Set ๊ฐ์ฒด์ ๋ชจ๋ ์์๋ฅผ ์ผ๊ด ์ญ์ ํ๋ ค๋ฉด Set.prototype.clear ๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ค. clear ๋ฉ์๋๋
์ธ์ ๋ undefined๋ฅผ ๋ฐํํ๋ค.
const set = new Set([1,2,3]);
set.clear();
console.log(set); // Set(0) {}
Set ๊ฐ์ฒด์ ์์๋ฅผ ์ํํ๋ ค๋ฉด Set.prototype.forEach ๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ค. 3๊ฐ์ ์ธ์๋ฅผ ์ ๋ฌ๋ฐ์.
- ์ฒซ ๋ฒ์งธ ์ธ์: ํ์ฌ ์ํ ์ค์ธ ์์๊ฐ
- ๋ ๋ฒ์งธ ์ธ์: ํ์ฌ ์ํ ์ค์ธ ์์๊ฐ
- ์ธ ๋ฒ์งธ ์ธ์: ํ์ฌ ์ํ ์ค์ธ Set ๊ฐ์ฒด ์์ฒด
Set ๊ฐ์ฒด๋ ์์์ ์๋ฏธ๊ฐ ์์ด ๋ฐฐ์ด๊ณผ ๊ฐ์ด ์ธ๋ฑ์ค๋ฅผ ๊ฐ์ง ์๋๋ค.
const Set = new Set([1,2,3]);
set.forEach((v, v2, set) => console.log(v, v2, set));
/*
1 1 Set(3) {1,2,3}
2 2 Set(3) {1,2,3}
3 3 Set(3) {1,2,3}
*/
Set ๊ฐ์ฒด๋ ์ดํฐ๋ฌ๋ธ์ด๋ค. ๋ฐ๋ผ์ for...of ๋ฌธ์ผ๋ก ์ํํ ์ ์์ผ๋ฉฐ, ์คํ๋ ๋ ๋ฌธ๋ฒ๊ณผ ๋ฐฐ์ด ๋์คํธ๋ญ์ฒ๋ง์ ๋์์ด ๋ ์๋ ์๋ค.
Set ๊ฐ์ฒด๋ ์์์ ์์์ ์๋ฏธ๋ฅผ ๊ฐ์ง ์์ง๋ง Set ๊ฐ์ฒด๋ฅผ ์ํํ๋ ์์๋ ์์๊ฐ ์ถ๊ฐ๋ ์์
๋ฅผ ๋ฐ๋ฅธ๋ค. ๋ค๋ฅธ ์ดํฐ๋ฌ๋ธ์ ์ํ์ ํธํ์ฑ์ ์ ์งํ๊ธฐ ์ํจ์ด๋ค.
Set ๊ฐ์ฒด๋ ์ํ์ ์งํฉ์ ๊ตฌํํ๊ธฐ ์ํ ์๋ฃ๊ตฌ์กฐ
์ด๋ค. ๋ฐ๋ผ์ Set ๊ฐ์ฒด๋ฅผ ํตํด ๊ต์งํฉ, ํฉ์งํฉ, ์ฐจ์งํฉ ๋ฑ์ ๊ตฌํํจ
A์ ์งํฉ B์ ๊ณตํต ์์๋ก ๊ตฌ์ฑ๋๋ค.
Set.prototype.intersection = function (set) {
const result = new Set();
for(const value of set) {
// 2๊ฐ์ set์ ์์๊ฐ ๊ณตํต๋๋ ์์์ด๋ฉด ๊ต์งํฉ์ ๋์์ด๋ค
if (this.has(value)) result.add(value);
}
return result;
};
const setA = new Set([1,2,3,4]);
const setB = new Set([2,4]);
// setA์ setB์ ๊ต์งํจ
console.log(setA.intersection(setB)); // Set(2) {2,4}
A์ ์งํฉ B์ ์ค๋ณต ์๋ ๋ชจ๋ ์์ ๊ตฌ์ฑ๋๋ค.
Set.prototype.union = function (set) {
// this(Set ๊ฐ์ฒด)๋ฅผ ๋ณต์ฌ
const result = new Set();
for(const value of set) {
// ํฉ์งํฉ์ 2๊ฐ์ Set ๊ฐ์ฒด์ ๋ชจ๋ ์์๋ก ๊ตฌ์ฑ๋ ์งํฉ์ด๋ค. ์ค๋ณต๋ ์์๋ ํฌํจ๋์ง ์๋๋ค.
result.add(value);
}
return result;
};
const setA = new Set([1,2,3,4]);
const setB = new Set([2,4]);
// setA์ setB์ ๊ต์งํจ
console.log(setA.union(setB)); // Set(4) {1,2,3,4}
์งํฉ A์๋ ์กด์ฌํ์ง๋ง ์งํฉ B์๋ ์กด์ฌํ์ง ์๋ ์์๋ก ๊ตฌ์ฑ
Set.prototype.difference = function (set) {
// this(Set ๊ฐ์ฒด)๋ฅผ ๋ณต์ฌ
const result = new Set();
for(const value of set) {
// ์ฐจ์งํฉ์ ์ด๋ ํ์ชฝ ์งํฉ์๋ ์กด์ฌํ์ง๋ง ๋ค๋ฅธ ํ์ชฝ ์งํฉ์๋ ์กด์ฌํ์ง ์๋ ์์๋ก ๊ตฌ์ฑ๋ ์งํฉ์ด๋ค.
result.delete(value);
}
return result;
};
const setA = new Set([1,2,3,4]);
const setB = new Set([2,4]);
// setA์ setB์ ๊ต์งํจ
console.log(setA.difference(setB)); // Set(2) {1,3}
์งํฉ A๊ฐ ์งํฉ B์ ํฌํจ๋๋ ๊ฒฝ์ฐ ์งํฉ A๋ ์งํฉ B์ ๋ถ๋ถ ์งํฉ์ด๋ฉฐ, ์งํฉ B๋ ์งํฉ A์ ์์ ์งํฉ์ด๋ค.
//this๊ฐ subset์ ์์ ์งํฉ์ธ์ง ํ์ธํ๋ค.
Set.prototype.isSuperset = function (subset) {
for (const value of subset) {
// superset์ ๋ชจ๋ ์์๊ฐ subset์ ๋ชจ๋ ์์๋ฅผ ํฌํจํ๋์ง ํ์ธ
if (!this.has(value)) return false;
}
return true;
};
const setA = new Set([1,2,3,4]);
const setB = new Set([2,4]);
// setA์ setB์ ์์ ์งํฉ์ธ์ง ํ์ธํ๋ค.
console.log(setA.isSuperset(setB)); // true
Map ๊ฐ์ฒด๋ ํค์ ๊ฐ์ ์์ผ๋ก ์ด๋ฃจ์ด์ง ์ปฌ๋ ์ ์ด๋ค. Map ๊ฐ์ฒด๋ ๊ฐ์ฒด์ ์ ์ฌํ์ง๋ง ๋ค์๊ณผ ๊ฐ์ ์ฐจ์ด๊ฐ ์๋ค.
๊ตฌ๋ถ | ๊ฐ์ฒด | Map ๊ฐ์ฒด |
---|---|---|
ํค๋ก ์ฌ์ฉํ ์ ์๋ ๊ฐ | ๋ฌธ์์ด ๋๋ ์ฌ๋ฒ๊ฐ | ๊ฐ์ฒด๋ฅผ ํฌํจํ ๋ชจ๋ ๊ฐ |
์์ ์์์ ์๋ฏธ๊ฐ ์๋ค. | O | X |
์์ ๊ฐ์ ํ์ธ | Object.keys(obj).length | map.size |
Map ๊ฐ์ฒด๋ Map ์์ฑ์ ํจ์๋ก ์์ฑํ๋ค. Map ์์ฑ์ ํจ์์ ์ธ์๋ฅผ ์ ๋ฌํ์ง ์์ผ๋ฉด ๋น Map ๊ฐ์ฒด๊ฐ ์์ฑ๋๋ค.
const map = new Map();
console.log(map); // Map(0) {}
Map ์์ฑ์ ํจ์๋ ์ดํฐ๋ฌ๋ธ์ ์ธ์๋ก ์ ๋ฌ๋ฐ์ Map ๊ฐ์ฒด๋ฅผ ์์ฑํ๋ค. ์ด๋ ์ธ์๋ก ์ ๋ฌ๋๋ ์ดํฐ๋ฌ๋ธ์ ํค์ ๊ฐ์ ์์ผ๋ก ์ด๋ฃจ์ด์ง ์์๋ก ๊ตฌ์ฑ๋์ด์ผ ํ๋ค.
const map1 = new Map(['key1', 'value1'], ['key2', 'value2']]);
console.log(map1); // Map(2) {"key1" => "value1", "key2" => "value2"}
const map2 = new Map([1,2]); // TypeError
Map ์์ฑ์ ํจ์์ ์ธ์๋ก ์ ๋ฌํ ์ดํฐ๋ฌ๋ธ์ ์ค๋ณต๋ ํค๋ฅผ ๊ฐ๋ ์์๊ฐ ์กด์ฌํ๋ฉด ๊ฐ์ด ๋ฎ์ด์จ์ง๋ค. ๋ฐ๋ผ์ Map ๊ฐ์ฒด์๋ ์ค๋ณต๋ ํค๋ฅผ ๊ฐ๋ ์์๊ฐ ์กด์ฌํ ์ ์๋ค.
const map = new Map([['key1', 'value1'], ['key1', 'value2']]);
console.log(map); // Map(1) {"Key1" => "value2"}
Map ๊ฐ์ฒด์ ์์ ๊ฐ์๋ฅผ ํ์ธํ ๋๋ Map.prototype.size ํ๋กํผํฐ๋ฅผ ์ฌ์ฉํ๋ค.
const { size } = new Map([['key1', 'value1'], ['key2], 'value2']]);
console.log(size); // 2
size ํ๋กํผํฐ๋ setter ํจ์ ์์ด getter ํจ์๋ง ์กด์ฌ
ํ๋ ์ ๊ทผ์ ํ๋กํผํฐ๋ค. ๋ฐ๋ผ์ size ํ๋กํผํฐ์ ์ซ์๋ฅผ ํ ๋นํ์ฌ Map ๊ฐ์ฒด์ ์์ ๊ฐ์๋ฅผ ๋ณ๊ฒฝํ ์ ์๋ค.
Map ๊ฐ์ฒด์ ์์๋ฅผ ์ถ๊ฐํ ๋๋ Map.prototype.set ๋ฉ์๋๋ฅผ ์ฌ์ฉ
const map = new Map();
console.log(map); // Map(0) {}
map.set('key1', 'value1');
console.log(map); // Map(1) {"key1" => "value1"}
set ๋ฉ์๋๋ ์๋ก์ด ์์๊ฐ ์ถ๊ฐ๋ Map ๊ฐ์ฒด๋ฅผ ๋ฐํ
ํ๋ค. ๋ฐ๋ผ์ set ๋ฉ์๋๋ฅผ ํธ์ถํ ํ์ set ๋ฉ์๋๋ฅผ ์ฐ์์ ์ผ๋ก ํธ์ถํ ์ ์๋ค.
Map ๊ฐ์ฒด์๋ ์ค๋ณต๋ ํค๋ฅผ ๊ฐ๋ ์์๊ฐ ์กด์ฌํ ์ ์๊ธฐ ๋๋ฌธ์ ์ค๋ณต๋ ํค๋ฅผ ๊ฐ๋ ์์๋ฅผ ์ถ๊ฐํ๋ฉด ๊ฐ์ด ๋ฎ์ด์จ์ง๋ค
์๋ฌ๊ฐ ๋ฐ์ํ์ง๋ ์๋๋ค
์ผ์น ๋น๊ต ์ฐ์ฐ์ ===์ ์ฌ์ฉํ๋ฉด NaN๊ณผ NaN์ ๋ค๋ฅด๋ค๊ณ ํ๊ฐํ๋ค. ํ์ง๋ง Map ๊ฐ์ฒด๋ NaN๊ณผ NaN์ ๊ฐ๋ค๊ณ ํ๊ฐํ์ฌ ์ค๋ณต ์ถ๊ฐ๋ฅผ ํ์ฉํ์ง ์์.
+0๊ณผ -์ ์ผ์น ๋น๊ต ์ฐ์ฐ์ ===์ ๋ง์ฐฌ๊ฐ์ง๋ก ๊ฐ๋ค๊ณ ํ๊ฐํ์ฌ ์ค๋ณต ์ถ๊ฐ๋ฅผ ํ์ฉํ์ง ์๋๋ค.
๊ฐ์ฒด๋ ๋ฌธ์์ด ๋๋ ์ฌ๋ฒ ๊ฐ๋ง ํค๋ก ์ฌ์ฉ
ํ ์ ์๋ค. ํ์ง๋ง Map ๊ฐ์ฒด๋ ํค ํ์
์ ์ ํ์ด ์๋ค.
๋ฐ๋ผ์ ๊ฐ์ฒด๋ฅผ ํฌํจํ ๋ชจ๋ ๊ฐ์ ํค๋ก ์ฌ์ฉ
ํ ์ ์๋ค.
์ด๋ Map ๊ฐ์ฒด์ ์ผ๋ฐ ๊ฐ์ฒด์ ๊ฐ์ฅ ๋๋๋ฌ์ง๋ ์ฐจ์ด์ .
Map ๊ฐ์ฒด์์ ํน์ ์์๋ฅผ ์ทจ๋ํ๋ ค๋ฉด Map.prototype.get ๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ค.
get ๋ฉ์๋์ ์ธ์๋ก ํค๋ฅผ ์ ๋ฌํ๋ฉด Map ๊ฐ์ฒด์์ ์ธ์๋ก ์ ๋ฌํ ํค๋ฅผ ๊ฐ๋ ๊ฐ์ ๋ฐํ.
Map ๊ฐ์ฒด์์ ์ธ์๋ก ์ ๋ฌํ ํค๋ฅผ ๊ฐ๋ ์์๊ฐ ์กด์ฌํ์ง ์์ผ๋ฉด undefined๋ฅผ ๋ฐํ
const map = new Map();
const lee = { name: 'Lee' };
const kim = { name: 'Lim' };
map
.set(lee, "developer")
.set(kim, "designer");
console.log(map.get(lee)); // developer
console.log(map.get('key')); // undefined
Map ๊ฐ์ฒด์ ํน์ ์์๊ฐ ์กด์ฌํ๋์ง ํ์ธํ๋ ค๋ฉด Map.prototype.has ๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ค. has ๋ฉ์๋๋ ํน์ ์์์ ์กด์ฌ ์ฌ๋ถ๋ฅผ ๋ํ๋ด๋ ๋ถ๋ฆฌ์ธ ๊ฐ์ ๋ฐํํ๋ค.
const lee = { name: 'Lee' }
const kim = { name: 'Kim' }
const map = new Map([[lee, 'developer'], [kim, 'designer']]);
console.log(map.has(lee)); // true
console.log(map.has('key')); // false
Map ๊ฐ์ฒด์ ์์๋ฅผ ์ญ์ ํ๋ ค๋ฉด Map.prototype.delete ๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ค. delete ๋ฉ์๋๋ ์ญ์ ์ฑ๊ณต ์ฌ๋ถ๋ฅผ ๋ํ๋ด๋ ๋ถ๋ฆฌ์ธ ๊ฐ์ ๋ฐํํ๋ค.
const lee = { name : 'Lee' }
const kim = { name : 'kim' }
const map = new Map([[lee, 'developer'], [kim, 'designer']]);
map.delete(kim);
console.log(map); // Map(1) { {name: "Lee"} => "developer" }
์กด์ฌํ์ง ์๋ ํค๋ก Map ๊ฐ์ฒด์ ์์๋ฅผ ์ญ์ ํ๋ ค ํ๋ฉด ์๋ฌ ์์ด ๋ฌด์๋๋ค.
delete ๋ฉ์๋๋ ์ญ์ ์ฑ๊ณต ์ฌ๋ถ๋ฅผ ๋ํ๋ด๋ ๋ถ๋ฆฌ์ธ ๊ฐ์ ๋ฐํํ๋ค. ๋ฐ๋ผ์ set ๋ฉ์๋์ ๋ฌ๋ฆฌ ์ฐ์์ ์ผ๋ก ํธ์ถํ ์ ์๋ค.`
Map ๊ฐ์ฒด์ ์์๋ฅผ ์ผ๊ด ์ญ์ ํ๋ ค๋ฉด Map.prototype.clear ๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ค. clear ๋ฉ์๋๋ ์ธ์ ๋ undefined๋ฅผ ๋ฐํํ๋ค.
const lee = { name : 'Lee' }
const kim = { name : 'kim' }
const map = new Map([[lee, 'developer'], [kim, 'designer']]);
map.clear();
console.log(map); // Map(0) {}
Map ๊ฐ์ฒด์ ์์๋ฅผ ์ํํ๋ ค๋ฉด Map.prototype.forEach ๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ค. Map.prototype.forEach ๋ฉ์๋๋ Array.prototype.forEach ๋ฉ์๋์ ์ ์ฌํ๊ฒ ์ฝ๋ฐฑ ํจ์์ forEach ๋ฉ์๋์ ์ฝ๋ฐฑ ํจ์ ๋ด๋ถ์์ this๋ก ์ฌ์ฉ๋ ๊ฐ์ฒด๋ฅผ ์ธ์๋ก ์ ๋ฌํ๋ค. ์ด๋ ์ฝ๋ฐฑ ํจ์๋ ๋ค์๊ณผ ๊ฐ์ด 3๊ฐ์ ์ธ์๋ฅผ ์ ๋ฌ ๋ฐ๋๋ค.
- ์ฒซ ๋ฒ์งธ ์ธ์:ํ์ฌ ์ํ ์ค์ธ ์์๊ฐ
- ๋ ๋ฒ์จฐ ์ธ์:ํ์ฌ ์ํ ์ค์ธ ์์ํค
- ์ธ ๋ฒ์จฐ ์ธ์:ํ์ฌ ์ํ ์ค์ธ Map ๊ฐ์ฒด ์์ฒด
const lee = { name: 'Lee' }
const kim = { name: 'Kim' }
const map = new Map([[lee, 'developer'], [kim, 'designer']]);
map.forEach((v, k, map) => console.log(v,k,map));
/*
developer {name: "Lee"} Map(2) {
{name : "Lee"} => "developer",
{name : "Kim"} => "designer"
}
designer {name: "Kim"} Map(2) {
{name: "Lee"} => "developer",
{name: "Kim"} => "designer"
}
*/
Map ๊ฐ์ฒด๋ ์ดํฐ๋ฌ๋ธ์ด๋ค. ๋ฐ๋ผ์ for... of๋ฌธ์ผ๋ก ์ํํ ์ ์์ผ๋ฉฐ, ์คํ๋ ๋ ๋ฌธ๋ฒ๊ณผ ๋ฐฐ์ด ๋์คํธ๋ญ์ฒ๋ง ํ ๋น์ ๋์์ด ๋ ์๋ ์๋ค.
Map ๊ฐ์ฒด๋ ์ดํฐ๋ฌ๋ธ์ด๋ฉด์ ๋์์ ์ดํฐ๋ ์ดํฐ์ธ ๊ฐ์ฒด๋ฅผ ๋ฐํํ๋ ๋ฉ์๋๋ฅผ ์ ๊ณต
ํ๋ค.
Map ๊ฐ์ฒด๋ ์์์ ์์์ ์ ๋ฏธ๋ฅผ ๊ฐ์ง ์์ง๋ง Map ๊ฐ์ฒด๋ฅผ ์ํํ๋ ์์๋ ์์๊ฐ ์ถ๊ฐ๋ ์์๋ฅผ ๋ฐ๋ฅธ๋ค. ์ด๋ ECMAScript ์ฌ์์ ๊ท์ ๋์ด ์์ง๋ ์์ง๋ง ๋ค๋ฅธ ์ดํฐ๋ฌ๋ธ์ ์ํ์ ํธ์์ฑ์ ์ ์งํ๊ธฐ ์ํจ์ด๋ค.