ES5新增的数组方法

1. map():

语法；

arr.map(function(item,i){

return item*3;

}

含义。遍历数组，item代表的是没一个元素，i代表下标

返回值；映射后的新数组

2. forEach()：

arr.forEach(function(item,i){

                //  没有return

             })

含义；遍历数组

返回值；无

3，filtre（）

语法:

                arr.filter(function(item,index){

                   return item>8

                })

含义；过滤满足条件的元素

返回值；数组形式大于满足条件的

4. some()

语法:

                 arr.some(function(item,index){

                     return item>8

                 })

 含义：数组中有一个满足条件的，返回的就是true， 都不满足才返回false

                返回值：true/false

 5. every()

 语法:

                 arr.every(function(item,index){

                     return item>8

                 })

 含义：数组中必须每一个都大于8，返回的是true，有一个不大于8的就是false

                返回值：true/false

 数组排序：冒泡排序和选择排序

 冒泡排序：

         排序思路：相邻两个元素进行比较，大的往后排

var arr = [12, 8, 5, 1];
    /* 
      冒泡排序：
         排序思路：相邻两个元素进行比较，大的往后排

        //  第一轮
         arr[0]和arr[1]     [8,12,5,1]
         arr[1]和arr[2]     [8,5,12,1]
         arr[2]和arr[3]     [8,5,1,12]

        //  比完一轮，最大的跑最后了

        // 第二轮： 
        arr[0] 和arr[1]     [5,8,1,12]
        arr[1]和arr[2]      [5,1,8,12]
        // 第二轮，最大的两个跑后面了

        // 第三轮
        arr[0]和arr[1]    [1,5,8,12]
    */

    // arr.length - 1: 元素是4个，但是比了3次
    // for (var i = 0; i < arr.length - 1 - 0; i++) {
    //     if (arr[i] > arr[i + 1]) {
    //         var temp = arr[i];
    //         arr[i] = arr[i + 1];
    //         arr[i + 1] = temp;
    //     }
    // }

    // //  arr.length - 1-1: 元素是4个，但是比了2次
    // for (var i = 0; i < arr.length - 1 - 1; i++) {
    //     if (arr[i] > arr[i + 1]) {
    //         var temp = arr[i];
    //         arr[i] = arr[i + 1];
    //         arr[i + 1] = temp;
    //     }
    // }

    // for (var i = 0; i < arr.length - 1 - 2; i++) {
    //     if (arr[i] > arr[i + 1]) {
    //         var temp = arr[i];
    //         arr[i] = arr[i + 1];
    //         arr[i + 1] = temp;
    //     }
    // }

 // 这个-1的目的是，4个元素，排够3次就够了

    for (var j = 0; j < arr.length - 1; j++) {

        // -j的目的是 减少排序的次数，由于最大的元素已经排到了最后了，就不需要再排了

        for (var i = 0; i < arr.length - 1 - j; i++) {

            if (arr[i] > arr[i + 1]) {

                var temp = arr[i];

                arr[i] = arr[i + 1];

                arr[i + 1] = temp;

            }

        }

    }

    console.log(arr);

 选择排序：

         排序思路： 假设第一个元素是最小值，拿第一个元素和后面所有的元素依次进行比对，    、

                    如果发现有比第一个元素还小的，就进行交换

 arr[0] 和 arr[1]      [8,12,5,3]
         arr[0] 和 arr[2]      [5,12,8,3]
         arr[0] 和 arr[3]      [3,12,8,5]

        //  经过一轮比较，最小跑前面了


        // 第一轮比较完毕，第一个元素已经确定最小啦

        arr[1] 和 arr[2]      [3,8,12,5]
        arr[1] 和 arr[3]      [3,5,12,8]


        // 
        arr[2]和arr[3]        [3,5,8,12]


*/
    // 
    // for (var j = 1; j < arr.length; j++) {
    //     if (arr[0] > arr[j]) {
    //         var temp = arr[0];
    //         arr[0] = arr[j];
    //         arr[j] = temp;
    //     }
    // }
    // for (var j = 2; j < arr.length; j++) {
    //     if (arr[1] > arr[j]) {
    //         var temp = arr[1];
    //         arr[1] = arr[j];
    //         arr[j] = temp;
    //     }
    //     console.log(arr);
    // }
    // for (var j = 3; j < arr.length; j++) {
    //     if (arr[2] > arr[j]) {
    //         var temp = arr[2];
    //         arr[2] = arr[j];
    //         arr[j] = temp;
    //     }
    //     console.log(arr);
    // }

 //  简化成for循环嵌套

    // 由于上述循环判断了3次，总共有4个元素，所有-1

 

    for (var i = 0; i < arr.length - 1; i++) {

        for (var j = i + 1; j < arr.length; j++) {

            if (arr[i] > arr[j]) {

                var temp = arr[i];

                arr[i] = arr[j];

                arr[j] = temp;

            }

        }

    }

    console.log(arr);

 基本数据类型：1.  基本数据类型变量存的是值

                   2. 基本数据类的变量存储在栈内存

                   3. 基本数据类型的变量和变量互不影响

      var a = 10;

引用数据类型：1.引用数据类型的变量存储的是地址值

                   2. 基本数据类的变量存储在堆内存

                   3. 引用数据类型的变量如果和另外一个引用数据类型的变量公用一个地址，

                       其中一个变化，另外一个也会受到影响

例如：

 var a = 10;
    var b = a;
    b = 20;
    console.log(a); // 10
    console.log(b);// 20
    console.log('----------------------------------------------------');
    var arr = [12, 34, 21]
    var arr1 = arr; // 将arr的地址值赋值给arr1
    arr[0] = 10;
    console.log(arr1); // [10,34,21]
    console.log(arr);// [10,34,21]
    console.log('----------------------------------------------------');
    var obj = { name: "张三", age: 18 }
    var obj1 = obj;//将obj的地址值赋值给obj1
    obj.name = "大黄";
    console.log(obj1); //{name: '大黄', age: 18}
    console.log(obj); //{name: '大黄', age: 18}
    console.log('----------------------------------------------------');
    function fn(arr) {
        arr[0] = 10;
    }
    var arr = [12, 43, 1]
    fn(arr);
    console.log(arr); //[10,43,1]  
    // 引用数据类型作为参数传递
    console.log('----------------------------------------------------');
    function fn1(a) {
        a = 10;
    }
    var a = 20;
    fn1(a);
    console.log(a); // 20 //基本数据类型作为参数传递

    console.log('----------------------------------------------------');
    function fn2(obj) {
        obj.name = '小李'
    }
    var obj2 = { name: "校长", age: 90 }
    console.log(obj2);
    fn2(obj2);// 引用数据类型作为参数传递,实参和形参公用一个地址
    console.log(obj2);