数组Array

1. 数组概念

2. 数组创建

2.1 利用 new 创建数组

2.2 利用数组字面量创建数组

2.3 数组元素类型

3. 获取元素

4. 遍历元素

4.1 数组遍历

4.2 数组长度

4.3 代码示例

5. 新增元素

6. 数组案例

6.1 计算数组的和以及平均值

求数组 [2,6,1,7, 4] 里面所有元素的和以及平均值

<script>
        // 1. 求数组 [2,6,1,7, 4] 里面所有元素的和以及平均值。
        // (1)声明一个求和变量 sum。
        // (2)遍历这个数组，把里面每个数组元素加到 sum 里面。
        // (3)用求和变量 sum 除以数组的长度就可以得到数组的平均值。
        var arr = [2, 6, 1, 7, 4];
        var sum = 0;
        var average = 0;
        for (var i = 0; i < arr.length; i++) {
            sum += arr[i]; // 我们加的是数组元素 arr[i] 不是计数器 i
        }
        average = sum / arr.length;
        console.log(sum, average); // 想要输出多个变量，用逗号分隔即可
</script>

6.2 求数组最大值

求数组[2,6,1,77,52,25,7]中的最大值

<script>
        // 2、求数组[2,6,1,77,52,25,7]中的最大值
        // 声明一个保存最大元素的变量 max。
        // 默认最大值可以取数组中的第一个元素。
        // 遍历这个数组，把里面每个数组元素和 max 相比较。
        // 如果这个数组元素大于max 就把这个数组元素存到 max 里面，否则继续下一轮比较。
        // 最后输出这个 max
        var arr = [2, 6, 1, 77, 52, 25, 7, 99];
        var max = arr[0];
        for (var i = 1; i < arr.length; i++) {
            if (arr[i] > max) {
                max = arr[i];
            }
        }
        console.log('该数组里面的最大值是：' + max);
</script>

6.3 数组转换为字符串

将数组 [‘red’, ‘green’, ‘blue’, ‘pink’] 转换为字符串，并且用 | 或其他符号分割

<script>
        // 3、将数组 ['red', 'green', 'blue', 'pink'] 转换为字符串，并且用 | 或其他符号分割
        // 1.需要一个新变量用于存放转换完的字符串 str。
        // 2.遍历原来的数组，分别把里面数据取出来，加到字符串里面。
        // 3.同时在后面多加一个分隔符
        var arr = ['red', 'green', 'blue', 'pink'];
        var str = '';
        var sep = '*';
        for (var i = 0; i < arr.length; i++) {
            str += arr[i] + sep;
        }
        console.log(str);
</script>

6.4 数组存放1-10个字

新建一个数组，里面存放10个整数（ 1~10）

<script>
        // 4、新建一个数组，里面存放10个整数（ 1~10）
        // 核心原理：使用循环来追加数组。
        // 1、声明一个空数组 arr。
        // 2、循环中的计数器 i  可以作为数组元素存入。
        // 3、由于数组的索引号是从0开始的， 因此计数器从 0 开始更合适，存入的数组元素要+1。
        var arr = [];
        for (var i = 0; i < 100; i++) {
            // arr = i; 不要直接给数组名赋值 否则以前的元素都没了
            arr[i] = i + 1;
        }
        console.log(arr);
</script>

6.5 筛选数组

将数组 [2, 0, 6, 1, 77, 0, 52, 0, 25, 7] 中大于等于 10 的元素选出来，放入新数组。

<script>
        // 5、将数组 [2, 0, 6, 1, 77, 0, 52, 0, 25, 7] 中大于等于 10 的元素选出来，放入新数组。
        // 1、声明一个新的数组用于存放新数据newArr。
        // 2、遍历原来的旧数组， 找出大于等于 10 的元素。
        // 3、依次追加给新数组 newArr。
        // 方法1
        var arr = [2, 0, 6, 1, 77, 0, 52, 0, 25, 7];
        var newArr = [];
        var j = 0;
        for (var i = 0; i < arr.length; i++) {
            if (arr[i] >= 10) {
                // 新数组索引号应该从0开始 依次递增
                newArr[j] = arr[i];
                j++;
            }
        }
        console.log(newArr);

        // 方法2 
        var arr = [2, 0, 6, 1, 77, 0, 52, 0, 25, 7];
        var newArr = [];
        // 刚开始 newArr.length 就是 0
        for (var i = 0; i < arr.length; i++) {
            if (arr[i] >= 10) {
                // 新数组索引号应该从0开始 依次递增
                newArr[newArr.length] = arr[i];
            }
        }
        console.log(newArr);
</script>

6.6 数组去重

将数组[2, 0, 6, 1, 77, 0, 52, 0, 25, 7]中的 0 去掉后，形成一个不包含 0 的新数组。

<script>
        // 6、将数组[2, 0, 6, 1, 77, 0, 52, 0, 25, 7]中的 0 去掉后，形成一个不包含 0 的新数组。
        // 1、需要一个新数组用于存放筛选之后的数据。
        // 2、遍历原来的数组， 把不是 0 的数据添加到新数组里面(此时要注意采用数组名 + 索引的格式接收数据)。
        // 3、新数组里面的个数， 用 length 不断累加。
        var arr = [2, 0, 6, 1, 77, 0, 52, 0, 25, 7];
        var newArr = [];
        for (var i = 0; i < arr.length; i++) {
            if (arr[i] != 0) {
                newArr[newArr.length] = arr[i];
            }
        }
        console.log(newArr);
</script>

6.7 数组翻转

将数组 [‘red’, ‘green’, ‘blue’, ‘pink’, ‘purple’] 的内容反过来存放

<script>
        // 6、将数组 ['red', 'green', 'blue', 'pink', 'purple'] 的内容反过来存放
        // 1、声明一个新数组 newArr
        // 2、把旧数组索引号第4个取过来（arr.length - 1)，给新数组索引号第0个元素 (newArr.length)
        // 3、我们采取 递减的方式  i--
        var arr = ['red', 'green', 'blue', 'pink', 'purple', 'hotpink'];
        var newArr = [];
        for (var i = arr.length - 1; i >= 0; i--) {
            newArr[newArr.length] = arr[i]
        }
        console.log(newArr);
</script>

6.8 冒泡排序

<script>
        // 8、冒泡排序
        // var arr = [5, 4, 3, 2, 1];
        var arr = [4, 1, 2, 3, 5];
        for (var i = 0; i <= arr.length - 1; i++) { // 外层循环管趟数 
            for (var j = 0; j <= arr.length - i - 1; j++) { // 里面的循环管 每一趟的交换次数
                // 内部交换2个变量的值 前一个和后面一个数组元素相比较
                if (arr[j] < arr[j + 1]) {
                    var temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
        console.log(arr);
</script>

6.9 一些函数与数组小案例

<!-- 
        1. 写一个函数，能返回传入的任意两个数字的最大值。
        2. 写一个函数，能返回传入的任意三个数字的最大值。
        3. 写一个函数，能判断传入的一个数值是否是质数，如果是质数返回true，如果不是质数返回false，(质数：从2开始只能被1和自身整数的数)
        4. 写一个函数，能翻转传入的任意数组，并把翻转结果通过返回值返回。
        5. 写一个函数，能对所有传入的数组按照从小到大进行排序，并把排序结果通过返回值返回
     -->
    <script>
        // 1. 写一个函数，能返回传入的任意两个数字的最大值。
        function max(num1, num2) {
            return num1 > num2 ? num1 : num2;
        }
        console.log(max(23, 56));

        // 2. 写一个函数，能返回传入的任意三个数字的最大值。
        function getMax(arr) {
            var max = 0;
            for (var i = 0; i < arr.length; i++) {
                if (arr[i] > max) {
                    max = arr[i];
                }
            }
            return max;
        }
        console.log(getMax([23, 45, 14]))
        
        // 3. 写一个函数，能判断传入的一个数值是否是质数，如果是质数返回true，如果不是质数返回false，(质数：从2开始只能被1和自身整数的数)
        function Prime(params) {
            for (var i = 2; i < params; i++) {
                if (params % i != 0) {
                    return true
                } else {
                    return false
                }
            }
        }
        console.log(Prime(5));

        // 4. 写一个函数，能翻转传入的任意数组，并把翻转结果通过返回值返回。
        function arr(arr1) {
            var arr2 = new Array();
            for (var i = arr1.length - 1; i >= 0; i--) {
                arr2[arr2.length] = arr1[i]
            }
            return arr2;
        }
        console.log(arr([12, 23, 34, 5, 45, 56]));

        // 5. 写一个函数，能对所有传入的数组按照从小到大进行排序，并把排序结果通过返回值返回
        function arra(arr) {
            for (var i = 0; i < arr.length - 1; i++) {
                for (var j = 0; j <= arr.length - i - 1; j++) {
                    if (arr[j] > (arr[j + 1])) {
                        var temp = arr[j];
                        arr[j] = arr[j + 1];
                        arr[j + 1] = temp;
                    }
                }
            }
            return arr;  
        }
        console.log(arra([12, 23, 34, 5, 45, 56]));
</script>