数组内置函数

• arr.push(value): 向数组尾部添加一个或多个元素，会影响原数组，此函数返回数组的新长度
• unshift(value): 在数组最前面添加元素, 会影响原数组 并且返回值为新数组的长度

• arr.indexOf(value): 找某个元素首次在数组中出现位置，找到返回其下标，否则返回 -1

• lastIndexOf(value): 从后向前循环遍历数组如果找到元素会返回元素索引(下标) 如果没找到会返回 -1
• arr.includes(value):判断数组中是否存在某个元素，存在返回true，否则返回false

函数内部属性arguments

• arguments是函数内部的特殊属性。

• 作用：获取所有的实参。

           function val() {
                for (var i = 0; i < arguments.length; i++) {
                    console.log(arguments[i]); // 1, 5, 8, 3, 7
                }
                console.log(arguments.length); // 5
            }
            val(1, 5, 8, 3, 7)

注意点:

• arguments是一个伪数组（类数组对象）。
• 所谓伪数组就类似于真数组一样，可通过下标获取元素和通过length属性获取元素个数。也可for循环遍历元素，但是不能调用真数组的方法（如：push）。

• 案例：求任意个数数字的和

    function sum(){
        var sum = 0;
        for(var i = 0; i < arguments.length; i++ ){
            sum += arguments[i]
        }
        return sum;
    }
    console.log(  sum(10,20,30,40) ); // 100

获取函数的形参个数

获取函数定义的形参个数:函数名.length

function sum(num1,num2,num3){
    return num1 + num2 + num3;
}
console.log( sum.length ); // 3 

实现数组内置函数

• 实现indexOf方法

var arr = [1, 2, 2, 2, 3]
// 首次出现的位置
console.log(arr.indexOf(2)) // 1

// 封装内置函数indexOf,判断数组中是否存在某个元素，存在返回其在数组中的首次出现的下标，没找到返回 -1
function myIndexOf(arr, value) {
    for (var i = 0; i < arr.length; i++) {
        if (arr[i] === value) {
            return i
        }
    }
    return -1
}
console.log(myIndexOf([10, 14, 20, 14, 23], 14)) // 1
console.log(myIndexOf([10, 14, 20, 14, 23], 15)) // -1

• 实现indexOf方法

           function myLastIndexOf(arr, val) {
                for (var i = arr.length - 1; i >= 0; i--) {
                    // console.log(i, arr[i]);
                    if (arr[i] === val) {
                        return i
                    }
                }
                return -1
            }
            console.log(myLastIndexOf([5, 14, 18, 22, 18], 18));
            console.log(myLastIndexOf([5, 14, 18, 22, 18], 6));

• 实现includes方法

// 判断数组中是否存在某个元素 ，存在返回true,否则返回false
function myIncludes(arr, value) {
    for (var i = 0; i < arr.length; i++) {
        if (arr[i] === value) {
            // 说明找到了
            return true
        }
    }
    // 上面没有找到则直接返回false
    return false
}

• 实现push方法

前提：要求掌握基本和引用数据类型赋值的区别

            function myPush () {
                // console.log(arguments[0]);
                // 获取第一个实参，内存地址和外部的arr内存地址是一样的
                var originArr = arguments[0];
                 originArr.push(4, 8, 10)
                 console.log(originArr);
                 // 从arguments下标为1开始循环，获取值，往originArr里面放
                for (var i = 1; i < arguments.length; i++) {
                    originArr[originArr.length] = arguments[i]
                    // console.log(originArr);
                }
                return originArr.length
            }
            var arr = [2, 6, 7, 11,4]
            var res = myPush(arr,3, 5, 8, 9)
            console.log(arr, res);

• 封装函数-实现数组去重

var arr = [1, 3, 4, 6, 3, 8];
/* 方法一: 通过indexOf 来判断是否有值等于-1, 如果等于-1 说明是新元素 添加到新数组, 
                                如果不等于-1说明该元素已经添加过了 */
            function MyReduce(arr) {
                var newArr = [];
                for (var i = 0; i < arr.length; i++) {
                    // 通过indexof来判断新数组中是否有原数组的元素 如果等于 -1 说明没有 就将该元素添加到新数组中
                    if (newArr.indexOf(arr[i]) === -1) {
                        newArr.push(arr[i]);
                    }
                }
                return newArr;
            }
            console.log(MyReduce([1, 3, 5, 3, 6, 5]));

            //  方法二: 通过数组方法includes来判断原数组中是否有该元素
            function MyReduce2(arr) {
                var newArr = [];
                for (var i = 0; i < arr.length; i++) {
                  /* 通过includes来判断新数组中是否有原数组中的元素 如果有则是true 
                    如果没有就返回false 又因为if条件表达式为真值故需要取反来筛选数组 */
                    if (!newArr.includes(arr[i])) {
                        newArr.push(arr[i]);
                    }
                }
                return newArr;
            }
            console.log(MyReduce2([1, 1, 2, 2, 5, 3, 2, 6, 5]));