1：join()
主要用于将原数组内的所有元素连接在一起转化为字符串，并返回这个字符串
var arr=[1,2,3]
arr.join('-')
console.log(arr)
打印返回"1-2-3"2：sort()
将数组中的每个元素按一定条件排序后返回排序后的新数组，会改变原数组
var arr=[11,33,22]
arr.sort(function(a,b){ return a-b})
console.log(arr)
返回 [11，22，33 ]
arr.sort(function(a,b){ return b-a})
console.log(arr)
返回 [33,22,11]3：reverse()
将数组中的元素颠倒，并返回颠倒后的数组（会改变原数组）
var arr=[1,2,3]
arr.reverse()
console.log(arr)
返回[3,2,1]4：concat
将合并两个数组。并且返回一个新数组，不会改变原数组
var arr=[1,2,3]
var brr=[2,3]
var newarr=arr.concat(brr)
conso.log(newarr)
返回[1,2,3,2,3]5：slice()
返回指定的一个数组片段；有两个参数，第一个不能省略,第二个可以省略
第一个参数表示截取的起始位置，第二个参数表示数组片段的结束位置，
var arr = [1,2,3,4,5,6,7]
arr.slice(1,3) //返回 [2,3]
arr.slice(3) //返回 [4,5,6,7]
arr.slice(4,-1) //返回 [5,6]
arr.slice(-3) //返回 [5,6,7]
arr.slice(-3,-2) //返回 [5]6：splice()
在数组指定位置插入或删除元素，并返回删除元素组成的数组（会改变原数组）
- 第一个参数：删除或插入元素的起始位置；
- 第二个参数：从起始位置开始往后需要删除的元素个数。若该元素省略，则表示从起始位置开始到最后的所有元素都删除；
- 第三个参数及之后的所有参数：将该值作为数组的元素依次插入到第一个参数表示的位置上
var arr = [1,2,3,4,5,6,7]
arr.splice(4) //返回 [5,6,7],此时arr为[1,2,3,4]
arr.splice(1, 2) //返回 [2,3],此时arr为[1,4]
arr.splice(1, 0, 'new1', 'new2') //返回[],此时arr为[1,'new1','new2',4]7：push()
在数组尾部添加一个或多个元素，并返回数组的长度（会改变原数组）
var arr = []
arr.push(1) //返回 1, 此时arr为 [1]
arr.push(5) //返回 2, 此时arr为 [1,5]
arr.push(3,2) //返回 4, 此时arr为 [1,5,3,2]8：pop()
删除数组最后一个元素，并返回该元素（会改变原数组）
9：unshift()
在数组头部第一项添加一个或多个元素，并返回数组的长度（会改变原数组）
10：shift()
删除数组第一个元素，并返回该元素（会改变原数组）
11：toString()
将数组转化为字符串并用逗号分隔连接起来的字符串(不会改变原数组)
如果遇到数组嵌套数组的话，同样也会将该嵌套数组的每个元素转化为字符串并连接起来
[1,2,3].toString() //返回 '1,2,3'
['cherry','apple','bannana'].toString() //返回 'cherry,apple,banana'
[1,2,[6,7]].toString() //返回 '1,2,6,7'
[1,[3,6,[8,9]]].toString() //返回 '1,3,6,8,9'12：forEach()
循环遍历ES5新增 用来为每个元素调用指定的函数(可以修改原数组)
var a = [1,2,3,4,5]
a.forEach(function (value, index, arr) {
arr[index] = value + 2
})
console.log(a) // [3,4,5,6,7]13：map()
ES5新增 将调用的数组的而每个元素传递给指定的函数，吧每次调用的回调函数的返回值存入到一个新的数组，最后返回新的数组（不会改变原数组）
var arr = [1,2,3,4,5]
var new_arr = arr.map((value) => {
return value * value
})
console.log(new_arr) // [1, 4, 9, 16, 25]14：filter()
ES5新增的 过滤器，通过回调函数里的逻辑判断过滤掉不需要的元素，再将剩下的元素都放到一个新的数组中并返回（不会改变原数组）
- a: 元素
var arr = [6, 12, 7, 1, 9, 3, 0, 19]
var new_arr = arr.filter((value) => {
return value < 6
})
console.log(new_arr) // [1, 3, 0]- b: 索引位置
var arr = [6,12,7,1,9,3,0,19]
var new_arr = arr.filter(function (value, index) {
return index % 2 === 0
})
console.log(new_arr) // [6, 7, 9, 0]15：every()
针对一个数组的逻辑判定（不会改变元原数组）
返回值全部为true时，最后返回true，只要有一个不为true，就会返回false
var arr = [1,2,3,4,5,6,7,8]
var result = arr.every((value)=> {
return value < 10
})
console.log(result) // true16：some()
和上者方法类似 逻辑判断略有不同
只要有一个为true就会返回true，只有全部返回值为false。最后才返回false
var arr = [3, 8, 9, 45, 12]
var result = arr.some(function (value) {
return value === 12
})
console.log(result) // true, 表示该数组中有元素1217：reduce()
通过调用指定的回调函数及那个数组元素进行组合，并返回组合后的值(不会改变原数组)
参数（共2个）：
- 第一个参数：为回调函数，用于处理数组元素。该回调函数有两个参数x、y，这两个参数都为调用 数组的元素成员
- 第二个参数：为可选参数，作为传递给回调函数的初始值。若省略该参数，则将数组的第一个数作为初初始值
- 一个参数实例
var arr = [1,2,3,4,5,6]
var result = arr.reduce(function (x, y) {
return x * y
})
console.log(result) // 720- 两个参数实例
var arr = [10, 11, 13, 14, 12]
var result = arr.reduce(function (x, y) {
return x + y
}, 29) //这里将老师的年龄29作为reduce()方法的第二个参数
console.log(result) // 8918：reduceRight()
和上者方法类似，不同的是，后者在调用数组元素的时候是从左往右调用的，前者是从右往左调用
19：indexOf()
是获取某元素在数组中的索引，并且只返回第一个匹配到的元素的索引，若该元素不在数组中，则返回-1（不会改变原数组）
参数：第一个参数必填，为需要查询的元素，第二个参数为可选参数，标识从数组的那个位置开始搜索
- 一个参数实例
var arr = ['小红', '小明', '张三', '李四', '王五']
var index = arr.indexOf('张三') + 1
console.log(index) // 3, 表示张三成绩排名第三- 两个参数实例
var arr = ['张三', '小红', '小明', '张三', '李四', '王五']
//给indexOf() //方法的第二个参数赋值1，表示从数组的第二个元素开始找
var index = arr.indexOf('张三', 1) + 1
console.log(index) // 4, 表示成绩差点的张三排名第四- 第三个实例
var arr = ['小红', '小明', '张三', '李四', '王五']
var index = arr.indexOf('小王')
if(index === -1) {
console.log('false')
}
else {
console.log('true')
} // false20：lastIndexOf()
和indexOf()类似，唯一区别就是，前者是从数组的末尾开始搜索，后者是数从数组 二点开头开始搜索
ES6方法:
21：find()
ES6新增的遍历数组，找出并返回第一个符合回调函数的元素（可以通过回调函数的某些参数对原数组进行改动）
var arr = [1, 7, 3, 10, 12, 20]
var result = arr.find(function (value) {
return value > 10
})
console.log(result) // 12, 表示数组中找到的第一个比10大的元素为1222：findIndex()
ES6新增的遍历数组，找出第一个符合回调函数的元素的索引(不会改变原数组)
var result = [3, 4, 10, 8, 9, 0].findIndex(function (value) {
return value > 9
})
console.log(result) // 2，表示该数组中第一个大于9的元素索引为223：fill()
ES6新增的方法，用于填充数组的（会改变原数组）
参数（共3个）：
- 第一个参数：表示用于填充数组的值
- 第二个参数：可选参数，表示填充的起始位置
- 第三个参数：可选参数，表示填充的结束位置，若省略该参数并且填写了第二个参数，则表示从起始位置开始一直到末尾的所有元素都被填充
[1,2,3,4,5].fill(6) //返回 [6, 6, 6, 6, 6]
[1,2,3,4,5].fill(6, 2) //返回 [1, 2, 6, 6, 6]
[1,2,3,4,5].fill(6, 2, 3) //返回 [1, 2, 6, 4, 5]24：includes()
ES6新增的非常实用的方法，判断一个数是否在该数组中（不会改变原数组）
参数（共2个）：
- 第一个参数：该参数为需要判断是否存在于数组中的数
- 第二个参数：表示搜索的起始位置，默认为0，即从头开始搜索。若为负数，则表示从倒数第几个开始搜索，若输入的位置超出了数组长度，则默认还是为0
- 一个参数实例
var arr = ['chery', 'banana', 'apple', 'watermelon']
var result = arr.includes('banana')
console.log(result) //true, 表示banana在数组中- 两个参数实例
var arr = ['chery', 'banana', 'apple', 'watermelon']
var result = arr.includes('banana', -2) //表示从倒数第二个开始找
console.log(result) //false, 表示从倒数第二个开始找，没有找到banana
扫一扫
47
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
