37장 Set과 Map

2022-05-10

37.1 Set

배열과 유사하지만 다음과 같은 차이가 있다
동일한 값을 중복하여 포함할 수 있다 : 배열O, Set객체X 요소 순서에 의미가 있다 : 배열O, Set객체X 인덱스로 요소에 접근할 수 있다 : 배열O, Set객체X

37.1.1 Set 객체의 생성(37-01)

Set 객체는 생성자 함수로 생성

const set = new Set();
console.log(set); // Set(0) {}

37-02

이터러블을 인수로 받으며 중복된 값은 중복되게 저장하지 않는다

const set1 = new Set([1, 2, 3, 3]);
console.log(set1); // Set(3) {1, 2, 3}

const set2 = new Set('hello');
console.log(set2); // Set(4) {"h", "e", "l", "o"}

37-03

중복 요소 제거하기 편리하다

// 배열의 중복 요소 제거
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)]; // (array) => [~~]와 동일
console.log(uniq([2, 1, 2, 3, 4, 3, 4])); // [2, 1, 3, 4]

37.1.2 요소 개수 확인(37-04)

Set.prototype.size 프로퍼티 사용

const { size } = new Set([1, 2, 3, 3]); // 디스트럭처링 할당 사용
console.log(size); // 3

37-05

size프로퍼티는 setter이 없고 getter만 존재하는 접근자 프로퍼티다

const set = new Set([1, 2, 3]);

console.log(Object.getOwnPropertyDescriptor(Set.prototype, 'size'));
// {set: undefined, enumerable: false, configurable: true, get: ƒ}

set.size = 10; // 무시된다.
console.log(set.size); // 3

37.1.3 요소 추가(37-06)

Set.prototype.add 프로퍼티 사용

const set = new Set();
console.log(set); // Set(0) {}

set.add(1);
console.log(set); // Set(1) {1}

37-07

const set = new Set();

set.add(1).add(2);
console.log(set); // Set(2) {1, 2}

37-08

const set = new Set();

set.add(1).add(2).add(2); // 중복 허용X
console.log(set); // Set(2) {1, 2}

37-09

NaN을 ===로 비교시 같다고 하지않는다고 했는데 set에선 알아서 중복 확인해줌

const set = new Set();

console.log(NaN === NaN); // false
console.log(0 === -0); // true

// NaN과 NaN을 같다고 평가하여 중복 추가를 허용하지 않는다.
set.add(NaN).add(NaN);
console.log(set); // Set(1) {NaN}

// +0과 -0을 같다고 평가하여 중복 추가를 허용하지 않는다.
set.add(0).add(-0);
console.log(set); // Set(2) {NaN, 0}

37-10

모든 값을 요소로 사용가능

const set = new Set();

set
  .add(1)
  .add('a')
  .add(true)
  .add(undefined)
  .add(null)
  .add({})
  .add([]);

console.log(set); // Set(7) {1, "a", true, undefined, null, {}, []}

37.1.4 요소 존재 여부 확인(37-11)

Set.prototype.has 메서드 사용

const set = new Set([1, 2, 3]);

console.log(set.has(2)); // true
console.log(set.has(4)); // false

37.1.5 요소 삭제(37-12)

Set.prototype.delete 메서드 사용

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}

37-13

const set = new Set([1, 2, 3]);

// 존재하지 않는 요소 0을 삭제하면 에러없이 무시된다.
set.delete(0);
console.log(set); // Set(3) {1, 2, 3}

37-14

불리언 값(성공여부)를 반환하기 때문에 add처럼 연속적으로 호출 불가

const set = new Set([1, 2, 3]);

// delete는 불리언 값을 반환한다.
set.delete(1).delete(2); // TypeError: set.delete(...).delete is not a function

37.1.6 요소 일괄 삭제(37-15)

Set.prototype.clear 메서드 사용

const set = new Set([1, 2, 3]);

set.clear();
console.log(set); // Set(0) {}

37.1.7 요소 순회(37-16)

첫, 두번째 인수가 같은 이유는 forEach 메서드와 인터페이스를 통일하기 위함일 뿐

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}
*/

37-17

Set 객체는 이터러블이므로 for…of나, 스프레드 문법, 배열 디스트럭처링의 대상

const set = new Set([1, 2, 3]);

// Set 객체는 Set.prototype의 Symbol.iterator 메서드를 상속받는 이터러블이다.
console.log(Symbol.iterator in set); // true

// 이터러블인 Set 객체는 for...of 문으로 순회할 수 있다.
for (const value of set) {
  console.log(value); // 1 2 3
}

// 이터러블인 Set 객체는 스프레드 문법의 대상이 될 수 있다.
console.log([...set]); // [1, 2, 3]

// 이터러블인 Set 객체는 배열 디스트럭처링 할당의 대상이 될 수 있다.
const [a, ...rest] = [...set];
console.log(a, rest); // 1, [2, 3]

37.1.8 집합 연산(37-18)

교집합
참고로 여기서 prototype~ 은 메서드이고, 내부의 this는 이 메서드를 부른 객체를 가리킨다

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}
// setB와 setA의 교집합
console.log(setB.intersection(setA)); // Set(2) {2, 4}

37-19

교집합

Set.prototype.intersection = function (set) {
  return new Set([...this].filter(v => set.has(v)));
};

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}
// setB와 setA의 교집합
console.log(setB.intersection(setA)); // Set(2) {2, 4}

37-20

합집합

Set.prototype.union = function (set) {
  // this(Set 객체)를 복사
  const result = new Set(this); // this로 바로 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}
// setB와 setA의 합집합
console.log(setB.union(setA)); // Set(4) {2, 4, 1, 3}

37-21

합집합

Set.prototype.union = function (set) {
  return new Set([...this, ...set]); // 어차피 Set은 중복 알아서 없애줘서 가능
};

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}
// setB와 setA의 합집합
console.log(setB.union(setA)); // Set(4) {2, 4, 1, 3}

37-22

차집합

Set.prototype.difference = function (set) {
  // this(Set 객체)를 복사
  const result = new Set(this);

  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}
// setB에 대한 setA의 차집합
console.log(setB.difference(setA)); // Set(0) {}

37-23

차집합

Set.prototype.difference = function (set) {
  return new Set([...this].filter(v => !set.has(v)));
};

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}
// setB에 대한 setA의 차집합
console.log(setB.difference(setA)); // Set(0) {}

37-24

부분 집합과 상위 집합

// 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
// setB가 setA의 상위 집합인지 확인한다.
console.log(setB.isSuperset(setA)); // false

37-25

부분 집합과 상위 집합

// this가 subset의 상위 집합인지 확인한다.
Set.prototype.isSuperset = function (subset) {
  const supersetArr = [...this];
  return [...subset].every(v => supersetArr.includes(v));
};

const setA = new Set([1, 2, 3, 4]);
const setB = new Set([2, 4]);

// setA가 setB의 상위 집합인지 확인한다.
console.log(setA.isSuperset(setB)); // true
// setB가 setA의 상위 집합인지 확인한다.
console.log(setB.isSuperset(setA)); // false

37.2 Map

객체와 유사하지만 다음과 같은 차이가 있다
키로 사용할 수 있는 값 : 객체 - 문자열 또는 심벌값, Map객체 - 객체를 포함한 모든 값 이터러블 : 객체X, Map객체O 요소 개수 확인 : 객체 - Object.keys(obj).length, Map객체 - map.size

37.2.1 Map 객체의 생성(37-26)

생성자 함수로 생성한다

const map = new Map();
console.log(map); // Map(0) {}

37-27

이터러블을 인수로 받으며, 키와 값의 쌍으로 이루어진 요소로 구성되어야 함

const map1 = new Map([['key1', 'value1'], ['key2', 'value2']]);
console.log(map1); // Map(2) {"key1" => "value1", "key2" => "value2"}

const map2 = new Map([1, 2]); // TypeError: Iterator value 1 is not an entry object

37-28

중복된 키의 값은 덮어씌움. 즉, 중복X

const map = new Map([['key1', 'value1'], ['key1', 'value2']]);
console.log(map); // Map(1) {"key1" => "value2"}

37.2.2 요소 개수 확인(37-29)

Map.prototype.size 사용

const { size } = new Map([['key1', 'value1'], ['key2', 'value2']]);
console.log(size); // 2

37-30

setter 없고 getter 만 존재하는 접근자 프로퍼티다

const map = new Map([['key1', 'value1'], ['key2', 'value2']]);

console.log(Object.getOwnPropertyDescriptor(Map.prototype, 'size'));
// {set: undefined, enumerable: false, configurable: true, get: ƒ}

map.size = 10; // 무시된다.
console.log(map.size); // 2

37.2.3 요소 추가(37-31)

Map.prototype.set 메서드 사용

const map = new Map();
console.log(map); // Map(0) {}

map.set('key1', 'value1');
console.log(map); // Map(1) {"key1" => "value1"}

37-32

set메서드는 Map객체 반환하기 때문에 연속으로 호출 가능

const map = new Map();

map
  .set('key1', 'value1')
  .set('key2', 'value2');

console.log(map); // Map(2) {"key1" => "value1", "key2" => "value2"}

37-33

에러 발생하지 않음

const map = new Map();

map
  .set('key1', 'value1')
  .set('key1', 'value2');

console.log(map); // Map(1) {"key1" => "value2"}

37-34

Set과 마찬가지

const map = new Map();

console.log(NaN === NaN); // false
console.log(0 === -0); // true

// NaN과 NaN을 같다고 평가하여 중복 추가를 허용하지 않는다.
map.set(NaN, 'value1').set(NaN, 'value2');
console.log(map); // Map(1) { NaN => 'value2' }

// +0과 -0을 같다고 평가하여 중복 추가를 허용하지 않는다.
map.set(0, 'value1').set(-0, 'value2');
console.log(map); // Map(2) { NaN => 'value2', 0 => 'value2' }

37-35

Map객체와 일반객체의 가장 큰 차이점인 모든 값을 키로 사용한다는 점

const map = new Map();

const lee = { name: 'Lee' };
const kim = { name: 'Kim' };

// 객체도 키로 사용할 수 있다.
map
  .set(lee, 'developer')
  .set(kim, 'designer');

console.log(map);
// Map(2) { {name: "Lee"} => "developer", {name: "Kim"} => "designer" }

37.2.4 요소 취득(37-36)

Map.prototype.get 메서드 사용

const map = new Map();

const lee = { name: 'Lee' };
const kim = { name: 'Kim' };

map
  .set(lee, 'developer')
  .set(kim, 'designer');

console.log(map.get(lee)); // developer
console.log(map.get('key')); // undefined

37.2.5 요소 존재 여부 확인(37-37)

Map.prototype.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

37.2.6 요소 삭제(37-38)

Map.prototype.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" }

37-39

const map = new Map([['key1', 'value1']]);

// 존재하지 않는 키 'key2'로 요소를 삭제하려 하면 에러없이 무시된다.
map.delete('key2');
console.log(map); // Map(1) {"key1" => "value1"}

37-40

불리언을 반환하기 때문에 연속적으로 호출 불가

const lee = { name: 'Lee' };
const kim = { name: 'Kim' };

const map = new Map([[lee, 'developer'], [kim, 'designer']]);

map.delete(lee).delete(kim); // TypeError: map.delete(...).delete is not a function

37.2.7 요소 일괄 삭제(37-41)

Map.prototype.clear 메서드 사용

const lee = { name: 'Lee' };
const kim = { name: 'Kim' };

const map = new Map([[lee, 'developer'], [kim, 'designer']]);

map.clear();
console.log(map); // Map(0) {}

37.2.8 요소 순회(37-42)

v : 현재 순회 중인 요소값 k : 현재 순회 중인 요소키 map : 현재 순회 중인 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"
}
*/

37-43

이터러블 이기 때문에 for…of문, 스프레드 문법, 배열 디스트럭처링 할당의 대상

const lee = { name: 'Lee' };
const kim = { name: 'Kim' };

const map = new Map([[lee, 'developer'], [kim, 'designer']]);

// Map 객체는 Map.prototype의 Symbol.iterator 메서드를 상속받는 이터러블이다.
console.log(Symbol.iterator in map); // true

// 이터러블인 Map 객체는 for...of 문으로 순회할 수 있다.
for (const entry of map) {
  console.log(entry); // [{name: "Lee"}, "developer"]  [{name: "Kim"}, "designer"]
}

// 이터러블인 Map 객체는 스프레드 문법의 대상이 될 수 있다.
console.log([...map]);
// [[{name: "Lee"}, "developer"], [{name: "Kim"}, "designer"]]

// 이터러블인 Map 객체는 배열 디스트럭처링 할당의 대상이 될 수 있다.
const [a, b] = map;
console.log(a, b); // [{name: "Lee"}, "developer"]  [{name: "Kim"}, "designer"]

37-44

이터레이터인 객체를 반환하는 메서드를 제공(아래 3개)

const lee = { name: 'Lee' };
const kim = { name: 'Kim' };

const map = new Map([[lee, 'developer'], [kim, 'designer']]);

// Map.prototype.keys는 Map 객체에서 요소키를 값으로 갖는 이터레이터를 반환한다.
for (const key of map.keys()) {
  console.log(key); // {name: "Lee"} {name: "Kim"}
}

// Map.prototype.values는 Map 객체에서 요소값을 값으로 갖는 이터레이터를 반환한다.
for (const value of map.values()) {
  console.log(value); // developer designer
}

// Map.prototype.entries는 Map 객체에서 요소키와 요소값을 값으로 갖는 이터레이터를 반환한다.
for (const entry of map.entries()) {
  console.log(entry); // [{name: "Lee"}, "developer"]  [{name: "Kim"}, "designer"]
}

Twitter Facebook LinkedIn

37.1 Set

37.1.1 Set 객체의 생성(37-01)

37-02

37-03

37.1.2 요소 개수 확인(37-04)

37-05

37.1.3 요소 추가(37-06)

37-07

37-08

37-09

37-10

37.1.4 요소 존재 여부 확인(37-11)

37.1.5 요소 삭제(37-12)

37-13

37-14

37.1.6 요소 일괄 삭제(37-15)

37.1.7 요소 순회(37-16)

37-17

37.1.8 집합 연산(37-18)

37-19

37-20

37-21

37-22

37-23

37-24

37-25

37.2 Map

37.2.1 Map 객체의 생성(37-26)

37-27

37-28

37.2.2 요소 개수 확인(37-29)

37-30

37.2.3 요소 추가(37-31)

37-32

37-33

37-34

37-35

37.2.4 요소 취득(37-36)

37.2.5 요소 존재 여부 확인(37-37)

37.2.6 요소 삭제(37-38)

37-39

37-40

37.2.7 요소 일괄 삭제(37-41)

37.2.8 요소 순회(37-42)

37-43

37-44

공유하기

댓글남기기

참고

2022-05-10 36장 디스트럭처링 할당 Modern_JavaScript_Deep_Dive

2022-05-10 37장 Set과 Map Modern_JavaScript_Deep_Dive

2022-05-10 38장 브라우저의 렌더링 과정 Modern_JavaScript_Deep_Dive

2022-05-10

36장 디스트럭처링 할당

Modern_JavaScript_Deep_Dive

2022-05-10

37장 Set과 Map

Modern_JavaScript_Deep_Dive

2022-05-10

38장 브라우저의 렌더링 과정

Modern_JavaScript_Deep_Dive