***数组:（多用数组，少用变量）
   what: 内存中连续存储多个数据的一块存储空间
      vs 变量: 内存中存储一个数据的存储空间
   why: ***程序=数据结构+算法
                算法: 解决问题的步骤
                数据结构: 数据在内存中的存储结构
                    好的数据结构可以极大提高程序的执行效率
   when : 今后，只要连续存储多个相关的数据，都要用数组
   how: 创建，访问元素

1、创建数组: 3个场景

         1. 创建空数组: var arr=[];//创建新数组
                                  var arr =new Array();
             何时: 在创建数组时，暂时不知道数组中的元素内容
         2. 创建数组时，初始化数组内容:
                                var 变量=[值1,值2,...];
                                             =new Array(值1,值2,...);
             何时: 在创建数组时，已经知道元素的内容
             强调: 每个元素之间，必须用逗号分隔
         3. 创建n个空元素的数组: var 变量=new Array(n);
             何时: 在创建数组时，仅知道元素的个数，暂时不知道元素的内容。

每个数据都称为一个元素，每个元素的用法和一个普通变量完全一样，所以数组也称为一组变量的集合，起一个统一的变量名

2、访问数组

       访问数组中的元素:
       下标: 数组中唯一标识每个元素存储位置的序号
              默认从0开始，连续不重复
       取值：arr[i]；访问arr数组中下标为i位置的元素值，每个元素的用法和一个普通变量完全一样

赋值：arr[i] = 值；

    三个不限制:（和其他语言相当大的区别，管得很松）
       1. 不限制元素的数据类型
       2. 不限制元素的个数:可随时在任意位置添加新元素
       3. 不限制下标越界:
              赋值: 如果下标越界，不报错！而是在指定位置自动添加新元素。——稀疏数组: 下标不连续的数组(注意其长度)
              取值: 如果下标越界，不报错！而是返回undefined

    length属性: 记录理论上数组的元素个数
                 length永远是最大下标+1
       固定套路:
          1. 最后一个元素: arr[arr.length-1]
          2. 倒数第n个元素: arr[arr.length-n]
          3. 在末尾追加新元素: arr[arr.length]=值
          4. 清空数组: arr.length=0;
          5. 删除末尾最后一个元素: arr.length--;
          6. 删除末尾的n个元素: arr.length-=n;

3、遍历数组

    遍历: 依次访问数组中每个元素:
       for(var i=0;i<arr.length;i++){
           arr[i]//当前元素
       }
       何时: 今后只要对数组中每个元素执行相同的操作时

***数组是引用类型的对象:
    数据类型: 基础类型: 值直接存储在变量本地的数据类型
                    引用类型: 值无法保存在变量本地的数据类型
                        数据实际存储在变量外的一个独立存储空间
                            同时存储多个数据的一块存储空间-对象
                            每个对象都有唯一的内存地址
                        变量中仅保存对象的地址值！
                        访问变量等效于通过地址值找到具体对象去访问
    数组就是引用类型的对象

4、***按值传递:

       两变量间赋值，或将变量作为参数传入函数时，其实仅将原变量中值，复制一个副本给对方变量:
       对基础类型: 修改新变量的值，不影响原变量；
       对引用类型: 仅复制对象的地址给对方，不创建新对象
                          通过新变量修改对象，等效于直接修改原对象

为什么：因为引用类型按值传递时，复制的是地址值，实际的数组始终只有一个

null vs undefined
undefined: 空, 专门用于程序自动给变量初始化空值
null: 空, 专门用于程序员主动释放对一个对象的引用
     垃圾回收: 内存中引擎会自动释放不再被任何变量引用的对象
     垃圾回收器: 在内存中自动执行的小程序
                        自动释放不被任何变量引用的对象
     好的习惯: 只要一个对象不再使用，都要主动将变量置为null

5、关联数组:

   索引数组: 下标为数字的数组
   问题: 每个元素，只有值，没有有意义的名称
   解决: 关联数组: 可自定义下标名称的数组
   如何:
      创建: 2步: 1. 先创建空数组: var scores=[]
                       2. 在空数组中添加新元素，使用自定义的下标名
                              scores["MATH"]=81;
      访问元素: 用自定义的下标名称:
            scores["MATH"] 用法和普通变量完全一样

关联数组原理:(根本不存在索引数列，两者根本区别：hash是将值贴在门上，而索引数组是将值放在房间里面了)
hash算法: 散列: 接收一个字符串，然后（前台）根据字符串计算出一个尽量不重复的数字（这个数字就作为一个标识）。

            索引数组得遍历，根据值来，一个一个敲房间
           相同字符串，计算出的数字一定相同
           不同的字符串，计算出的数字几乎不同的
       关联数组: hash数组
          存入元素: 将下标名交给hash算法，计算出一个尽量不重复的序号，将元素存储到数组中序号指定的位置
          获取元素: 将下标名交给hash算法，计算出和存入时完全一样的序号，直接去数组中序号位置获取元素值——不用遍历
    为什么: 1. 因为下标有意义，便于维护
                 2. 查找极快——和总元素个数以及存储位置无关！
    何时: 1. 今后只要快速查找某个元素时，都用hash数组
             2. 今后只要存储有意义的一组元素时，都用hash数组
    笔试: 谈谈对hash的理解:
      hash算法; 存入; 获取;   优;

   特点: length属性失效，永远为0
   遍历: for in循环:
      for(var key in hash){//in依次获得每个元素的下标名称
         key//自动获得当前元素的下标名
         hash[key]//当前元素值
      }

6、数组API:

浏览器已经实现的，我们直接用的函数
数组对象: 存储一组数据，提供操作数据的API

6.1. 数组转为字符串: 2种

        1. var str=String(arr): 将arr中每个元素转为字符串，再用逗号链接成一个字符串。
        2. 可自定义连接符:
            var str=arr.join("自定义连接符")
            固定套路: 1. 无缝拼接: arr.join("")
                            2. 判断数组是空数组: arr.join("")===""
                            3. 动态生成页面元素的内容

练习：

方法二：利用哈希算法，查找速度快

数组API: 浏览器已经实现的，我们直接用的函数
数组对象: 存储一组数据，提供操作数据的API

============================================================================================
    1. 数组转为字符串: 2种:
        1. var str=String(arr): 将arr中每个元素转为字符串，再用逗号链接成一个字符串。
        2. 可自定义连接符:
            var str=arr.join("自定义连接符")，若没有参数的话相当于第一种连接
            固定套路: 1. 无缝拼接: arr.join("")，参数只写引号就行
                            2. 判断数组是空数组: arr.join("")===""
                            3. 动态生成页面元素的内容

6.2. 拼接和选取

   拼接: 将其它元素或其它数组拼接到当前数组末尾,返回新数组
      var newArr=arr1.concat(值1,值2,arr2,......)
      强调: 1. 无权修改原对象，只能返回新对象，所以得用变量接住拼接后的返回值
               2. 打散传入的数组参数——珍贵
   选取: 复制原数组中指定位置的元素组成新数组
      var subArr=arr1.slice(start i,end i+1);         注意，数组是从0开始的
      强调: 1. 无权修改原对象，只能返回新对象
               2. 规律: 所有两个参数都是下标的API，都含头不含尾，即想写到哪儿就加一
      简写: 1. 省略第二个参数: arr1.slice(starti)
                      从starti位置一直选取到结尾
               2. 不写参数: arr1.slice()——复制整个数组中所有元素
               3. 如果离结尾近:
                      arr1.slice(arr1.length-n,arr1.length-m+1)
                      支持负数参数，表示倒数第n到倒数第m的元素
                      arr1.slice(-n,-m+1);

6.3. 修改数组splice: 删除，插入，替换

    删除: arr.splice(starti,n) 从arr中starti开始，删除n个元素
        强调: 1. 不遵循含头不含尾（俩参数都为下标的才遵循）
                 2. 直接修改原数组
                 3. starti也支持负数参数，表示倒数第n个位置
        简写: 省略第二个参数: arr.splice(starti) 删除starti后所有
        返回值: var deletes=arr.splice(starti,n)
              返回被删除的元素组成的临时新数组
    插入: arr.splice(starti,0,值1,值2,...)
              在arr中starti位置插入: 值1,值2,...
              原starti位置及其之后的值，向后顺移
        强调: 不能打散数组参数
    替换: arr.splice(starti,n,值1,值2,...)
              在arr中先删除starti位置后的n个元素
                         再在starti位置插入新元素
        强调: 删除的元素个数和插入的新元素个数不必一样
                数组自动调整length

=============================================================================================

6.4. 翻转数组: arr.reverse();

强调：不负责排序，仅原样点到数组元素

===========================================================================================

7. ****排序

自定义排序算法: 冒泡，快速，插入
冒泡: 原理:

1. 排序:
自定义排序: 冒泡

排序API: arr.sort();
       大问题: 默认将所有元素转为字符串再按字符串排列
                  只能对字符串类型的元素正确排序
       解决: 自定义比较规则:

      函数在引擎中以变量的形式存在，比较器函数相当于替换了原装函数
         比较器函数: 专门比较任意两值大小的函数:
                   要求: 两个参数: a,b
                            返回值: 如果a>b，就返回正数，就交换
                                        如果a<b，就返回负数
                                        如果a=b，就返回0
         最简单的数字比较器函数:
           function compare(a,b){return a-b;}
         如何使用: 将比较器函数名作为参数传入sort函数中
           arr.sort(compare) //强调: 不要加()，圆括号是立刻执行的意思
       compare函数作为参数传入sort中，被sort反复调用，而不是亲自执行，以后只要是把一个函数给另一个函数，就不要加（）
         降序: 颠倒比较器函数的正负号，可改升序为降序
           最简单的数字降序比较器函数:
              function compare(a,b){return b-a;}

何时使用：只要默认的排序规则（字符串升序）不是你想要的，就使用比较器函数

说明：所有排序算法都只有升序，没有降序

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/我家自动化/article/detail/624985

07 JS CORE 数组_core js 数组方法

一、数组概述