JavaScript学习笔记6

最新推荐文章于 2024-11-02 19:19:35 发布
最新推荐文章于 2024-11-02 19:19:35 发布
阅读量131 收藏
点赞数 1
分类专栏： JS 文章标签： javascript 前端 开发语言
原文链接：https://www.bilibili.com/video/BV1Sy4y1C7ha?p=148&spm_id_from=333.851.header_right.history_list.click
版权

目录

函数没有return返回undefined

arguments的使用

伪数组

利用arguments求任意个数的最大值

利用函数翻转数组

利用函数封装进行冒泡排序

利用函数封装判断是否是闰年

函数可以调用另外一个函数

输出2月份天数

函数的两种声明方式

1.利用函数function关键字来自定义函数（命名函数）

2.函数表达式（匿名函数）

作用域

JavaScript作用域

全局作用域

局部作用域

变量作用域

全局变量

局部变量

区别

JS没有块级作用域

作用域链

JS预解析

预解析

变量预解析

函数预解析

预解析案例1

JavaScript对象（object）

对象是由属性和方法来组成的

属性

方法

创建对象的三种方法

利用字面量

结果​编辑​编辑

利用new Object

利用构造函数

  • 函数没有return返回undefined

    • 函数如果有return则返回的是return，如果没有 则返回undefined

    • return退出循环，且能够返回return语句中的值

    • 代码

      <!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>没有return返回undefined</title>
    <script>
        //4.函数如果有return则返回的是return，如果没有 则返回undefined
        function fun1() {
            return 666;
        }
        console.log(fun1());

        function fun2() {

        }
        console.log(fun2());
    </script>
</head>

<body>

</body>

</html>

    • 结果

  • arguments的使用

    • 只有函数才有arguments对象 而且每个函数都内置好了arguments

    • 当不确定有多少个参数传递，使用arguments获取参数

    • arguments是当前函数的内置对象

    • arguments存储了传递的所有实参

    •  

    • 伪数组

      • 1.不是真正意义上的数组

      • 2.具有数组的length的属性

      • 3.按照索引的方式进行存储

      • 4.但是它没有真正数组的一些方法：pop（）  push（）

      • 代码

        <!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>arguments的使用</title>
    <script>
        //伪数组 并不是真正意义上的数组
        function fn() {
            /* console.log(arguments);//里面存储了所有传递过来的实参
            console.log(arguments.length);//伪数组具有数组的length属性
            console.log(arguments[2]);//伪数组也用索引方式存储 */
            //我们可以使用数组的方式遍历arguments
            for (var i = 0; i < arguments.length; i++) {
                console.log(arguments[i]);
            }
        }
        fn(1, 2, 3);
        fn(1, 2, 3, 4, 5);

    </script>
</head>

<body>

</body>

</html>

         

      • 结果

    • 利用arguments求任意个数的最大值

      • 案例

        <!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>利用arguments求任意数的最大值</title>
    <script>
        function getMax() {
            var max = arguments[0];
            for (var i = 0; i < arguments.length; i++) {
                if (arguments[i] > max) {
                    max = arguments[i];
                }
            }
            return max;
        }
        console.log(getMax(1, 2, 3));
        console.log(getMax(1, 2, 3, 4, 5));
        console.log(getMax(11, 2, 34, 444, 5, 100));
    </script>
</head>

<body>

</body>

</html>

      • 结果

         

    • 利用函数翻转数组

      • 案例

        <!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>利用函数翻转数组</title>
    <script>
        //reverse 翻转的意思
        function reverse(arr) {
            var newArr = [];
            for (var i = arr.length - 1; i >= 0; i--) {
                newArr[newArr.length] = arr[i];
            }
            return newArr;
        }
        var arr1 = reverse([1, 3, 4, 6, 9]);
        console.log(arr1);
    </script>
</head>

<body>

</body>

</html>

      • 结果

    • 利用函数封装进行冒泡排序

      • 案例

        <!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>利用函数封装进行冒泡排序</title>
    <script>
        //sort排序的意思
        function sort(arr) {
            var temp;
            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]) {
                        temp = arr[j];
                        arr[j] = arr[j + 1];
                        arr[j + 1] = temp;
                    }
                }
            }
            return arr;
        }
        var re = sort([1, 9, 3, 15, 5]);
        console.log(re);
        var re2 = sort([9, 66, 45, 43]);
        console.log(re2);
    </script>
</head>

<body>

</body>

</html>

         

      • 结果

         

    • 利用函数封装判断是否是闰年

      • 案例

        <!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>利用函数封装判断是否是闰年</title>
    <script>
        //如果是闰年返回true 否则返回false
        function isRunYear(year) {
            var flag;
            if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0) {
                flag = true;
            } else {
                flag = false;
            }
            return flag;
        }
        var re = isRunYear(2012);
        console.log(re);
    </script>
</head>

<body>

</body>

</html>

      • 结果

         

    • 函数可以调用另外一个函数

      • 每个函数都是一个代码块，用于完成特殊任务，所以经常函数之间相互调用

      • 案例

        <!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>函数之间的相互调用</title>
    <script>
        //1.案例一
        /* function fn1() {
            console.log(11);
            fn2();//在fn1里面调用了fn2函数
        }
        fn1();
        function fn2() {
            console.log(22);
        } */
        //2.案例二 fn1与fn2之间的相互调用
        function fn1() {
            console.log(111);
            fn2();
            console.log('fn1');
        }

        function fn2() {
            console.log(222);
            console.log('fn2');
        }
        fn1();

    </script>
</head>

<body>

</body>

</html>

      • 结果

         

    • 输出2月份天数

      • 案例

        <!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>输出年份的2月份天数</title>
    <script>
        function backDay() {
            var year = prompt('请你输入年份');
            if (isRunYear(year)) {//实参year
                alert('当前年份是闰年2月份有29天');
            } else {
                alert('当前年份是平年2月份有28天');
            }
        }
        backDay();
        //2.判断是否是闰年的函数
        function isRunYear(year) {//形参year
            var flag;
            if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0) {
                flag = true;
            } else {
                flag = false;
            }
            return flag;
        }
    </script>
</head>

<body>

</body>

</html>

      • 结果

         

  • 函数的两种声明方式

    • 1.利用函数function关键字来自定义函数（命名函数）

    • 2.函数表达式（匿名函数）

      • 格式：var 变量名 = function（）{}；

      • 没有函数名

      • 函数表达式声明方式和变量差不多

      • 函数表达式也可以进行传递参数

      • 代码

        <!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>函数的两种生命方式</title>
    <script>
        //2.函数表达式 (匿名函数)
        //var 变量名 = function (aru) { };
        var fun = function (aru) {//fun是变量名不是函数名
            console.log(aru);
        }
        fun('多云');

    </script>
</head>

<body>

</body>

</html>

      • 结果

         

  • 作用域

    • JavaScript作用域

      • 就是代码名字在某个范围内起作用效果

      • 提高程序的可靠性，减少命名冲突

    • 全局作用域

      • 整个script标签或者一个单独的JS文件

    • 局部作用域

      • 在函数内部就是局部作用域  只在函数内部起效果和作用

      • 代码

        <!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script>
        //全局作用域
        var num = 10;
        //局部作用域
        function fn() {
            var num = 20;
            console.log(num);
        }
        fn();
    </script>
</head>

<body>

</body>

</html>

      • 结果

         

    • 变量作用域

      • 全局变量

        • 在全局作用域下的变量

        • 在代码任何位置都可以使用

        • 注意：在函数内部没有声明直接使用的变量也属于全局变量

      • 局部变量

        • 在局部作用域下

        • 在函数内部var声明的变量是局部变量

        • 函数的形参也是局部变量

      • 区别

        • 执行效率：全局变量只有浏览器关闭的时候才会销毁，比较占用资源；局部变量当程序执行完毕就会销毁，比较节约内存资源。

        • 代码

          <!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>变量作用域</title>
    <script>
        //1.全局变量  
        var num = 10;//num全局变量
        console.log(num);
        function fn() {
            console.log(num);
        }
        fn();
        //2.局部变量  函数内部变量
        function fun(aru) {
            var num1 = 10;//num1是局部变量 只能在函数内使用
            num2 = 20;//num2没有声明直接使用 也属于全局变量
        }
        fun();
        console.log(num1);//不能被调用
        console.log(num2);//注意 如果在函数内部没有声明，直接使用的变量也是全局变量

    </script>
</head>

<body>

</body>

</html>

        • 结果

           

    • JS没有块级作用域

      • 但是在es6新增了块级作用域

      • 块级作用域使用{}进行包含

      • 代码

        <!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>JS没有块级作用域</title>
    <script>

        if (3 > 5) {
            var num = 10;
        }
        console.log(num);//在块级作用域里面声明的变量 外面也可以使用 所以可以输出
    </script>
</head>

<body>

</body>

</html>

      • 结果

         

    • 作用域链

      • 只要是代码就有一个作用域

      • 如果函数中还有函数，那么在这个作用域中又诞生了新的作用域

      • 定义：内部函数访问外部函数的变量，采取链式方法查找决定哪些数据能被内部函数访问（就近原则）

      • 代码

      • <!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>作用域链</title>
    <script>
        var num = 10;
        function fn() {//外部函数
            var num = 20;
            function fun() {//内部函数
                console.log(num);//输出结果为20
            }
            fun();
        }
        fn();
    </script>
</head>

<body>

</body>

</html>

      • 结果

      • 案例1

        • 案例

          <!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>作用域链案例</title>
    <script>
        //案例1
        function f1() {//0级链
            var num = 123;//1级链
            function f2() {//1级链
                console.log(num);//2级链  输出1级链结果  123
            }
            f2();//1级链
        }
        var num = 456;//0级链
        f1();//0级链
        //案例2
        var a = 1;
        function fn1() {
            var a = 2;
            var b = '22';
            fn2();
            function fn2() {
                var a = 3;
                fn3();
                function fn3() {
                    var a = 4;
                    console.log(a);//输出结果为4
                    console.log(b);//输出结果为'2'
                }
            }
        }
        fn1();
    </script>
</head>

<body>

</body>

</html>

        • 结果 

           

    • JS预解析

      • JavaScript代码是由浏览器的JavaScript解析器来执行的

      •   解析器在运行JavaScript代码分为两步：预解析、代码执行

      • 预解析

        • JS引擎会把js里面所有的var 还有function提升到当前作用域的最前面

        • 变量预解析

          • 把所有的变量声明提升到当前作用域的最前面

          • 只提升声明，不提升赋值操作

        • 函数预解析

          • 把所有的函数声明提升到当前作用域的最前面，但是不调用函数。

          • 代码

            <!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>预解析</title>
    <script>
        //1.
        //console.log(num);  输出结果报错

        //2.
        /* console.log(num); 输出结果为undefined
        var num = 10; */
        //2.相当于执行了以下代码
        /* var num;
        console.log(num);
        num = 10; */

        //3.
        /* fn();
        function fn() {
            console.log(11); 输出结果为11，正常输出
        } */
        //3.相当于
        /* function fn(){
            console.log(11);
        }
        fn(); */

        //4.
        /* fun();
        var fun = function () {
            console.log(22);  输出结果报错，
        } */
        //4.相当于以下代码
        /* var fun;
        fun();
        fun =function(){
            console.log(22);
        } */

        //5.预解析


    </script>
</head>

<body>

</body>

</html>

      • 代码执行：执行代码书写顺序从上往下执行

    • 预解析案例1

      • 案例

        <!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>预解析案例/title>
        <script>
            //案例1
            var num = 10;
            fun();
            function fun() {
                console.log(num);//输出结果为undefined
                var num = 20;
            }
            //相当执行了一下操作
            /* var num;
            function fun() {
                var num;
                console.log(num); 只有输出结果没有赋值
                num = 20;
            }
            num = 10;
            fun(); */

            //案例2
            var num = 10;
            function fn() {
                console.log(num);//输出结果为undefined
                var num = 20;
                console.log(num);//输出结果为20
            }
            fn();
            //相当于一下代码
            /* var num;
            function fn() {
                var num;
                console.log(num);//输出结果为undefined
                num = 20;
                console.log(num);//输出结果为20
            }
            num = 10;
            fn(); */
        </script>
</head>

<body>

</body>

</html>

  • JavaScript对象（object）

    • 对象是一个具体事物

    • JavaScript对象是一组无序的相关属性和方法的集合，所有事物都是对象，例如字符串、数值、数组、函数

    • 对象是由属性和方法来组成的

      • 属性

        • 事物的特征，在对象中用属性表示（常用名词）

      • 方法

        • 事物的行为，在对象中用方法来表示（常用动词）

    • 创建对象的三种方法

      • 利用字面量

        • 对象字面量：花括号包含了表达这个具体事物的属性和方法

        • 注意事项

          • 里面的属性和方法采取键值对 键 属性名： 属性值

          • 多个属性或者方法使用逗号隔开，最后一个不需要

          • 方法冒号后面是一个匿名函数

          • 使用对象：

            • 调用对象属性

              • 1. 对象名.属性名  如 obj.uname；

              • 2.对象名['属性名'] 如obj['age'];

            • 调用对象的方法

              • 对象名.方法名（）;

              •  代码

                <!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script>
        var obj = {
            uname: '张三',//采取键值对形式 属性名：属性值
            age: 18,//不同属性或者方法采用逗号隔开
            sex: '男',
            sayHi: function () {//function方法
                console.log('Hi~');
            }
        }
        console.log(obj.uname);//调用uname对象名 对象名.属性名
        console.log(obj.age);//调用age对象名
        obj.sayHi();//调用函数  对象.方法名()
    </script>
</head>

<body>

</body>

</html>

              • 结果

      • 变量、属性、函数、方法区别

        • 变量和属性都是用来保存数据的

        • 变量单独声明并赋值  ，使用的时候直接写变量名

        • 属性在对象里面，不需要声明， 使用的时候是 对象.属性

        • 函数时单独声明，并且调用的， 而方法在对象里面，调用的时候 对象.方法（）

        • 代码

          <!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script>
        var num = 10;
        var obj = {
            age: 18,
            fn: function () {//这是方法  在对象里面

            }
        }
        function fn() {//这是函数

        }
        console.log(obj.age);
    </script>
</head>

<body>

</body>

</html>

        • 结果

           

      • 利用new Object

        • 语法：var 对象 = new Object

        • 对象名.属性 = 属性值;

        • 利用等号赋值的方法，添加对象属性和方法

        • 每个属性和方法之间用分号结束

        • 代码

          <!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
    <script>
        var obj = new Object();
        obj.uname = '张三';
        obj.age = 18;
        obj.sex = '男';
        obj.sayHi = function () {
            console.log('Hi~');
        }
    </script>
</head>

<body>

</body>

</html>

      • 利用构造函数

 

正在加载jjj
关注
专栏目录
Javascript学习笔记6 prototype的提出
01-19
首先我们继续上文的代码，我们来把这段代码延伸一下： 代码如下: [removed] var Person = function (name, age) { this.name = name; this.age = age; this.Introduce = function () { alert(...
javascript学习笔记
11-24
学习JavaScript时，了解这些基础知识是至关重要的。随着深入学习，你将接触到更高级的概念，如闭包、异步编程（回调函数、Promise、async/await）、模块系统以及现代框架如React、Vue和Angular的使用。JavaScript的...
web前端面试题之魂（js）
qq_45832807的博客
05-21 3753
JS基础 变量 面试题 1、JS使用typeof能得到哪些类型？ 考点： JS变量类型 typeof undefined, //undefined typeof 'abc' ,//string typeof 123 ,//number typeof true ,//boolean typeof {} ,//object typeof [] ,//object typeof null ,//object typeof console.log ,//function typeof Symbol(1) // sy
javascript中参数的详细理解
南风花海的博客
08-26 433
//形参、实参 functionadd(v1,v2){ console.log(v1,v2); console.log(add.length); console.log('内部变量',arguments); //形参的个数：函数名称.length //实参的个数：arguments.length console.log('arguments不被枚举到的值',arguments.length,arguments.callee); //[...
arguments.callee.length与arguments.length
WEB_YH的博客
04-29 921
arguments.callee.length:当前调用函数的实参长度是多少。 arguments.length：当前你传了多少个参数 function a(args0,args1){ console.log(arguments.length);//输出3 调用函数时传了多少个参数 console.log(arguments.callee.length);//输出2 函数括号里
arguments的使用
Var521的博客
02-25 523
在JavaScript中，arguments是当前函数的一个内置对象。所有函数都内置了一个arguments对象，arguments对象中存储了传递的所有实参。当我们不确定有多少个参数传递的时候，可以用arguments来获取。 1.arguments的使用 注：只有函数才有arguments对象，而且是每个函数都内置好了的arguments <script> ...
JS学习总结-----arguments的使用
m0_48716885的博客
01-18 622
在不知道有多少参数的情况下，这个时候就可以用arguments来获取，JS中arguments是当前函数的内置对象。函数中的一个arguements对象，而arguements对象中存储了传送过来的所有实参。 案例： <script> function arr() { console.log(arguments);//arguments中存储了传送过来的arr(1,2,3,4)所有实参 } arr(1,2,3,4); </script>
尚硅谷JavaScript高级学习笔记
javaThinker的专栏
03-08 1139
JavaScript中函数是对象。我们后续描述构造函数的内存模型时，会将构造函数称为构造函数对象。typeof 运算符来查看值的类型，它返回的是类型的字符串值 会做数据转换 输出： 每个函数都有一个prototype属性，它默认指向一个0bject空对象(即称为:原型对象) 给原型对象添加属性、方法，函数的所有实例对象自动拥有原型中的属性(方法) 16、显式原型和隐式原型 和 中保存的都是原型对象的地址值。Fun的prototype、f的__proto__属性什么时
Javascript入门学习笔记
weixin_61370021的博客
04-27 4678
JS入门学习笔记，JavaScript是目前web开发中不可缺少的脚本语言，js不需要编译即可运行，运行在客户端，需要通过浏览器来解析执行JavaScript代码。
Javascript学习笔记五
qwsadsdga的博客
12-03 462
JavaScript中函数的定义方式。
JavaScript学习笔记
08-16
### JavaScript学习笔记精要 #### 一、JavaScript概述 JavaScript是一种重要的编程语言，在现代Web开发中扮演着不可或缺的角色。它最初由Netscape公司的Brendan Eich在1995年开发完成，并且最初的名字叫做...
es6的this指向问题
06-15 122
普通函数 普通函数中的this，普通函数中的this表示调用此函数时的对象，如下例： var x=11; var obj={ x:22, say:function(){ console.log(this.x) } } obj.say(); //console.log输出的是22 //调用say函数的是对象obj，所以this指代对象obj，输出的就是obj对象里的x值...
CesiumJS 案例 P12：添加指定长宽的图片图层并居中显示（圆点分别为图片图层的中心点、左上角顶点、右上角顶点、左下角顶点、右下角顶点）
weixin_52173250的博客
10-30 1128
CesiumJS 案例 P12：添加指定长宽的图片图层并居中显示（圆点分别为图片图层的中心点、左上角顶点、右上角顶点、左下角顶点、右下角顶点）
JavaScript 生成二维码
qq_30049249的博客
11-02 120
我试过了，这一款js库支持中英文混合。进入网站后，可以直接点击运行哟～
基于vue框架的的汇生活家居商城的设计与实现bdjlq（程序+源码+数据库+调试部署+开发环境）系统界面在最后面。
h2345678的博客
10-29 1367
项目功能：商品分类,商品信息,用户。
JavaScript中this的指向和改变this指向的方法 - 2024最新版前端秋招面试短期突击面试题【100道】
everfoot的博客
10-29 679
了解this的工作原理是掌握JavaScript的关键之一，特别是在编写复杂的应用程序时。正确使用this可以避免许多常见的问题和错误。在实际开发中，合理选择不同的绑定方法，可以让你的代码更加灵活和易于维护。掌握这些this的知识点将帮助你在前端面试中脱颖而出！祝你顺利上岸！
echarts 遍历多个图表，并添加resize缩放
licongmingli的博客
10-30 224
遍历echarst多个图表，并添加独立的缩放函数
基于SpringBoot+Vue的快递物流信息查询系统设计与实现【前后端分离】
最新发布
m0_67428300的博客
11-02 603
随着电子商务的快速发展，快递物流系统的重要性愈发突出。针对用户对快递信息的实时查询需求，本系统结合Spring Boot和Vue技术，设计并实现了一个高效、易用的快递物流信息查询系统。系统实现了用户信息管理、订单查询、物流跟踪等功能，用户可通过简单操作即可查询快递状态，实现信息的实时展示。本快递物流信息查询系统基于Spring Boot与Vue的开发，前后端分离架构提升了系统的扩展性和开发效率。
JavaScript的第十一天
全栈学习ing
10-31 722
在使用offset系列时需注意该属性为css属性，一般用于和javascript结合使用来获取信息，所以在使用该属性时只能获取值而不能改变值。最近的具有定位属性的祖先元素顶部边缘左侧边缘。
JavaScript学习笔记：从基础到DOM编程
"这是一份全面的JavaScript学习笔记，涵盖了从CSS样式表基础到JavaScript语法、DOM编程等多个方面，旨在帮助读者深入理解并掌握JavaScript语言。" 在这份笔记中，作者首先介绍了CSS样式表的基本概念，包括什么是CSS...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值