/**
  Object
**/
var obj = {
  1: 1,
  '2': '2',
  [Symbol('sy')]: function () { },
  [true]: true,
  [{}]: {},
  [[]]: [],
  [null]: null,
  [undefined]: undefined,
  [function add() { }]: function add() { }
}
// 除了 symbol 类型的属性不能被遍历出来，其他的所有 key 类型都被转成了 string 类型的 key
// 本质上是被调用了 对应类型的 toString() 方法得到的结果
Object.keys(obj).forEach(key => {
  console.log("key = ", key, " type = ", typeof key);
  //  key =  1                      type =  string
  //  key =  2                      type =  string
  //  key =  true                  type =  string
  //  key =  [object Object]   type =  string
  //  key =                          type =  string
  //  key =  null                   type =  string
  //  key =  undefined          type =  string
  //  key =  function add(){}  type =  string
});
/**
  Map
**/
var map = new Map();
map.set({}, {})
  .set([], [])
  .set(false, false)
  .set(null, null)
  .set(undefined, undefined)
  .set(function add() { }, function add() { })
  .set(Symbol('test'), Symbol('test'))
  .set('string', 'string')
  .set(1, 1);
for (const key of map.keys()) {
  console.log(typeof key);
  // object
  // object
  // boolean
  // object
  // undefined
  // function
  // symbol
  // string
  // number
}
复制代码

// 1. map 的 for of 遍历在上边的代码中就已经使用过了，这里不再展示
  typeof Map.prototype[Symbol.iterator] === 'function'
// 2. obj 的 for of 遍历
  typeof Object.prototype[Symbol.iterator] === 'undefined'
 var obj = {
   n1: 1,
   n2: 2,
 };
 for (const iterator of obj) {
   // Uncaught TypeError: obj is not iterable
 }
复制代码

// 1. 初始化时，由于没有 {} 的其他引用指向，当这段代码执行完成时，这个对象键就会被当作垃圾回收，于是对应的值也会被处理掉
// 最终这个键/值对就从弱映射中消失了，成为了一个空映射
const wm = new WeakMap();
wm.set({}, "val");
// 2. 对象维护着一个对弱映射键的引用，因此这个对象键不会成为垃圾回收的目标。
//    当 setTimeout 中清除掉会摧毁键对象的最后一个引用，垃圾回收程序就可以把这个键/值对清理掉
const weakKey = {
  name: {}
};
const wm = new WeakMap();
wm.set(weakKey.name, "val");
console.log(wm.has(weakKey.name)); // true
setTimeout(()=>{
  weakKey.name = null;
  console.log(wm.has(weakKey.name)); // false
});
复制代码

// 1. 使用常规 Map
  const m = new Map();
  const loginButton = document.querySelector('#login');
  // 给这个节点关联一些元数据
  m.set(loginButton, {disabled: true});
 // 假设 loginButton 节点在页面上被删除了
 // 由于映射中还保存着按钮的引用，所以对应的 DOM 节点仍然会逗留在内存中
 // 除非明确将其从映射中删除或者等到映射本身被销毁
// 2. 使用 WeaMap
  const wm = new WeakMap();
  const loginButton = document.querySelector('#login');
  // 给这个节点关联一些元数据
  wm.set(loginButton, {disabled: true});
  // 当节点从 DOM 树中被删除后，垃圾回收程序就可以立即释放其内存（前提是没有其他地方引用这个对象）
复制代码

const s = new Set(["val1", "val2", "val3"]);
console.log([...s]); // ["val1", "val2", "val3"]
复制代码

const s = new Set(["val1", "val2", "val3"]);
for (let pair of s.entries()) {
   console.log(pair);
}
// ["val1", "val1"]
// ["val2", "val2"]
// ["val3", "val3"]
复制代码

const set = new Set();
set.add(123);
console.log(set); // Set(1) {123}
const weakSet = new WeakSet();
weakSet.add(123); // TypeError: Invalid value used in weak set
console.log(weakSet);
复制代码

// 由于没有指向 {} 这个对象的其他引用，所以当这行代码执行完成后，这个对象值就会被当作垃圾回收。
// 这个值就从弱集合中消失了，使其成为一个空集合
const ws = new WeakSet();
ws.add({});
// container 对象维护着一个对弱集合值的引用，因此这个对象值不会成为垃圾回收的目标
// 当 setTimeout 中清除掉引用，就会摧毁值对象的最后一个引用，垃圾回收程序就可以把这个值清理掉
const ws = new WeakSet();
const container = {
   val: {}
};
ws.add(container.val);
setTimeout(()=>{
  container.val = null;
});
复制代码

// 1. 使用常规 Set
// 通过查询元素在不在 disabledElements 中，就可以知道它是不是被禁用了。
// 假如 DOM 树中被删除了，它的引用却仍然保存在 Set 中，因此垃圾回收程序也不能回收它
const disabledElements = new Set();
const loginButton = document.querySelector('#login');
// 通过加入对应集合，给这个节点打上“禁用”标签
disabledElements.add(loginButton);
// 2. 使用 WeakSet
// 只要 WeakSet 中任何元素从 DOM 树中被删除，垃圾回收程序就可以忽略其存在，而立即释放其内存（假设没有其他地方引用这个对象）
const disabledElements = new WeakSet();
const loginButton = document.querySelector('#login');
// 通过加入对应集合，给这个节点打上“禁用”标签
disabledElements.add(loginButton);
复制代码