数组

• 什么是数组
  • 数组: 存放一些数据的集合,也是引用数据类型(复杂数据类型)
  • 引用数据类型：数组/对象/函数
• 数组和对象将来如何选择?
  • 示例:
    • 商品的详情存放到某一个对象中，比如: 商品名， 商品价格，商品折扣，商品描述......
    • 商品列表假设有100个商品，那么你就有100个商品详情，按照上述的封装，那么你有100个对象
    • 我们可以将这100个对象，存放到某个数组中，进行维护管理...

var arr = [1, 2, 3, "qwe", "abc", true, false, undefined, null];
// 我们把一堆数据存放到一个盒子中, 这就叫做数组 对应我们上述的 数组是存放一些数据的集合

一、创建数组

• 数组内部是存放一些数据的, 数据的类型没有限制
• 但是在开发的时候一般需要将一个数组内的数据类型限制为一个
• 比如: 纯字符串数组, 纯数字数组, 纯对象数组

1. 字面量的方式创建 (使用场景最多的方式)

        // 创建一个空数组
        var arr1 = []
        console.log(arr1)
        // 创建一个有内容的数组
        var arr1 = [true, undefined, null, 999, 578, 'QF999']
        console.log(arr1)

2. 内置构造函数的方式创建

// 创建一个空数组
var arr = new Array()
console.log(arr)

// 创建一个有长度的数组
var arr1 = new Array(10)
console.log(arr1)

// 创建一个有内容的数组
var arr2 = nee Array(1, 2, 3)
console.log(arr2)

二、数组的长度

• 数组的长度并不固定，取决于数组内部有多少个元素
• 查看方式：
  1、打印数据，在控制台展开数组，找到最后的length
  2、打印 数组名.length
• 当数组的长度 === 0 ，代表当前数组为空数组
• 当数组为空数组的时候，做某些操作 数组的长度并固定, 取决于数组内部有多少个元素

        var arr = [1, 2, 3, 4, 5]
        console.log(arr)
        console.log(arr.length)  //5

三、数组的索引(下标)

• 作用： 表明 数组 的这个位置上 有什么内容
• 注意:
  • 下标是固定的, 永远是 0 1 2 3 4 5 ....
  • 但是下标对应的内容, 不是固定的

四、数组遍历

需求: 拿到数组各个位置上的值

        var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2]
        // 下标    0  1  2  3  4  5  6  7  8  9
        
        // for (var i = 0; i <= arr.length - 1;) {
        for (var i = 0; i < arr.length; i++) {
            // console.log(i)
            console.log(arr[i])
        }

案例1. 找出数组中的最大值

        var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2]
        var max = arr[0]
        for(var i = 1;i < arr.length; i++){
            if(arr[i] > max){
                max= arr[i]
            }
        }
        console.log(max)   //10

案例2. 计算数组中所有内容相加的和

        var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2]
        var sum = 0
        for(var i = 0; i < arr.length; i++){
            sum += arr[i]
        }
        console.log(sum)  //58

案例3. 封装一个函数, 名为 includes(功能为传入一个数组和数字, 判断这个数组中是否包含这个数字 包含返回true, 否则返回 false)

       function includes(arr,n){
            for(var i = 0; i < arr.length;i++){
                if (arr[i] === n) {
                    return true 
                }
            }
            return false
        }
        var a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2]
        var res = includes(a,10)
        console.log(res)  //true

案例4. 封装一个函数, 名为 indexOf(功能为 传入一个数组和数字, 判断这个数组中是否包含这个数字 包含返回 这个数字的下标(从左到右第一个) 否则返回 - 1)

       function indexOf(arr,n){
            for(var i = 0;i < arr.length; i++){
                // console.log(arr[i])
                if (arr[i] === n) {
                    return i
                }
            }
            return -1
        }
        var a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2]
        console.log(indexOf(a, 2))  //1

案例5. 封装一个函数, 名为 LastIndexOf(功能为 传入一个数组和数字, 判断这个数组中是否包含这个数字 包含返回 这个数字的下标(从右往左第一个) 否则返回 - 1)

            function LastIndexOf(arr, n) {
                for (var i = arr.length - 1; i >= 0 ; i--) {
                    if (arr[i] === n) {
                        return i
                    }
                }
                return -1
            }
            var a = [1, 2, 3, 4, 5, 2, 2, 2, 2]
            console.log(LastIndexOf(a, 2))  //8

五、常用算法

1.冒泡排序

        var arr = [9, 5, 6, -7, 32, 1, 2, 18, 4]
        for( var j = 0; j < arr.length - 1; j++){
            for(var i = 0; i < arr.length-j-1; i++){
                if(arr[i] > arr[i+1]){
                    var temp = arr[i]
                    arr[i] = arr[i+1]
                    arr[i+1] = temp
                }
            }
        }console.log(arr)  //[-7, 1, 2, 4, 5, 6, 9, 18, 32]

2.选择排序

        var arr = [9, 5, 6, -7, 32, 1, 2, 18, 4]
        for(var j = 0;j < arr.length -1;j++){
            // 1. 假设 j 是最小值的下标, 保存在 minIndex
            var minIndex = j
            // 2. 循环会帮我们找到真实最小值的下标, 并保存在变量 minIndex
            for(var i = j+1;i<arr.length;i++){
                if(arr[i]<arr[minIndex]){
                    min = i
                }
            }
            // 3. 交换 真实最小值(下标 minIndex) 和 假设最小值 (j) 的位置
            var temp = arr[j]
            arr[j] = arr[minIndex]
            arr[minIndex] = temp
        }
        console.log(arr)  //[-7, 1, 2, 4, 5, 6, 9, 18, 32]