JavaScript循环结构及数组学习（学习日记七）

break语句和continue语句都具有跳转作用，可以让代码不按既有的顺序执行。

一、break语句

        break关键字：在循环中使用，遇到break立即跳出当前循环，用于跳出代码块或循环

        for循环也可以用break跳出循环

        //1.
        while(true) {
            console.log("我在循环");
            break;
        } 
        //2.
        for(var i = 0; i < 10; i++) {
            while(true) {
                console.log("我在循环");
                break;
            }
            console.log("for循环的");
            break;
        } 
        //3.
        var i = 0;
        while(i < 100) {
          console.log('i 当前为：' + i);
          i++;
          if (i === 10) break;//只会执行10次循环，一旦`i`等于10，就会跳出循环。
        }

        
        //4. 100-200之间找到第一个可以被7整除
        for(var i = 100; i <=200; i++) {
            if(i % 7 == 0) {
                console.log(i);
                break;
            }
        } 
        //5.
        for (var i = 0; i < 5; i++) {
            console.log(i);
            if (i === 3)
            break;
        }
        // 0
        // 1
        // 2
        // 3

        //6. 计算1-100的累加和，遇3停止
        var i = 1;
        var sum = 0;
        while(i <= 100) {
            if(i % 10 == 3) {
                i++;
                break;
            }
            sum += i;
            i++;
        }
        console.log(sum);

二、continue语句

continue关键字：在循环中遇到continue，直接开始下一次循环，continue后面的内容不会执行,用于立即终止本轮循环，返回循环结构的头部，开始下一轮循环。

//1.只有在`i`为奇数时，才会输出`i`的值。如果`i`为偶数，则直接进入下一轮循环。
    var i = 0;
    while (i < 100){
        i++;
    if (i % 2 === 0) continue;
    console.log('i 当前为：' + i);
}


//2.
    var i = 0;
        while(i < 10) {
            console.log(i);
            continue;
            i++;
        } 

 // 3.求200-300之间所有奇数的和（用continue）
        var i = 200;
        var sum = 0;
        while(i <= 300) {
            if(i % 2 == 0) {
                i++;
                continue;
            }
            sum += i;
            i++;
        }
        console.log(sum);// 12500 */

//4. 100-200的累加值，跳过所有个位数为3的数
        var i = 100;
        var sum = 0;
        while(i <= 200) {
            if(i % 10 == 3) {
                i++;
                continue;
            }
            sum += i;
            i++;
        }
        console.log(sum);// 13670

三、label（标签）

JavaScript允许语句的前面有标签（label），相当于定位符，用于跳转到程序中的任意位置

            label:

                语句;

            - 标签可以是任意的标识符，但是不能是保留字，语句部分可以是任意的语句。

            - 标签通常与break语句和continue语句配合使用，跳出特定的循环

//一个双重循环区块，`break`命令后面加上了`muxiao`标签（注意，`muxiao`不用加引号），满足条件时，直接跳出双层循环。如果`break`语句后面不使用标签，则只能跳出内层循环，进入下一次的外层循环。
muxiao:
        for(var i = 0; i < 3; i++) {
            for(var j = 0; j < 3; j++) {
                if(i === 1 && j === 1) break muxiao;
                console.log('i=' + i + '；j=' + j);
            }
        } 
        // i=0；j=0
        // i=0；j=1
        // i=0；j=2
        // i=1；j=0
        

        // 标签也可以用于跳出代码块
        foo: {
            console.log(1);
            break foo;
            console.log('本行根本不会输出');
        }
        console.log(2); 

        // continue语句也可以与标签配合使用
        top:
        for(var i = 0; i < 3; i++) {
            for(var j = 0; j < 3; j++) {
                if(i === 1 && j === 1) continue top;
                console.log('i=' + i + '；j=' + j);
            }
        }
        // i=0；j=0
        // i=0；j=1
        // i=0；j=2
        // i=1；j=0
        // i=2；j=0
        // i=2；j=1
        // i=2；j=2

四、总结

            - while语句包括了一个循环条件和一段代码块，只要条件为真，就不断循环执行代码块

            - do...while循环和while循环类似，唯一的区别就是线运行一次循环体，然后判断循环条件

            - for语句是循环命令的另一种形式，可以指定循环的起点、终点和终止条件

            - 所有for循环，都可以改写成while循环

            - for语句的三个部分（initialize、test、increment），可以省略任何一个，也可以全部省略，省略三个部分导致无限循环。

            - break语句和continue语句都具有跳转作用，可以让代码不按既有的顺序执行

            - break立即跳出整个循环，即循环结束，开始执行循环后面的内容（直接跳到大括号）

            - continue立即跳出当前循环，继续下一次循环（跳到i++的地方），continue语句用于立即终止本轮循环，返回循环结构的头部，开始下一轮循环

五、数组

数组(array)：一组有序的数据,每个值的位置都有编号（从0开始），整个数组用方括号表示。

作用：一次存储多个数据

用法：

                - 通过构造函数的方法创建数组

                    语法：var 数组名 = new Array();

                - 通过字面量的方式创建数组

                    字面量：把一个值/数据直接赋值给一个变量

                    语法：var 数组名 = [];

//构造函数的方法创建数组
var arr1 = new Array();// 定义了一个空数组
var arr2 = new Array(7);// 只有一个值，代表该数组中有7个元素，数组的长度是7，每一个数据都是空的，undefined
var arr3 = new Array(1, 2, 3, 'aaaaa', 5, '6', 7);// 代表当前数组中有数据，数组的长度就是这些数据的个数
console.log(arr1, arr2, arr3);

//字面量的方式创建数组
var arr1 = [];// 空数组
var arr2 = [9, 2];// 有值，数组的长度就是数据的个数
console.log(arr1, arr2);


//除了在定义时赋值，数组也可以先定义后赋值。

var arr = [];

arr[0] = 'a';
arr[1] = 'b';
arr[2] = 'c';

//任何类型的数据，都可以放入数组。

var arr = [
  {a: 1},
  [1, 2, 3],
  function() {return true;}
];

arr[0] // Object {a: 1}
arr[1] // [1, 2, 3]
arr[2] // function (){return true;}

//如果数组的元素还是数组，就形成了多维数组。
var a = [[1, 2], [3, 4]];
a[0][1] // 2
a[1][1] // 4

            - 数组的元素：数组中存储的每个数据

            - 数组的索引（下标）：用来存储数据，或者访问数组中的数据，索引从0开始，从长度-1结束
 

var arr = new Array(1, 2, 3, 4, 5, 6, 7);
        console.log(arr[0]);
        arr[3] = 999;
        console.log(arr);

        // .length获取当前数组的长度
        console.log(arr.length);

        //数组的`length`属性，返回数组的成员数量。
        ['a', 'b', 'c'].length // 3

        //只要是数组，就一定有`length`属性。该属性是一个动态的值，等于键名中的最大整数加上`1`。

        var arr = ['a', 'b'];
        arr.length // 2

        arr[2] = 'c';
        arr.length // 3

        arr[9] = 'd';
        arr.length // 10

        arr[1000] = 'e';
        arr.length // 1001

        //length`属性是可写的。如果人为设置一个小于当前成员个数的值，该数组的成员数量会自动减少到`length`设置的值。


        var arr = [ 'a', 'b', 'c' ];
        arr.length // 3

        arr.length = 2;
        arr // ["a", "b"]


        //清空数组的一个有效方法，就是将`length`属性设为0。

        var arr = [ 'a', 'b', 'c' ];
        arr.length = 0;
        arr // []

            - 数组的长度（length）：数组中元素的个数

            - 索引和长度的关系：最大索引值就是长度-1（length-1）

//本质上，数组属于一种特殊的对象。`typeof`运算符会返回数组的类型是`object`。

typeof [1, 2, 3] // "object"

//数组的特殊性体现在，它的键名是按次序排列的一组整数（0，1，2...）。

var arr = ['a', 'b', 'c'];
Object.keys(arr)
// ["0", "1", "2"]


//由于数组成员的键名是固定的（默认总是0、1、2...），因此数组不用为每个元素指定键名，而对象的每个成员都必须指定键名。JavaScript 语言规定，对象的键名一律为字符串，所以，数组的键名其实也是字符串。之所以可以用数值读取，是因为非字符串的键名会被转为字符串。

var arr = ['a', 'b', 'c'];
arr['0'] // 'a'
arr[0] // 'a'

//注意，这点在赋值时也成立。一个值总是先转成字符串，再作为键名进行赋值。

var a = [];

a[1.00] = 6;
a[1] // 6

//由于`1.00`转成字符串是`1`，所以通过数字键`1`可以读取值。

六、循环遍历数组

var arr = [1, 2, 3, 4];
        // 长度：4
        // 索引：0-3
    console.log(arr[0]);
    console.log(arr[1]);
    console.log(arr[2]);
    console.log(arr[3]);

    for(var i = 0; i <= arr.length - 1; i++) {
        console.log(arr[i]);
    }

// 数组中可以存数多种数据类型
var arr1 = [10, 'Cherry', true, undefined, new Object()];
    for(var i = 0; i <= arr1.length - 1; i++) {
        console.log(arr1[i]);
        } 

// 数组长度可以改变
        arr[7] = '哈哈';
        console.log(arr);

七、作业

 1.求arr1中的所有数据的和、平均值、最大值、最小值 

// 1.求arr1中的所有数据的和、平均值、最大值、最小值
        var arr1 = [104,204,520,44,300];
        var sum = 0;
        var avg = 0;
        var max = 0;
        var min = arr1[0];
        for(var i = 0;i <= arr1.length - 1;i++){
            sum = arr1[i] + sum;
            avg = sum / arr1.length;
            if(arr1[i] > max){
                max = arr1[i];
            }else if(arr1[i] < min){
                min = arr1[i];
            }
        }
        console.log('数据和为:' + sum);
        console.log('平均值为:' + avg);
        console.log('最大值为:' + max);
        console.log('最小值为:' + min); 
       

 2.将arr2中的数据用“|拼接起来，输出:muxiao | study | javascript

 // 2.将arr2中的数据用“|拼接起来，输出:muxiao | study | javascript
        var arr2 = [ 'muxiao' , 'study', 'javascript'];
        // console.log(arr2[0] + '|' +arr2[1] + '|' +arr2[2]);
        var sum = '';
        for(var i = 0;i <= arr2.length-1; i++){
            sum += arr2[i];
            if(i < arr2.length-1){
                sum += '|'
            }else{
                break;
            }
        }
        console.log(sum.toString()); 
        

3.将arr3中的数据翻转，首位对调，输出:[33,555,1,66，9，7]注:数组中数据可自拟 

// 3.将arr3中的数据翻转，首位对调，输出:[33,555,1,66，9，7]注:数组中数据可自拟
        
        var arr3 =[7,9,66,1,555,33];
        console.log(arr3.length);
        var num2 = arr3.length-1;
        var num1 = 0;
        for(var i = 0; i < arr3.length /2; i++){
            num1 = arr3[i];
            arr3[i] = arr3[num2 - i];
            arr3[num2- i] = num1;
        }
        console.log(arr3);