一、数组对象

 1、·数组的概念：

        所谓数组，就是将多个元素（通常是同一类型)按一定顺序排列放到一个集合中，那么这个集合我们就称之为数组。

2、·数组的定义：

        数组是一个有序的列表，可以在数组中存放任意的数据，并且数组的长度可以动态的调整。·

3、创建数组对象的两种方式：

• 字面量方式
• new Array0)

4、

 // 声明数组
        // 第一种方式：使用Array对象创建
        var arr_1 = new Array()
        console.log(arr_1.length)
        var arr_2 = new Array('黄兵里', '赵硕', '柳青')
        console.log(arr_2.length)
            // 获取数组中的元素：数组名[下标]
        console.log(arr_2[1])

 // 数组的下标是从0开始的最大值可以取到数组的长度减一
        // 第二种方式： 使用字面量的方式（ 直接赋值）
        var arr_3 = [12, 45, 36, 59]
            // console.log(arr_3.length)

        // 打印出数组中的所有元素
        for (var i = 0; i < arr_3.length; i++) {
            console.log(arr_3[i])
        }

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

// 输出学生成绩中及格的成绩>59
        var scores = [90, 56, 78, 23, 9, 57, 65]
        for (var i = 0; i < scores.length; i++) {
            // 判断是否大于59
            if (scores[i] > 59) {
                console.log(scores[i], i)
            }
        }

// 打印出一个数组中的所有奇数之和
        var scores = [90, 56, 78, 23, 9, 57, 65]
        var sum = 0
        for (var i = 0; i < scores.length; i++) {
            if (scores[i] % 2 != 0) {
                sum += scores[i]
                console.log(scores[i])
            }
        }
        console.log(sum)

5、常用函数：

• 向数组中添加元素:
  • push(:向数组末尾添加元素
  • unshifto:向数组前面添加元素
• 删除数组中的元素:
  • pop():删除并返回数组中的最后一个元素
  • shift():删除并返回数组中的第一个元素
•  排序和反转: 
  • sort():进行升序排列
  • reaverseo:颠倒元素顺序
• 拼接元素: concat()，join()
• 从指定位置删除指定长度的元素:splice()
• 复制从指定位置到结束位置的元素: slice()
• 获取指定元素的索引: indexOf(）

        //数组中常用的一些函数
        var arr_4 = [90, 56, 78, 23, 9, 57, 65]
            //push():向数组的末尾添加一个元素
        var result = arr_4.push(100)


        //unshift():向数组的前面添加一个元素
        result = arr_4.unshift(60)
        console.log(result, arr_4)


        //pop():删除数组中的最后一个元素并返回
        var result_2 = arr_4.pop()
        console.log(result_2, arr_4)


        //shift():删除数组中的第一个元素并返回
        result_2 = arr_4.shift()
        console.log(result_2, arr_4)

        var arr_5 = ['jeason', 'mary', 'lily']
        var result_3 = arr_5.sort() //进行升序，先将数组中的元素转换成字符串之后再进行升序
        console.log(result_3)
        var arr_6 = ['jeason1', 'mary1', 'lily1']
        console.log(arr_6.reverse())
            //将字符串类型的数组进行降序排列:先试用sort()，然后再使用reverse( )进行倒叙
            //将一个数组中的所有元素拼接成 - 一个字符串，用逗号隔开
            //var str='
        console.log(arr_6.join(",")) //将数组以某个符号进行拼接，返回一个字符串
        var arr_7 = ["aa", "bb"]
        console.log(arr_6.concat(arr_7)) //将某个元素添加到数组的末尾

        // 从指定位置删除指定长度的元素splice()
        var arr_8 = [12, 345, 67, 89, 100, 237]
            // console.log(arr_8.splice(2, 2), arr_8)
            // 复制从指定位置到结束位置的元素：slice()
        console.log(arr_8.slice(1, 4), arr_8)
            // 获取指定位置的索引：indexOf
        console.log(arr_8.indexOf(100))

        //定义一个数值比较函数：当a小于b时，a在b面前,返回一个小于0的数，
        // 当a>b时，a在b的后面，返回一个大于0的数，当a等于b时，返回0
        function compare(a, b) {
            if (a < b) {

            } else {

            }
        }

6、案例

// 数组的去重问题
        var arr_9 = [90, 100, 78, 65, 100, 78, 66, 30, 65]
            //最后得到的结果是[90,100,65,78,66,30]
            // 先定义一个空数组，用来存放不重复的元素
        var newArr = []
        for (var i = 0; i < arr_9.length; i++) {
            // 判断一下将要添加的元素是否存在于新数组newArr中，如果存放，反之，
            // 则将该元素添加到新的数组中
            if (newArr.indexOf(arr_9[i]) == -1) {
                // 将不重复的元素放到新数组newArr中
                newArr.push(arr_9[i])
            }
            // newArr.push(arr_9[0])
            // newArr.push(arr_9[1])
            // newArr.push(arr_9[2])
            // newArr.push(arr_9[3])
            // newArr.push(arr_9[6])
            // newArr.push(arr_9[7])
        }
        console.log(newArr)

// 将数组中的元素进行转换，不适用reverse()函数
        var arr = [10, 20, 30, 50, 80]
            // var temp = arr[0]
            // arr[0] = arr[4]
            // arr[4] = temp
            // var temp2 = arr[1]
            // arr[1] = arr[3]
            // arr[3] = temp2
        for (var i = 0; i < arr.length / 2; 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)

// 清空数组

        // arr = []

        // arr.length = 0

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

二、冒泡排序

冒泡排序的原理：
        每一趟只能确定将一个数归位。即第一趟只能确定将末位上的数归位，第二趟只能将倒数第 2 位上的数归位，依次类推下去。如果有 n 个数进行排序，只需将 n-1 个数归位，也就是要进行 n-1 趟操作。而 “每一趟 ” 都需要从第一位开始进行相邻的两个数的比较，将较大的数放后面，比较完毕之后向后挪一位继续比较下面两个相邻的两个数大小关系，重复此步骤，直到最后一个还没归位的数。

// 冒泡排序
        var arr_10 = [10, 50, 30, 15, 80]
            // 比较了几轮
        for (var i = 0; i < arr_10.length - 1; i++) {
            for (var j = 0; j < arr_10.length - i - 1; j++) {
                // 当前面的元素值大于后面相邻元素的值时，两者的值进行交换。
                if (arr_10[j] > arr_10[j + 1]) {
                    var temp = arr_10[j]
                    arr_10[j] = arr_10[j + 1]
                    arr_10[j + 1] = temp
                }
            }
        }
        console.log(arr_10)

 三、函数

1、什么是函数：

        把一段相对独立的具有特定功能的代码块封装起来，形成一个独立实体，就是函数，起个名字(函数名)，在后续开发中可以反复调用

        函数的作用就是封装一段代码，将来可以重复使用

2、函数的定义：

function函数名（）{

        //函数体

}

  // 求两个数的个
        function sun() {
            var a = 10
            var b = 20
            console.log(a + b)
        }
        //调用函数
        sum()

案例

        // 计算20+70的结果
        function sum_1() {
            var a = 20
            var b = 70
            console.log(a + b)
        }
        sum_1(20, 70)
            //90

// 利用给函数传参数的方法解决
        // 如何定义带有参数的函数
        function sum(a, b) {
            console.log(a + b)
        }
        // 调用带有参数的函数
        sum(10, 20) //30
        sum(20, 70)  //90
        sum(90, 100)  //190
            /*
            函数定义时， 函数名后面的参数： 形参(形式参数)
            函数调用时， 函数名后面的参数： 实际(实际参数) 
            */

函数表达式：

var 函致名= function(){

        //函数体

}

特点:

        函数声明的时候，函数体并不会执行。只有当函数被调用的时候才会执行

调用函数的语法:

函数名();

// 定义一个函数，用来打招呼
        function sayHello() {
            console.log("hello")
        }
        //调用函数：函数名(参数列表)
        sayHello()
            // 赋值式
        var eat = function() {
                console.log("喜欢吃")
            }
            // 调用函数：
        eat()
        /*区别：
            声明式：可以先调用在声明
            赋值式：必须先定义，后调用
        */

案例

 // 求1-100之间的所有偶数之和
        function test_2(n) {
            var result = 0 //
            for (var i = 1; i <= n; i++) {
                // 判断是否是偶数
                if (i % 2 == 0) {
                    result += i
                }
            }
            console.log("和:" + result)
        }
        // 求1-100之间的所有偶数之和
        test_2(100)
            // 求1-200之间的所有偶数之和
        test_2(200)

// 打印九九乘法表和六六乘法表
        function sum_2(n) {
            for (var i = 1; i < n + 1; i++) {
                for (var j = 1; j <= i; j++) {
                    document.write(j + "*" + i + "=" + (j * i) + "    ")
                }
                document.write("<br>")
            }
        }
        sum_2(9)
        document.write("<br>")
        sum_2(6)

 // 求一个长方形的面积
        function test_1(long, width) {
            console.log(long, width)
        }
        test_1(5, 3) // 15

// 利用给函数传参数的方法解决：将函数中的某一个结果在函数外获取到
        // 修改成带有返回值的函数
        function test_3(long, width) {
            return long * width
        }
        var result = test_3(5, 3)
        if (result % 2 == 0) {
            console.log("是偶数")
        } else(
            console.log("是奇数")
        )
        if (result % 5 == 0) {
            console.log("能被5整除")
        } else(
            console.log("不能被5整除")
        )