JS数据方法，掌握知识点！

数据的操作功能

数组的操作
push/pop/unshift/shift
slice/splice
reverse/sort
join
reverse
执行数组操作后原数组不变的数组操作有：
第一：slice;
第二：join;
第三：concat;
第四：toString；
第五：substring;
第六：substr;
slice和substring都是从第一个参数开始截取到第二个参数结束；但是；
substring可以自动更换位置；当第一个参数大于第二个参数时；可以正常更换位置后继续执行；但是对于slice就会出现错误；
其他的数组在操作完后其数组都发生变化；
其中concat和push的作用都一样但是push的原数组发生改变；
他们的作用是给原数组的尾部添加数组值；
unshift的作用是给原数组的头部添加数组值；
pop的作用是删除原数组的尾部；
shift的作用是删除原数组 的头部；
slice的作用是截取数组里面的数；（其一般取一个参数或者两个参数；）
splice的作用是截取数组里面的数：
当其参数为无时；输出空数组；
当其参数为一个时，就是从代表这个参数的下标的值前截取；直到最后；
当其参数为两个时，从第一个参数代表的下标开始截取；后面的参数代表，截取的个数；
当其参数为三个时，和两个时一样但是多了一部，其第三个参数，代表插入的那个数，从哪里截取；从哪里插入；
reverse代表翻转原数组；
tostring的作用：
调用数组每一项的 toString()方法，返回以逗号分隔的字符串；
let arr = [‘a’,‘b’,‘c’,‘d’]
let arr1 = arr.toString();
console.log(arr) // [“a”, “b”, “c”, “d”]
console.log(arr1) // a,b,c,d

sort代表给原数组排序；
var arr=[1,11,10,2,3,4,5,6,8,12]
arr.sort(function(a,b){
return a-b;//排序从小到大;结果为【1,2,3,6,8,10,11,12】
return b-a;//排序从大到小；结果和第一个相反；
})
arr.sort();如果仅仅如左边的样式那么,将会按照第一个字符的大小进行排序;
不会按照数值的大小;此时输出的结果为[1,10,11,12,2,3,6,8]

//join() 以参数来拼接
			//var arr = ["a","b","c"];
			//var a = arr.join("----");结果为a----b----c;
			//var a = arr.join(" ");
			//var a = arr.join("");

indexOf() 和 lastIndexOf()
作用：返回对应项的索引
参数：一个参数或两个参数
返回值：
原数组是否改变：无

let arr = [1,3,5,7,7,5,3,1];
console.log(arr.indexOf(5)); //2
console.log(arr.lastIndexOf(5)); //5
console.log(arr.indexOf(5,2)); //2
console.log(arr.lastIndexOf(5,4)); //2
console.log(arr.indexOf("5")); //-1
console.log(arr) // [1,3,5,7,7,5,3,1]

forEach()
作用：对数组中的每一项运行给定的函数。
参数：参数是function函数。函数的参数分别为：值，索引，数组本身
返回值：无 (因此在callback里面加不加return，效果都是一样的)
原数组是否改变：这个不确定。跟运行的回调函数有关

   let arr = [1,2,3,4,5];
    let arr1 = arr.forEach(function(item,index,array){
        array[index] = item * 10
    })
    console.log(arr) //  [10,20,30,40,50]
    console.log(arr1) // undefined

map()
作用：map就是‘映射’。对数组中的每一项运行给定函数
参数：参数是function函数。函数参数分别是：值，索引，数组本身。
返回值：调用函数之后的结果组成的数组
原数组是否改变：否

et arr = [1,2,3,4,5];
let arr1 = arr.map(function(item,index,array) {
   return item = item * 10
})
console.log(arr) // [1, 2, 3, 4, 5]
console.log(arr1) // [10,20,30,40,50]

filter()
作用：‘过滤’。对数组中每一项运行给定的函数。
参数：参数是function函数。函数有三个参数：值，索引，数组本身
返回值：调用函数之后的结果组成的数组。
原数组是否改变：不确定。因为跟运行的函数有关。

let arr = [1,2,3,4,5];
let arr1 = arr.filter(function(item,index) {
   return item > 3
})
console.log(arr) // [1, 2, 3, 4, 5]
console.log(arr1) // [ 4, 5]

every()
作用：判断数组中的每一项是否满足条件。
参数：参数是函数function。函数有三个参数：值，索引，数组本身
返回值：数组中的所有项满足条件，才返回 true
原数组是否改变：涉及运行的函数，因此不确定

let arr = [1,2,3,4,5];
let arr1 = arr.every(function(item,index) {
   return item < 10
})
console.log(arr) // [1, 2, 3, 4, 5]
console.log(arr1) // tru

some()
作用：判断数组中的是否有满足条件的一项。
参数：参数是函数function。函数有三个参数：值，索引，数组本身
返回值：数组中的有一项满足条件，才返回 true
原数组是否改变：涉及运行的函数，因此不确定

let arr = [1,2,3,4,5];
let arr1 = arr.some(function(item,index) {
   return item < 2
})
console.log(arr) // [1, 2, 3, 4, 5]
console.log(arr1) // true

reduce() 和 reduceRight()
作用：迭代数组的所有项，然后构建一个最终返回的值。
参数：callback[, initialValue]
返回值：数组迭代之后，整体的迭代结果。
原数组是否改变：涉及运行的函数，因此不确定
reduce()方法从数组的第一项开始，逐个遍历到最后。而 reduceRight()则从数组的最后一项开始，向前遍历到第一项。
参数说明：
callback迭代函数，有四个参数（prev, cur, index, array）
prev 前一个值，（initialValue || 数组第一项 || 上一次迭代的结果）
cur 当前迭代项
index 当前迭代项索引
array 迭代的原数组
initialValue 迭代的基础值，不传基础值是数组第一项
// 数组求和

let arr = [1, 2, 3];
let sum = arr.reduce((prev, cur, index, array) => {
    return prev + cur;
});
console.log(arr, sum); // [ 1, 2, 3 ] 6
// 传initialValue 基础值的示例
let sum1 = arr.reduce((prev, cur, index, array) => {
    return prev + cur;
}, 10);
// 返回的值是：10+1+2+3
console.log(arr, sum1); // [ 1, 2, 3 ] 16

findIndex()
作用：查找数组中第一个符合条件的元素的索引。并返回索引。
参数：参数是函数function。函数的三个参数是：值，索引，数组本身。
返回值：符合条件的第一个元素的索引
原数组是否改变：涉及到函数，不确定。

let arr = [1, 2, 3, 4, 5];
let arr1 = arr.findIndex((item, index, array) => {
    return item > 2;
})
console.log(arr); // [1, 2, 3, 4, 5] 
console.log(arr1) // 2

find()
作用：查找数组中第一个符合条件的元素，返回该元素
参数：参数是函数function。函数的三个参数是：值，索引，数组本身。
返回值：符合条件的第一个元素
原数组是否改变：涉及到函数，不确定。

let arr = [1, 2, 3, 4, 5];
let arr1 = arr.find((item, index, array) => {
    return item > 2;
})
console.log(arr); // [1, 2, 3, 4, 5] 
console.log(arr1) // 3