Map-Set
新增的基本数据Symbol
它是一个内置全局函数,生成一个独一无二的数据
let s1=Symbol(100)
let s2=Symbol(100)
console.log(s1,s2,s1==s2)
Map
1）Map 对象保存键值对。任何值(对象或者原始值) 都可以作为一个键或一个值。
2）没有语法糖。
3）初始化
var m1=new Map([["age",100],[20,"hello"],["a",90]])
4）取数据get
var m1=new Map([["age",100],[20,"hello"],["a",90]])
var re1=m1.get("age")
var re2=m1.get(20)
var re3=m1.get(["key"])
var re4=m1.get("a")
console.log(re1,re2,re3,re4)
5）存数据set
var m1=new Map([["age",100],[20,"hello"],["a",90]])
m1.set("life",1)
m1.set("age",1)
console.log(m1)
console.log(m1.size)
6）删数据delete
var m1=new Map([["age",100],[20,"hello"],["a",90]])
m1.delete(20)
var re5=m1.delete("age")
var re6=m1.delete("age")
console.log(m1,re5,re6)
7）清除数据clear
var m1=new Map([["age",100],[20,"hello"],["a",90]])
m1.clear()
console.log(m1)
Set
要点
1）Set 对象允许你存储任何类型的唯一值，无论是原始值或者是对象引用
2）Set中的特殊值
Set 对象存储的值总是唯一的，所以需要判断两个值是否恒等。有几个特殊值需要特殊对待
+0 与 -0 在存储判断唯一性的时候是恒等的，所以不重复；
undefined 与 undefined 是恒等的，所以不重复；
NaN 与 NaN 是不恒等的，但是在 Set 中只能存一个，不重复。
3）只能用 new方法创建，没有语法糖，new Set（）
4）用add添加元素，var s=new Set();s.add(100)
Set对象的作用
1.数组去重
var mySet = new Set([1, 2, 3, 4, 4]);
[...mySet];
2.并集
var arr = [10, 20, 30, 10,{}]
var arr2 = [100, 200,30,10]
var s1 = new Set([...arr,...arr2])//通过...取出来的引用数据还是原来那个引用数据，并没有创建新的引用数据
console.log(s1)
3.交集
var arr = [10, 20, 30, 10,{}]
var arr2 = [100, 200,30,10]
var s2 = new Set(arr.filter(function(el) {
if (arr2.includes(el)) {
return el
}
}))
console.log(s2)
arr-map-set
1.数组转map:必须是二维数组
var arr=[[1,"hello"],[2,"h5"],[3,{name:"karen"}]]
var m1=new Map(arr)
2.map转数组: Array.from()静态方法
var arr=[[1,"hello"],[2,"h5"],[3,{name:"karen"}]]
var m1=new Map(arr)
var arr2=Array.from(m1)
console.log(arr,m1,arr2,arr==arr2,arr[2][1]==arr2[2][1])
3.数组转集合
var arr=[100,200,100,{age:20},{age:20}]
var s1=new Set(arr)
console.log(s1,s1.size)
4.集合转数组
var arr=[100,200,100,{age:20},{age:20}]
var s1=new Set(arr)
var arr2=Array.from(s1)
console.log(arr,s1,arr2,arr[4]==arr2[3])//取出来的对象还是原来的那个对象并没有创建新的对象
5.多个数组转集合(Set)和Map: ... 以及字符串与Set
var arr1=[10,20]
var arr2=[100,20]
var arr3=[200,{name:"karen"}]
var s1=new Set([...arr1,...arr2,arr3])
var m1=new Map([arr1,arr2,arr3])
var m2=new Map(m1)
console.log(m1,m2,m1==m2,m1.get(200)==m2.get(200))//m1不等于m2，因为创建了新的对象m2 m1.get(200)==m2.get(200)，因为{name:"karen"}没有被重新创建
var arr1=[10,20]
var arr2=[100,20]
var arr3=[200,{name:"karen"}]
var s1=new Set([...arr1,...arr2,arr3])
字符串
子串的识别
ES6 之前判断字符串是否包含子串，用 indexOf 方法，ES6 新增了子串的识别方法
- includes() ：返回布尔值，判断是否找到参数字符串。
- startsWith() ：返回布尔值，判断参数字符串是否在原字符串的头部。
- endsWith() ：返回布尔值，判断参数字符串是否在原字符串的尾部。
以上三个方法都可以接受两个参数，需要搜索的字符串，和可选的搜索起始位置索引
1.includes() ：返回布尔值，判断是否找到参数字符串。
var str="hello,华清远见"
var re1=str.includes("华清")
var re2=str.includes(" ")
var re3=str.includes("")//空也为真
console.log(re1,re2,re3)
2.startsWith() ：返回布尔值，判断参数字符串是否在原字符串的头部。
第一个参数为你想要的查找的字符串，第二个参数（字符串取下标）为查找的起始位置
var str="182828323410"
var str2=str.startsWith("8",1)
console.log(str2)
3. endsWith() ：返回布尔值，判断参数字符串是否在原字符串的尾部。
第一个参数为查找的字符串，第二个为字符串的总共长度
var str="182828323410"
var str3=str.endsWith("2341",11)
console.log(str3)
字符串重复
repeat() ：返回新的字符串，表示将字符串重复指定次数返回。
1.字符串重复的多种情况
repeat() ：返回新的字符串，表示将字符串重复指定次数返回。
console.log("Hello,".repeat(2)); // "Hello,Hello,"
如果参数是小数，向下取整
console.log("Hello,".repeat(3.2)); // "Hello,Hello,Hello,"
如果参数是 0 至 -1 之间的小数，会进行取整运算，0 至 -1 之间的小数取整得到 -0 ，等同于 repeat 零次
console.log("Hello,".repeat(-0.5)); // ""
如果参数是 NaN，等同于 repeat 零次
console.log("Hello,".repeat(NaN)); // ""
如果参数是负数或者 Infinity ，会报错:
console.log("Hello,".repeat(-1));
// RangeError: Invalid count value
console.log("Hello,".repeat(Infinity));
// RangeError: Invalid count value
如果传入的参数是字符串，则会先将字符串转化为数字
console.log("Hello,".repeat("hh")); // ""
console.log("Hello,".repeat("2")); // "Hello,Hello,"
2.可以替换字符串
var str="华清远见666"
var str2="*".repeat(str.length)
console.log(str2)
字符串补全
- padStart：返回新的字符串，表示用参数字符串从头部补全原字符串。
- padEnd：返回新的字符串，表示用参数字符串从尾部补全原字符串。
以上两个方法接受两个参数，第一个参数是指定生成的字符串的最小长度，第二个参数是用来补全的字符串。如果没有指定第二个参数，默认用空格填充。
var str="99"
var str2=str.padEnd(6,"abc")
var str3=str.padStart(6,"abc")
console.log(str2,str3)
1.如果指定的长度小于或等于原字符串的长度，则返回原字符串:
console.log("hello".padStart(5,"A")); // "hello"
2.如果原字符串加上补全字符串长度大于指定长度，则截去超出位数的补全字符串:
console.log("hello".padEnd(10,",world!")); // "hello,worl"
3.常用于补全位数：
console.log("123".padStart(10,"0")); // "0000000123"
模板字符串
模板字符串
模板字符串相当于加强版的字符串，用反引号 ` ,除了作为普通字符串，还可以用来定义多行字符串，还可以在字符串中加入变量和表达式。
注意：模板字符串中的换行和空格都是会被保留的。
普通字符串
let string = `Hello'\n'world`;
console.log(string);
多行字符串
let string1 = `Hey,
can you stop angry now?`;
console.log(string1);
变量名写在 ${} 中，${} 中可以放入 JavaScript 表达式。
let name = "Mike";
let age = 27;
let info = `My Name is ${name},I am ${age+1} years old next year.`
console.log(info);
字符串中调用函数
function f(){
return "have fun!";
}
let string2= `Game start,${f()}`;
console.log(string2); // Game start,have fun!
对象
1.对象字面量
- 属性的简洁表示法：ES6允许对象的属性直接写变量，这时候属性名是变量名，属性值是变量值。
var count=20
var obj={count}//es6的对象成员可以写做 一个单词 这个单词是变量名:把变量名作为对象的属性名 值取出作为属性值(易于读取,提高开发效果)
console.log(obj["count"])
方法简写：函数根据业务有很多别称:构造函数 静态函数 方法 事件处理程序(监听器) 闭包 回调函数 钩子函数
var obj = {
name: "karen",
say: function() {}
}
//name和say都是obj对象成员 name是obj的属性(pro) say是对象obj的方法
var obj2 = {
name: "jack",
say() {}
}
ES6写法与其他写法对比：
var obj = {
name: "karen",//常用写法
"age":20,//标准写法,
["hello"+100]:90,//es6写法
[false]:90,//es6写法
[{life:100}]:90,//es6写法,
[Symbol(100)]:200
}
console.log(obj)
2.对象的拓展运算符...
拓展运算符（...）用于取出参数对象所有可遍历属性然后拷贝到当前对象。
var obj={name:"karen",age:20,arr:[10,20],life:2}
var obj3={life:7,x:100}
var obj2={life:80,...obj,life:100,...obj3}
console.log(obj2)
console.log(obj2,obj==obj2,obj.arr==obj2.arr)
3.对象的新静态方法
Object.is(value1, value2) ：用来比较两个值是否严格相等，与（===）基本类似
与===的区别是：
1） Object.is(+0,-0)， 为false ；+0 === -0 ，为true
2） Object.is(NaN,NaN)，为true ； NaN === NaN ，为false
数组
1.数组的创建，Array.of（）
var arr=Array.of(10,20,30)
var arr2=new Array(10)//空数组，长度为10
console.log(arr,arr2)
2.将类数组对象或可迭代对象转化为数组Array.from()。
Array.from(参数一，参数二，参数三)
参数1：传入的类数组
参数2：回调函数，处理传入的类数组的数据
参数3：指定回调函数的this
let arr = Array.from({
0: '1',
1: '2',
2: 3,
length: 3
});
console.log(arr);
3.拓展的方法
3.1 find() ：查找数组中符合条件的元素,若有多个符合条件的元素，则返回第一个元素
var arr=[10,203,400,2,3,5,6]
var re=arr.find(function(el){
console.log(111)
if(el>18){return true}
})
console.log(re)
3.2 findIndex() ：查找数组中符合条件的元素索引，若有多个符合条件的元素，则返回第一个元素索引（下标）。
var arr=[10,304,50]
var re=arr.findIndex(function(el){
if(el>18){return true}
})
console.log(re)
3.3 fill() ：将一定范围索引的数组元素内容填充为单个指定的值，返回原数组
参数1：用来填充的值
参数2：被填充的起始索引
参数3(可选)：被填充的结束索引，默认为数组末尾
var arr=[10,203,4,100,3004,5]
var arr2=arr.fill("hello",2,4)//2 3
console.log(arr,arr2,arr==arr2)
3.4 includes() ：数组是否包含指定值。注意：与 Set 和 Map 的 has 方法区分；Set 的 has 方法用于查找值；Map 的 has 方法用于查找键名
var arr=[1,23,5,56,{name:"karen"}]
var re1=arr.includes(23)
var re2=arr.includes({name:"karen"})//引用数据与基本数据不同，这里相当于重新创建了一个对象，因此为false
console.log(re1,re2)
3.5 flat()：嵌套数组转一维数组
括号中的数字为降几次
var arr=[[10,20,30],40,50,[[60,70],80,[90,[110],100]]]
var arr2=arr.flat(3)
console.log(arr2)
笔试题预测：实现flat（）函数
var arr=[[10,20,30],40,50,[[60,70],80,[90,[110],100]]]
Array.prototype.myflat=function(count=Infinity){
var arr=[]
for(var i=0;i<this.length;i++){
if(this[i].constructor==Array&&count>0){
var newarr=this[i].myflat(count-1)
for(var j=0;j<newarr.length;j++){
arr.push(newarr[j])
}
}else{
arr.push(this[i])
}
}
return arr
}
var re2=arr.myflat(1)
console.log(re2)
3.6 遍历（了解）
entrys() ：遍历键值对。
```
for(let [key, value] of ['a', 'b'].entries()){
console.log(key, value);
}
// 0 "a"
// 1 "b"
// 不使用 for... of 循环
let entries = ['a', 'b'].entries();
console.log(entries.next().value); // [0, "a"]
console.log(entries.next().value); // [1, "b"]
// 数组含空位
console.log([...[,'a'].entries()]); // [[0, undefined], [1, "a"]]
```
keys() ：遍历键名。
```
for(let key of ['a', 'b'].keys()){
console.log(key);
}
// 0
// 1
// 数组含空位
console.log([...[,'a'].keys()]); // [0, 1]
```
values() ：遍历键值
```
for(let value of ['a', 'b'].values()){
console.log(value);
}
// "a"
// "b"
// 数组含空位
console.log([...[,'a'].values()]); // [undefined, "a"]
```
