set

• 值总是唯一的
• 使用数组创建set可以实现过滤 keys()返回值和values()一致

迭代-类lambda操作
foreach
for … of

set、array 转换
let myArr = Array.from(mySet);
let mySet = new Set(myArray);

reverse
不能直接reverse，可以借助array.reverse实现

主要方法
add
clear
delete-直接delete value
entries -和map一样返回keys和values（KEY==VALUE)
foreach
has
keys/values

测试代码

let myArray = ["value1", "value2", "value3"];

// 用Set构造器将Array转换为Set
let mySet = new Set(myArray);

for (let item of mySet) console.log(item);

// 用forEach迭代
mySet.forEach(function(value) {
  console.log(value);
});

for (let item of mySet) console.log(item);

// 按顺序输出：1, "some text", {"a": 1, "b": 2}, {"a": 1, "b": 2}
for (let item of mySet.keys()) console.log(item);

// 按顺序输出：1, "some text", {"a": 1, "b": 2}, {"a": 1, "b": 2}
for (let item of mySet.values()) console.log(item);

// 按顺序输出：1, "some text", {"a": 1, "b": 2}, {"a": 1, "b": 2}
//(键与值相等)
for (let [key, value] of mySet.entries()) console.log(key);



let text = 'India';

let myArr = Array.from(mySet);
console.log(myArr);


let myStringSet = new Set(text);  // Set {'I', 'n', 'd', 'i', 'a'}
console.log(myStringSet.size);  // 5

set1 = new Set([1, 2, 3, 4]);

set2 = new Set([7, 2, 3, 4]);


// 可以通过如下代码模拟求交集
let intersection = new Set([...set1].filter(x => set2.has(x)));

for (let [key, value] of intersection.entries()) 
    console.log("intersection="+key);

// 可以通过如下代码模拟求差集
let difference = new Set([...set1].filter(x => !set2.has(x)));
for (let [key, value] of difference.entries()) 
    console.log("difference="+key);

function pop(set) {
  const last = [ ...set ].pop();
  set.delete(last);
  return last;
}

function shift(set) {
  const first = [ ...set ].shift();
  set.delete(first);
  return first;
}

function sendFirstToBack(set) {
  const arr = [ ...set ];
  arr.push( arr.shift() );
  return new Set(arr);
}

function reverse(set) {
  const arr = [ ...set ].reverse();
  set.clear()
  
  for( const item of arr)
    
    {  
set.add(item);}
      
}
 
for (let [key, value] of set2.entries()) 
    console.log("set2="+key);
  reverse(set2)

for (let [key, value] of set2.entries()) 
    console.log("reverse="+key); 

weakset

成员都是对象
成员都是弱引用，可以被垃圾回收机制回收

var ws = new WeakSet();
let foo = {ww: "wwww"};
var bar = {};

ws.add(foo);
ws.add(bar);

ws.has(foo);    // true
ws.has(bar);   // true

  foo =  null
 // 从set中删除 foo 对象
console.log(ws.has(foo));    // false, foo 对象已经被删除了
console.log(ws.has(bar));    // true, bar 依然存在

不能遍历，方法有 add、delete、has
只要该元素对象没有被除WeakSet以外的其他对象引用，就会被垃圾回收释放
clear方法已经不支持

map

主要方法
和set相似
set(key, value);
clear
delete
forEach
get
has
keys
values

NaN 也可以作为Map对象的键

myMap.set(NaN, “not a number”);
myMap.get(NaN); // “not a number”
迭代-类lambda操作
foreach
for … of
Map 与数组的关系
使用常规的Map构造函数可以将一个二维键值对数组转换成一个Map对象
合并map
使用… spread 合并
测试代码

 
let first = new Map([
  [1, 'one'],
  [2, 'two'],
  [3, 'three'],
]);

let second = new Map([
  [1, 'uno'],
  [2, 'dos']
]);

// 合并两个Map对象时，如果有重复的键值，则后面的会覆盖前面的。
// 展开运算符本质上是将Map对象转换成数组。
let merged = new Map([...first, ...second]);

let kvArray = [["key1", "value1"], ["key2", "value2"]];

// 使用常规的Map构造函数可以将一个二维键值对数组转换成一个Map对象
let myMap = new Map(kvArray);

myMap.get("key1"); // 返回值为 "value1"

// 使用Array.from函数可以将一个Map对象转换成一个二维键值对数组
console.log(Array.from(myMap)); // 输出和kvArray相同的数组

// 更简洁的方法来做如上同样的事情，使用展开运算符
console.log([...myMap]);

// 或者在键或者值的迭代器上使用Array.from，进而得到只含有键或者值的数组
console.log(Array.from(myMap.keys())); // 输出 ["key1", "key2"]

  

//OBJECT TO MAP
const myObjMap = { foo: 'bar' }
const myObjectMap = new Map(Object.keys(myObjMap).map(key => [ key, myObjMap[key] ]))
console.log("objectMap="+[...myObjectMap])

function strMapToObj(strMap){
    let obj= Object.create(null);
    for (let[k,v] of strMap) {
    obj[k] = v;
}
    return obj;
}
let obj= Object.create(null);
Object.assign(obj,myObjectMap)
console.log(obj)
obj= strMapToObj(myObjectMap)
console.log(obj)
object2map
//OBJECT TO MAP
const myObjMap = { foo: 'bar' }
const myObjectMap = new Map(Object.keys(myObjMap).map(key => [ key, myObjMap[key] ]))
console.log("objectMap="+[...myObjectMap])

function strMapToObj(strMap){
    let obj= Object.create(null);
    for (let[k,v] of strMap) {
    obj[k] = v;
}
    return obj;
}

weakmap

键是弱引用的。其键必须是对象，而值可以是任意的
clear方法已经不支持,变通办法：

 clear() {
    this._wm = new WeakMap()
  }

只要该元素对象没有被除WeakSet以外的其他对象引用，就会被垃圾回收释放
不能遍历，方法有 set、delete、has