数组的方法（es5-，es5）

保存对代码的热爱，并保存怀疑态度

es5-

方法名 对应版本 功能 原数组是否改变 返回值
concat(连接的数组) ES5- 合并数组，并返回合并之后的数据 n
join(“-”) ES5- 使用分隔符，将数组转为字符串并返回 n
pop(无参数) ES5- 删除最后一位，并返回删除的数据 y
shift(无参数) ES5- 删除第一位，并返回删除的数据 y
unshift() ES5- 在第一位新增一或多个数据，返回长度 y
push() ES5- 在最后一位新增一或多个数据，返回长度 y
reverse() ES5- 反转数组，返回结果 y
slice() ES5- 截取指定位置的数组，并返回 n 开始索引，结束索引
sort() ES5- 排序（字符规则），返回结果 y
splice() ES5- 删除指定位置，并替换，返回删除的数据 y
toString() ES5- 直接转为字符串，并返回 n
valueOf() ES5- 返回数组对象的原始值 n

es5

参数：
函数 - 这个函数会被多次执行
这个函数自身有三个形参
形参1：数组中的数据 ，单个拿出，依次显示
形参2：数据对应的索引
形参3：数组自身
全都不更改原数组
filter(function(val, idx, self){ 开始的格式}) 三个参数写完整，比如取最后一个，前面两个必须写！
除了indexof

方法名 对应版本 功能 原数组是否改变 返回值
indexOf() ES5 根据数据查索引 不改变 查到就返回索引，没有就算是-1；
和字符的indexOf功能一致，但不是同一个方法
forEach() ES5 遍历 不改变 没有返回值
filter() ES5 遍历并过滤，用return来写条件 不改变 新数组，用来保存回调函数中返回值为true时遍历到的数据
map() ES5 遍历 并 操作（修改） 不改变 长度和原数组相同的新数组，用来保存回调函数的返回值 ，也就是retrun执行完后的值
some() ES5 遍历 并 查找 不改变 或来理解 这个函数需要有返回值，是布尔值// true：会停止遍历 false：继续遍历，返回值：布尔值。只要回调函数有一次true，就是true，回调函数全部为false，才是false
every() ES5 在最后一位新增一或多个数据，返回长度 不改变 &&来理解 返回值：布尔值。只要回调函数有一次false，就是false，回调函数全部为true，才是true
reduce（）ES5 遍历 并 归并 不改变 返回值：最后一次回调函数的返回值
具体理解参照下面的详解

ES5详解-
数组方法
方法要关注的内容有：功能，参数，返回值，是否改变原数据

// arr.push()
// 功能：末尾新增
// 参数：要新增的数据
// 返回值：新增之后的数组的长度
// 是否改变原数组：是
// var res = arr.push("hello","world");
// console.log(res);


// arr.pop()
// 参数：无
功能：末尾删去，一个pop表示一个索引删去
参数：无
返回值：删除的值
是否改变原数组：是
// var res = arr.pop();
// var res = arr.pop();
// var res = arr.pop();
// var res = arr.pop();
// console.log(res)

  arr.shift()
功能 数组最前面（也就是从前往后删除）删去，一个shift表示一个索引删去
参数：无
返回值：删除的值
是否改变原数组：是
    // arr.shift(3);
// var res = arr.shift();
// var res = arr.shift();
// var res = arr.shift();
// console.log(res);

  arr.unshift();
// arr.unshift();
// var res = arr.unshift("hello","world");
// console.log(arr)
// console.log(res);

功能 数组最前面（也就是从前往后新增，一个shift表示一个索引；
参数：新增的值
返回值：新增后的数组的长度
是否改变原数组：是


// arr.splice();
// 功能：删除并替换
// 参数：
     第一个参数：要删除数据的起点索引，必传
    第二个参数：删除的数据的个数，可选
     第三个参数：在删除的位置插入数据，可选
     ...：删除的位置要插入数据，可选
   返回值:删除的个数，没有删除返回空数组；
       是否改变原数组：是

    // arr.splice();
    // var xc= arr.splice(3,3,"新来的");
    // console.log(arr);
    // console.log(xc);


    // 灵活运用,表示从第三个开始新增，删除0个
    // var vc=arr.splice(3,0,"sdfdhufshushf");
    // console.log(arr);
    // console.log(vc)

arr.sort（function（）{
return a-b;
}）

var arr2 = [23,65,13,146,9,78];
console.log(arr2)
// 功能：排序，默认排序规则：字符的排序规则，逐位比较
// 参数：
    // 函数
        // 这个函数又接收了两个参数
        // 这个函数需要有返回值
            // 返回值是两个参数之差

方法的返回值：排序后的数组；
是否改变原数组：是

var xc=arr.sort(function(a,b){
    return a-b;
});
console.log(xc);
console.log(arr)

.reverse()
功能：颠倒数组中元素的顺序；
参数：无；
方法的返回值：颠倒后的数组；
是否改变原数组：是

toString()

功能：转换成字符串，类似于没有参数的join()。
该方法会在数据发生隐式类型转换时被自动调用，如果手动调用，就是直接转为字符串。；
参数：无；
方法的返回值：转换后数组；
是否改变原数组：否

valueOf()
功能：返回数组的原始值（一般情况下其实就是数组自身
一般由js在后台调用，并不显式的出现在代码中；
参数：无；
方法的返回值：本身；
是否改变原数组：否

// arr.slice();
// 功能：截取指定位置的数据
// 参数：
//     参数1：起点
//     参数2：终点（不包括）
// 返回值：截取出的新数组
// 是否改变原数组：否
var res = arr.slice(2,5);
console.log(res);

arr.concat()
功能：连接两个数组；
参数：要连接的数组名；
方法的返回值：连接后 的数组；
是否改变原数组：否

 var xc=arr.concat(arr1);
console.log(xc);
console.log(arr);

arr.join()
功能：根据指定分隔符将数组中的所有元素放入一个字符串，并返回这个字符串。
参数：join(str);参数可选，默认为","号，以传入的字符作为分隔符。；
方法的返回值：改变后的数组（是字符串类型）；
是否改变原数组：否

var arr = [1,2,3];
console.log(arr.join());         //1,2,3
console.log(arr.join("lo"));      //1-2-3
console.log(arr);                //[1,2,3]---原数组未改变

es5详解
arr.forEach(function(vel,ind,self){ })
// 功能：遍历
// 参数：
// 函数 - 这个函数会被多次执行
// 这个函数自身有三个形参
// 形参1：数组中的数据 ，单个拿出，依次显示
// 形参2：数据对应的索引
// 形参3：数组自身
// 返回值：没有返回值
// 是否改变原数据：否

arr.filter(function(val, idx, self){
console.log(idx, self)
// return val%2===0; 可以加返回的条件，整个filter的返回值就是判断后的新值；
})
// 功能：遍历 并 过滤
// 参数：
// 函数 - 这个函数会被多次执行
// 这个函数自身有三个形参
// 形参1：数组中的数据
// 形参2：数据对应的索引
// 形参3：数组自身
// 这个函数需要有返回值，是布尔值
// true：会将当前这次遍历到的数据，放在filter的返回的数组内
// false：会略过这次遍历到的数据
// 返回值：新数组，用来保存回调函数中返回值为true时遍历到的数据
// 是否改变原数据：否

arr.map(function(val, idx, self){
console.log(val, idx, self);
return self;
})
// 功能：遍历 并 操作（修改）
// 参数：
// 函数 - 这个函数会被多次执行
// 这个函数自身有三个形参
// 形参1：数组中的数据
// 形参2：数据对应的索引
// 形参3：数组自身
// 这个函数需要有返回值，是操作之后的数据
// 操作之后的数据，或全部保存到map的返回值
// 返回值：长度和原数组相同的新数组，用来保存回调函数的返回值 ，也就是retrun执行完后的值
// 是否改变原数据：否

var res = arr.map(function(val, idx, self){
    console.log(val, idx, self);
    return self;
})
console.log(res);


// 功能：遍历 并 查找
// 参数：
    // 函数 - 这个函数会被多次执行
        // 这个函数自身有三个形参
            // 形参1：数组中的数据
            // 形参2：数据对应的索引
            // 形参3：数组自身
        // 这个函数需要有返回值，是布尔值
            // true：会停止遍历
            // false：继续遍历
// 返回值：布尔值。只要回调函数有一次true，就是true，回调函数全部为false，才是false
// 是否改变原数据：否
// var res = arr.some(function(a,b,c){
//     console.log(a,b,c);
//     return a === 9;
// })
// console.log(res);


// 功能：遍历 并 查找
// 参数：
    // 函数 - 这个函数会被多次执行
        // 这个函数自身有三个形参
            // 形参1：数组中的数据
            // 形参2：数据对应的索引
            // 形参3：数组自身
        // 这个函数需要有返回值，是布尔值
            // true：继续遍历
            // false：停止遍历
// 返回值：布尔值。只要回调函数有一次false，就是false，回调函数全部为true，才是true
// 是否改变原数据：否
// var res = arr.every(function(a,b,c){
//     console.log(a,b,c);
//     return a<9;
// })
// console.log(res);


// =========以下了解即可=========
// 功能：遍历 并 归并
// 参数：
    // 参数1：函数 - 这个函数会被多次执行
        // 这个函数自身有三个形参
            // 形参1：如果reduce有参数2，那么是reduce这个参数2；如果reduce没有参数2，那么是数组的第一个数据
            // 形参2：数组中的数据（如果reduce没有参数2，那么从数组的第二个数据开始）
            // 形参3：数据对应的索引
            // 形参4：数组自身
        // 这个函数需要有返回值，是一个数据
            // 是下一次的形参1的数据
    // 参数2：数据，可选
// 返回值：最后一次回调函数的返回值
// 是否改变原数据：否
// arr.reduce(function(a,b,c,d){
//     console.log(a,b,c,d)
//     return "world";
// }, "hello")
// var res = arr.reduce(function(a,b,c,d){
//     return a+b;
// }, 0)
// console.log(res);



// 反向归并（从右向左）
// arr.reduceRight()