본문 바로가기

JavaScript

[Deep dive] 37장 Set과 Map

37.1 Set

- Set 객체는 중복되지 않는 유일한 값들의 집합

- 배열과의 차이점

구분 배열 set 객체
동일한 값을 중복하여 포함할 수 있다 O X
요소 순서에 의미가 있다 O X
인덱스로 요소에 접근할 수 있다. O X

- 수학적 집합을 구현하기 위한 자료구조 

- Set 객체는 객체나 배열과 같이 자바스크립트의 모든 값을 요소로 저장 가능

 

37.1.1 Set 객체의 생성

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

- Set 생성자 함수에 인수를 전달하지 않으면 빈 객체 생성

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

- Set 생성자 함수는 이터러블을 인수로 전달받아 Set 객체를 생성

- 중복된 값은 Set 객체에 요소로 저장되지 않음

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.1.2 요소 개수 확인

- Set.prototype.size 프로퍼티를 사용하여 Set 객체의 요소 개수 확인 

- size 프로퍼티는 setter 함수 없이 getter 함수만 존재하는 접근자 프로퍼티. 따라서 size 프로퍼티에 숫자를 할당하여 Set 객체의 요소 개수를 변경할 수 없음

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

 

37.1.3 요소 추가 

- Set.prototype.add 메서드를 이용하여 Set 객체에 요소 추가 

- add 메서드는 새로운 요소가 추가된 Set 객체 반환 

- add 메서드를 연속적 호출(method chaining) 가능

- Set 객체에 중복된 요소의 추가는 허용되지 않음 

const set = new Set();

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

-Set 객체는 NaN과 NaN을 같다고 평가하여 중복 추가 허용 X

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.1.4 요소 존재 여부 확인

- Set.prototype.has 메서드를 사용하여 Set 객체에 특정 요소가 존재하는지 확인

- has 메서드는 특정 요소의 존재 여부를 나타내는 불리언 값 반환

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

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

 

37.1.5 요소 삭제 

- Set.prototype.delete 메서드를 사용하여 Set 객체의 특정 요소 삭제 

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

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

- delete 메서드는 연속적으로 호출 불가 

 

37.1.6 요소 일괄 삭제 

- Set.prototype.clear 메서드를 사용하여 Set 객체의 모든 요소를 일괄 삭제 

- clear 메서드는 언제나 undefiend를 반환

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

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

 

37.1.7 요소 순회

- Set.prototype.forEach 메서드를 사용하여 Set 객체의 요소 순회 

- forEach 메서드는 콜백함수와 forEach 메서드의 콜백 함수 내부에서 this로 사용될 객체(옵션)을 인수로 전달

 

 1) 첫 번째 인수 : 현재 순회중인 요소값

 2) 두 번째 인수 : 현재 순회중인 요소값

 3) 세 번째 인수:  현재 순회중인 Set 객체 자체 

 

 -> 첫 번째 인수랑 두 번째 인수가 동일한데 Array.prototype.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 }

- Set 객체는 이터러블이므로  for..of 문으로 순회 가능, 스프레드 문법과 배열 디스트럭처링의 대상될 수 있음

 

37.1.8 집합 연산

- Set 객체를 통해 교집합, 합집합, 차집합 등을 구현 가능

 

1) 교집합

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

 

2) 합집합

- 집합 A와 집합 B의 중복없는 모든 요소로 구성

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

  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 }

 

3) 차집합 

- 집합 A에는 존재하지만 집합 B에는 존재하지 않는 요소들로 구성

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) {}

 

4) 부분집합과 상위집합

- 집합A가 집합 B에 포함되는 경우 집합A는 집합B의 부분집합(subset)이며, 집합B는 집합A의 상위 집합(superset)

//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.2 Map

 

- Map 객체는 키와 값의 쌍으로 이루어진 컬렉션

- 객체와의 차이점

구분 객체 Map 객체
키로 사용할 수 있는 값 문자열 또는 심벌값 객체를 포함한 모든 값
이터러블  X O
요소 개수 확인 Object.Keys(obj).length map.size

 

37.2.1 Map 객체의 생성

- Map 객체는 Map 생성자 함수로 생성 

- Map 생성자 함수에 인수를 전달하지 않으면 빈 Map 객체가 생성

- Map 생성자 함수는 이터러블을 인수로 전달받아 Map 객체를 생성

- 인수로 전달되는 이터러블은 키와 값의 쌍으로 이루어진 요소로 구성되어 있어야 함

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

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 객체에는 중복된 키를 갖는 요소가 존재할 수 없음

 

37.2.2 요소 개수 확인

- Map.prototype.size 프로퍼티를 사용해 Map 객체의 요소 개수 확인

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

- size 프로퍼티는 setter 없이 getter함수만 존재하는 접근자 프로퍼티. 따라서  size프로퍼티에 숫자를 할당하여 Map 객체의 요소 개수 변경 불가 

 

37.2.3 요소 추가 

- Map.prototype.set 메서드를 통해 Map 객체에 요소를 추가 

- set 메서드는 새로운 요소가 추가된 Map 객체를 반환 

- set 메서드를 연속적으로 호출(method chaining)가능

const map = new Map();

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

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

- Map 객체는 NaN과 NaN을 같다고 평가하여 중복 추가 허용 X

- 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 요소 취득

- Map.prototype.get 메서드를 사용해 Map 객체에서 특정 요소 취득 

- get 메서드의 인수로 키를 전달하면 Map 객체에서 이누로 전달한 키를 갖는 값을 반환

- 인수로 전달한 키를 갖는 요소가 존재하지 않으면 undefined 반환

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 요소 존재 여부 확인

- Map.prototype.has 메서드를 사용하여 Map 객체에 특정 요소가 존재하는지 확인

- 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 요소 삭제 

- Map.prototype.delete 메서드를 사용하여 Map 객체의 요소 삭제 

- delete 메서드는 삭제 성공 여부를 나타내는 불리언 값을 반환

- delete 메서드는 연속적으로 호출 (method chaining) 불가 

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' }

//존재하지 않는 키 'key'로 요소를 삭제하려 하면 에러없이 무시
map.delete(key);
console.log(map);

 

37.2.7 요소 일괄 삭제 

- Map.prototype.clear 메서드를 사용하여 Map 객체의 요소를 일괄 삭제 

- 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) {}

 

32.2.8 요소 순회 

- Map.prototype.forEach 메서드를 사용하여 Map 객체의 요소 순회 

 

- 콜백함수와 forEach 메서드의 콜백 함수 내부에서 this로 사용될 객체(옵션)을 인수로 전달

 1) 첫 번째 인수 : 현재 순회 중인 요소값

 2) 두 번째 인수 : 현재 순회 중인 요소키

 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.prototype.keys Map 객체에서 요소키를 값으로 갖는 이터러블이면서 동시에 이터레이터인 객체 반환
Map.protoype.vlaues Map 객체에서 요소값을 값으로 갖는 이터러블이면서 동시에 이터레이터인 객체 반환
Map.prototype.entries Map 객체에서 요소키와 요소값을 값으로 갖는 이터럽르이면서 동시에 이터레이터인 객체 반환
const lee = {name:'Lee'};
const kim = {name:'Kim'};

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

for(const key of map.keys()) {
  console.log(key); //{ name: 'Lee' }{ name: 'Kim' }
}

for(const value of map.values()) {
  console.log(value); //eveloper designer
}

for(const entry of map.entries()) {
  console.log(entry); //[ { name: 'Lee' }, 'developer' ][ { name: 'Kim' }, 'designer' ]
}