ES6的方法&类数组转成真正的数组&判断数组的方法

forEach--循环数组:

   forEach循环的回调函数中， 不可以return一个值，但是可以终止方法的执行

   forEach循环，循环结束没有返回值，返回值是undifind，可以改变原来的数组

<script>
        let arr = [{
            name: "张三",
            age: 20
        },
        {
            name: "李四",
            age: 50
        },
        {
            name: "王五",
            age: 10
        }]
        // forEach循环的回调函数中， 不可以return一个值，但是可以终止方法的执行
        // forEach循环，循环结束没有返回值，返回值是undifind.可以改变原来的数组
        arr.forEach(function (item, index) {
            console.log(item.name + "--" + index);
        })
    </script>

map --循环数组：l例如只会返回[20,50,10]

   <script>
        let arr = [{
            name: "张三",
            age: 20
        },
        {
            name: "李四",
            age: 50
        },
        {
            name: "王五",
            age: 10
        }]

 // map根据回调函数返回一个新数组
        let narr = arr.map(function (item, index) {
            return item.name //返回：张三 李四 王五
        })
        console.log(narr);

        // 下面等于上面的map遍历
        let arr2 = []
        arr.forEach(function (item) {
            arr2.push(item.name)
        })
        console.log(arr2);
    </script>

filter  --过滤筛选：

作用：通过return中的判断条件，返回一个判断为true的组成一个新数组返回出去

 <script>
        let arr = [{
            name: "张三",
            age: 30
        },
        {
            name: "李四",
            age: 40
        },
        {
            name: "王五",
            age: 50
        }]
        // 筛选1
        let arr2 = arr.filter(function (item, index) {
            return item.age > 30
        })
        // 筛选2
        let arr3 = []
        arr.forEach(function (item, index) {
            if (item.age > 30) {
                arr3.push(item)
            }
        })
        console.log(arr3);
    </script>

find  --查找返回的是新的对象：

作用：循环数组，通过return判断，返回一个新的对象

    <script>
        let arr = [{
            name: "张三",
            age: 30
        },
        {
            name: "李四",
            age: 40
        },
        {
            name: "王五",
            age: 50
        }]
        // find查找返回对象
        let arr3 = arr.find(function (v, i) {
            return v.name == "张三"
        })
        // 第二种返回对象的方法
        function findFn() {
            var obj = {};
            arr.forEach(function (item) {
                if (item.name == "张三") {
                    //   浅拷贝
                    obj = item
                }
            })
            return obj;
        }
        let obj2 = findFn()
        console.log(obj2);
    </script>

every  --循环：

作用：循环数组，通过return来判断条件，如果数组的每一项条件都满足，则返回true，否则false

    <script>
        let arr = [{
            name: "张三",
            age: 30
        },
        {
            name: "李四",
            age: 40
        },
        {
            name: "王五",
            age: 50
        }]
        let flag = arr.every(function (item, index) {
            return item.age > 20
        })
        console.log(flag);
    </script>

其他循环判断方法：

  let arr = [{
            name: "张三",
            age: 30
        },
        {
            name: "李四",
            age: 40
        },
        {
            name: "王五",
            age: 50
        }]

        Array.prototype.everyFn = function () {
            for (var i in this) {
                if (this[i].age <= 30) {
                    return false
                }
            }
            return true
        }
        var flag = arr.everyFn()
        console.log(flag);

some --循环：

作用：循环数组，通过return来判断条件，如果数组有一些满足，则返回true，否则false

    let arr1 = [{
            name: "张三",
            age: 30
        },
        {
            name: "李四",
            age: 40
        },
        {
            name: "王五",
            age: 50
        }]
        // some 返回的是布尔值
        let aa = arr1.some(function (item, index) {
            return item.age > 40
        })
        console.log(aa);

reduce--高阶函数：

作用：实现数组的累加、乘、求和等

(for in 循环会把其他的自带属性全部打印出来)

  let arr = [2, 3, 4, 5, 6];
        let s = arr.reduce(function (sum, num) {
            console.log(sum, num);
            // sum:每次循环累加后的值
            // num:表示数组中sum后面的值
            return sum + num
        })
        console.log(s);
        var sum = 0
        for (var i in arr) {
            sum += arr[i]
        }
        console.log(sum);

findindex --循环数组，返回数组中最近的索引，不会改变原数组（不太经常用到），一个也不满足返回-1：

  let arr = [{
            name: "张三",
            age: 30
        },
        {
            name: "李四",
            age: 40
        },
        {
            name: "王五",
            age: 50
        }]
        // 第一种寻找下标
        let s = arr.findIndex(function (item, index) {
            return item.age > 40
        })
        console.log(s);
        // 第二种寻找下标
        Array.prototype.findIndex = function () {
            for (var i = 0; i < arr.length; i++) {
                if (this[i].age > 40) {
                    return i
                }
            }
            return -1
        }

toString-- 转化为字符串：

作用：数字、数组、字符串都有toString方法

 var num = [1, 2, 3]
        var n = num.toString()  //(数组是去除左右的中括号，再转成字符串)
        console.log(n);

        var num2 = 2
        var n2 = num2.toString()
        console.log(n2);

---

类数组转成真正的数组

有哪些类数组$转为数组的方法：

arguments

 <script>
        function fn() {
            // 类数组用不了数组的方法，所以要转成真正的数组
            console.log(arguments);//1,2,3,4
            // 1、⭐es6之前转数组的方法
            let arr = Array.prototype.slice.call(arguments)
            console.log(arr);

            // 2、 ES6 类数组转数组方法
            let arr2 = Array.from(arguments)
            console.log(arr2);


            // 3、利用拓展运算符实现转数组
            let arr3 = [...arguments]
            console.log(arr3);

            // 如何判断一个数组是真正的数组
            // Array.isArray()方法返回一个true表示是真正的数组，反之不是
            console.log(Array.isArray(arr2));
        }
        fn(1, 2, 3, 4)

    </script>

如何判断一个数组是真正的数组:

  <script>
        function fn() {
            // 3、利用拓展运算符实现转数组
            let arr3 = [...arguments]
            console.log(arr3);

            // 如何判断一个数组是真正的数组
            // ES6之前判断方法instanceof：
            console.log(arr3 instanceof Array);
            // ES6之前判断方法instanceof：
            console.log(Object.prototype.toString.call(arr3));
            // ES6中的另一个方法：返回一个true表示是真正的数组，反之不是
            console.log(Array.isArray(arr2));
        }
        fn(1, 2, 3, 4)

    </script>