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