JavaScript基础--数组

什么是数组：

数组是一系列数据的集合--也就是我们把一些数据放在一个盒子里面，按照顺序排好,这个东西就是一个数组，存储着一些数据的集合

例如：[100,200,'hello','javascript']

数组基础

（1）数据类型

• 基本数据类型：number / string / boolean / undefined / null
• 复杂数据类型： Object / Function  /  Array  / ...

（2）创建一个数组

• 字面量方式：

1. 创建空数组：var  arr = [ ]
2. 创建有内容的数组： var arr = [10,20,30,40,50]

• 构造函数方式

1. 创建空数组：var arr = new Array ( )
2. 创建有内容的数组： var arr = new Array(10,20,30,40,50)
3. 创建一个长度为10的数组： var arr = new Array(10)

（3）数组的长度

•  length 就是表示数组的长度，数组里面有多少个成员，length 就是多少

<script>
    var arr = [10, 20, 30, 40, 50]
    console.log(arr.length)  // 5
</script>

 （4）数组的索引

• 索引，也叫做下标，是指一个数据在数组里面排在第几
• 注意： 在所有的语言里面，索引都是从 0 开始的

<script>
    var arr = ['hello', 'world', 'javascript']
    console.log(arr[0])  // hello
    console.log(arr[1])  // world
    console.log(arr[2])  // javascript
</script>

 （5）数组的遍历

• 数组的索引就可以获取数组中的内容
• 数组的索引又是按照 0 ～ n 顺序排列
• 我们就可以使用 for 循环来循环数组，因为 for 循环我们也可以设置成 0 ～ n 顺序增加

 例如：依次打印出数组arr[10,20,30,40,50]的内容

    <script>
        var arr = [10, 20, 30, 40, 50]
        for (var i = 0; i < arr.length; i++) {
            console.log(arr[i])
        }
    </script>

 数组的常用方法

 （1）push

• 用来在数组的末尾追加一个元素

    <script>
        var arr = [10, 20, 30]
        arr.push(40)
        console.log(arr)  // [10,20,30,40]
    </script>

 （2）pop

• 用来删除数组末尾的一个元素

    <script>
        var arr = [10, 20, 30]
        arr.pop()
        console.log(arr)  // [10,20]
    </script>

（3）unshift

• 用来在数组的最前面添加一个元素

    <script>
        var arr = [10, 20, 30]
        arr.unshift(40)
        console.log(arr)  // [40,10,20,30]
    </script>

（4）shift

• 用来删除数组最前面的一个元素

    <script>
        var arr = [10, 20, 30]
        arr.shift()
        console.log(arr)  // [20,30]
    </script>

（5）splice

• 截取数组中的某些内容，按照数组的索引来截取
• 语法： splice(从哪一个索引位置开始，截取多少个，替换的新元素) （第三个参数可以不写）

    <script>
        var arr = [10, 20, 30, 40, 50]
        arr.splice(3, 2, '新内容')
        console.log(arr)  // [10,20,30,'新内容']
    </script>

（6）reverse

• 用来反转数组

    <script>
        var arr = [10, 20, 30, 40, 50]
        arr.reverse()
        console.log(arr)  // [50,40,30,20,10]
    </script>

 （7）sort

• 用来给数组排序的
• 当数组内容全是个位数时：

    <script>
        var arr = [3, 6, 4, 1, 8, 9]
        arr.sort()
        console.log(arr)  // [1,3,4,6,8,9]
    </script>

•  当数组内容不全是个位数时：

    <script>
        var arr = [3, 66, 34, 1, 28, 9]
        // 从小到大排列
        arr.sort(function (a, b) {
            return a - b
        })
        console.log(arr)  //  [1, 3, 9, 28, 34, 66]
        // 从大到小排列
        arr.sort(function (a, b) {
            return b - a
        })
        console.log(arr)  //  [66, 34, 28, 9, 3, 1]
    </script>

 （8）concat

• 把多个数组进行拼接
• 不会改变原始数组，会返回一个新数组

    <script>
        var arr1 = [1, 2, 3]
        var arr2 = [4, 5, 6]
        var newArr = arr1.concat(arr2)
        console.log(newArr)  //  [1, 2, 3, 4, 5, 6]
    </script>

 （9）join

• 把数组里面的每一项内容链接起来，变成一个字符串
• 不会改变原始数组，而是把链接好的字符串返回

    <script>
        var arr = [1, 2, 3]
        var str = arr.join('-')
        console.log(arr)  //  [1, 2, 3]
        console.log(str)  //  1-2-3
    </script>

 （10）indexOf      

        用来找到数组中某一项的索引

    <script>
        var arr = [1, 2, 3]
        var index = arr.indexOf(2)
        console.log(index)  //  1
    </script>

 数组遍历方法

• forEach遍历数组

        var arr = [10,20,30]

        arr.forEach(function(item,index,arr){

                console.log(item)  //依次输出数组的每一项

                console.log(index)  //依次输出数组每一项的索引号

         })

• map可以对数组每一项进行操作，返回一个新数组

        var arr = [10,20,30]

        var newArr = arr.map(function(item,index,arr){

                return item+10

        })

        console.log(newArr)   //  [20,30,40]

• filter按照条件进行筛选，返回一个新数组

        var arr = [10, 20, 30]

        var newArr = arr.filter(function (item, index, arr) {

                return item > 10

        })

        console.log(newArr)   //  [20,30]

• find按照条件进行筛选，返回第一个满足条件的项

        var arr = [10, 20, 30]

        var newItem = arr.find(function (item, index, arr) {

                return item > 10

        })

        console.log(newItem)   //  20

• every查找数组中是否每个元素都满足指定条件，都满足返回true否则返回false

        var arr = [10, 20, 30]

        var isOk = arr.every(function (item, index, arr) {

             return item >= 10

        })

        console.log(isOk)    // true

•  some查找数组中是否有元素都满足指定条件，只要有一个满足条件就返回true否则返回false

        var arr = [10, 20, 30]

        var isOk = arr.some(function (item, index, arr) {

             return item > 20

        })

        console.log(isOk)   //  true

• reduce接收一个方法作为累加器，数组中每个值从左往右开始合并，最终为一个值

        var arr = [10, 20, 30]

        var sum = arr.reduce(function (s, item, index) {

             return s + item

        }, 0)

        console.log(sum)    //  60

数组的排序

•  排序，就是把一个乱序的数组，通过我们的处理，让他变成一个有序的数组

（1）冒泡排序

        基本思想

1. 先遍历数组，让挨着的两个进行比较，如果前一个比后一个大，那么就交换位置
2. 数组遍历一遍以后，最后一个数字就是最大的数
3. 然后进行第二遍的遍历，还是按照之前的规则，第二大的数字就会跑到倒数第二的位置
4. 以此类推，最后就会按照顺序把数组排好了

        使用方法

    <script>
        var arr = [76, 44, 98, 38, 99, 21]
        var n = arr.length
        // 外层循环，冒泡次数
        for (var i = 0; i < n - 1; i++) {
            // 内循环，交换元素
            for (var j = 0; j < n - i - 1; j++) {
                if (arr[j] > arr[j + 1]) {
                    var temp = arr[j]
                    arr[j] = arr[j + 1]
                    arr[j + 1] = temp
                }
            }
        }
        console.log(arr)    // [21, 38, 44, 76, 98, 99]
    </script>

（2）选择排序

        基本思想

• 在要排序的一组数中，选出最小的一个数与第一个位置的数交换
• 在剩下的数当中再找最小的与第二个位置的数交换
• 如此循环到倒数第二个数和最后一个数比较为止

       使用方法

    <script>
        var arr = [39, 49, 22, 98, 33, 54, 23]
        var n = arr.length
        // 外层循环排序次数
        for (var i = 0; i < n - 1; i++) {
            var minIndex = i
            // 内层循环找最小数并记录其位置
            for (var j = i + 1; j < n; j++) {
                if (arr[j] < arr[minIndex]) {
                    minIndex = j
                }
            }
            var temp = arr[i]
            arr[i] = arr[minIndex]
            arr[minIndex] = temp
        }
        console.log(arr)  // [22, 23, 33, 39, 49, 54, 98]
    </script>

数组去重

        使用数组indexOf()方法实现

1. 定义一个空数组newArr，用于存储不重复的数组元素
2. 循环遍历原数组
3. 判断新数组中是否有原数组元素，没有就放入

    <script>
        var arr = [10, 20, 30, 10, 20, 10, 20, 10, 10]
        var newArr = []
        for (var i = 0; i < arr.length; i++) {
            if (newArr.indexOf(arr[i]) == -1) {
                newArr.push(arr[i])
            }
        }
        console.log(newArr)  // [10, 20, 30]
    </script>