数组【array】

A.【数据的值类型和引用类型】

值类型：number string boolean null undefined

引用类型（复杂的数据结构）：function [] {}

值类型 是储存在栈中的

引用数据类型存放在堆空间

值类型赋值是直接将对应的值 传递过去

引用数据类型是将对应的地址传递过去

        var a = 1;
        var b = a; //b=1
        console.log(a, b);
        a=2;
        console.log(a,b);
        var obj1 = {
            name:"张三",
            age:18
        }

        var obj2 = obj1;//引用数据类型 赋值 传递是一个地址 属于浅拷贝
        console.log(obj1.age,obj2.age);

        obj1.age=28;
        console.log(obj1.age,obj2.age);
        //    引用数据类型 直接使用== 比较 比较的是地址 
        console.log(obj1==obj2)
复制代码

B.【数组的定义】

数组 储存一组数据类型相同的数据

1 通过字面量的方式语法糖

    var arr1 = [1,2,3,4,6,4];  
复制代码

2 通过new 的方式

    var  arr2 = new  Array(1,2,3,4); 
复制代码

3构造函数

    var  arr3 = Array("1","2");
复制代码

4在定义数组时可以传参一个字面量的格式的数组

    var arr4 = new  Array([1,2,3,4,6,4]);
复制代码

5定义数组时可以指定数组长度

    var arr5  = new  Array(5); // 5表示该数组的长度
复制代码

其他数组知识:

【typeof】运算符可以判断数据类型

            console.log(typeof(arr1),typeof(arr2),typeof(arr3));

            // length 数组的长度 数组中的元素个数
            console.log(arr1.length);

            // 通过索引号可以访问 数组中的元素

            console.log(arr1[0]);

            // 给数组中的元素重新赋值
            arr1[0] = 23;
            console.log(arr1[0]);

            // 给数组中添加一个新的元素
            arr1[6] = 666; 
            console.log(arr1);
            // 通过改版 数组的长度来实现删除元素
            arr1.length = 3;
            console.log(arr1);

            // 使用for循环数组遍历

           for(var i =0;i<arr1.length;i++){
               console.log(arr1[i]);
           }
复制代码

C.【数组的常用API(重点)】

数组遍历的api

定义数组：

           var arr = [1,2,3];
           var arr = new Array();
复制代码

数组长度：

    arr.length
复制代码

遍历数组：【forEach、every、some、map、filter、for of】

     foreach(function(item,index,arr){})
     every(function(item,index,arr){ return item>1}) 
复制代码

返回boolean值所有的都符合条件才会返回true

     some(function(item,index,arr){ return item>1}) 
复制代码

返回boolean 只要有一个满足条件的返回 true

    map(function(item,index,arr){ return item*10})  
复制代码

返回处理过的数组

    filter(function(item,index,arr){ return item>10}) 
复制代码

返回符合条件的元素组成的新数组

for of 利用迭代器遍历数组

    for(item of  arr.entries()){console.log(item)} ; 
复制代码

增加元素：【posh、unshift、splice】

     push(arg) 数组末尾新增元素    返回新数组的长度
     
     unshift(arg) 数组开头添加元素  返回新数组的长度
     
     splice(arg1,arg2,arg3...)
     
     //arg3以后是要插入的元素 
     //arg1开始插入或删除的位置 
     //arg2 表示删除的个数  
复制代码

删除元素：【pop、shift、splice】

    pop()
复制代码

从数组末尾删除一个元素返回被删除的元素

    shift() 
复制代码

从数组开头删除元素返回被删除的元素注意后面的元素索引会立即发生改变

    splice(arg1,arg2)  
    //arg1开始插入或删除的位置 arg2 表示删除的个数 
复制代码

修改元素：

  arr[i] = 23;
复制代码

数组反转：【reverse】

    reverse();
复制代码

数组排序：【sort】

    sort(function(a,b){return a-b}) 升序排列
复制代码

数组是否包含某个元素:

    includes(item);  //返回 true/false 
    indexOf(arg1,arg2) 
    //arg1要找的元素 arg2 开始查找的索引号 返回值是元素的索引 没有 -1
复制代码

数组拼接：

    contact(arr); 
复制代码

数组拷贝：

    copyWithin()
复制代码

数组转字符串：

   join("*") //可以指定分隔符 
   
   toString() 
复制代码

判断对象是否是数组：

    Array.isArray();
复制代码

伪数组转为数组：

    Array.from(arr);
复制代码

数组检索：

    find(function(item,index){return item>10}) 
复制代码

找到第一个符合条件的元素

    findIndex(function(item,index){return item>10}) 
复制代码

找到第一个符合条件的元素的索引

数组截取：

   slice(starNum,endNum);
复制代码

注意不包含endNum位置

D.【经典算法：冒泡排序】

例题：数组从小到大排列 [2,3,1,6,5] –> [1,2,3,5,6]

冒泡排序原理：两两进行比较

function bubble(arr) {
            var temp;
        // 外层循环的第一次循环结束 找出了 数组中的最大值 并放到数组的最后
        //  外层循环的第二次循环结束 找到 倒数第二大的值 并放到数组的倒数第二

            for (var i = 0; i < arr.length - 1; i++) {
                for (var j = 0; j < arr.length - i - 1; j++) {
           // 相邻的两个值进行比较 如果后面的值小于前面的值 就进行数据的交换
                    if (arr[j + 1] < arr[j]) {
                        temp = arr[j];
                        arr[j] = arr[j + 1];
                        arr[j + 1] = temp;
                    }
                }
            }
            return arr;
        }
        //     var arr = [2,3,1,6,5];
        //   console.log(bubble(arr)) ;
复制代码

【拓展：选择排序】

function fastSort(arr) {
            var minNum ;//定义一个最小值
            var index = 0;// 定义一个变量用于记录 最小值的索引
            var temp = 0;
            for (var j = 0; j < arr.length - 1; j++) {
                minNum = arr[j];  
                // 内层循环用于找到 从 j到 arr.length 中间的最小值
                for (var i = j; i < arr.length; i++) {

                    if (minNum > arr[i]) {
                        minNum = arr[i];
                        index = i;
                    }
                }
                //  交换 将最小值 放到  arr[j] 的位置     
                    temp = arr[j];
                    arr[j] = arr[index];
                    arr[index] = temp;
            }
            return arr;
        }
        var arr = [2, 3, 1, 6, 5];
        console.log(fastSort(arr));
复制代码