Js内置对象---数组Array

1.数组的了解：

   数组是一个用于保存批量数据的数据结构，数组是按照线性结构来保存数据的。
   附加：数组开辟的空间是连续的。

2.数组的创建

<script>
    // 1.创建一个空数组
    var arr = [];
    var arr = new Array();
    console.log(arr, typeof arr)       //结果：[]  "object"

    // 2.创建数组并初始化元素
    var arr = [1,2,3,3,5,6,6,8]
    var arr = new Array(1,2,3,3,5,6,6,8)
    console.log(arr, typeof arr)       //结果：[1, 2, 3, 3, 5, 6, 6, 8]  "object"

    // 3.创建数组并初始化数组长度，附加：数组的长度在创建完成后，还可以更改。
    var arr = new Array(5);
    arr[0]=1;  arr[1]=2;  arr[3]=3;  arr[4]=5;
    console.log(arr, arr.length);                         //结果：[1, 2, 3: 3, 4: 5]  5
    console.log(arr[0], arr[1], arr[2], arr[4], arr[5]);  //结果：1 2 undefined 5 undefined
    arr[5]=6;  arr[7]="你好"; 
    console.log(arr, arr.length);                         //结果：[1, 2, 3: 3, 4: 5, 5: 6, 7: "你好"]  8
    // 附加：arr[6]是空元素。这时候数组长度变成了8。
</script>

3.数组的使用以及方法

<script>
    var arr = [1, 2, 3, 3, 5, 6, 6, 8]
    // 1.获取数组的长度
    var length = arr.length;
    console.log(arr, length);      //结果：[1, 2, 3, 3, 5, 6, 6, 8]  8

    // 2.清空数组
    arr.length=0;
    console.log(arr, arr.length);  //结果：[]  0

    // 3.遍历数组
    for(var i=0;i<arr.length;i++){
	console.log(arr[i]);       //结果：1  2  3  3  5  6  6  8
    }


    // 4.toString()：将数组转换成字符串，将转换后的字符串进行返回。使用toString()时候，arr数组本身并不会发生改变，即arr还是一个数组。
    var str = arr.toString();
    console.log(str, typeof str);  //结果：1,2,3,3,5,6,6,8  string


    // 5.join(seperator)：返回一个由seperator连接的数组元素的字符串。
    var sss = arr.join();
    var str = arr.join("-");
    console.log(sss, typeof sss);  //结果：1,2,3,3,5,6,6,8  string
    console.log(str, typeof str);  //结果：1-2-3-3-5-6-6-8  string


    // 6.reverse()：数组反转。注意：该函数会改变现有数组的结构。
    arr1 = arr.reverse();
    console.log(arr);             //结果：[8, 6, 6, 5, 3, 3, 2, 1]
    console.log(arr1);            //结果：[8, 6, 6, 5, 3, 3, 2, 1]


    // 7.sort()：对现有数组的内容进行排序。默认是按照元素的unicode码升序排序（按照字符串的方式排序）
    // 注意：该函数会改变现有数组的结构。
    var arr1 = [1, 3, 2, 21, 7, 520, 6, 8];
    var arr2 = ["hello", "world", "kitty"];
    arr3 = arr1.sort();
    arr4 = arr2.sort();
    // arr1与arr3结果一样。 arr2与arr4结果一样。
    console.log(arr1, arr3);       //结果：[1, 2, 21, 3, 520, 66, 7, 8]  
    console.log(arr2, arr4);       //结果：["hello", "kitty", "world"]
    

    // 8.sort()：对现有数组的内容进行排序。注意：该函数会改变现有数组的结构。排序规则自己定义。
    // 方法1：定义一个指明了排序规则的排序函数
    // 1、将sortAsc指定为排序函数。2、数组会自动的将相邻的两个数字传递到参数的位置处。3、如果返回值是 > 0的数字，则交换两个数字的位置，否则不变。
    var arr1 = [1, 3, 2, 21, 7, 520, 6, 8];
    var arr2 = ["hello", "world", "kitty"];
    arr3 = arr1.sort(sortAsc);
    arr4 = arr2.sort(sortAsc);
    // arr1与arr3结果一样。 arr2与arr4结果一样。
    console.log(arr1, arr3);         //结果：[1, 2, 3, 7, 8, 21, 66, 520]
    console.log(arr2, arr4);         //结果：["hello", "world", "kitty"]
    function sortAsc(a, b){
	return a-b;   //升序
	return b-a;   //降序    
    }
    // 方法2：使用匿名函数指定排序规则 
    arr1.sort(function(a, b){return a-b;});
    console.log(arr1)                 //升序：[1, 2, 3, 7, 8, 21, 66, 520]
    arr1.sort(function(a, b){return b-a;}); 
    console.log(arr1)                 //降序：[520, 66, 21, 8, 7, 3, 2, 1]
    arr3 = arr1.sort(function(a, b){return a-b;});  
    console.log(arr1, arr3)           //升序：arr1与arr3结果一样。 
    arr4 = arr1.sort(function(a, b){return b-a;}); 
    console.log(arr1, arr4)           //降序：arr1与arr4结果一样。
</script>

4.进出栈操作

// 栈式操作：提供了快速操作数组头部和尾部元素的方法
<script>
    var arr = [1, 2, 3, 3, 5, 6, 6, 8];
    // 1.push()：入栈，压栈。向数组尾部增加新元素，并返回新数组的长度。
    var len = arr.push("你好");
    console.log(arr, len);      //结果：[1, 2, 3, 3, 5, 6, 6, 8, "你好"]   9

    // 2.pop()：出栈，弹栈。 删除并返回数组尾部的元素。
    var ele = arr.pop();
    console.log(arr, ele);      //结果：[1, 2, 3, 3, 5, 6, 6]   8

    // 3.向数组尾部增加新元素
    var length = arr.length;
    console.log(arr, arr.length);      //结果：[1, 2, 3, 3, 5, 6, 6, 8]   8
    arr[length] = "你好";
    console.log(arr, arr.length);      //结果：[1, 2, 3, 3, 5, 6, 6, 8, "你好"]   9

    // 4.unshift()：向数组头部添加新元素，并返回新数组的长度
    var len = arr.unshift("你好");
    console.log(arr, len);      //结果：["你好", 1, 2, 3, 3, 5, 6, 6, 8]   9

    // 5.shift()：删除并返回数组头部的元素。
    var ele = arr.shift();
    console.log(arr, ele);      //结果：[2, 3, 3, 5, 6, 6, 8]   1
</script>

5.其他方法

<script>
    // 1.concat()：
    // 该方法不会改变原有的数组。参数可以是array，string，number，object。
    // 返回一个新的数组，如果有数组作为参数传入concat（）方法里时，添加的是数组中的元素而不是数组本身。
    var arr1 = [1, 2, 3];
    var arr2 = ["a","b","c"];
    var arr3 = arr1.concat(5, 9);
    var arr4 = arr1.concat(arr2);
    var arr5 = arr1.concat([5, 9], [6, 8]);
    var arr6 = arr1.concat(arr2,"sv",4,{"a":18,"ss":"ddd"});
    console.log(arr3, arr3.length);      //结果：[1, 2, 3, 5, 9]      5
    console.log(arr4, arr4.length);      //结果：[1, 2, 3, "a", "b", "c"]      6
    console.log(arr5, arr5.length);      //结果：[1, 2, 3, 5, 9, 6, 8]      7 
    console.log(arr6, arr6.length);      //结果：[1, 2, 3, "a", "b", "c", "sv", 4, Object]      9
</script>

6.数组去重

<script>
    // 方法一
    var a = [1, 2, 3, 3, 5, 6, 6, 8];
    var b = [];        //一个新的临时数组
    for(var i = 0; i < a.length; i++){ 
        // indexOf( )方法搜索数组b中的a[i]元素，并返回它首次出现的位置，如果没找到则返回 -1。 
        if(b.indexOf(a[i]) == -1){ 
            b.push(a[i]); 
        } 
    }
    console.log(a);      //结果：[1, 2, 3, 3, 5, 6, 6, 8]
    console.log(b);      //结果：[1, 2, 3, 5, 6, 8]
    console.log(a.indexOf(9));      //结果：-1
    console.log(a.indexOf(1), a.indexOf(3), a.indexOf(6));   //结果：0  2  5  

    // 方法二
    let arr1 = [...new Set([1, '1', 2, 1, 1, 3, 2, '4'])];
    console.log(arr1);      //结果：[1, "1", 2, 3, "4"]
    let arr2 = [...new Set([1, 2, 3, 3, 5, 6, 6, 8])];
    console.log(arr2);      //结果：[1, 2, 3, 5, 6, 8]    
</script>