（一）数组方法补充
（1）map
map() 方法返回一个新数组，数组中的元素为原始数组元素调用函数处理后的值。
map() 方法按照原始数组元素顺序依次处理元素。
注意：map不会对空数组进行检测，也不会改变原数组
语法：array.map(function(currentValue,index,arr), thisValue)
参数：
currentValue：必需；当前元素
index：可选；元素的索引
arr：可选；当前元素所属的数组
thisValue：可选；传递给函数的值一般用 "this" 值。如果这个参数为空， "undefined" 会传递给 "this" 值。
let arr=[1,2,3,4,5]
let arr2=arr.map((item)=>{
return item*2
})
console.log(arr2);
输出： [2, 4, 6, 8, 10]
注意：一定要return返回数据
（2）find(es6新增)
find() 方法返回通过测试（函数内判断）的数组的第一个元素的值，
find() 方法为数组中的每个元素都调用一次函数执行：
注意: find() 对于空数组，函数是不会执行的，find() 并没有改变数组的原始值。
语法：array.find(function(currentValue, index, arr),thisValue)
参数：
currentValue：必需；当前元素
index：可选；元素的索引
arr：可选；当前元素所属的数组
thisValue：可选；传递给函数的值一般用 "this" 值。如果这个参数为空， "undefined" 会传递给 "this" 值。
let arr=[1,2,3,4,5]
let arr2=arr.find((item)=>{
return item>1
})
console.log(arr2);
输出：2
（3）findIndex(es6新增)
findIndex() 方法返回传入一个测试条件（函数）符合条件的数组第一个元素位置(索引)。
findIndex() 方法为数组中的每个元素都调用一次函数执行：
当数组中的元素在测试条件时返回 true 时, findIndex() 返回符合条件的元素的索引位置，之后的值不会再调用执行函数。如果没有符合条件的元素返回 -1
注意: findIndex() 对于空数组，函数是不会执行的， findIndex() 并没有改变数组的原始值。
语法：array.findIndex(function(currentValue, index, arr),thisValue)
参数：currentValue：必需；当前元素
index：可选；元素的索引
arr：可选；当前元素所属的数组
thisValue：可选；传递给函数的值一般用 "this" 值。如果这个参数为空， "undefined" 会传递给 "this" 值。
let arr=[1,2,3,4,5]
let arr2=arr.findIndex((item)=>{
return item>1
})
console.log(arr2);
输出：1
（4）join 数组转换为字符串
join() 方法用于把数组中的所有元素放入一个字符串。元素是通过指定的分隔符进行分隔的。
语法：arrayObject.join(separator)
separator：分隔符
let arr=[2012,12,21]
let str=arr.join("-")
console.log(str);
输出：2012-12-21
（5）includes(es6新增)
includes() 方法返回一个布尔值，表示某个数组是否包含给定的值，与字符串的includes方法类似。
语法：string.includes(searchvalue, start)
参数：searchvalue:必需；要查找的字符串。
start:可选；设置从那个位置开始查找，默认为 0。
let arr=[2012,12,21]
let bool=arr.includes(12)
console.log(bool);
输出：true
（6）reverse 改变原数组
reverse() 方法用于颠倒数组中元素的顺序。
语法：array.reverse()
let arr=[2012,12,21]
let arr2=arr.reverse()
console.log(arr2);
console.log(arr);
输出：[21, 12, 2012]
[21, 12, 2012]
（7）sort 改变原数组
sort() 方法用于对数组的元素进行排序，排序顺序可以是字母或数字，并按升序或降序，默认排序顺序为按字母升序。使用数字排序，你必须通过一个函数作为参数来调用，函数指定数字是按照升序还是降序排列。
let arr=["a","c","d","e","g","b"]
arr.sort()
console.log(arr);
输出： ['a', 'b', 'c', 'd', 'e', 'g']
let arr=[1,3,21,45,2,44,99]
arr.sort((a,b)=>{
return a-b //升序
})
console.log(arr);
输出： [1, 2, 3, 21, 44, 45, 99]
let arr=[1,3,21,45,2,44,99]
arr.sort((a,b)=>{
return b-a //降序
})
console.log(arr);
输出：[99, 45, 44, 21, 3, 2, 1]
数组对象，根据对象里特定属性排序
let arr=[
{ id:1,name:"张三" },
{ id:6,name:"李四" },
{ id:8,name:"王宇" },
{ id:3,name:"二麻子"},
{ id:4,name:"小小" }
]
arr.sort((a,b)=>{
return a.id-b.id //升序
})
console.log(arr);
输出：[
{ id:1,name:"张三" },
{ id:3,name:"二麻子"},
{ id:4,name:"小小" },
{ id:6,name:"李四" },
{ id:8,name:"王宇" }
]
let arr=[
{ id:1,name:"张三" },
{ id:6,name:"李四" },
{ id:8,name:"王宇" },
{ id:3,name:"二麻子"},
{ id:4,name:"小小" }
]
arr.sort((a,b)=>{
return b.id-a.id //降序
})
console.log(arr);
输出：[
{ id:8,name:"王宇" },
{ id:6,name:"李四" },
{ id:4,name:"小小" },
{ id:3,name:"二麻子"},
{ id:1,name:"张三" }
]
(8)indexOf
indexOf() 方法可返回数组中某个指定的元素位置。
该方法将从头到尾地检索数组，看它是否含有对应的元素。开始检索的位置在数组 start 处或数组的开头（没有指定 start 参数时）。如果找到一个 item，则返回 item 的第一次出现的位置。开始位置的索引为 0。如果在数组中没找到指定元素则返回 -1。
语法：Array.indexOf(searchvalue,start)
检索的元素必须是完全匹配才能找到，不能是只包含其中一部分。
let arr=["a","b","cd","e"]
console.log(arr.indexOf("cd"));
输出：2
console.log(arr.indexOf("c"));
输出：-1
（9）flat(es6新增)
flat(n)用于将嵌套的数组“拉平”，变成一维的数组。该方法返回一个新数组，对原数据没有影响。
语法：array.flat(n)
不确定是几维数组可以使用：array.flat(Infinity)，可以将任意多维数组转换为一维数组
(10)every
every() 方法用于检测数组所有元素是否都符合指定条件（通过函数提供）。
every() 方法使用指定函数检测数组中的所有元素：
如果数组中检测到有一个元素不满足，则整个表达式返回 false ，且剩余的元素不会再进行检测。
如果所有元素都满足条件，则返回 true。
注意： every() 不会对空数组进行检测，every() 不会改变原始数组。
语法：array.every(function(currentValue,index,arr), thisValue)
参数：currentValue：必需；当前元素
index：可选；元素的索引
arr：可选；当前元素所属的数组
thisValue：可选；传递给函数的值一般用 "this" 值。如果这个参数为空， "undefined" 会传递给 "this" 值。
let arr=[
{ id:1,name:"张三" },
{ id:6,name:"李四" },
{ id:8,name:"王宇" },
{ id:3,name:"二麻子"},
{ id:4,name:"小小" }
]
let arr2= arr.every((item)=>{
return item.id>0
})
console.log(arr2);
输出：true
let arr=[
{ id:1,name:"张三" },
{ id:6,name:"李四" },
{ id:8,name:"王宇" },
{ id:3,name:"二麻子"},
{ id:4,name:"小小" }
]
let arr2= arr.every((item)=>{
return item.id>6
})
console.log(arr2);
输出：false
(11)some
some() 方法用于检测数组中的元素是否满足指定条件（函数提供）。
some() 方法会依次执行数组的每个元素：
如果有一个元素满足条件，则表达式返回true , 剩余的元素不会再执行检测。
如果没有满足条件的元素，则返回false。
注意： some() 不会对空数组进行检测,some() 不会改变原始数组。
语法：array.some(function(currentValue,index,arr), thisValue)
参数：currentValue：必需；当前元素
index：可选；元素的索引
arr：可选；当前元素所属的数组
thisValue：可选；传递给函数的值一般用 "this" 值。如果这个参数为空， "undefined" 会传递给 "this" 值。
let arr=[
{ id:1,name:"张三" },
{ id:6,name:"李四" },
{ id:8,name:"王宇" },
{ id:3,name:"二麻子"},
{ id:4,name:"小小" }
]
let arr2= arr.some((item)=>{
return item.id>6
})
console.log(arr2);
输出：true
（12）filter
filter() 方法创建一个新的数组，新数组中的元素是通过检查指定数组中符合条件的所有元素。
注意： filter() 不会对空数组进行检测，filter() 不会改变原始数组。
语法：array.filter(function(currentValue,index,arr), thisValue)
参数：currentValue：必需；当前元素
index：可选；元素的索引
arr：可选；当前元素所属的数组
thisValue：可选；传递给函数的值一般用 "this" 值。如果这个参数为空， "undefined" 会传递给 "this" 值。
let arr=[
{ id:1,name:"张三" },
{ id:6,name:"李四" },
{ id:8,name:"王宇" },
{ id:3,name:"二麻子"},
{ id:4,name:"小小" }
]
let arr2= arr.filter((item)=>{
return item.id>4
})
console.log(arr2);
输出：[{ id:6,name:"李四" },{ id:8,name:"王宇" }]
(13)slice
slice() 方法可从已有的数组中返回选定的元素。
slice()方法可提取字符串的某个部分，并以新的字符串返回被提取的部分。
注意：slice() 方法不会改变原始数组。
语法：array.slice(start,end)
参数：start：可选；规定从何处开始选取。如果是负数，那么它规定从数组尾部开始算起的位置。也就是说，-1 指最后一个元素，-2 指倒数第二个元素，以此类推。
end：可选。规定从何处结束选取。该参数是数组片断结束处的数组下标。如果没有指定该参数，那么切分的数组包含从 start 到数组结束的所有元素。如果这个参数是负数，那么它规定的是从数组尾部开始算起的元素。
let arr=[
{ id:1,name:"张三" },
{ id:6,name:"李四" },
{ id:8,name:"王宇" },
{ id:3,name:"二麻子"},
{ id:4,name:"小小" }
]
let arr2= arr.slice(1,-1)
let arr2= arr.slice(-4,-1) 这种写法和上面写法效果一致
console.log(arr2);
输出：[{id: 6, name: '李四'},{id: 8, name: '王宇'}, { id:3,name:"二麻子"}]
（二）对象
（1）Object.assign
Object.assign()是object的新api，主要用于将一个或多个源对象复制到目标对象，它将返回目标对象。
语法：Object.assign(目标对象，源对象1，源对象2， 源对象3, ...)
注意：多个对象合并的时候，如果key相同，后面的会覆盖前面的【对象的key是唯一的】
let obj1={
name:'张三'
}
let obj2={
age:10
}
let obj3={
name:'王五'
}
let obj=Object.assign(obj1,obj2,obj3)
console.log(obj);
console.log(obj1);
console.log(obj2);
输出：{name: '王五', age: 10}
{name: '王五', age: 10}
{age: 10}
let obj1={
name:'张三'
}
let obj2={
age:10
}
let obj3={
name:'王五'
}
let obj=Object.assign({},obj1,obj2,obj3)
console.log(obj);
console.log(obj1);
console.log(obj2);
输出： {name: '王五', age: 10}
{name: '张三'}
{age: 10}
（2）location对象常用API属性和方法
location对象属性
location.href // 设置或返回完整的 URL
location.protocol // 设置或返回当前 URL 的协议
location.origin // 协议+域名+端口
location.host // 域名+端口
location.hostname // 域名
location.port // 端口
location.pathname // 路径【端口之后，从/开始，到参数之前，?之前结束】
location.search // 参数
location.hash // 哈希
location对象方法
location.reload() // 重新加载网页【刷新】
onhashchange
Window.onhashchange可以监听浏览器hash的改变
window.onhashchange = function () {
console.log('hash地址改变...')
}
onpopstate
window.onpopstate = function () {
console.log('监听浏览器的前进、后退')
}
（三）正则表达式
正则表达式：是描述字符模式的对象，以一个用简单方式描述或者匹配一系列符合某个句法规则的字符串。正则表达式通常被用来验证、检索、替换那些符合某个模式的文本。
作用：
1、检查字符串是否合法性
例如：验证用户名 （a-z，0-9，不能全是数字，不能全是字母）；验证邮箱格式 (xxx@qq.com)；验证电话号码(11位数字)；验证身份证 (18位 )
2、提取字符串中信息 例如：提取一条短信中数字；提取文件名的后缀；
3、替换字符串 例如：替换字符串中的非法字符；对电话号码进行屏蔽；（1852****0102）
正则表达式是一种字符模式对象（RegExp）
定义： 两种方法
let reg = new RegExp("字符串",[模式修饰符])；
let reg = /字符串/[模式修饰符]
修饰符：i:不区分大小写；g:全局匹配
RegExp方法：exec；检索字符串中指定的值。返回找到的值，并确定其位置
test：检索字符串中指定的值。返回 true 或 false
let str="1237456"
let reg=new RegExp(7)
console.log(reg.exec(str));
输出：['7', index: 3, input: '1237456', groups: undefined]
let str="12374567"
console.log(str.match(/7/g));
输出：['7', '7']
let str="Hello Box"
// let reg=new RegExp("box","i")
let reg=/box/i
console.log(reg.test(str));
输出：true
(四)事件对象
概念：就是当你触发了一个事件以后，对该事件的一些描述信息。event 对象代表事件的状态，比如事件在其中发生的元素、键盘按键的状态、鼠标的位置、鼠标按钮的状态。
语法：dom节点.addEventListener(“事件类型”,function(event){
//event：事件对象
})
属性：
event.target ： 获取事件源
event.type : 获取事件类型
event.clientX：水平坐标
event.clientY：垂直坐标
event.keycode 键盘码
方法：
event.preventDefault(); //阻止浏览器的默认行为
event.stopPropagation(); //阻止事件传播 === 阻止事件冒泡
（五）DOM事件流
概念：事件流描述元素接收事件的顺序。包括3个阶段：事件捕获阶段、当前目标阶段、冒泡阶段。
事件委派：事件的委派也叫事件代理，简单理解就是：原本是某个元素需要绑定的事件，现在将这个事件交给别的元素去做，正常我们把它交给父级元素，比如：原本是给li绑定点击事件，现在交给它父级ul绑定，利用冒泡原理，点击li的时候会触发ul的事件；
好处：提升性能；能绑定新添加标签的事件
