数组

认识数组
- 一种数据类型(引用数据类型/复杂数据类型),片面讲是把数字放到盒子,盒子就是数组,严谨来讲--存放数据的集合
- 数组内的数据是有顺序的(按照写的顺序排)
创建数组
- 字面量 var arr=[1,2,'qqq',true,undefined]
- 内置构造函数语法1:var arr=new Array()//---创建空数组语法2:var arr=new Array(5)//---创建有长度的数组语法3:var arr=newArray(1,2,3,'asd',null)//---创建有内容的数组
length属性
- 代表数组内有多少个成员,在后台可以看到
- 语法: 数组名.length
索引/下标
- 一个数据,在这个数组内排列在第几个位置上(JS中,索引从0开始计数)
遍历数组
- 想办法拿到数组的每一个成员-----先拿到下标,就能拿到值-----------
- 规律:下标从0开始,到length-1结束\
求数组内所有成员的和

var arr=[9,5,6,11,8,4,3]
var sum=0
for(i=0;i<arr.length;i++){
  sum+=arr[i]
}
console.log(sum)

求数组内最大的数字

var arr=[9,5,6,11,8,4,3]
var max=arr[0]
for(var i=1;i<arr.length;i++){
  max<arr[i]? max=arr[i]:0 
}
console.log(max)

数组基本操作

冒泡排序

var arr = [9, 8, 7, 6, 5, 4, 3, 2, 1]
//冒泡排序核心:对比前一项和后一项,前大,就往后挪(从小到大排序)
for (var k =0 ; k <arr.length - 1; k++) {
 for (var i = 0; i <arr.length - 1-k; i++) {
   if (arr[i] > arr[i + 1]) {
     var temp = arr[i]
     arr[i] = arr[i + 1]
     arr[i + 1] = temp
   }
 }
}
console.log(arr)

选择排序

var arr = [9, 3, 6, 2, 4, 1, 8, 5, 7]
for (var k = 0; k < arr.length-1; k++) {
       var minIndex = k
       for (var i = k + 1; i < arr.length; i++) {
           if (arr[minIndex] > arr[i]) {
               minIndex = i
           }
       }
       var temp = arr[k]
       arr[k] = arr[minIndex]
       arr[minIndex] = temp
   }

   console.log(arr)

数据类型之间的区别
- 存储的区别
  - 基本数据类型(number/string/boolean/null/undefined)---栈内存
  - 引用数据类型(对象/数组/函数)---本体在堆内存,变量名在栈内存
  - 基本内部存储的是值,引用内部存储的是地址
- 赋值的区别
  - 基本数据类型赋值后,两个变量之间没有任何关系
  - 引用数据类型赋值后,因为变量内部储存的指向堆内存的地址,so,在赋值时就是将这个地址给了另一个变量,两个变量存储的是同一个钥匙,所以操作一个变量,另一个变量也会改变
- 比较的区别
  - 基本数据类型,值的比较
  - 引用数据类型,比较的是存储地址,不是值
- 传参的区别
  - 基本数据类型,将值拷贝,传形参,在函数内修改,不会影响外界
  - 引用数据类型,将储存地址赋值形参,会影响外界
案例:已知一个排序好的数组,往数组里添加n,将数,按照原有顺序插入到数组内,把该操作封装成函数

var arr = [10, 20, 30, 40, 50];
    function fn(n) {
      arr.push(n)
      for (var k = 0; k < arr.length - 1; k++) {
        for (var i = 0; i < arr.length - 1 - k; i++) {
          if (arr[i] > arr[i + 1]) {
            var temp = arr[i]
            arr[i] = arr[i + 1]
            arr[i + 1] = temp
          }
        }
      }
      return arr
    }
    var err = fn(35);
    console.log(err)

var arr = [10, 20, 30, 40, 50];
    function fn(n) {
      arr.push(n)
      for (var k = 0; k < arr.length-1 ; k++) {
        var minx = k
        for (var i = k + 1; i < arr.length; i++) {
          if (arr[minx] > arr[i]) {
            minx = i
          }
        }
        var temp = arr[minx]
        arr[minx] = arr[k]
        arr[k] = temp
      }
      return arr
    }
    var err = fn(35);
    console.log(err)

数组常用方法
- 数组.push(数据)
  - 向数组末尾添加数据
  - 返回值,追加数据后,数据最新长度(length)
```
var arr=[1,2,3,4]
var err=arr.push(999)
console.log(err)//------5
console.log(arr)//------[1,2,3,4,999]
```
- 数组.pop()
  - 删除数组末尾数据
  - 返回值,被删除的数据
```
var arr=[1,2,3,4]
var err=arr.pop()
console.log(err)//------4
console.log(arr)//------[1,2,3]
```
- 数组.unshift(数据)
  - 向数组开头添加数据
  - 返回值,追加数据后,数据最新长度(length)
- 数组.reverse()
  - 反转数组
  - 返回值,反转后的数组
- sort
  - 返回值,排序后的数组
  - 数组.sort()
    - 将数据转string,一位一位对比
  - 数组.sort(function (a,b){return a-b})
    - 按数字大小升序排列(不用转字符串)
  - 数组.sort(function (a,b){return b-a})
    - 按数字大小降序排列(不用转字符串)
- splice数组.splice(开始索引,多少个,插新1,插新2...)
  - 插新不写,即不插入新值
  - 截取数组部分内容,插入一些数据
  - 返回值,截取出来的部分内容
以上7个数组方法能改变原先数组
- 数组.slice(开始索引,结束索引)
  - 截取数组部分内容
    - 参数包前不包后
    - 不写开始索引,默认0;不写结束索引,默认length
    - 支持负数,即为倒数第几个
  - 返回值,截取数组部分内容组成的新数组(包前不包后)
  - splice与slice区别:
    - 1参数含义不同,然后分别介绍;
    - 2.slice不会改变原数组,splice会
- 原始数组.concat(数组1,数组2...,数据1,数据2...)
  - 进行数据拼接,把数组/数据之类的小括号的内容,拼接在原始数组
  - 返回值,拼接好的数组
- 数组.join('连接符')
  - 使用连接符,把数组内的每一个数据连接成一个字符串(不写连接符,默认",")
  - 返回值,连接好的字符串
- 数组.indexOf(要检查的数据,开始索引)
  - 删除数组开头数据
  - 返回值,被删除的数据
- 数组.shift()
  - 在开始索引的位置,从前到后检查该数据第一次在该数组内出现的索引
  - 开始索引不写,默认为0
  - 返回值,找到数据的情况下,将数据第一次出现的下标(索引)返回; 没找到,直接返回 -1
- 数组.iLastIndexOf(要检查的数据,开始索引)
  - 在开始索引的位置,从后到前检查该数据第一次在该数组内出现的索引
  - 开始索引不写,默认为0
  - 返回值,找到数据的情况下,将数据第一次出现的下标(索引)返回; 没找到,直接返回 -1
- 数组.forEach(function(item,index,origin){console.log(item,index)})
  - item---数组的每一项的值; index---数组每一项的下标; origin--原始数组(origin了解即可,一般不用)
  - 遍历数组
  - 返回值:该方法永远没有返回值,只能为undefined
- 数组.map(function(item,index,origin){console.log(item,index)})
  - item---数组的每一项的值; index---数组每一项的下标; origin--原始数组(origin了解即可,一般不用)
  - 映射数组
  - 返回值:返回一个和原数组长度相同的数组,但是内部数据可以进行映射加工
  - 映射加工:在函数内用return形式书写
  - forEach与map区别: a.forEach遍历数组,map映射数组; b.forEach没有返回值,map有返回值
- 数组.filter(function(item,index,origin){})
  - item---数组的每一项的值; index---数组每一项的下标; origin--原始数组(origin了解即可,一般不用)
  - 过滤数组
  - 返回值,返回一个新数组,存储的是原始数组过滤出来的部分内容
  - 过滤条件:以return方式书写
- 数组.find(function(item,index,origin){})
  - item---数组的每一项的值; index---数组每一项的下标; origin--原始数组(origin了解即可,一般不用)
  - 在数组内查找满足条件的第一项
  - 返回值,找到的数据
  - 查找条件:以return方式书写
- 数组.findIndex(function(item,index,origin){})
  - item---数组的每一项的值; index---数组每一项的下标; origin--原始数组(origin了解即可,一般不用)
  - 在数组内查找满足条件的第一项的下标
  - 返回值,找到的数据的下标
  - 查找条件:以return方式书写
- 数组.some(function(item,index,origin){})
  - item---数组的每一项的值; index---数组每一项的下标; origin--原始数组(origin了解即可,一般不用)
  - 判断数组内是否有一个满足条件
  - 返回值,true/false
  - 判断条件:以return方式书写
- 数组.every(function(item,index,origin){})
  - item---数组的每一项的值; index---数组每一项的下标; origin--原始数组(origin了解即可,一般不用)
  - 判断数组内是否全都满足条件
  - 返回值,true/false
  - 判断条件:以return方式书写
- 数组.reduce(function(prev,item,index,origin){},init)
  - prev----初始值或者上一次运算结果; item---数组的每一项的值; index---数组每一项的下标; origin--原始数组(origin了解即可,一般不用)
  - 实现叠加效果
  - 返回值,叠加结果
  - 叠加条件:以return方式书写

数组塌陷案例

var arr = [0,1, 2, 3, 4, 5]//利用数组方法,将每一项删除----pop/shift/splice

var arr = [0, 1, 2, 3, 4, 5]
for (i = 0; i < arr.length; i++){
  arr.splice(i,1)//arr.pop()//arr.shift()
  i--
}
console.log(arr)//----- []

数学方法
- Math.random()
  - 得到一个随机数,每次生成的数字不一样,数字区间[0,1)
- Math.round(数字)
  - 将数字(小数),四舍五入-----整数
- Math.ceil(数字) *将数字(小数)向上取整
- Math.floor(数字)
  - 将数字(小数)向下取整
- Math.abs(数字)
  - 返回数字的绝对值
- Math.sqrt(数字)
  - 求平方根
- Math.pow(基数,幂)
  - 返回基数的几次幂
- Math.max(数字1,数字2...)
  - 返回传入数字中最大值
- Math.min(数字1,数字2...)
  - 返回传入数字中最大值
- Math.PI
  - 返回π
需求,数组去重var arr=[1,1,1,2,2,2,3,3,3,4,4,4,5,5,5]

for (var i = 0; i < arr.length; i++) {
      if (arr.indexOf(arr[i], i + 1) !== -1) {
        arr.splice(i, 1)
        i--
      }
    }
    console.log(arr)

需求,封装一个函数,函数值返回[0,10]之间的随机整数

    function fn() {
      return Math.floor(Math.random() * 11)
    }
    var num = fn()
    console.log(num)

JS严格模式
- js默认没有开启严格,想开启,在script标签内第一行写字符串'use strict'
- 声明变量必须要写var
- 函数的形参不能重复

数组

数组

数组

以上7个数组方法能改变原先数组