javascript学习笔记06

最新推荐文章于 2024-10-02 05:39:15 发布

WA终结者

最新推荐文章于 2024-10-02 05:39:15 发布

阅读量413

点赞数

分类专栏： web前端文章标签： javascript 前端开发语言

本文链接：https://blog.csdn.net/qq_53107845/article/details/121525900

版权

web前端专栏收录该内容

31 篇文章 0 订阅

订阅专栏

本文详细介绍了JavaScript中的控制流程语句，包括break和continue的使用，以及标签的运用。此外，还讲解了数组的创建和操作，以及函数的定义和调用。最后，讨论了变量的作用域和不同类型的变量。内容涵盖循环控制、数据组织和代码组织的基本概念。

摘要由CSDN通过智能技术生成

break关键字：

在循环中使用，遇到break立即跳出当前循环

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

        // 计算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后面的内容不会执行


        // 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

lable

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

label:

语句;

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

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

        /* cherry:
        for(var i = 0; i < 3; i++) {
            for(var j = 0; j < 3; j++) {
                if(i === 1 && j === 1) break cherry;
                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

数值

数组：一组有序的数据

作用：一次存储多个数据

用法：

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

语法：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);

        /* 
            数组的元素：数组中存储的每个数据
            数组的长度（length）：数组中元素的个数
            数组的索引（下标）：用来存储数据，或者访问数组中的数据，索引从0开始，从长度-1结束
            索引和长度的关系：最大索引值就是长度-1（length-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);

函数

函数：把一堆重复性的代码封装，哪里需要，那里调用

语法:

function 函数名(形参){

代码块;

return 返回值;

}

【形参】：函数【定义】的时候小括号里面的【变量】叫形参，形参名自定义

【实参】：函数【调用】的时候小括号里面的【值】叫实参，实参的值可以是变量，一般都是固定值

传值：函数调用的时候，小括号里面的值回传给函数定义时的参数

函数中有return关键字，return后面的代码不会执行

return后面有一个值，叫返回值，要接收返回值，用变量接收

return后面没有返回值，变量接收到的是undefined

可以返回不同的数据类型

没有括号返回的是整个函数体

        function f1(x, y) {
            var sum = x + y;
            console.log("return前的" + sum);
            return "a";
            console.log("return后的" + sum);
        }

       var result = f1(1, 2);

//结果为 return前的3

当需要传的参数自己也不知道个数时使用arguments

        function max() {
            // 通过arguments获取实参的值，本质是对象，其实是伪数组，具有数组才会有的属性length
            console.log(typeof arguments);
            var max = arguments[0];
            for(var i = 0; i < arguments.length; i++) {
                if(max < arguments[i]) {
                    max = arguments[i];
                }
            }
            return max;
        }
        var result = max(12, 22, 56, 3, 99, 21, 888, -52, -79);
        console.log(result);



//object
//888

命名函数：函数有名字

匿名函数：函数没有名字

function f1() {
    console.log('命名函数');
}

var f2 = function () {
    console.log('匿名函数');
};

函数的另一种定义方式

函数表达式：var 函数名/变量 = 匿名函数

函数的声明：function 函数名() {}

函数自调用，一次性调用，函数没有名字，相当于声明函数的同时直接调用

        (function() {
            console.log('撒浪嘿呦~');
        })();

        console.log(typeof f2);// function

作用域：使用的范围

全局变量：用var声明的变量，可以在页面中任何位置使用

局部变量：函数内部定义的变量，在函数外面不能使用

全局作用域：全局变量使用的范围

局部作用域：局部变量使用的范围

块级作用域：一对大括号{}中可以堪称是一块，在这个区域中定义的变量只能在这个区域中使用，在目前用法中没有涉及到块级作用域

隐式全局变量：声明的变量没有var

区别：

- 全局变量不能被删除

- 隐式全局变量能被删除

只有函数可以制造作用域结构，只要是代码，就至少有一个作用域

凡是代码中有函数，这个函数就构成另一个作用域，如果函数中还有函数，在这个作用域中又诞生一个作用域

将这样的所有作用域列出来，可以有一个结构：函数内指向函数外的一个链式结构，就是作用域链
        var num = 10;
        console.log(num);  //10
        function f1() {
            var num = 0;
            console.log(num);  //0
            function f2() {
                var num = 500;
                console.log(num);  //500
                function f3() {
                    var num = 200;  
                    console.log(num);  //200
                    function f4() {
                        var num = 100;
                        console.log(num);  //100
                    }
                    f4();
                    console.log(num);  //200
                }
                f3();
                console.log(num);  //500
            }
            f2();
            console.log(num);  //0
        }
        f1();
        console.log(num);  //10