JS中两种创建数组的方法，两种遍历数组的方法，以及数组的一些常用方法

1. 字面量的方式创建数组：

        var  数组名  =  [ 初始值1，初始值2，初始值3 ]；

        （其中，初始值可以是不同的数据类型）

2. new arr的方式创建数组：

        var  数组名  =  new  Array();

        （Array()：表示定义了一个空数组；

           Array(23，55，78，“89”)：传入一系列参数表示数组的初始值；

           Array(4)：传入一个number类型的整数表示定义出了数组的长度；

           Array(5.78)：传入非整数类型会报错；

           Array("4567890")：传入字符串类型的表示给数组初始值；）

3. 遍历数组的方式一：

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

               console.log( arr[ i ] );

         }

4. 遍历数组的方式二：

        for ( var  j  in  arr3 ) {

                console.log( arr[ j ] );

        }

5. 数组的常用方法：

        push() ;   unshift() ;   pop() ;   shift() ;   join() ;   split()

6.  简单的数组排序

7. splice 的运用：

        

8.  indexOf 的运用：

举例：

1. 字面量的方式创建数组并遍历数组

<!-- 字面量的方式创建数组并遍历数组 -->
    <script>
        var arr1 = [11, 22, 33, 44, "55"];
        arr1[2] = "hello";  //arr1 = [11,22,"hello",44,"55"]
        arr1[6] = 99;  //arr1 = [11,22,"hello",44,"55",undefined,99]

        // 遍历数组一
        var str1 = "";
        for (var i = 0; i < arr1.length; i++) {
            str1 += arr1[i] + ",";
        }
        console.log(str1);

        // 遍历数组二
        var str2 = "";
        for (var j in arr1) {   //这种遍历方式会忽略数组中没有被定义的位置
            str2 += arr1[j] + ",";
        }
        console.log(str2);
    </script>

2. new arr的方式创建数组并遍历数组

<!-- new arr的方式创建数组并遍历数组 -->
    <script>
        var arr2 = new Array();
        console.log(arr2.length);   //0,未定义数组长度即为空数组

        var arr3 = new Array(11, 22, 33, "67", 88);
        console.log(arr3.length);   //5
        console.log(arr3);  //定义数组的时候传入很多参数，这些参数表示数组的初始值

        var arr4 = new Array(3);
        console.log(arr4.length);   //3
        console.log(arr4);  //定义数组的时候传入一个Number类型的整数，表述数组的长度

        //var arr5 = new Array(3.14);
        //console.log(arr5.length);   //定义数组的时候传入一个Number类型的小数，会报错

        var arr6 = new Array("56789");
        console.log(arr6.length);
        console.log(arr6);

        // 遍历数组一
        var str3 = "";
        for (var i = 0; i < arr3.length; i++) {
            str3 += arr3[i] + ",";
        }
        console.log(str3);

        // 遍历数组二
        var str4 = "";
        for (var j in arr3) {   //这种遍历方式会忽略数组中没有被定义的位置
            str4 += arr3[j] + ",";
        }
        console.log(str4);
    </script>

3. 数组的常用方法

var arr1Demo = [4, 9];
        var str1Demo = "hahahahahaha";

        arr1Demo.push(78);  //在数组末尾追加78
        console.log(arr1Demo);  //(3) [4, 9, 78]

        arr1Demo.unshift(0);    //在数组开头追加0
        console.log(arr1Demo);  //(4) [0, 4, 9, 78]

        var a = arr1Demo.pop(); //删除数组末尾的一个元素，并将删除的元素返回
        console.log(a); //78
        console.log(arr1Demo);  //(3) [0, 4, 9]

        var b = arr1Demo.shift();   //从数组开头删除一个元素，并返回删除的元素
        console.log(b); //0
        console.log(arr1Demo);  //(2) [4, 9]

        var str2Demo = arr1Demo.join("_");  //用_连接数组，返回被连接好的字符串
        console.log(str2Demo);  //4_9

        var arr2Demo = str1Demo.split("a"); //从a处分割字符串使之成为数组
        console.log(arr2Demo);  //(7) ["h", "h", "h", "h", "h", "h", ""]

4. 选择排序：

//排序
        var _arr = [2, 7, 1, 78, 8, 7];
        for (var i = 0; i <= _arr.length; i++) {
            for (var j = i + 1; j <= _arr.length - 1; j++) {
                if (_arr[i] > _arr[j]) {
                    var temp = _arr[i];
                    _arr[i] = _arr[j];
                    _arr[j] = temp;
                }
            }
        }
        //遍历数组
        for (var i in _arr) {
            console.log(_arr[i]);
        }
        console.log(_arr);//(6) [1, 2, 7, 7, 8, 78]

5. splice 函数的相关运用：

        //splice数组去重
        var _arr1 = [2, 5, 1, 8, 9];

        _arr1.splice(4);    //删除_arr1[4]及其之后的所有元素
        console.log(_arr1); //(4) [2, 5, 1, 8]

        _arr1.splice(1, 2); //删除_arr1[1]及其之后的2个元素
        console.log(_arr1); //(2) [2, 8]

        _arr1.splice(0, 1, "你好");    //删除_arr1[0]及其之后的1个元素，并在_arr1[0]位置添加“你好”
        console.log(_arr1); //(2) ["你好", 8]

        _arr1.splice(_arr1.length, 0, "追加", 2, 3);
        console.log(_arr1); //(5) ["你好", 8, "追加", 2, 3]

        //数组嵌套数组
        _arr1.splice(_arr1.length, 0, "追加数组", [2, 5, 8]);
        console.log(_arr1); //(7) ["你好", 8, "追加", 2, 3, "追加数组", Array(3)]

        //数组嵌套函数
        _arr1.splice(_arr1.length, 0, "追加函数", function () { console.log(34567); });
        console.log(_arr1);//(9) ["你好", 8, "追加", 2, 3, "追加数组", Array(3), "追加函数", ƒ]

6. indexOf 查找：

        //数组元素查找array.indexOf(item , start)
        console.log(_arr1.indexOf(7));//-1 数组中没有该元素，返回-1
        console.log(_arr1.indexOf(3));//4 数组中有该元素返回该元素位置下标