Array对象的简介 数组的声明 案例：//打印数组的所有奇数 数组中常用的函数 数组中的去重问题 将一个数组的元素的顺序进行反转案例 使用函数减少代码的重复问题：冒泡排序

数组的声明

// 1.声明对象
        //第一种方式 使用Array 数组创建对象
        var arr_1 = new Array()
        console.log(arr_1.length) //数组的长度
        var arr_2 = new Array("大名", "二名", "三名")
        console.log(arr_2[1]) //[下标从0开始]
            // 第二种方式 直接声明
        var arr_3 = [12, 23, 34, 45]
            //打印所有元素
            //第一种
        console.log("............................")

        for (let i = 0; i < arr_3.length; i++) {
            // const element = array[i];
            console.log("第一种：" + arr_3[i])

        }
        //第二种
        console.log("............................")
        for (var i in arr_3) {
            console.log("第二种：" + arr_3[i])
        }

案例：//打印数组的所有奇数

//求数组中的所有奇数，的累加求和
        var sum = 0
        var shu_z = new Array(1, 2, 3, 4, 5, 6, 7, 8, 9, 0)
        for (var i = 0; i < shu_z.length; i++) {
            // const element = array[i];
            if (shu_z[i] % 2 != 0) {
                // console.log(shu_z[i])
                sum += shu_z[i]
            }
        }
        console.log("和：" + sum)

数组中常用的函数

push()在数组末尾填元素

unshift()在数组的前面添加元素

pop()删除并返回数组的最后一个元素        

shift() 删除并返回数组的第一个

 var arr_4 = [1, 2, 3, 4, 5]
        var result = arr_4.push(10)
        console.log(arr_4)
        var result = arr_4.unshift(99)
        console.log(arr_4)
        var result = arr_4.pop()
        console.log(arr_4)
        var result = arr_4.shift()
        console.log(arr_4)

        var arr_5 = ["q", "w", "a", "b", "c"]
        console.log(arr_5.sort())   //字符串按照abc排列
        console.log(arr_5.reverse()) //颠倒顺序
        console.log(arr_5.join(".")) //在每个元素中间用 · 分开
        console.log(arr_5.concat("john")) //在最后添加一个元素

效果：

从指定位置删除指定元素 splice 将删除的元素进行返回（从那开始， 几个元素）

复制从指定位置到结束位置的元素 slice（“开始位置的下标”，结束的个数不包含末尾的元素）

var arr = [43, 54, 65, 4, 3, 23, 32, 39]

        function name(a, b) {
            if (a < b) {
                return -1
            } else if (a > b) {
                return 1
            } else {
                return 0
            }
        }
        console.log(arr.sort(name))

利用比较函数实现函数值的升序排列

当a小于b时 返回一个小于0的数 

数组中的去重问题

1.第一种

获取指定元素的索引 indexOf("元素")返回元素的下标 只返回第一个字符的索引 没有就返回-1

  // 数组的去重问题
        var arr_4 = [1, 2, 3, 4, 2, 3, 5, 6, 7, 5, 6, 7, 8, 9, 0]
        var newarr = [] //定义一个空数组
        for (let i = 0; i < arr_4.length; i++) {
            // const element = array[i];
            // console.log(arr_4[i]) //数组中的元素
            // indexOf("元素")返回元素的下标 只返回第一个字符的索引 没有就返回-1
            if (newarr.indexOf(arr_4[i]) == -1) {
                //push()向末尾添加元素
                newarr.push(arr_4[i])
            }
        }
        console.log(newarr)

 2.第二种

// 第二种 去重方法
        //会破坏原数组
        var arr_4 = [1, 2, 3, 4, 2, 3, 5, 6, 7, 5, 6, 7, 8, 9, 0]
        for (let i = 0; i < arr_4.length; i++) {
            // const element = array[i];
            var cent = arr_4[i]
            for (let j = i + 1; j < arr_4.length; j++) {
                // const element = array[j];
                if (arr_4[j] == cent) {
                    // splice("指定数组","指定长度")
                    arr_4.splice(j, 1)
                }
            }
        }
        console.log(arr_4)

 1.将一个字符串数组的元素的顺序进行反转。["a", "b", "c", "d"] -> [ "d","c","b","a"]。（不能使用reverse()函数）

        var arr = ["a", "b", "c", "d"]
        for (let i = 0; i < arr.length / 2; i++) {
            // const element = array[i];
            var temp = arr[i]
                // arr.length-i-1 最后一个元素的下标
            arr[i] = arr[arr.length - i - 1]
            arr[arr.length - i - 1] = temp
        }
        console.log(arr)

冒泡排序

// 冒泡排序
        var arr_5 = [1, 2, 3, 4, 2, 3, 5, 6]
        for (let i = 0; i < arr_5.length; i++) {
            // const element = array[i];
            for (let j = 0; j < arr_5.length - i - 1; j++) {
                // const element = array[j];
                if (arr_5[j] > arr_5[j + 1]) {
                    var temp = arr_5[j]

                    arr_5[j] = arr_5[j + 1]

                    arr_5[j + 1] = temp
                }
            }
        }
        console.log(arr_5)

清空数组

1.arr[ ]

2.arr.length = 0

3.arr.splice(0,arr.length)

使用函数减少代码的重复问题：

函数最大的特点就是可以是我们的代码块复用

     <script>
        function text(arr) {
            for (let i = 0; i < arr.length - 1; i++) {
                // const element = array[i];
                // arr_5.length - i - 1 循环次数每次都 -i 避免和最大的（最小的）重复比较 
                for (let j = 0; j < arr.length - i - 1; j++) {
                    // const element = array[j];
                    if (arr[j] > arr[j + 1]) {
                        var temp = arr[j]
                        arr[j] = arr[j + 1]
                        arr[j + 1] = temp
                    }
                }
            }
            console.log(arr)
        }
        var arr_5 = [1, 2, 3, 4, 2, 3, 5, 6]
        var arr_1 = [43, 54, 65, 4, 3, 23, 32, 39]
        text(arr_5)
        text(arr_1)
    </script>

 声明式：先调用，在声明

赋值时：必须先定义，后调用

求两个数的和

function name2(a, b) {
            console.log(a + b)
        }
        name2(1, 2)

 1-n 之间的偶数之和

// 1-n 的偶数之和
        function name(a) {
            var sum = 0
            for (let i = 1; i <= a; i++) {
                // const element = array[i];
                if (i % 2 == 0) {
                    // console.log(i)
                    sum += i
                }

            }
            console.log(sum)
        }
        name(100)

return  声明的可以被调用        

 function name2(a, b) {
            return (a + "*" + b + "=" + a * b)
        }
        // name2(1, 2)
        // console.log(name2(1, 2))
        var result = name2(2, 6)
        if (result % 2 == 0) {
            console.log("偶数")
        } else {
            console.log("奇数")
        }

 不用return  不可以被调用

 function name(c, d) {
            console.log(c * d)
        }
        name(2, 3)