Object.keys()、Array.from()、Set、Map

 

Object.keys()

返回一个每个元素为字符串的数组，返回顺序与使用for in返回的顺序一致。

// 传入简单的数组
Object.keys(["a","b","c"]);   //["1","2","3"]

//传入对象
Object.keys({0:"a",1:"b",2:"c"});  //["0","1","2"]

//
Object.keys({100:"a",1:'b',22:"c"})  //["1", "22", "100"]

Object.hasOwnPropertyNames(obj) //返回obj的所有属性，包括不可枚举的属性。

Array.from()

参数是伪数组对象或者可迭代的数组，返回一个新的数组实例

Array.from('foo')   //["f", "o", "o"]

Array.from([1, 2, 3], x => x + x)   //[2, 4, 6]

Set
//本身是一个构造函数，类似数组，成员都是唯一的
 const set = new Set([1, 2, 3, 4, 4]);
 console.log([...set]); //[1,2,3,4]

 // console.log(set.entries())
 var arr = [1,1,2,3,4,5,6,1,2,3,6];
 console.log([...new Set(arr)]); //[1,2,3,4,5,6]

 console.log([...new Set('abcabs')].join()); //['a','b','c','s']

 //add（） 方法 操作方法
 set.add(5);
 console.log(set.add(5));  //[1,2,3,4,5]  表明Set不会重复添加

 //NaN 是不等于自身的，但是在Set中是被认为是相等的
 const set1 = new Set();
 set1.add(NaN);  //第一次添加NaN
 console.log([...set1]);  //[NaN]
 set1.add(NaN);   //第二次添加NaN
 console.log([...set1]);  //[NaN]  还是只有一个元素NaN

 //add（）添加{} 会认为两个空对象是不相等的
 const set2 = new Set();
 set2.add({});
 console.log(...set2);  //[{}]
 set2.add({});
 console.log(...set2);  //[{},{}]

 //delete()  删除  操作方法
 console.log(set.delete(5)); //返回一个布尔值，true代表删除成功，false代表删除失败

 //clear()  清除所有
 console.log(set.clear());  //没有返回值,console.log是undefined

 const set3 = new Set([1, 2, 3, 4, 4]);
 //has()  操作方法，判断是否有该元素，如果有，返回true;否则返回false
 console.log(set3.has(1));

 //Array.from() 将Set结构转换为数组
 console.log(Array.from(set3)); //[1,2,3,4]

 //遍历方法 keys() values()  entries()
 console.log(set3.keys());
 // for (let item of set3.keys()) {  //返回键
 //     console.log(item);
 // }
 // for (let item of set3.values()) {  //返回值
 //     console.log(item);
 // }
 for (let item of set3.entries()) { //返回键值对
     console.log(item);
 }
 var set4 = new Set([1,4,9]);

 //filter()
 set4.forEach((value,key)=>{
    console.log(value+':'+key)  //key value是一样的
 });

 //map()
 var set5 = new Set([...set4].map(x=>x*x));
 console.log(set5);

 //filter()
 var set6 = new Set([...set4].filter(x=>set5.has(x)));
 console.log(set6);

 //WeakSet() 只能添加对象  没有size属性，不能使用foreach（）方法

 //Map()
 const map1 = new Map();
 map1.set(1,'content');
 map1.set(2,'hello');

 //如果是键1重复赋值，值1会被覆盖
 map1.set(1,'haha');
 console.log(map1);  // {1:'haha',2:'hello'}

 //读取一个未知的键，会返回undefined
 console.log( map1.get(3)); //undefined

 //set()方法 返回的Map对象 可以采用链式写法
 const map2 = new Map()
     .set(1,"a")
     .set(2,'b')
     .set(3,'c');
 console.log([...map2]);

 //操作方法：set()  get() has()  delete()  clear()
 //遍历方法 forEach() keys() values()  entries()

 //Map转为数组
 var map3 = new Map()
     .set(1,'hello')
     .set('2','world')
     .set('name','xiaoMing');
 console.log([...map3]);

 //数组转为Map  将数组当作参数传进去
 var map4 = new Map([
     [true,7],['name','ha']
 ]);
 console.log(map4);

 //将对象转为Map
 function objToMap(obj) {
   var map = new Map();
   for(let k of Object.keys(obj)){
       map.set(k,obj[k]);
   }
   return map
 }
 // console.log(objToMap({'name':'ha','age':20}));

 //Map转为对象
 function mapToObj(map){
   var obj = Object.create(null);
   for(let [v,k] of map){
       // console.log(v);  name
       // console.log(k)  hello
       obj[v] = k;
   }
   return obj;
 }
 var map = new Map()
     .set('name','hello')
     .set('age',20);
 mapToObj(map);
 //0: {"name" => "ha"}
//1: {"age" => 20}

 //Map转为JSON
 //如果Map的键名都是字符串，那么可以先转为对象，再转为JSON
 function mapToObjJSON(map){
     var obj = Object.create(null);
     for(let [v,k] of map){
         obj[v] = k;
     }
     return JSON.stringify(obj);
 }
 var map = new Map()
     .set('name','world')
     .set('sex','boy');
 console.log(mapToObjJSON(map)); // '{"name":"world","sex":"boy"}'

 //如果Map的键名有些是字符串，有些不是，那么可以先转为数组，再转为JSON
 function mapToArrayJSON(map){
     return JSON.stringify([...map])
 }
var map = new Map()
    .set('name','world')
    .set('sex','boy')
    .set(1,'en');
console.log(mapToArrayJSON(map));//'[["name","world"],["sex","boy"],[1,"en"]]'

 //JSON转为map
function jsonToStrMap(jsonStr) {
    return objToMap(JSON.parse(jsonStr));
}

jsonToStrMap('{"yes": true, "no": false}');
// Map {'yes' => true, 'no' => false}
function jsonToMap(jsonStr) {
    return new Map(JSON.parse(jsonStr));
}

jsonToMap('[[true,7],[{"foo":3},["abc"]]]')
// Map {true => 7, Object {foo: 3} => ['abc']