很全的用法链接 www.cnblogs.com/sqh17/p/852…
1.forEach (数组方法)
单纯的数组方法，不能遍历字符串
字符串上面没这个方法
用法
var num=[0,1,2,3,5,4,5,8,4,5,5,4,4,7]
num.forEach(item=>{
console.log("做操作")
})
2.map方法
用法
var num=[0,1,2,3,5,4,5,8,4,5,5,4,4,7]
num.map(item=>{
console.log("做操作")
})
map的算法是优于forEach的，map是一种数据结构，直接用key拿到value值，而forEach是每个循环遍历的。map判断会返回布尔值，每一个都返回一个布尔值，组成的一个数组，map操作数组对象的时候会改变原数组（是因为操作了item）。
1.map的速度比forEach快。
2.map会返回一个新的数组，不会对原数组产生影响，forEach不会产生新的数组，并且会返回undefined
3.map因为返回数组所以可以做链式操作，forEach不能
4.map里可以用return（return的是什么，相当于把数组中的这一项变为什么，并不影响原来的数组，只是相当于clone了这一项对应的改变），而forEach里面用return不起作用，forEach不能用break会直接报错。
3. slice（字符串和数组）
做字符串或者数组分割
不会改变原来的
返回一个新的字符串或者数组
//字符串
string.slice(2,4) //起始位置和结束位置， 开始取得到，结尾不取（前闭后开）
//数组
let arr = [1,2,3,4,5]
// 截取下标 [2,5) 区间的数组，左闭右开，结果为：[3, 4, 5]
let arr2 = arr.slice(2,5)
4.substr和substring
substr
substrstr.substr(start,num) //截取字符串，从 start下标 开始，截取 num 个字符串。
substring
str.substring(start,end)
//截取字符串，从 start下标 开始，保留到 end下标 的前一个结束，如果没有 end，就保留到最后一个字符结束，跟 slice方法 一样。
5. splice (数组方法)
开始的位置，取几个
arr.splice(start,num,arg1,arg2...)
是一个很强的数组操作方法，可以增删改
注意：操作的是原数组
a、删除数组元素
let arr = [1,2,3,4,5,6,7,8,9]
// 从 下标为 3 的项开始，依次向后删除 2 个元素，返回被删除的元素数组：[4, 5]，原数组改变为：[1, 2, 3, 6, 7, 8, 9]
arr.splice(2,4)
//输出结果 (2) [4, 5]
从 start下标 开始，删除 num 个元素，再在此处插入 arg1，arg2，arg3...
如果只填了 start 却没填 其它参数，则代表删除其后的所有元素
b、替换元素
let arr = [1,2,3,4,5,6,7,8,9]
// 从 下标为 3 的项开始，依次向后删除 2 个元素，并将 1, 2, 3 添加到被删除的元素的位置。
//返回被删除的元素数组：[4, 5]，原数组改变为： [1, 2, 'zsy', 'love', 'zsy', 6, 7, 8, 9]
arr.splice(2,3,'zsy','love','zsy')
//输出结果(9) [1, 2, 'zsy', 'love', 'zsy', 6, 7, 8, 9]
c、单纯插入数组
let arr = [1,2,3,4,5,6,7,8,9]
// 从 下标为 3 的项开始，依次向后添加 1, 2, 3 等元素。返回被删除的元素数组：[]，
//原数组改变为： [1, 2, 'zsy', 'love', 'zsy', 3, 4, 5, 6, 7, 8, 9]
//输出结果 (12) [1, 2, 'zsy', 'love', 'zsy', 3, 4, 5, 6, 7, 8, 9]
6.split字符串分割(字符串)
用一个字符串里面含有的字符，把这个字符串分隔开，放在一个数组里面，不会改变原来的字符串
可以和14条replace比较
let str = "I really like playing games"
let ntr = str.split(' ')
console.log(ntr)
//输出结果(5) ['I', 'really', 'like', 'playing', 'games']
7.添加和删除方法
这两对都会改变原数组。
push() // 在数组的末尾添加一个或多个元素 返回数组新长度
pop() //移除数组的最后一项，返回移除的项
shift() //移除数组的第一项，返回移除项
unshift() //在数组的第一项前面添加一个或多个元素，返回数组的长度
8. find和filter两种方法
查找数组元素,都不会改变原数组。
a.find方法 (查找元素)
const arr = [{
name: '1',
age: 25,
gender: '男'
}, {
name: '2',
age: 25,
gender: '男'
}, {
name: '3',
age: 25,
gender: '男'
}]
const arr1 = arr.find(item => {
return item.name == '2'
})
console.log(arr1)
//输出结果 {name: '2', age: 25, gender: '男'}
findIndex查找下标的,找到返回下标，找不到返回-1
b.filter 方法
const arr = [{
name: '1',
age: 25,
gender: '男'
}, {
name: '2',
age: 25,
gender: '男'
}, {
name: '3',
age: 25,
gender: '男'
}]
const arr1 = arr.filter(item => {
return item.name == '2'
})
console.log(arr1)
//输出结果 [{age: 25},{ gender: "男"},{name: "2"}]
他们的区别是，fing返回的是一个对象，返回的是满足条件的第一个对象。 而filter返回的是一个数组对象，就是满足条件的所有对象都会放在一个数组返回。
const array = [1, 5, 1, 4, 8, 9, 6, 4, 4, 4, ]
const arr1 = array.find(item => {
return item == 4
})
console.log(arr1)
//输出结果 4
const arr2 = array.filter(item => {
return item == 4
})
console.log(arr2)
//输出结果 (4) [4, 4, 4, 4]
8. for有关的所有方法
a.for
最原始的for循环， 从c开始一直在用。
const arr = [{
name: '1',
age: 25,
gender: '男'
}, {
name: '2',
age: 25,
gender: '男'
}, {
name: '3',
age: 25,
gender: '男'
}]
for (let i = 0; i < arr.length; i++) {
console.log(arr[i])
}
// 输出结果 ： {name: '1', age: 25, gender: '男'}
// {name: '2', age: 25, gender: '男'}
// {name: '3', age: 25, gender: '男'}
b.for in
遍历对象键名的
const array = [1,5, 1, 4, 8, 9, 6, 4, 4, 4]
for (let item in array) {
console.log(item)
}
//输出结果 0 1 2 3 4 5 6 7 8 9
要是遇到自己做echarts图得时候拿到后端给得map数据得时候自己处理一下。
下面得方法可以拿到key，可以拿到value
var y=[], x=[]
console.log('初始拿到得对象：',{'2022-06-30': 1, '2022-06-29': 5})
let obj = {'2022-06-30': 1, '2022-06-29': 5}
for (let item in obj){
x.push(item)
}
Object.keys(obj).map(key => {
y.push(obj[key])
})
//Object.keys() 返回对象自身的所有可枚举的属性并以数组形式返回 即:[name,age]
//Object.values() 返回对象自身所有可枚举的属性值,并以数组形式返回：[小王,永远年轻]
console.log('我自己遍历得x轴', x,'我自己遍历得y轴',y)
//输出结果 我自己遍历得x轴 (2) ['2022-06-30', '2022-06-29'] 我自己遍历得y轴 (2) [1, 5]
c.for of （可以遍历字符串）
for of 不能遍历对象。可以作用于数组。
const array = [1, 5, 1, 4, 8, 9, 6, 4, 4, 4, ]
for (let item of array) {
console.log(item)
}
//1
//5
//1
//4
//8
//9
//6
//4 这个打了三次
d.forEach
const arr = [{
name: '1',
age: 25,
gender: '男'
}, {
name: '2',
age: 25,
gender: '男'
}, {
name: '3',
age: 25,
gender: '男'
}]
arr.forEach((a, b, c) => {
console.log(a, 'aaaaaaaaaa')
console.log(b, 'bbbbb')
console.log(c, 'cccccccc')
})
//输出结果 {name: '1', age: 25, gender: '男'} 'aaaaaaaaaa'
//0 'bbbbb'
//(3) [{…}, {…}, {…}] 'cccccccc'
//{name: '2', age: 25, gender: '男'} 'aaaaaaaaaa'
//1 'bbbbb'
//(3) [{…}, {…}, {…}] 'cccccccc'
//{name: '3', age: 25, gender: '男'} 'aaaaaaaaaa'
//2 'bbbbb'
//(3) [{…}, {…}, {…}] 'cccccccc'
forEach 的第一个参数是每一项，item。 第二项 index下标 。 第三个参数是原数组。
不会改变原数组，没有返回值。并且不能break和return。
9. reduce
10个例子，用好reduce ： juejin.cn/post/703206…
reduce25个高级用法 ： juejin.cn/post/684490…
可以做很多操作，可以累加。之类的
const array = [1, 2, 3, 4, 5]
const num = array.reduce((a, b, c, d) => {
return a + b
},7)
console.log(num)
//输出结果 22
因为这里累加是15，但是初始用的是7.
更加复杂的操作移步 www.jianshu.com/p/e375ba1cf…
10.set
参考 www.cnblogs.com/ccv2/p/1250…
set是个不重复容器。
a.去重用的最多
new 一个set，把数组传进去就可以了。但是不能使用数组对象。
const array = [1, 2, 3, 4, 5, 1, 2, 1, 1, 5, 1, 4, 8, 9, 7]
const num = new Set(array)
console.log(num)
console.log(array.length)
//输出结果 Set(8) {1, 2, 3, 4, 5, …}
// 15
b.set上面的方法
console.log(new Set)
//输出结果1. Set(0) {size: 0}
//1. 1. [[Entries]]
// size: 0
// 1. [[Prototype]]: Set
// add: ƒ add()
// clear: ƒ clear()
// constructor: ƒ Set()
// delete: ƒ delete()
// entries: ƒ entries()
// forEach: ƒ forEach()
// has: ƒ has()
// keys: ƒ values()
// size: (...)
// values: ƒ values()
// Symbol(Symbol.iterator): ƒ values()
// Symbol(Symbol.toStringTag): "Set"
// get size: ƒ size()
// [[Prototype]]: Object
提一点小问题 就是在用console.dir()打印数组的时候每个网页打开控制台打印出来可能不一样，有的数组方法在prototype上面，感觉是因为框架和babel解析器的原因，才导致的不同。
图失效了，上面cv去打印一下就是下面的图
- has检测有没有这个值。
const array = [1, 2, 3, 4, 5, 1, 2, 1, 1, 5, 1, 4, 8, 9, 7]
const num = new Set(array)
console.log(num.has(1))
- add是在后面添加一个值
const array = [1, 2, 3, 4, 5, 1, 2, 1, 1, 5, 1, 4, 8, 9, 7]
const num = new Set(array)
console.log(new Set)
console.log(num.add('恩'))
- clear 全删除，直接undefined了
console.log(num.clear('1'))
- delete 删除有的，执行返回true，没执行返回false 和sql语句一样
console.log(num.delete(1))
- entries （条目）变化成键值对的形式
console.log(num.entries(1))
- size 获得size容器的长度
console.log(num.size)
//结果输出 8
- keys和valuses不知道干啥的。
11. sort 排序
升序排列
const array = [2, 6, 5, 4, 7, 8]
array.sort((a, b) => {
return a - b
})
console.log(array)
//输出结果 (6) [2, 4, 5, 6, 7, 8]
降序排列
const array = [2, 6, 5, 4, 7, 8]
array.sort((a, b) => {
return b - a
})
console.log(array)
//输出结果 (6) [8, 7, 6, 5, 4, 2]
12.some 和 every
some是有一个满足的条件就返回，every是需要全部满足才返回。
const array = [2, 6, 5, 4, 7, 8]
const num = array.some((item, index, array) => {
item > 6
})
const num1 = array.every((item, index, array) => {
item > 6
})
console.log('第一个：',num,'第二个',num1)
//输出结果 第一个： false 第二个 false
some是每个都遍历一遍，every是找到就停下了。
返回都是布尔值。
13.数组扁平化（递归）
在vue 里面写的
let num =[1,[2,3,[4,5],[6,8,7]]]
this.recursion(num)
recursion(arr){
arr.forEach(item=>{
if (typeof (item)=='object'){
this.recursion(item)
}else {
this.kong.push(item)
}
})
},
//输出结果 (8) [1, 2, 3, 4, 5, 6, 8, 7]
javaScript
let arr =[1,[2,3,[4,5],[6,8,7]]]
function flatten(arr){
let result =[];
for(let i =0; i < arr.length; i++){
if(Array.isArray(arr[i])){
result = result.concat(flatten(arr[i]));
}else{
result.push(arr[i]);
}
}
return result;
}
console.log(flatten(arr));
//输出结果 (8) [1, 2, 3, 4, 5, 6, 8, 7]
14.replace和replaceAll
字符串替换
replace 只替换遇到的第一个，replaceAll替换字符串里面所有的字符
let data = [
["The","red", "horse"],
["Plane","over","the","ocean"],
["Chocolate","ice","cream","is","awesome"],
["this","is","a","long","sentence"]
]
let str =data.toString().replace(',',' ')
let str1 =data.toString().replaceAll(',',' ')
console.log('第一个输出的值：',str,'第二个输出的值：',str1)
//输出结果 第一个输出的值： The red,horse,Plane,over,the,ocean,Chocolate,ice,cream,is,awesome,this,is,a,long,sentence
//第二个输出的值： The red horse Plane over the ocean Chocolate ice cream is awesome this is a long sentence
15.join (将数组用特殊符号分割变成字符串)
join操作过的数组会变成字符串， 并且数组是用自己定义的字符分隔开的字符串
let data = [
["The","red", "horse"],
["Plane","over","the","ocean"],
["Chocolate","ice","cream","is","awesome"],
["this","is","a","long","sentence"]
]
let str = data.join('|')
console.log(str)
//输出结果'The,red,horse|Plane,over,the,ocean|Chocolate,ice,cream,is,awesome|this,is,a,long,sentence'
16. Math的方法
看一下上面封装的有什么方法
console.dir(Math)
thirdpartimg.51ishare.com/16570791151…
-Math里面有8个属性常量可以使用 参考这篇文章
baijiahao.baidu.com/s?id=169311…
1.Math.E
自然数e E: 2.718281828459045
2.LN2: 0.6931471805599453
LN2和LN10比较相似，唯一的不同就是它代表的是2的自然对数，它的值约等于0.6931471805599453。
3.LN10: 2.302585092994046
LN10属性代表的是10的自然对数（以自然常数e为底数的对数），它的值约等于2.302585092994046。
属性名中的LN对应自然对数在数学上的符号ln，而LN10当然就是对10求自然对数了。
4.LOG2E: 1.4426950408889634
LOG2E和LOG10E比较相似，不同的是它表示的是自然常数e的以2为底数的对数，它的值约等于1.4426950408889634。
5.LOG10E: 0.4342944819032518
LOG10E表示的是自然常数e的以10为底数的对数，它的值约等于0.4342944819032518。
属性名中的LOG表示对数的数学符号log，10表示对数的底数为10，E表示对数的真数为e
（综合起来，就是e的以10为底数的对数）。
6.PI: 3.141592653589793
圆周率
7.SQRT1_2: 0.7071067811865476
SQRT1_2属性代表的是1/2的平方根，它的值约等于0.7071067811865476。
属性名中的SQRT是“square root”的缩写，它的意思正是“平方根”；
而后面的1_2表示的就是二分之一，这里用下划线表示分数线。
8.SQRT2: 1.4142135623730951
SQRT2属性和SQRT1_2比较相似，不同的是它代表的是2的平方根，它的值约等于1.4142135623730951。
- Math上面还有许多的方法提供给我们使用
1.Math.min() 用于找出传入里面最小的数值 注意里面只能是number，不能是array不然会NaN!
let min = Math.min(4.5,2.6,10,1.1,6.3,6.6)
console.log('min找出最小的数字',min )
//min找出最小的数字 1.1
2.Math.max() 用于找出传入里面最大的数值 注意里面只能是number，不能是array不然会NaN!
let max = Math.max(4.5,2.6,10,1.1,6.3,6.6)
console.log('max找出最小的数字',max )
//max找出最小的数字 10
3.Math.abs() 返回一个数的绝对值
let abs = Math.abs(-10)
console.log('abs的绝对值',abs)
//abs的绝对值 10
4.Math.cos() 返回一个值的余弦值。
let sin = Math.sin(90 * Math.PI / 180)
console.log('sin 的余弦值',sin)
//sin 的余弦值 1
5..Math.ceil() 向上取整
let ceil = Math.ceil(6.6)
console.log('ceil大于传入值的最大定数',ceil)
//ceil大于传入值的最大定数 7
6.Math.floor() 向下取整
let floor1 = Math.floor(5.4)
let floor2 = Math.floor(8.6)
console.log('floor1 的向下取整',floor1,'floor2 的向下取整',floor2)
//floor1 的向下取整 5 floor2 的向下取整 8
7.Math.round() 四舍五入的整数
let RU = Math.round(5.5)
let she =Math.round(5.4)
console.log('ru入',RU,'she舍弃',she)
//ru入 6 she舍弃 5
8.Math.sqrt() 求一个数的平方根
let a = Math.sqrt(4)
let b =Math.sqrt(25)
console.log(a,b)
//2 5
10.Math.random() 随机数
let random = Math.random()*10
console.log(Math.round(random))
//2 十以内的随机数
11.Math.pow() 返回基数(base)的指数(exponent)次幂
Math.pow(4, 2)
// 16
12.Math.trunc() 返回的是一个数的整数部分，不管正数还是负数，直接去掉小数点及之后的部分
Math.trunc(13.37)
// 13
Math.trunc(42.84)
// 42
Math.trunc(0.123)
// 0
Math.trunc(-0.123)
// -0
Math.trunc("-1.123")
// -1
Math.trunc(NaN)
// NaN
Math.trunc("foo")
// NaN
Math.trunc()
// NaN
13.Math.radians 计算弧度用不到把 = =
17. 结构赋值
1.数组的解构赋值（位置要一样才能拿到，和顺序有关）
是为了更加方便地将数组中的某个值赋值给别的变量。
原始写法
const arr =[2,3,4]
const a1 =arr[0]
const a2 =arr[1]
const a3 =arr[2]
结构赋值
const arr =[2,3,4]
const [a1,a2,a3] =arr
console.log(a1,a2, a3)
// 2 3 4
特殊情况
let arr =[1,2,[3,4,[5,[6,7,[8]]]]]
// 取 2，6，8 这里不需要取的直接用，隔开即可
const [,a,[,,[,[b,,[c]]]]] =arr
console.log(a,b,c)
// 2 6 8
// 数组结构赋值的时候可以给默认值的
let arr1 =[]
const [d=2] =arr1
console.log(d)
//2
rest参数...
//rest参数,在解构赋值中，通常 有const [a,b,...rest],这里面...rest就是将之前取剩下的所有值拿出来给rest
let array1 =[1,2,3,4,5,6,7,8,9]
const [a,b,...all]=array1
console.log(a,b,all)
//1 2 [3,4,5,6,7,8,9]
2.对象的解构赋值（属性名一样才能拿到，和顺序无关）
解构赋值
let obj ={
name:'zsy',
sex:0,
address:'四川省'
}
const {name,sex,address} =obj
console.log(name,sex,address)
//zsy 0 四川省
复杂的解构赋值这里，p只是路径只是模式，而不是值
let obj ={
name:'zsy',
p:{
0:{
sex:0
},
1:{
type:"null"
}
}
}
const {name,p:{0:{sex},1:{type}}} =obj
console.log(name,sex,type)
//zsy 0 null
重命名 有多个相同的名字的时候
let obj ={
name:'zsy',
p:{
0:{
name:"zsy0"
},
1:{
name:"zsy1"
}
}
}
const {p:{0:{name:name1},1:{name:name2}}} =obj
console.log(name1,name2)
//zsy0 zsy1
默认值 也可以给默认值 ...rest和上面数组一样
let obj ={
name:'zsy',
sex:0,
address:'四川省'
}
const {name,sex=2,address} =obj
console.log(name,sex,address)
//zsy 0 四川省
3.函数解构赋值
形参
let obj={
name:"askdjaksd",
time:'2022-7-20',
type:2
}
function demo({name:a,time:b}){
console.log(a,b)
}
demo({
name:"askdjaksd",
time:'2022-7-20',
type:2
})
//askdjaksd 2022-7-20
let arr=[1,2,3,4]
function demo([a,b,,]){
console.log(a,b)
}
demo(arr)
//1 2
实参
let obj={
name:"askdjaksd",
time:'2022-7-20',
type:2
}
function demo(a,b){
console.log(a,b)
}
const {name,type}=obj
demo(name, type)
//askdjaksd 2
18.字符串方法
1.includes 返回布尔值，查看是否含有（区分大小写）
const str ='The wind is so noisy today'
console.log(str.includes('i'))
//true
2.startsWith 返回布尔值，查看开头是否含有目标字符串（区分大小写）
const str ='The wind is so noisy today'
console.log(str.startsWith("t"))
//false
3.endsWith 返回布尔值，查看结尾是否含有目标字符串（区分大小写）
const str ='The wind is so noisy today'
console.log(str.endsWith("y"))
//true
4.repeat 将原本的字符串重复的次数，小数会直接向下取整
const str ='The wind is so noisy today'
console.log(str.repeat(2))
//The wind is so noisy todayThe wind is so noisy today
5.padEnd 补全方法，第一个是字符串的个数，后面是不全的字符串，end在末尾补全
const str ='The'
console.log(str.padEnd(5,'123'))
//The12
6.padEnd 补全方法，第一个是字符串的个数，后面是不全的字符串，start在之前补全
const str ='The'
console.log(str.padStart(5,'123'))
//12The
7.trim 删除空格
const str =' The '
console.log(str.trim())
//The
- trimStart 删除前面的空格
- trimEnd 删除后面的空格
19.扩展运算符
扩展运算符...出现在等号的右边，...rest参数出现在等号左边
语法：...array
作用：能把数组中的元素释放出来
tips：如果又相同的值，前面展开的会覆盖后面展开的。
//能把数组中的元素释放出来
const arr = [2,5,8,4,6,9,3]
console.log(...arr)
//2 5 8 4 6 9 3
用来合并数组和对象
数组：
const arr =[1,2,3]
const arr1 =[4,5]
const arr3 =[...arr,...arr1]
console.log(arr3)
// (5) [1, 2, 3, 4, 5]
对象：
const obj={
a:1,
b:2,
c:3
}
const obj1 ={
d:4
}
let object2 ={...obj,...obj1}
console.log(object2)
//{a: 1, b: 2, c: 3, d: 4}
替代apply方法
const arr =[1,2,3,4,5]
function demo(a,b,c,d,f){
console.log(a,b,c,d,f)
}
demo.apply(null,arr)
//1 2 3 4 5
//现在
demo(...arr)
浅拷贝数组
- 浅拷贝：只是复制了一个指向堆内存中值的指针，堆内存并没有独立，所以会相互影响；
- 深拷贝：增加了一个指针并且申请了一个新的内存，使这个增加的指针指向这个新的内存，完全独立，两者互不影响；
但是，我写的我数组是深拷贝的，对象是改变了的，所以说不能直接定义为深拷贝或者浅拷贝。
如果只是一层数组或是对象，其元素只是简单类型的元素，那么属于深拷贝，如果数组或对象中的元素是引用类型的元素，那么就是浅拷贝。
还有一种拷贝，当对象中包含复杂数据类型时，只能深拷贝一级的简单数据类型，而一级以上的数据都是浅拷贝。比如以ES6的展开运算符为例，到底算深拷贝还是浅拷贝
let arr =[1,2,3]
let arr1 =[...arr]
arr[1] =8
console.log(arr)
console.log(arr1)
//(3) [1, 8, 3]
//(3) [1, 2, 3]
let obj =[{name:'zsy',gender:1}]
let obj1 =[...obj]
obj[0].name ='思莹欧巴'
console.log(obj)
console.log(obj1)
// {name: '思莹欧巴', gender: 1}
// {name: '思莹欧巴', gender: 1}
比如arguments ，在传参进来的时候不写参数，就拿到一个类数组。
let arr ={
0:'aasdk',
1:'asd',
2:'asd',
length:3
}
let array1 =Array.from(arr)
console.log(array1)
//(3) ['aasdk', 'asd', 'asd']
应用 比如arguments ，在传参进来的时候不写参数，就拿到一个类数组。
此时Map Set Denerator等函数也可以使用这种方法来做
function demo(){
console.log(arguments)
//Arguments(6) [1, 2, 3, 4, 5, 6, callee: (...), Symbol(Symbol.iterator): ƒ]
console.log([...arguments])
//(6) [1, 2, 3, 4, 5, 6]
}
demo(1,2,3,4,5,6)
new array
let arr =new Array(3)
//生成了一个数组，里面3个空元素
let arr1 =new Array(3,4)
//一个参数是元素格式，大于一个就是参数项
//[3 ,4]
Array of
Array.of()是为了弥补new Array 的缺点
let arr2 = Array.of(3,4)
//[3 ,4]
这个就是数组里面的项，不会产生参数的问题
20.fill 填充数组的
比如需求要求打星，评分，这个时候就可以用到这个
//打几分就是几，不用自己去创造
let array1 = new Array(5).fill(3)
//[3,3,3,3,3]
21.indexOf（判断数组是否有某个值，有就删除，没有就增加）
if(this.treeList.indexOf(data.power)>-1){
this.treeList.splice(this.treeList.indexOf(data.power),1)
}else{
this.treeList.push(data.power)
}
console.log(this.treeList)
也可以写成三元去判断。
