继承和进阶函数

最新推荐文章于 2024-07-09 22:08:35 发布
最新推荐文章于 2024-07-09 22:08:35 发布
阅读量116 收藏 2
点赞数 3
分类专栏： JavaScript 前端学习 函数 文章标签： js 函数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46492364/article/details/118032886
版权
前端学习 同时被 3 个专栏收录
38 篇文章 1 订阅
订阅专栏
JavaScript
18 篇文章 1 订阅
订阅专栏
函数
2 篇文章 0 订阅
订阅专栏

文章目录

前言

这部分学习继承和进阶函数，深化js学习。

一、继承

1.对象拷贝

通过for in的方式将父级的内容拷贝给子级。

<!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>
</head>
<body>
    <script>
        var laoli = {
            name: "laoli",
            money: 1000000,
            house: ["商铺","住宅"],
            tech: function () {
                console.log("厨艺");
            }
        };
        var xiaoli = {
            name: "xiaoli"
        };
        //封装一个继承的函数
        function extend(parent,child) {
            for (var k in parent){
            //判断子级是否含有父级的元素
            if (child[k]) {
                continue;
            }
            child[k] = parent[k];
            }
        }
        //调用函数 实现继承
        extend(laoli,xiaoli);
        console.log(xiaoli);
    </script>
</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>Document</title>
</head>
<body>
    <script>
        //人类类型
        function Person(name,age,sex) {
            this.name = name;
            this.age = age;
            this.sex = sex;
        }
        //学生类型
        function Student(score) {
            this.score = score;
        }
        //老师类型
        function Teacher(salary) {
            this.salary = salary;
        }
        //通过原型让学生继承人类
        Student.prototype = new Person("zs",18,"男");
        Student.prototype.constructor = Student;
        var s1 = new Student(88);
        var s2 = new Student(100);
        console.log(s2);
    </script>
</body>
</html>

3.构造函数属性继承

（1）call方法
功能：既能执行函数，又能将this的指向改变
参数：第一个参数是this指向的内容，第二个及后续参数是执行函数的参数

<!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>
</head>
<body>
    <script>
        //call方法有两个功能
        //1.能够将内容指向this
        //2.执行函数
        function fn(a,b) {
            console.log(this);
            console.log(a+b);
        }
        var o = {
            name: "lm"
        }
        //call有两个参数，第一个参数是指向this，第二个及以后的参数是正常的需要执行函数的参数
        fn.call(o,3,4);
    </script>
</body>
</html>

（2）构造函数属性继承（通过使用call方法）

<!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>
</head>
<body>
    <script>
        //人类类型
        function Person(name,age,sex) {
            this.name = name;
            this.age = age;
            this.sex = sex;
        }
        //学生类型
        function Student(name,age,sex,score) {
            Person.call(this,name,age,sex);
            this.score = score;
        }
        //老师类型
        function Teacher(name,age,sex,salary) {
            Person.call(this,name,age,sex);
            this.salary = salary;
        }
        var s1 = new Student("zs",17,"男",88);
        var s2 = new Student("ls",19,"男",90);
        console.dir(s1);
        console.dir(s2);
        
    </script>
</body>
</html>

4.构造函数方法继承

（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>Document</title>
</head>
<body>
    <script>
        //人类类型
        function Person(name,age,sex) {
            this.name = name;
            this.age = age;
            this.sex = sex;
        }
        Person.prototype.sayHi = function () {
            console.log("你好");
        };
        //学生类型
        function Student(name,age,sex,score) {
            Person.call(this,name,age,sex);
            this.score = score;
        }
        //第一种方式：拷贝继承
        for (var k in Person.prototype) {
            //将constructor重新指向Student
            if (k === "constructor") {
                Student.prototype.constructor = Student;
            }
            Student.prototype[k] = Person.prototype[k];
        }
        //第二种方式：原型继承
        // Student.prototype = new Person();
        // Student.prototype.constructor = Student;
        //老师类型
        function Teacher(name,age,sex,salary) {
            Person.call(this,name,age,sex);
            this.salary = salary;
        }
        var s1 = new Student("zs",17,"男",88);
        var s2 = new Student("ls",19,"男",90);
        console.dir(s1);
        console.dir(s2);
        s1.sayHi();
    </script>
</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>Document</title>
</head>
<body>
    <script>
        //人类类型
        function Person(name,age,sex) {
            this.name = name;
            this.age = age;
            this.sex = sex;
        }
        Person.prototype.sayHi = function () {
            console.log("你好");
        };
        //学生类型
        function Student(name,age,sex,score) {
            Person.call(this,name,age,sex);
            this.score = score;
        }
        //第一种方式：拷贝继承
        // for (var k in Person.prototype) {
        //     //将constructor重新指向Student
        //     if (k === "constructor") {
        //         Student.prototype.constructor = Student;
        //     }
        //     Student.prototype[k] = Person.prototype[k];
        // }
        //第二种方式：原型继承
        Student.prototype = new Person();
        Student.prototype.constructor = Student;
        //老师类型
        function Teacher(name,age,sex,salary) {
            Person.call(this,name,age,sex);
            this.salary = salary;
        }
        var s1 = new Student("zs",17,"男",88);
        var s2 = new Student("ls",19,"男",90);
        console.dir(s1);
        console.dir(s2);
        s1.sayHi();
    </script>
</body>
</html>

5.组合继承

组合继承：属性继承在构造函数内部继承，方法继承通过原型对象继承。

<!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>
</head>
<body>
    <script>
        //组合继承：属性继承在构造函数内部继承，方法继承通过原型对象继承
        function Person(name,age) {
            this.name = name;
            this.age = age;
        }
        Person.prototype.sayHi = function () {
            console.log("你好");
        };
        //一个子级继承父级的属性和方法
        function Student(name,age,score) {
            //继承父级的属性
            Person.call(this,name,age);
            this.score = score;
        }
        //继承父级方法
        Student.prototype = new Person();
        Student.prototype.constructor = Student;
        //创建实例
        var s1 = new Student("gg",22,100);
        console.log(s1.name);
        s1.sayHi();
    </script>
</body>
</html>

二、函数进阶

1.函数的调用和this

函数调用根据目前的学习，在五种情况下，有五种不同的调用方法，同时this的指向也不同，但this的具体指向要根据实际调用的情况来决定。
在这里插入图片描述
接下来通过代码来体验不同方式调用函数的方式以及this的指向。

<!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>
</head>
<body>
    <script>
        //五种不同的函数调用方式
        //1.普通函数调用通过变量名加（）来调用
        //默认this指向window
        function fun() {
            console.log("普通函数调用");
        }
        fun();
        //2.构造函数通过new方式调用
        //this指向实例对象
        function Person(name) {
            this.name = name;
        }
        var fn = new Person("gg");
        //3.对象函数通过对象打点调用
        //this指向该方法所使用的对象
        var funs = {
            sayHi: function () {
                console.log("对象函数");
            }
        };
        funs.sayHi();
        //4.事件函数，当事件执行时就自动进行调用
        //this指向事件函数
        document.onclick = function () {
            console.log("事件函数");
        }
        //5.定时器和延时器，在规定时间内自动进行调用
        //this指向window
        setInterval(function () {
            console.log("定时器");
        },1000)
    </script>
</body>
</html>

2.改变this指向的三种方法

（1）call
（2）apply
（3）bind
下面通过代码来看各种方法的功能、参数及返回值。

<!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>
</head>
<body>
    <script>
        function fn(a,b) {
            console.log(this);
            console.log(a+b);
        }
        var o = {
            name: "hg"
        };
        //call方法
        //1.功能：更改this指向的对象，执行函数并传参数
        //2.参数：第一个参数是this指向的对象，第二个以后的参数指向的是参数列表
        //3.返回值：返回的是函数执行的结果
        fn.call(o,1,2);
        //apply方法
        //1.功能：更改this指向的对象，执行函数并传参数
        //2.参数：第一个参数是this指向的对象，第二个以后的参数是参数数组
        //3.返回值：返回的是函数执行的结果
        fn.apply(o,[2,3]);
        //bind方法
        //1.功能：更改this指向的对象，不能执行函数，但可以传参数
        //2.参数：第一个参数是this指向的对象，第二个以后的参数指向的是参数列表，参数可以接收存储
        //3.返回值：this的指向
        var fn = fn.bind(o,2,5);
        console.log(fn);
        fn(6,8);
    </script>
</body>
</html>

3.call的应用

使用call方法改变this的指向，可以将this指向数组，从而给对象添加一些数组可以使用的方法，那么对象就也可以使用数组的方法了。

<!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>
</head>
<body>
    <script>
        var o = {
            0: 10,
            1: 20,
            2: 30,
            length: 3
        }
        //将this指向数组，借用数组的push方法，给对象添加最后一项数据
        Array.prototype.push.call(o,40);
        console.log(o);

    </script>
</body>
</html>

4.apply的应用

同样的，可以利用apply方法将this指向Math，从而给数组添加一些数组没有的方法。

<!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>
</head>
<body>
    <script>
        var arr = [1,2,6,9,3];
        //数组本身是不具备给数组中的数找最大值的，但是Math中的max方法可以找最大值
        //那么我们就可以将this指向max，从而让数组也可以找最大值
        console.log(Math.max.apply(null,arr));

        //可以将数组输出为零散的数，而不是一个数组
        console.log(arr);
        console.log.apply(null,arr);
    </script>
</body>
</html>

5.bind的应用

在只指定this并且不需要执行函数的时候使用，那么就可以应用于事件函数更改this和定时器内部函数更改this，接下来用代码进行进一步的理解。

<!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>
</head>
<body>
    <script>
        //更改定时内部函数的this
        var o = {
            name: "zs",
            age: 18,
            timer: function () {
                setInterval(function () {
                    console.log(this.age);
                }.bind(this),1000);
            }
        }
        o.timer();

        //更改事件函数内部的this
        document.onclick = function () {
            console.log(this);
        }.bind(o);

    </script>
</body>
</html>

6.高阶函数

两种情况下是高阶函数：
（1）参数作为另一个函数的参数
（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>Document</title>
</head>
<body>
    <script>
        //高阶函数
        //函数作为另一个函数的参数
        function eat(fn) {
            console.log("吃饭");
            fn();
        }
        eat(function () {
            console.log("看书");
        });
        //函数的返回值是一个函数
        function outer(n) {
            return function inner(m) {
                console.log(m+n);
            }
        }
        var fun = outer(100);
        fun(3);
        fun(20);
        var fun1 = outer(1000);
        fun1(2);
        fun1(30);
    </script>
</body>
</html>

三、闭包

1.闭包的理解和应用

一个函数和对其周围状态（lexical environment，词法环境）的引用捆绑在一起（或者说函数被引用包围），这样的组合就是闭包（closure）。也就是说，闭包让你可以在一个内层函数中访问到其外层函数的作用域。在 JavaScript 中，每当创建一个函数，闭包就会在函数创建的同时被创建出来。
闭包的用途：可以在函数外部读取内部成员，让函数内的成员始终存活在内存中。
函数定义时天生就能记住自己生成的作用域环境和函数自己，将它们形成一个密团的环境，这就是闭包。不论函数以任何方式在任何地方进行调用，都会回到自己定义时的密闭环境进行执行。

<!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>
</head>
<body>
    <script>
        function outer() {
            var a = 10;
            function inner() {
                console.log(a++);
            }
            return inner;
        }
        var fun = outer();
        fun();
        fun();
    </script>
</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>Document</title>
</head>
<body>
    <script>
        var arr = [];
        for (var i = 0 ; i <= 10 ; i++ ) {
            (function (i) {
                arr[i] = function () {
                    console.log(i);
                }
            })(i);
        }
        arr[0]();
        arr[1]();
        arr[2]();

    </script>
</body>
</html>

总结

这部分学习了继承和函数的进阶，能够更好地掌握函数，能更加熟练的书写js代码，使代码更加简洁。每天坚持学习前端~
在这里插入图片描述

程序媛Render
关注
  • 3
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
封装、继承和多态进阶（二）
weixin_52066667的博客
11-12 2373
任务描述 本关任务：按要求编写一个Java应用程序，巩固Java封装、继承和多态的知识。 相关知识 为了完成本关任务，你需要掌握：1.重写和重载；2.abstract(抽象类)和interface(接口)；3.final关键字；4.static关键字；5.多态。 重写和重载 方法重载（overload）： 必须是同一个类； 方法名（也可以叫函数）一样； 参数类型不一样或参数数量或顺序不一样； 不能通过返回值来判断重载。 方法的重写（override）子类重写
Web前端学习笔记——JavaScript 之继承、函数进阶
唯恋殊雨的博客
09-24 549
函数进阶 函数的定义方式 函数声明 函数表达式 new Function 函数声明 function foo () { } 函数表达式 var foo = function () { } 函数声明与函数表达式的区别 函数声明必须有名字 函数声明会函数提升，在预解析阶段就已创建，声明前后都可以调用 函数表达式类似于变量赋值 函数表达式可以没有名字，例如匿名函数 函数表达式没有变量提升，...
js中继承以及函数进阶
qq_43665021的博客
07-17 185
继承 是指一种关系，面向对象的三大特征之一 js中的继承 js中是通过构造函数中的原型来实现继承，模拟强类型语言中类的概念 优点是：可实现数据共享，优化内存，节省资源 实现方式是将父类构造函数的原型赋给子类构造函数 继承的实例应用 动物有名字,有体重,有吃东西的行为 小狗有名字,有体重,有毛色,有吃东西的行为,还有咬人的行为 二哈有名字,有体重,有毛色,性别,有吃东西的行为,还有咬人的行为,逗主人...
JS高级—继承和函数进阶
qq_43352105的博客
02-09 416
文章目录继承和函数进阶继承对象之间的继承原型继承函数的call方法借用构造函数继承属性构造函数方法的继承组合继承函数进阶函数声明和函数表达式函数调用和thiscall、apply、bind方法函数的其他成员高阶函数闭包概念理解和应用问题 继承和函数进阶 继承 对象之间的继承 通过for…in实现对象间的拷贝 //继承的函数 function extend(parent, child) { for (var k in parent) {
C++进阶：继承
yourfriendyo的博客
04-14 4078
继承 面向对象的三大特性：封装、继承、多态。继承在实际中用的也不是太多，但必须能熟练使用。 1. 继承的概念 继承机制是面向对象思想中复用代码的一种手段，它能够在原有类的特性的基础上进行扩展。由此产生新的类，称为派生类，原有类称作基类。继承体现了面向对象设计的层次结构，体现了由简单到复杂的认知过程，不同于面向过程只有函数复用，继承是类的设计层面上的复用。 1.1 继承的定义 对于具有一定联系的一类群体，将其抽象成一类对象后，这些对象必然会具有重复的属性。 比如学校中有学生老师两种群体，他们都是属于人这个
继承-进阶
li_peixiansang的博客
06-07 530
继承-进阶
04-继承和函数的进阶
zhzhzhyw的博客
01-05 93
2020-12-29-继承和函数的进阶 作者：zhzh 时间: 2020-12-29 书籍/博客/视频：前端39期视频–JavaScript高级 网站地址：## 摘要 重点：JavaScript中继承的三种方法， call函数的 使用 难点：原型和原型对象之间的关系 总结 继承的概念很容易理解，但就是在js中，原型和原型对象之间的关系有点点绕 目录 文章目录2020-12-29-继承和函数的进阶摘要总结目录@[toc]1、对象之间的继承：2、对象拷贝的应用3、原型继承4、call5、借用构造函数6、
C++进阶：继承和多态
最新发布
2301_79969994的博客
07-09 1510
面向对象编程中的一个核心概念，它允许对象以多种形式出现，并通过相同的接口来调用不同的实现。在 C++ 中，多态通常通过函数重载、运算符重载和虚函数来实现。多态的主要类型包括编译时多态（静态多态）和运行时多态（动态多态）。简单来说多态就是：就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状态。例如：每个动物都有叫声，我们将叫声写为一个函数，然后每个动物去继承这个 动物类，每个动物去调用叫声这个函数都会得到不同的结果，这就是多态。
Java面试基础——继承，封装和多态进阶（一）
weixin_43330835的博客
03-04 1301
Educoder java面向对象设计 任务描述 相关知识 面向对象思想 封装 继承 构造函数 super()和this() 编程要求 测试说明 任务描述 本关任务：按要求编写一个Java应用程序，巩固Java面向对象知识。 相关知识 为了完成本关任务，我们回顾一下前面所学知识：1.面向对象思想 ；2.封装；3.继承；4.构造函数；5.super()和this()。 面向对象思想 构造器：new就是一个构造器，作用是：①分配空间；②赋初始值（避免错误，简化输入）； new Object(Parameters
第1关：封装、继承和多态进阶（一）
Shisi1989的博客
05-20 5057
任务描述 本关任务：按要求编写一个Java应用程序，巩固Java面向对象知识。 相关知识 为了完成本关任务，我们回顾一下前面所学知识：1.面向对象思想 ；2.封装；3.继承；4.构造函数；5.super()和this()。 面向对象思想 构造器：new就是一个构造器，作用是：①分配空间；②赋初始值（避免错误，简化输入）； new Object(Parameters)构造器调用构造函数，传参为了赋初始值； 对象的基本元素是：属性和方法 类成员（属性和方法）。属性最为重要
JS函数进阶之继承用法实例分析
10-15
本文将深入探讨JavaScript函数进阶中的继承用法，并通过实例来分析相关定义和操作技巧。 首先，我们来看一个简单的构造函数示例： ```javascript function person(name, age) { this.name = name; this.age = ...
python进阶1.7继承，重写，多态等.zip
05-02
python基础进阶1.7继承，重写，多态等相关视频。至此，我认为了解这些python基础，便可以进行相关项目实践了。在实践中学习更多的python函数用法。关注微信公众号：深度学习社区DLC；博客：...
清华大学C++进阶讲义：第7章类的继承.pdf
01-22
继承是面向对象编程（OOP）中的一种机制，允许程序员创建一个新的类（派生类），该类继承了另一个类（基类）的所有成员变量和成员函数。继承的目的是实现设计与代码的重用。派生是继承的反方向，它允许程序员在已有...
HTML常用标签及跳转
qq_46492364的博客
03-05 3644
文章目录哇，今天要回学校了HTML常用标签1.音频和视频2.超级链接3.4.5.6.7.8.9.10.二、锚点跳转1.页面内锚点跳转总结 哇，今天要回学校了 学起来，一边要坐车还要学习，今日份的任务也要完成啊，继续学习HTML的常用标签。前端之路漫漫，加油~ HTML常用标签 1.音频和视频 （1）音频标签：< audio > 双标签，使用路径查找。支持格式：.mp3、.ogg、.wav。 音频控制条属性：使用controls属性进行设置，属性值也是controls。 代码如下（示例）： .
flex布局
qq_46492364的博客
04-07 3211
文章目录前言一、flex布局体验二、flex布局原理三、flex布局父项常见属性1.flex-direction设置主轴的方向2.justify-content主轴上子元素排列方式3.四、flex布局子项常见属性1.2.读入数据五、1.引入库2.读入数据总结 前言 这部分学习flex布局，还是通过写一个移动端网页进行练习，这里就只记录理论知识啦。 提示：以下是本篇文章正文内容，下面案例可供参考 一、flex布局体验 传统布局： （1）兼容性好 （2）布局繁琐 （3）局限性，不能在移动端很好的布局 fl.
流式布局
qq_46492364的博客
04-05 2426
文章目录前言一、流式布局原理二、使用步骤1.引入库2.读入数据总结 前言 一、流式布局原理 将盒子的宽度设为百分比，很具屏幕的宽度来进行伸缩，不受固定像素的限制，内容向两侧填充。 示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。 二、使用步骤 1.引入库 代码如下（示例）： import numpy as np import pandas as pd import matplotlib.pyplot as plt import seaborn as sns im.
CSS背景属性、定位
qq_46492364的博客
03-13 2347
文章目录前言一、css的常用样式-背景属性1.背景颜色 background-color2.背景图片 background-image3.背景重复 background-repeat二、使用步骤1.引入库2.读入数据总结 前言 又是内容超级多的一天啊，多也要学完，今天学校三节课呢，自己学习的时间少了点了。加油，坚持住！ 一、css的常用样式-背景属性 1.背景颜色 background-color background-color,作用在盒子区域内添加背景颜色进行修饰，在border及以内加载背景颜色.
DOM获取元素的几种方式
qq_46492364的博客
05-25 2304
文章目录一、对象1.对象的概念2.对象字面量 # 前言 这部分学习Web API,包括DOM和BOM。JavaScript包括ES、DOM、BOM三个部分，其中ES是ECMAScript，是JavaScript的核心，是一套 一、对象 1.对象的概念 JavaScript中的对象其实就是生活中对象的一个抽象。JavaScript的对象是无序属性的集合。 其属性可以包含基本值、对象或函数。对象就是一组没有顺序的值。我们可以把JavaScript 中的对象想象成键值对，其中值可以是数据和函数。 2.对象字面
Vue.js框架基础
qq_46492364的博客
08-31 2202
文章目录前言一、内容处理1.v-once指令二、使用步骤1.引入库2.读入数据总结 前言 指令的本质就是HTML自定义属性，Vue.js的指令就是以v-开头的自定义属性，接下来开始学习指令。 一、内容处理 1.v-once指令 示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。 二、使用步骤 1.引入库 代码如下（示例）： import numpy as np import pandas as pd import matplotlib.pyplot as plt i
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值