关于for in 、for of 、 forEach、map

关于for in 、for of 、 forEach

for in是ES5标准，遍历key.
map|forEach是ES5标准，遍历value.
for of|forEach是ES6标准，遍历value.

1.关于forEach

用forEach遍历数组，不能用break跳出循环，也不可用return返回外层
如果要提前终止，必须把forEach()方法放在一个try块中，并能抛出一个异常，

    function foreach（a,f,t）{
        try { a.forEach（f,t）; }
        catch（e）{
            if（e === foreach.break）return;
            else throw e;
        }
    }
    foreach.break = new Error（"StopIteration"）;

2.关于for in

（1）索引为字符串
（2）无顺序（通常用于对象或json中）
（3）可扩展属性也会遍历
（4）数组是分散赋值的，输出情况有误
fon in循环只遍历可枚举对象，比如array、object，Number等js中基本数据类型是不可枚举的，
它们是使用内置构造函数所创建的对象都会继承自 Object.prototype 和 String.prototype 的不可枚举属性，例如 String 的 indexOf() 方法或者 Object 的 toString 方法。循环将迭代对象的所有可枚举属性和从它的构造函数的 prototype 继承而来的（包括被覆盖的内建属性）

可以注意到for-in循环能够枚举继承的属性名，所以在数组上不建议使用for-in循环
例如：

    var arr = ["a","b","c"];
    arr.name = "hello";
    for(var v in arr){//这里的v代表的是key值，主要用于输出key值
        //console.log(typeof v);
        console.log(arr[v]);
        console.log(v)
    }
    这里会将arr的扩展name属性也被遍历出来了属性

可以使用 hasOwnProperty方法来过滤。所有继承了 Object 的对象都会继承到 hasOwnProperty 方法。这个方法可以用来检测一个对象是否含有特定的自身属性；和 in 运算符不同，该方法会忽略掉那些从原型链上继承到的属性。

    for（var i in a）{
         if(!   a.hasOwnProperty(i)) continue;//跳过继承的属性
         //循环体
    }

不建议用for-in循环遍历数组还有以下几点原因：

代码中的index不是数字，是字符串“0”、“1”、“2”，可能无意间进行字符串的计算“2”+1=“21”等。
代码可能按照随机顺序遍历数组元素。

for-in是为了对象设计的，可以遍历字符串型的键。

数组是分散赋值的，输出情况有误

    var a = []; 
    a[2] = 2;  
    for (var i = 0; i < a.length; i++) {
        console.log(i,a[i])
    } 
    // 0 undefined
    // 1 undefined
    // 2 2
    上述为正常打印
    for (var x in a){ 
        console.log(x,a[x])
    }
    // 2 2
    若用for in 则会将数组的第一第二值打印遗漏

    ps：属性的枚举性还会影响以下两个函数的结果:  Object.keys() ;  JSON.stringify();  它们只能返回对象本身具有的可枚举属性 

3.for-of循环

（1）目前遍历 数组 最便利的方法
（2）避免了for-in，forEach的所有缺陷
（3）可以用在 类数组（如DOM的NodeList对象），字符串，set和map数据 上
（4）不支持对象的遍历（但是它提供了其他的三种方法）
①Object.keys()
②Object.values()
③Object.entries()

    for(var value of myArray){
         console.log(value);
    }

for-of不支持普通对象，如果你想迭代一个对象属性，可以用for-in循环或内建Object.keys()方法：

    for(var key of object.keys(someObject)){
        console.log(key+":"+someObject[key]); // 把这个对象的属性给遍历出来
    }
    
    for(var i of Object.values(obj)){
        console.log(i); // 把这个对象的属性值给遍历出来
    }
    
    for(var i of Object.entries(obj)){
        console.log(i); // 对象的属性和属性值都被遍历了出来,i为当前属性和属性值的数组
    }

for-in循环用来遍历对象属性，for-of循环用来遍历数据--如数组中的值

    //使用异常的方式来跳出forEach循环
    function skipOutForeach() {

        //1.测试 return,return false是否能跳出循环
        var arr = [];
        arr = getArr(1, 30);
        console.log(arr);
        arr.forEach(function (el, index) {
            if (el == 20) {
                console.log("遇到20,能退出吗?");//并不能
                return;//return false;
            } else {
                console.log(el);
            }
        });

        //2.使用异常的方式来跳出forEach循环---------------------------
        console.log("-------------------------------")
        var myerror = null;
        try {
            arr.forEach(function (el, index) {
                if (el == 20) {
                    console.log("try中遇到20,能退出吗?");//
                    foreach.break = new Error("StopIteration");
                } else {
                    console.log(el);
                }
            });
        } catch (e) {
            console.log(e.message);
            if (e.message === "foreach is not defined") {
                console.log("跳出来了?");//
                return;
            } else throw e;
        }//可以跳出来,那么 我们可以重写foreach方法
        //-----------------------------
        console.log("aaa");

    }

    skipOutForeach();

    //自定义foreach方法(往Array或String的prototype添加也可以)
    function fore7(arr, func) {
        console.log(arr);
        for (var i = 0; i < arr.length; i++) {
            var ret = func.call(this, arr[i], i);//回调函数
            if (typeof ret !== "undefined" && (ret == null || ret == false)
            break;
        }

    }

    //自定义foreach,的用法
    fore7(getArr(1, 30), function (a, i) {
        // console.log(i + ':' + a);
        if (i == 20) return false;//跳出循环
    })

    //返回min,max之间的数组成的数组,无序
    function getArr(min, max) {
        if (typeof min !== 'number' || typeof max !== 'number') return [];
        var arr = [];
        for (var i = min; i <= max; i++) {
            if (arr.length < 1) {
                arr.push(i);
            } else {
                var len = arr.length;
                var rIndex = Math.round(Math.random() * (len - 1));
                var temp = arr[rIndex];
                arr[rIndex] = i;
                arr.push(temp);
            }
        }
        return arr;
    }

map()

map创建一个新的数组，其中每一个元素由调用数组中的每一个元素执行提供的函数得来,会得到一个新的数组并返回。

    let doubled = arr.map(num => {
     return num * 2;
    });
    
    // doubled = [2, 4, 6, 8, 10]

forEach()会改变原始的数组的值，而map()会返回一个全新的数组，原本的数组不受到影响。

forEach适合于你并不打算改变数据的时候，而只是想用数据做一些事情 – 比如存入数据库或则打印出来。

    let arr = ['a', 'b', 'c', 'd'];
    arr.forEach((letter) => {
     console.log(letter);
    });
    // a
    // b
    // c
    // d

map()适用于你要改变数据值的时候。不仅仅在于它更快，而且返回一个新的数组。这样的优点在于你可以使用复合(composition)(map(), filter(), reduce()等组合使用)来玩出更多的花样。

    let arr = [1, 2, 3, 4, 5];
    let arr2 = arr.map(num => num * 2).filter(num => num > 5);
    // arr2 = [6, 8, 10]

可以用forEach()做到的，map()同样可以。反过来也是这样。

map()会分配内存空间存储新数组并返回，forEach()不会返回数据。

forEach()允许callback更改原始数组的元素。map()返回新的数组。