자바스크립트 컬렉션

new Map([iterable])

var arr = [1, 2, 3]
let map = new Map([
  [NaN, 'Not a Num'],
  [arr, 'array'],
])
console.log(typeof arr) // object, object도 키가 됨

console.log(map) // Map { NaN => 'Not a Num', [ 1, 2, 3 ] => 'array' }
console.log(map.size) // 2
console.log(map.NaN) // undefined 접근불가
console.log(map.get(NaN)) // Not a Num, get()을 통해서만 접근

console.log(map.set('name', 'heecheol'))
/* 해당 키와 값을 넣고 그 map을 반환
Map {
  NaN => 'Not a Num',
  [ 1, 2, 3 ] => 'array',
  'name' => 'heecheol' }
 */

console.log(map.delete(arr)) // true 반환
console.log(map) // Map { NaN => 'Not a Num', 'name' => 'heecheol' }

map.forEach(function(value, key) {
  console.log(`${key} = ${value}`)
})
/* 출력값
NaN = Not a Num
name = heecheol
*/
console.log(map) // Map { NaN => 'Not a Num', 'name' => 'heecheol' }
map.clear() // 키와 값들 제거!
console.log(map) // Map {}

const map = new Map([
  [1, 'first'],
  [2, 'second'],
  [3, 'third'],
])

// keys(), values() 는 이터레이터 반환
const vals = map.values()
const keys = map.keys()

console.log(vals) // MapIterator { 'first', 'second', 'third' }
console.log(keys) // MapIterator { 1, 2, 3 }

const arr = [...vals]
console.log(arr) // [ 'first', 'second', 'third' ]

console.log(keys.next())
console.log(keys.next())
console.log(keys.next())
console.log(keys.next())
/* 출력값
{ value: 1, done: false }
{ value: 2, done: false }
{ value: 3, done: false }
{ value: undefined, done: true }
 */

const map = new Map([
  [1, 'first'],
  [2, 'second'],
  [3, 'third'],
])

map.forEach(function(value, key) {
  console.log(`${key} : ${value}`)
})
/*
1 : first
2 : second
3 : third
 */

const iterator = map[Symbol.iterator]()
console.log(typeof iterator.next == 'function')
// true, 키와 값이 쌍으로 이루어진 이터레이터 반환

for (const val of iterator) {
  console.log(val)
}
// 쌍으로 들어있음을 확인
/* 출력값
[ 1, 'first' ]
[ 2, 'second' ]
[ 3, 'third' ]
 */

new Set([iterable]);

const obj = {
  [Symbol.iterator]() {
    return this
  },
  array: [1, 2, 3, 4, NaN, null, undefined, -0, +0],
  next() {
    return {
      // 2번
      done: this.array.length == 0,
      value: this.array.pop(),
    } // 3번
  },
}

const iter = obj[Symbol.iterator]()
const s1 = new Set(iter) // 1번
console.log(s1)
/* 출력값
Set { 0, undefined, null, NaN, 4, 3, 2, 1 }
 */

const obj = {
    [Symbol.iterator](){return this;},
    array: [1, NaN, null, undefined, -0, +0, {}],
    next(){
        return {
            done: this.array.length == 0,
            value: this.array.pop()
        };
    }
};

const iter = obj[Symbol.iterator]();
const o = {};
// 이터러블 객체를 통해 이터레이터 객체 획득

const set = new Set(null);
console.log(set);
// Set{} , null 이나 undefined를 넣어도 빈 Set객체 생성

var refer = iter.next().value; // 빈객체를 참조하기위한 구문
set.add(refer); // 빈객체가 추가
set.add(o);
console.log(set); // {} 추가 object도 값이 됨
// 똑같이 빈 객체 o 와 refer 빈객체가 같음에도 추가되었다.
// 이러한것이 가능한 이유는 서로 다른 객체를 참조하기때문이다.


set.add(iter.next().value);
console.log(set); // 0 추가

set.add(iter.next().value);
console.log(set); // -0 과 +0 은 동일한 값임, ECMAScript 2015에서 변경

set.add(iter.next().value);
console.log(set); // undefined 추가

set.add(iter.next().value);
console.log(set); // null 추가

set.add(iter.next().value);
console.log(set); // NaN 추가

set.add(iter.next().value);
console.log(set); // 1 추가,
// 이 때 아직 done: false 임

set.add(iter.next().value); // 이 때 반환값은 undefined
console.log(set); // undefined 는 이미 set객체에 존재하므로 추가되지않음

console.log(set.delete({})); // false
// 엥? false 라니?!
// 해당 요소를 가리키고있는 객체를 전달
console.log(set.delete(o)); // true
console.log(set); // Set { {}, 0, undefined, null, NaN, 1 }
console.log(set.delete()); // 아무 매개변수도 넣지않아서 undefiend가 제거
console.log(set);// Set { {}, 0, null, NaN, 1 }

console.log(set.delete(refer)); // refer가 남아있는 빈 객체를 참조
console.log(set); // Set { 0, null, NaN, 1 }
console.log(set.size); // 4
console.log(set.has(null)); // true

set.forEach(function(value, key, setObj) {
  console.log(`${key} : ${value} <= ${setObj}`)
}) // set객체는 value만 저장하므로 value와 key 가 동일
/*
0 : 0 <= [object Set]
null : null <= [object Set]
NaN : NaN <= [object Set]
1 : 1 <= [object Set]
 */

for (const val of set) {
  console.log(val)
}
/*
0
null
NaN
1
 */
var array = Array.from(set)
console.log(array) // [ 0, null, NaN, 1 ]
var array2 = [...set]
console.log(array2) // [ 0, null, NaN, 1 ]

const weakMap = new WeakMap()

const obj1 = {}
const obj2 = function() {}

// weakMap.set("weakMap?", "error");  // 문자열이 키가 될수 없음
weakMap.set(obj1, 'emptyObject')
weakMap.set(obj2, 'function')
console.log(weakMap) // WeakMap{} 출력
// WeakMap 은 Iterable 하지 않다. 하지만 키:값 은 존재

console.log(weakMap.get(obj1)) // emptyObject
console.log(weakMap.get(obj2)) // function, 함수는 실제로 객체

console.log(weakMap.delete(obj1)) // true, 해당 key가 제거된후
// weakMap.has(obj1)가 제거되기전의 해당 key 존재여부를 알려줌

const weakSet = new WeakSet()

const obj1 = {},
  obj2 = function() {}

// weakSet.add("error"); // WeakSet은 object 만 들어갈수 있음
weakSet.add(obj1)
weakSet.add(obj2)

console.log(weakSet) // WeakSet{}
// WeakSet객체는 Iterable 하지 않다.

console.log(weakSet.has(obj1)) // true
console.log(weakSet.has(obj2)) // true

console.log(weakSet.delete(obj1)) // true
// 해당 value가 제거된 후 weakSet.has(obj1)이 제거되기전의 해당 value의 존재유무를 반환
console.log(weakSet.has(obj1)) // false, 지워져서 사라짐

// Map
function Obj(){
    this.val = new Array(10000000).join("---")
}

window.obj = new Obj();
var map = new Map();
map.set(window.obj, 123);
delete window.obj;

// WeakMap
function Obj(){
    this.val = new Array(10000000).join("---")
}

window.obj = new Obj();
var map = new WeakMap();
map.set(window.obj, 123);
delete window.obj;

let Person = (() => {
  let privateWM = new WeakMap()
  class Person {
    constructor(name, age) {
      this.name = name
      privateWM.set(this, { age: age })
    }

    showInfo() {
      console.log(`name: ${this.name}, age: ${privateWM.get(this).age}`)
    }
  }
  return Person
})()

let hee = new Person('heecheol', 24),
  girlfriend = new Person('unknown', undefined)

hee.showInfo()
girlfriend.showInfo()
/*
name: heecheol, age: 24
name: unknown, age: undefined
 */