JavaScript学习笔记03

最新推荐文章于 2024-07-08 16:22:29 发布
最新推荐文章于 2024-07-08 16:22:29 发布
阅读量197 收藏 1
点赞数 1
分类专栏： JavaScript学习笔记合集 文章标签： javascript 学习 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_53983068/article/details/132893459
版权

JavaScript笔记03

流程控制

if 判断

  • 和 Java 中if语句的使用方法相同。
  • 例：
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <script>
        "use strict";
        let score = 90;

        if (score === 100) { // 第一个判断
            alert("great");
        } else if (score >= 60 && score < 100) { // 第二个判断
            alert("pass");
        } else { // 否则...
            alert("fail");
        }
    </script>
</head>
<body>

</body>
</html>
  • 查看浏览器弹窗：

在这里插入图片描述

while 循环

  • 和 Java 中while循环语句的使用方法相同。
  • 注意：避免使用死循环。
  • 例：
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <script>
        "use strict";
        let age = 0;

        while (age < 100) {
            age = age + 1;
            console.log(age);
        }
    </script>
</head>
<body>

</body>
</html>
  • 查看浏览器控制台：

在这里插入图片描述

  • 补充：do...while...循环：
"use strict";
let age = 0;

do {
    age = age + 1;
    console.log(age);
} while (age < 100);

for 循环

  • 和 Java 中for循环语句的使用方法相同。
  • 例：
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <script>
        "use strict";
        for (let i = 0; i < 100; i++) {
            console.log(i);
        }
    </script>
</head>
<body>

</body>
</html>
  • 查看浏览器控制台：

在这里插入图片描述

forEach 循环

  • forEach()的使用方法参考：JavaScript Array forEach() 方法

  • 在 JavaScript 中，我们可以使用forEach()函数循环遍历数组中的元素。（ES 5.1）

  • 例：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <script>
        "use strict";
        let fruits = ["apple", "banana", "watermelon", "pear", "strawberry"];

        fruits.forEach(function (value) {
            console.log(value);
        });
    </script>
</head>
<body>

</body>
</html>
  • 查看浏览器控制台：

在这里插入图片描述

for…in 循环

  • for...in的使用方法参考：JavaScript For In
  • 除了forEach()方法，在 JavaScript 中，我们还可以使用for...in语句来循环遍历数组中的元素。
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <script>
        "use strict";
        let fruits = ["apple", "banana", "watermelon", "pear", "strawberry"];

        for (let index in fruits) {
            console.log(fruits[index])
        }
    </script>
</head>
<body>

</body>
</html>
  • 查看浏览器控制台：

在这里插入图片描述

  • 我们也可以使用for...in语句来循环遍历对象的属性。
  • 例：
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <script>
        "use strict";
        let person = {
            name: "张三",
            age: 18,
            gender: "男",
            hobby: "打篮球"
        }

        for (let key in person) {
            console.log(person[key])
        }
        
    </script>
</head>
<body>

</body>
</html>
  • 查看浏览器控制台：

在这里插入图片描述

for…of 循环

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <script>
        "use strict";
        let fruits = ["apple", "banana", "watermelon", "pear", "strawberry"];

        for (let fruit of fruits) {
            console.log(fruit)
        }
    </script>
</head>
<body>

</body>
</html>
  • 查看浏览器控制台：

在这里插入图片描述

集合 - Map 和 Set

  • ES6 的新特性~

Map

  • Map对象是键值对的集合。
  • 例：
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <script>
        "use strict";
        // Map和Set   ES6+
        // 学生的名字，学生的成绩
        // let names = ["Tom", "Jerry", "Spike"];
        // let score = [100,90,80];

        // 创建Map对象 - 保存键值对，并且能够记住键的原始插入顺序
        let map = new Map([["Tom", 100], ["Jerry", 90], ["Spike", 80]]);

        // get() - 通过key获得value
        let score1 = map.get("Tom");
        console.log(score1);

        // set() - 为Map对象添加或修改一个键值对
        map.set("Tuffy", 60); // 添加
        console.log(map);

        map.set("Jerry", 95); // 修改
        console.log(map);
        
        // delete() - 删除键值对
        map.delete("Spike");
        console.log(map);
    </script>
</head>
<body>

</body>
</html>
  • 查看浏览器控制台：

在这里插入图片描述

Set

  • Set对象是值的集合。Set集合中的元素只会出现一次，即集合中的元素是唯一的（可以去重~）。
  • 例：
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <script>
        "use strict";
        // 创建Set对象 - 保存值，并且集合中的元素不重复，有序
        let set = new Set([1, 1, 1, 1, 3, 4, 4, 4]);
        console.log(set);

        // add() - 添加元素
        set.add(2);
        console.log(set);

        // delete() - 删除元素
        set.delete(1);
        console.log(set);

        // has() - 判断Set对象是否包含某个元素
        console.log(set.has(3));
    </script>
</head>
<body>

</body>
</html>
  • 查看浏览器控制台：

在这里插入图片描述

iterator

  • 使用for...of语句来遍历Map和Set集合对象。（ES 6+）

遍历Map对象

  • 例：
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <script>
        "use strict";
        let map = new Map([["Tom", 100], ["Jerry", 90], ["Spike", 80]]);

        for (let student of map) {
            console.log(student);
        }
    </script>
</head>
<body>

</body>
</html>
  • 查看浏览器控制台：

在这里插入图片描述

遍历Set对象

  • 例：
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <script>
        "use strict";
        let set = new Set([1, 1, 1, 1, 3, 4, 4, 4]);

        for (let num of set) {
            console.log(num);
        }
    </script>
</head>
<body>

</body>
</html>
  • 查看浏览器控制台：

在这里插入图片描述

函数

  • 函数是 JavaScript 中的基本组件之一，它是一组可以随时随地运行的语句。 当一个函数是一个对象的属性时，称之为方法。

定义函数

  • 使用function关键字来定义函数。

定义方式一

  • 定义一个取绝对值函数：
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <script>
        "use strict";
        function abs(x) {
            if (x >= 0) {
                return x;
            } else {
                return -x;
            }
        }
    </script>
</head>
<body>

</body>
</html>
  • 一旦执行到retrun，函数就将停止执行，返回结果。
  • 打开浏览器控制台，使用我们刚才定义的取绝对值函数abs()，分别传入一个正数和一个负数，查看结果：

在这里插入图片描述

  • 补充：如果函数无明确的返回值，或调用了没有参数的return语句， 那么它的返回值为：undefined。

定义方式二

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <script>
        "use strict";
        // 匿名函数 - 没有函数名。
        // 将结果赋值给变量abs，通过abs就可以调用该匿名函数！
        let abs = function (x) {
            if (x >= 0) {
                return x;
            } else {
                return -x;
            }
        }
    </script>
</head>
<body>

</body>
</html>
  • 打开浏览器控制台，向函数abs()中分别传入一个正数和一个负数，查看结果：

在这里插入图片描述

  • 可以发现使用这两种方式来定义函数的效果是一样的。

参数问题

  • 参数问题：JavaScript 可以传任意个参数，也可以不传递参数~
  • 例：
    • 我们打开浏览器控制台，向之前定义的取绝对值函数abs()中分别传入多个参数和不传递参数，查看结果：

在这里插入图片描述

  • 可以看到程序依旧成功执行了，且并没有报错或提示出现异常。规避参数不存在的问题

规避参数不存在的问题

  • 我们可以通过手动判断并抛出异常的方式来规避参数不存在的问题。
  • 例：
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <script>
        "use strict";
        let abs = function (x) {
            // 手动抛出异常
            if (typeof x != "number") { // typeof - 返回一个字符串，表示操作数的类型
                throw "Not a Number";
            }
            if (x >= 0) {
                return x;
            } else {
                return -x;
            }
        }
    </script>
</head>
<body>

</body>
</html>
  • 打开浏览器控制台，不向函数abs()中传递任何参数，查看结果：

在这里插入图片描述

  • 可以看到程序提示了我们手动定义的异常Not a Number。

arguments

  • arguments是一个对应于传递给函数的参数的类数组对象。它代表传递进函数的所有参数，是一个数组。参考：Arguments 对象 - JavaScript
  • 例：
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <script>
        "use strict";
        let abs = function (x) {
            console.log("x=>"+x);

            for (let i = 0; i < arguments.length; i++) {
                console.log(arguments[i]);
            }
            
            if (x >= 0) {
                return x;
            } else {
                return -x;
            }
        }
    </script>
</head>
<body>

</body>
</html>
  • 打开浏览器控制台，给abs()函数传入多个参数，查看结果：

在这里插入图片描述

剩余参数 - rest

  • 剩余参数语法允许我们将一个不定数量的参数表示为一个数组。 （ES 6+）
  • 剩余参数只能写在所有参数的最后面，用...标识。
  • 例：
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <script>
        "use strict";
        let aaa = function (x, y, ...rest) {
            console.log("x=>" + x);
            console.log("y=>" + y);
            console.log("rest=>" + rest);
        }
    </script>
</head>
<body>

</body>
</html>
  • 打开浏览器控制台，给aaa()函数传入分别传入一个，两个以及多个参数，查看结果：

在这里插入图片描述

变量的作用域

  • 在 JavaScript 中，var定义的变量实际是有作用域的。

局部变量

  • 语句块中声明的变量将成为语句块所在函数的局部变量。
  • 假设在函数体中声明，则在函数体外不可以使用 ~（ 如果非要在函数体外引用的话，需要使用 闭包）
  • 例：
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <script>
        function abc() {
            var x = 1;
            x = x + 1;
        }

        x = x + 2; // Uncaught ReferenceError: x is not defined
    </script>
</head>
<body>

</body>
</html>
  • 打开浏览器控制台，发现程序报错：Uncaught ReferenceError: x is not defined

在这里插入图片描述

  • 如果两个函数使用了相同的变量名，只要都在函数内，就不冲突。
  • 例：
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <script>
        function abc() {
            var x = 1;
            x = x + 1;
        }

        function xyz() {
            var x = 10086;
            x = x + 1;
        }
    </script>
</head>
<body>

</body>
</html>
  • 函数abc()和函数xyz()都使用了x作为变量名，但都在函数体内，所以两者的变量名不会发生冲突，程序能够正常运行，不会报错。
  • 内部函数可以访问外部函数的成员，反之则不行。
  • 例：
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <script>
        function abc() {
            var x = 1;

            function xyz() {
                var y = x + 1; // 2
            }

            var z = y + 1; // Uncaught ReferenceError: z is not defined
        }
    </script>
</head>
<body>

</body>
</html>
  • 打开浏览器控制台，输入console.log(z);，查看结果：

在这里插入图片描述

  • 假设内部函数和外部函数的变量重名。
  • 例：
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <script>
        function abc() {
            var x = 1;

            function xyz() {
                var x = "A";
                console.log("inner => " + x);
            }
            console.log("outer => " + x);
            xyz(); // inner => A
        }
        abc(); // outer => 1
    </script>
</head>
<body>

</body>
</html>
  • 打开浏览器控制台，查看结果：

在这里插入图片描述

  • 在 JavaScript 中，函数会从自身开始，由内向外查找变量，假设外部存在这个同名的函数变量，则内部函数会屏蔽外部函数的变量（双亲委派机制）。

提示变量的作用域

  • 我们先来看以下代码：
    • 我们将需要调用变量y的语句写在变量y的声明与赋值语句之前：
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <script>
        function abc() {
            var x = "x" + y;
            console.log(x);
            var y = "y";
        }
        abc(); // xundefined
    </script>
</head>
<body>

</body>
</html>
  • 打开浏览器控制台，查看结果：

在这里插入图片描述

  • 原因：JavaScript 的执行引擎自动提升了变量y的声明，但却不会提升变量y的赋值。这是在 JavaScript 建立之初就存在的特性。
  • 由于 JavaScript 存在以上的特性，所以我们在编码过程中要规范书写顺序，用到的变量必须是前面定义过的，不要乱放，以便代码维护。
  • 例：
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <script>
        "use strict";
        function xyz() {
            var x = 10,
                y = 3,
                z,i; // undefined

            z = x + y;
            i = x - y;
            console.log(z);
            console.log(i);
        }
        xyz();
    </script>
</head>
<body>

</body>
</html>
  • 打开浏览器控制台，查看结果：

在这里插入图片描述

全局变量

  • 在函数之外声明的变量，叫做全局变量，它可被当前文档中的任何其他代码所访问。
  • 例：
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <script>
        "use strict";
        var x = 1;
        function f() {
            console.log(x);

        }
        f();
        console.log(x);
    </script>
</head>
<body>

</body>
</html>
  • 打开浏览器控制台，查看结果：

在这里插入图片描述

全局对象 - window

  • window对象表示一个浏览器窗口或一个框架。在 JavaScript 中，window对象是全局对象，所有的表达式都在当前的环境中计算。 也就是说在 JavaScript 中，默认所有的全局变量都会自动绑定在window对象下。（函数本身也可以是变量）
  • 例如：我们常用的弹窗函数alert()就可以写成window.alert()；同样的，我们定义的全局变量x也可以写作window.x：
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <script>
        "use strict";
        var x = 1;
        // 以下三种写法的表示的效果是相同的
        alert(x);
        window.alert(x);
        window.alert(window.x);
    </script>
</head>
<body>

</body>
</html>
  • 这三种写法的表示的效果是相同的：

在这里插入图片描述

  • 大胆尝试：
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <script>
        "use strict";
        var x = "xxx";

        window.alert(x);

        var old_alert = window.alert;

        // old_alert(x);

        window.alert = function () {

        };

        // 发现alert()失效了
        window.alert(123);

        // 恢复
        window.alert = window.old_alert;
        window.alert(456);
    </script>
</head>
<body>

</body>
</html>
  • 以上尝试说明了 JavaScript 实际上只有一个全局作用域（window），任何变量（函数本身也可以作为变量），假设在函数作用范围内没有找到，就会向外查找。如果在全局作用域（window）中都没有找到，那么就会报错：ReferenceError（引用异常）。
  • 例：
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <script>
        window.alert(x);
    </script>
</head>
<body>

</body>
</html>
  • 打开浏览器控制台，查看结果：

在这里插入图片描述

规范

  • 由于在 JavaScript 中，我们所有的全局变量都会绑定到window对象上。所以如果我们的项目中同时存在多个 js 文件，且它们之中使用了同名的全局变量，就会产生冲突。那么，我们应该如何减少这样的冲突呢？
  • 我们可以自己定义一个唯一全局变量来代替window对象，把自己的代码全部放进自己定义的唯一的空间名字中，通过这种方式来减少全局命名冲突的问题（ jQuery 就是使用的这种方式 ）。例：
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <script>
        // 唯一全局变量
        var MyApp = {};

        // 定义全局变量
        MyApp.name = "clown";
        MyApp.add = function (a, b) {
            return a + b;
        }
    </script>
</head>
<body>

</body>
</html>

局部作用域 - let

  • 我们先来看一个例子 - 在for循环体中使用var定义变量，然后我们再在循环体外调用这个变量：
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <script>
        function aaa() {
            for (var i = 0; i < 100; i++) {
                console.log(i);
            }
            console.log(i + 1);
        }
        aaa();
    </script>
</head>
<body>

</body>
</html>
  • 打开浏览器控制台，查看结果：

在这里插入图片描述

  • 我们发现，使用var定义变量时，即使除了循环体，我们也能调用到在循环体中定于的变量。这就说明发生了作用域冲突问题。
  • 为了解决作用域冲突这一问题，于是在 ES 6 就新推出了一个关键字：let。通过它，就能解决作用域冲突问题。它和var的区别在于：var定义的变量在其所在的整个函数体内都是可以被调用的，而let定义的变量只在其所在的语句块里可以被调用。
  • 下面我们把上面代码中的var改为let：
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <script>
        function aaa() {
            for (let i = 0; i < 100; i++) {
                console.log(i);
            }
            console.log(i + 1); // Uncaught ReferenceError: i is not defined
        }
        aaa();
    </script>
</head>
<body>

</body>
</html>
  • 打开浏览器控制台，查看结果：

在这里插入图片描述

  • 我们发现：在使用let定义循环体中的变量之后，循环体外的语句便不能再调用它了，作用域冲突问题得到了解决。
  • 所以，建议在编程过程中都使用let来定义局部作用域中的变量。

常量 - const

  • 和let一样，const也是 ES 6 推出的新特性。
  • 在 ES 6 推出之前，常量的定义方式：变量名的字母全部为大写字母的变量就代表常量（通过这种方法定义的 “常量” 本质上还是一个变量，它的值是可以被修改的）。所以如果我们在工作过程中见到了这样的变量名全部定义为大写的变量，建议不要去随意修改它的值，因为很可能它表示的是一个常量。
  • 例：
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <script>
        // 在 ES6 推出之前，约定俗成，名字全部用大写字母表示的变量，就代表它为常量
        var PI = 3.14;
        PI = 2;
        console.log(PI); // 这样定义的常量的值其实是可以被改变的
    </script>
</head>
<body>

</body>
</html>
  • 打开浏览器控制台，查看结果：

在这里插入图片描述

  • 所以，为了解决上述问题，规范编码，在 ES 6 中就推出了关键字 - const，用来定义常量（只读变量）。
  • 例：
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <script>
        // 在 ES6 推出了 const 关键字，用来定义只读变量（常量）
        const PI = 3.14;
        PI = 2; // Uncaught TypeError: Assignment to constant variable.
        console.log(PI);
    </script>
</head>
<body>

</body>
</html>
  • 我们可以发现 IDEA 会报错并提示我们该变量值是只读的，不允许修改：

在这里插入图片描述

  • 运行：发现程序报错：Uncaught TypeError: Assignment to constant variable.

在这里插入图片描述

Bald Monkey
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
javascript学习笔记
11-24
JavaScript 是一种具有面向对象能力的、解释型的程序设计语言。更具体一点，它是基于对象和事件驱动并具有相对安全性的客户端脚本语言。因为他不需要在一个语言环境下运行，而只需要支持它的浏览器即可。它的主要...
Ruffy javascript 学习笔记
10-29
Ruffy javascript 学习笔记
Javascript入门学习笔记
weixin_61370021的博客
04-27 4588
JS入门学习笔记，JavaScript是目前web开发中不可缺少的脚本语言，js不需要编译即可运行，运行在客户端，需要通过浏览器来解析执行JavaScript代码。
JavaScript学习笔记
qq_53388077的博客
03-30 1523
JavaScript是一门跨平台、面向对象的脚本语言，是用来控制网页行为的。脚本语言通常直接解释执行，不需要编译，缩短了传统编程语言的运行过程/*定义格式：var 对象名={属性名1：属性值1，属性名2：属性值2，属性名3：属性值3，函数名称：function(形参列表){}*/var user={age:20,alert("用膳");//简化方法：eat(){alert("用膳");
javaScript学习笔记（一）js基础
热门推荐
一叶知秋
09-21 13万+
================================= 公众号 关注一波 （一叶知秋博客） 不定期分享视频资料 一、简介 1、概述： JavaScript是目前web开发中不可缺少的脚本语言，js不需要编译即可运行，运行在客户端，需要通过浏览器来解析执行JavaScript代码。 诞生于1995年，当时的主要目的是验证表单的数据是否合法。 Java...
JavaScript 学习笔记 超详细（b站pink老师）
weixin_59531237的博客
05-10 5606
1. JavaScript （是什么？是一种运行在客户端（浏览器）的编程语言，实现人机交互效果。2. 作用（做什么？– 网页特效 (监听用户的一些行为让网页作出对应的反馈)– 表单验证 (针对表单数据的合法性进行判断)– 数据交互 (获取后台的数据, 渲染到前端)– 服务端编程 (node.js)3. JavaScript的组成（有什么？
JavaScript新手入门学习笔记
qq_43389754的博客
12-04 4万+
JavaScript介绍 1.1 前端三要素 HTML 超文本标记语言 决定了网页中的视图内容 CSS 层叠样式表 决定了网页中的视图效果 JavaScript 赋予网页动态功能 1.2 JavaScript简介 JavaScript是一种基于对象的事件驱动型、弱类型的脚本语言 基于对象：区别于Java中的面向对象，遵循对象.方法的规则，但是没有类的概念 事件驱动：脚本语言代码需要由网页中的事件来触发执行 脚本语言：JS作为寄生语言，写在HTML网页中 JavaScript在1995年
javascript 学习笔记
Katios
05-25 7221
注释“//”表示单行注释 “/* */”可以用来多行注释变量1.变量必须使用字母、下划线(_)或者美元符($)开始。2.然后可以使用任意多个英文字母、数字、下划线(_)或者美元符($)组成。3.不能使用JavaScript关键词与JavaScript保留字4.变量区分大小写 javascript作为一种脚本语言可以放在html页面中任何位置，但是浏览器解释html时是按先后顺序的，所以前
Javascript全程学习笔记
B_cecretary的博客
04-21 4339
Javascript语句查询 1、document.write( ); 只能在 HTML 输出中使用 document.write。如果您在文档加载后使用该方法，会覆盖整个文档。 2、alert( ); 在 JavaScript 中并不常用，但它对于代码测试非常方便。 3、document.getElementById(“ID”); 会经常看到 document.getElementById(“some id”)，这个方法是 HTML DOM 中定义的。 DOM (Document Object
JavaScript 学习笔记 ——document
我有两颗糖
02-20 5903
1. 浏览器环境 JavaScript 语言最初是为 Web 浏览器创建的。此后，它已经发展成为一种具有多种用途和平台的语言。 下面是 JavaScript 在浏览器中运行时的鸟瞰示意图： windows 是根对象，它充当 JavaScript 的全局对象以及代表着浏览器窗口，提供控制浏览器窗口的方法。 1.1 DOM 文档对象模型 DOM 将所有页面内容表示为可以修改的对象，document 是页面的入口，可以利用它修改创建 HTML 的内容，可以参考 DOM： document.bodyDOM.st
JavaScript基础知识学习笔记
weixin_43739821的博客
01-05 732
引入方式 基础语法 书写语法 变量 数据类型和运算符 函数function 第一种定义格式 第二种定义格式 闭包 对象 基本对象 Array对象 String对象 自定义对象 JSON对象 BOM对象 Window对象 Location对象 DOM对象 DOM介绍 获取DOM对象 操作DOM对象 案例 javascript事件 javascript事件简介 javascript事件绑定 常见javascript事件 javascript事件案例
JavaScript学习笔记（一）
SH041218121的博客
03-13 1592
前提提要： 学习视频来源：B站尚硅谷。 软件：HBuilder 浏览器：谷歌浏览器 这边记录个人学习笔记。 基本输出语句： 新建一个.html文件，在head中建立一个script中书写语句。 1、alert("在浏览器窗口弹出一个警告框"); 2、document.write("可以向body中输出一个内容") ; 3、console.log("向控制台输出一个内容"); ...
JavaScript 学习笔记（十一）
10-29
继续学习的是document对象。
HTML_表单 和 表单案例
secret010的博客
07-05 276
【代码】HTML_表单 和 表单案例。
什么是防抖和节流？如何理解它们并在不同的场景条件下灵活运用？
最新发布
Vinca@的博客
07-08 522
防抖（Debouncing）和节流（Throttling）是两种常见的性能优化技术，常用于控制某些操作（例如事件处理器）的频率，从而减少资源消耗并提高性能。防抖：在事件停止触发后的指定时间内执行函数。适用于需要等用户停止操作后再处理事件的场景。节流：在指定时间间隔内最多执行一次函数。适用于需要限制函数执行频率的场景。滚动停止后的操作：使用防抖。滚动过程中的持续操作：使用节流。根据具体需求选择适合的优化技术可以有效提高应用性能和用户体验。
Vue 3集成krpano 全景图展示
Mr丶GUO
07-06 363
Vue 3集成krpano 全景图展示，需要借助官方工具进行制作注意事项：vue@cli3没有static，需要放在public目录下。
lightchart 和百度echarts 有什么区别, 各自优势是什么
huanghm88的专栏
07-08 134
总体而言，Lightchart和百度Echarts都是强大的图表库，选择使用哪个取决于具体的需求和个人偏好。如果您对界面简洁和定制化有较高要求，可以选择Lightchart；社区活跃：百度Echarts拥有广泛的用户群体和开发者社区，用户可以通过社区获取到丰富的文档、教程和示例，解决问题和获取帮助。易于使用：Lightchart提供了方便易用的API和丰富的文档和示例，使用户能够快速上手并灵活使用图表库。成熟稳定：百度Echarts已经发布了多个版本，经过了长时间的发展和优化，具有较高的稳定性和可靠性。
JS混淆基本类型和原理
朴拙科技的博客
07-06 564
混淆技术为JS代码提供了一定程度的保护，但同时也给代码的维护和逆向工程带来了挑战。了解和掌握这些混淆技术的原理和解析方法，可以帮助开发者更好地保护或理解JS代码。然而，需要注意的是，混淆并不是万无一失的安全措施，它更多的是增加了攻击者理解代码的难度。在进行逆向工程时，应始终遵守法律法规，尊重知识产权，不要用于非法目的。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值