JavaScript 中的面向对象概述

最新推荐文章于 2024-07-19 12:58:53 发布
最新推荐文章于 2024-07-19 12:58:53 发布
阅读量131 收藏 1
点赞数 1
分类专栏： JavaScript web 基础 文章标签： javascript
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Mr_Lixiaoshuai/article/details/117577807
版权

JavaScript 中的面向对象概述

文章目录

对象和面向对象的概念

  • 什么是对象：
    • Everything is object （万物皆对象）。
    • 从两次层次来理解： (1) 对象是单个事物的抽象。 (2) 对象是一个容器装了属性（property）和方法（method）
    • 对象是单个事物的抽象
  • JS 中的对象
    • 在实际开发中，对象是一个抽象的概念，可以将其简单理解为：数据集或功能集
    • ECMAScript-262 把对象定义为：无序属性的集合，其属性可以包含基本值、对象或者函数
  • 面向对象编程 （OOP）
    • Object Oriented Programming，简称 OOP ，是一种编程开发思想
    • 它将真实世界各种复杂的关系，抽象为一个个对象，然后由对象之间的分工与合作，完成对真实世界的模拟

面向对象与面向过程对比

  • 面向过程就是亲力亲为，事无巨细，面面俱到，步步紧跟，有条不紊
  • 面向对象就是找一个对象，指挥得结果
  • 面向对象将执行者转变成指挥者
  • 面向对象不是面向过程的替代，而是面向过程的封装

面向对象的特性

  • 封装性
  • 继承性
  • [多态性] 抽象

面向对象的设计思想

  • 抽象出 Class(构造函数)
  • 根据 Class(构造函数) 创建 Instance(实例)
  • 指挥 Instance 得结果
  1. 在面向对象程序开发思想中，每一个对象都是功能中心，具有明确分工，可以完成接受信息、 处理数据、发出信息等任务。
  2. 因此，面向对象编程具有灵活、代码可复用、高度模块化等特点，容易维护和开发，比起由 一系列函数或指令组成的传统的过程式编程（procedural programming），更适合多人合作 的大型软件项目。

JS 中创建对象的几种方式

  • new Object() 构造函数
  • 对象字面量 {}
  • 工厂函数
  • 自定义构造函数

new Object()

var person = new Object();
person.name = "Bob";
person.age = 18;
person.sayName = function () {
  console.log(this.name);
};

对象字面量化简

var person1 = {
  name : "Bob",
  age : 18,
  sayName : function () {
    console.log(this.name);
  }
};
var person2 = {
  name : "Mike",
  age : 20,
  sayName : function () {
    console.log(this.name);
  }
};

工厂函数

function createPerson(name,age) {
  // 添加一个新对象
  var person = new Object();
  person.name = name;
  person.age = age;
  person.sayName = function () {
    console.log(this.name);
  };
  // 必须有返回值
  return person;
}

// 生成真正的对象
var person1 = createPerson("John",19);

自定义构造函数

function Person(name, age) {
  this.name = name;
  this.age = age;
  this.sayName = function () {
    console.log(this.name);
  };
}
var person1 = new Person("Bob", 18);
var person2 = new Person("Mike", 20);

构造函数

new 关键字的用途

  • 创建一个新对象
  • 将函数内部的 this 指向了这个新对象
  • 执行构造函数内部的代码
  • 将新对象作为返回值

构造函数和实例对象的关系

  • 构造函数是根据具体的事物抽象出来的抽象模板
  • 实例对象是根据抽象的构造函数模板得到的具体实例对象
  • 每一个实例对象都通过一个 constructor 属性，指向创建该实例的构造函数
    • 注意：constructor 是实例的属性的说法不严谨
    • 后面可以修改 原型对象的 prototype 属性覆盖自己的 constructor 属性
  • 可以通过 constructor 属性判断实例和构造函数之间的关系
    • 注意：这种方式不严谨，推荐使用 instanceof 操作符

静态成员和实例成员

  • 使用构造函数方法创建对象时，可以给构造函数和创建的实例对象添加属性和方法，这些属 性和方法都叫做成员
  • 实例成员：在构造函数内部添加给 this 的成员，属于实例对象的成员，在创建实例对象后 必须由对象调用
  • 静态成员：添加给构造函数自身的成员，只能使用构造函数调用，不能使用生成的实例对象 调用
// 自定义构造函数
function Person(name,age) {
  // 实例成员  ，通过将来生成的实例对象进行调用的成员
  // 创建时，是直接添加给函数内部的 this
  this.name = name;
  this.age = age;
  this.sayName = function () {
    console.log(this.name);
  };
}
// 静态成员 -- 直接给构造函数添加的成员
Person.version = "1.0";
// 生成对象实例
var person1 = new Person("Bob",18);
var person2 = new Person("Mike",20);

// 调用实例成员
console.log(person1.name);  // Bob
// 使用构造函数调用实例成员会出错
// console.log(Person.name);  // Person
/*
Person.sayName();
Uncaught TypeError: Person.sayName is not a function
*/
// 调用静态成员,只能通过构造函数进行调用
console.log(Person.version);  // 1.0
console.log(person1.version);  // undefined

构造函数的问题

造成内存浪费，同一个方法，指向不同引用

function Person(name,age) {
  this.name = name;
  this.age = age;
  // this 内部的 type 属性值是不变的
  this.type = "human";
  // 每个对象的 sayName 方法也是一样的
  this.sayName = function () {
    console.log(this.name);
  };
}
var person1 = new Person("Bob",18);
var person2 = new Person("Mike",20);
console.log(person1.sayName === person2.sayName);  // false

// 解决方法1： 将公共的函数提取到构造函数之外
function sayName() {
  console.log(this.name);
}
// 问题：如果有多个公共函数，需要在外部创建多个函数，可能会造成命名冲突
function sayAge() {
  console.log(this.age);
}
function Person(name,age) {
  this.name = name;
  this.age = age;
  this.type = "human";
  this.sayName = sayName;
  this.sayAge = sayAge;
}
var person1 = new Person("Bob",18);
var person2 = new Person("Mike",20);
console.log(person1.sayName === person2.sayName);  // true

// 解决方法第2种：将多个公共的函数封装到一个对象
var fns = {
  sayName : function () {
    console.log(this.name);
  },
  sayAge : function () {
    console.log(this.age);
  }      
};    
function Person(name,age) {
  this.name = name;
  this.age = age;
  // this 内部的 type 属性值是不变的
  this.type = "human";
  // 每个对象的 sayName 方法也是一样的
  this.sayName = fns.sayName;
  this.sayAge = fns.sayAge;
}
// 生成对象实例
var person1 = new Person("Bob",18);
var person2 = new Person("Mike",20);

// person1.sayName();
console.log(person1.sayName === person2.sayName);  // true
console.log(person1.sayAge === person2.sayAge);  // true

更好的解决方法 prototype

使用原型对象可以更好的解决构造函数的内存浪费问题
prototype 原型对象

  • 任何函数都具有一个 prototype 属性，该属性是一个对象。
  • 可以在原型对象上添加属性和方法。
  • 构造函数的 prototype 对象默认都有一个 constructor 属性，指向 prototype 对象所在 函数。
  • 通过构造函数得到的实例对象内部会包含一个指向构造函数的 prototype 对象的指针 __proto__
  • 实例对象可以直接访问原型对象成员
// 定义构造函数
function Person(name,age) {
  this.name = name;
  this.age = age;
}
// 获取 构造函数 的 prototype 属性
console.log(Person.prototype);
// 属性值是一个对象，通常叫做原型对象
// 对象内部可以添加一些属性和方法
Person.prototype.type = "human";
Person.prototype.sayHi = function () {
  console.log("hello");
};
// Person.prototype.constructor = Array;
// 构造函数的 原型对象上面都默认有一个 constructor 属性
// console.log(Person.prototype.constructor);

// 创建实例对象
var p1 = new Person("Mike",18);
// 所有的对象都有一个 __proto__ 的属性，是一个指针，指向的就是生成实例对象的 构造函数的原型对象
console.log(p1.__proto__);
console.log(p1.__proto__ === Person.prototype);  // true
// __proto__ 属性并不是一个标准的属性，是浏览器自己根据语法自动生成的
// p1.__proto__.sayHi();
// 在真正开发的过程中，是不会书写 __proto__ 属性的
p1.sayHi();
// console.log(p1.constructor);
// console.log(p1 instanceof Person);

构造函数、实例、原型对象三者之间的关系
构造函数、实例、原型对象三者之间的关系

  • JavaScript 规定，每一个构造函数都有一个 prototype 属性，指向构造函数的原型对象
  • 这个原型对象的所有属性和方法，都会被构造函数的实例对象所拥有
  • 因此，我们可以把所有对象实例需要共享的属性和方法直接定义在 prototype 对象上
  • 解决内存浪费问题

原型链

思考：为什么实例对象可以调用构造函数的 prototype 原型对象 的属性和方法？

原型链查找机制

  • 每当代码读取某个对象的某个属性时，都会执行一次搜索，目标是具有给定名字的属性：
  • 搜索首先从对象实例本身开始
  • 如果在实例中找到了具有给定名字的属性，则返回该属性的值
  • 如果没有找到，则继续搜索指针指向的原型对象，在原型对象中查找具有给定名字的属性
  • 如果在原型对象中找到了这个属性，则返回该属性的值
    原型链

实例对象读写原型对象成员

读取：

  • 先在自己身上找，找到即返回
  • 自己身上找不到，则沿着原型链向上查找，找到即返回
  • 如果一直到原型链的末端还没有找到，则返回 undefined

值类型成员写入（实例对象.值类型成员 = xx）：

  • 当实例期望重写原型对象中的某个普通数据成员时实际上会把该成员添加到自己身上
  • 也就是说该行为实际上会屏蔽掉对原型对象成员的访问 引用类型成员写入（实例对象.引用类型成员 = xx）：
  • 同上

复杂类型成员修改（实例对象.成员.xx = xx）：

  • 同样会先在自己身上找该成员，如果自己身上找到则直接修改
  • 如果自己身上找不到，则沿着原型链继续查找，如果找到则修改
  • 如果一直到原型链的末端还没有找到该成员，则报错（实例对象.undefined.xx = xx）

// 自定义构造函数
function Person(name,age) {
  this.name = name;
  this.age = age;     
}
// 将所有实例共享的属性和方法，都添加给原型对象
Person.prototype.type = "human";
Person.prototype.sayName = function () {
  console.log(this.name);
};
// 添加一个新的属性给原型对象，值是一个对象类型
Person.prototype.address = {
  city : "北京"
};
// 生成对象实例
var person1 = new Person("Bob",18);
var person2 = new Person("Mike",20);

// 读取 属性和方法
// console.log(person1.type);
// console.log(person1.city);
// console.log(person1.sayName);
// person1.sayName();

// 通过实例对象添加新成员,会直接添加给自己，会屏蔽掉对原型对象的访问
person1.sex = "male";
person1.sayAge = function () {
  console.log(this.age);
};

// 如果通过实例对象更改原型对象的属性和方法,会直接添加给自己，会屏蔽掉对原型对象的访问
person1.type = "person";
person1.sayName = function () {
  console.log(this.name);
}
console.dir(person1);

// 通过实例对象更改原型对象中复杂类型数据中的内容,还是会进行原型链的查找
person1.address.city = "上海";

更简单的原型语法

  • 前面在原型对象每添加一个属性和方法就要书写一遍 Person.prototype
  • 为减少不必要的输入，更常见的做法是用一个包含所有属性和方法的对象字面量来重写整个原 型对象，将 Person.prototype 重置到一个新的对象
  • 注意：原型对象会丢失 constructor 成员，所以需要手动将 constructor 指向正确的构造函 数
// 自定义构造函数
function Person(name,age) {
  this.name = name;
  this.age = age;     
}
// 将所有实例共享的属性和方法，都添加给原型对象
// Person.prototype.type = "human";
// Person.prototype.sayName = function () {
//   console.log(this.name);
// };  
// 直接使用一个对象字面量对 原型对象进行赋值
Person.prototype = {
  constructor : Person,  // 需要手动 将 constructor 属性指向正确的构造函数
  type : "human",
  sayName : function () {
    console.log(this.name);
  }
};
// 生成对象实例
var person1 = new Person("Bob",18);
var person2 = new Person("Mike",20);

person1.sayName();
console.log(person2.constructor);

原型对象使用建议

  • 在定义构造函数时，可以根据成员的功能不同，分别进行设置：
  • 私有成员（一般就是非函数成员）放到构造函数中
  • 共享成员（一般就是函数）放到原型对象中
  • 如果重置了 prototype 记得修正 constructor 的指向

对象之间的继承

对象拷贝 for……in ：父对象的属性拷贝给子对象

// 父级的对象
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);

原型继承

原型继承 : 将子类的 prototype 属性 赋值给 父类的实例对象上

// 封装的构造函数就是用来创建一类对象
// 继承指的是 类型 和 类型之间的继承
// 学生类型  老师类型  --> 抽象，提取所有的公共的属性，放到一个 父类型中
// 当前学习阶段，没有一个专门的用来继承的方法

// 人类类型
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(89);
var s2 = new Student(100);
console.dir(s1);
console.dir(s2);
console.log(s1.name);
console.log(s1.constructor);

构造函数的属性的继承

// 人类类型
function Person(name,age,sex) {
  this.name = name;
  this.age = age;
  this.sex = sex;
}
// 学生类型
function Student(name,age,sex,score) {
  // 直接对父类型的构造函数进行一个普通调用
  // Person 普通调用过程中，内部的 this 指向的是 window
  // 可以通过 call 方法更改Person 内部的 this
  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",18,"男",89);
var s2 = new Student("ls",19,"男",92);
console.dir(s1);
console.dir(s2);

构造函数（父类）的方法的继承

// 
// 人类类型
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;
}
// 子类型的原型对象上，需要继承父类型原型对象的方法
// 方法1：对象拷贝继承
// for (var k in Person.prototype) {
//   // 保留自己的 constructor 不要进行继承
//   if (k === "constructor") {
//     continue;
//   }
//   Student.prototype[k] = Person.prototype[k];
// } 

// 方法2：原型继承
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",18,"男",89);
var s2 = new Student("ls",19,"男",92);
console.dir(s1);
console.dir(s2);
s1.sayHi();

借助构造函数继承属性


// 组合继承：属性在构造函数内部继承，方法通过原型继承
function Person(name,age) {
  this.name = name;
  this.age = age;
}
Person.prototype.sayHi = function () {
  console.log("你好");
}
// 生成一个子类型
function Teacher(name,age,salary) {
  // 继承父类的属性
  Person.call(this,name,age);
  this.salary = salary;
}
// 方法继承，通过原型对象继承
Teacher.prototype = new Person();
Teacher.prototype.constructor = Teacher;
// 生成老师的一个实例
var t1 = new Teacher("wang",45,10000);
console.dir(t1);
console.log(t1.name);
t1.sayHi();

原型对象
原型对象的继承

Mr_Lixiaoshuai
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JavaScript面向对象-多态
William_fang的博客
06-17 562
文章目录1.多态的概述2.代码展示3.效果展示 1.多态的概述 多态：同一个操作在不同的对象上，出现不同的执行结果。 js的多态性是与生俱来的，就像代码中的形参animal可以传入任何类型的参数，十分灵活。 2.代码展示 <script> var makeSound=function(animal){ //执行了同一个操作 animal.sound(); } var Duck=function(){ } Duck.prototype.
面向对象（重点中的重点）
D____ppx的博客
04-12 130
面向对象的概述 面向对象不是一个新的内容，而是一个编程思想（oop） 面向过程 1.去相亲网站 2.填写信息 3.确定目标 4.建立联系 5.约会 .... 面向对象 1.找对象（找个媒婆） 2.调用对象的方法（说媒） 面向对象的主要思维是找能做这个事情的对象（万物皆对象 所有的东西都能被当成对象） 了解对象 对象类型属于引用数据类型 关于对象的创建 对象的创建 直接赋值 let obj = {} //对象类型 使用new关键词 let obj = new Obje
JavaScript声明一个对象的三种方式
热门推荐
相濡以沫的博客
11-14 1万+
1. 声明一个对象的语法 var person = { name: ['Bob', 'Smith'], age: 32, gender: 'male', interests: ['music', 'skiing'], bio: function() { alert(this.name[0] + ' ' + this.name[1] + ' is ' + this.a
JavaScript 面向对象详解
qq_36081714的博客
08-09 4647
JavaScript面向对象
JavaScript 之面向对象
msn131420的博客
03-03 4244
JavaScript 面向对象 一、面向对象编程介绍 1.1 两大编程思想 面向过程 面向对象 1.2 面向过程编程 POP(Process-oriented programming) 面向过程就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候再一个一个的依次调用就可以了。 举个栗子：将大象装进冰箱，面向过程做法。 面向过程，就是按照我们分析好了的步骤，按照步骤解决问题。 1.3 面向对象编程 OOP (Object Oriented .
JavaScript----面向对象编程
weixin_60291486的博客
08-12 535
面向对象概述 ES6面向对象语法 构造函数与原型对象 原型链 this的指向 错误处理 继承
Java面向对象浅谈
编程界明世隐的博客
12-06 4919
作者简介 作者名：编程界明世隐 简介：CSDN博客专家，从事软件开发多年，精通Java、JavaScript，博主也是从零开始一步步把学习成长、深知学习和积累的重要性，喜欢跟广大ADC一起打野升级，欢迎您关注，期待与您一起学习、成长、起飞！ 热门专栏推荐 【1】Java小游戏（俄罗斯方块、飞机大战、植物大战僵尸等） 【2】JavaWeb项目实战（图书管理、在线考试、宿舍管理等） 【3】JavaScript精彩实例（飞机大战、贪吃蛇、验证码等） 【4】Java小白入门200例 【5】从零学Java、趣学J
JavaScript 中的面向对象编程
KEEP的博客
03-21 241
JavaScript 是一个强大的面向对象编程语言，但是，并不像传统的编程语言，它采用一个以原型为基础的OOP模型，致使它的语法让大多数开发人员看不懂。另外，JavaScript 也把函数作为首要的对象，这可能会给不够熟悉这门语言的开发人员造成更大的困惑。那就是我们决定放在前面作为一个简短前言进行介绍的原因，并且在 JavaScript 里也可以用作面向对象编程的一个参考。　　这个文档没有提供一个...
JavaScript面向对象
河里的草_increase
05-29 461
JavaScript面向对象(包括ES6) 资料：《JavaScript+jQuery交互式Web前端开发》 上篇博客：jQuery和ES6知识整理；下篇预告：vue实例详细解析 文中有错的地方请及时提醒，喜欢的小伙伴可以三连支持，谢谢！ 效果图： 代码分享： html和js代码： <!doctype html> <html> <head> <meta charset="utf-8"> <title>JavaScript面向对象
JavaScript对象概述
橘猫吃不胖的博客
11-21 796
JavaScript对象1 初识对象1.1 什么是对象1.2 利用字面量创建对象1.3 访问对象的属性和方法1.4 用new Object创建对象1.5 利用构造函数创建对象1.6 遍历对象的属性和方法1.7 返回对象的属性值的数组Object.values()1.8 返回由对象的属性组成的数组Object.keys()2 内置对象 1 初识对象 1.1 什么是对象 在JavaScript中，对象是一种数据类型，它是由属性和方法组成的一个集合。属性是指事物的特征，使用“对象.属性名”访问；方法是指事物的
JavaScript程序设计课件：面向对象概述.pptx
06-15
6.1 面向对象概述 主讲：重庆机电职业技术大学 吴永强 6.1.2 面向对象的特征 6.1.2 面向对象的特征 1、面向对象的特征 面向对象具有三大特征： 封装性 继承性 多态性 6.1.2 面向对象的特征 特征一 封装性 封装：指的...
浅谈JavaScript中面向对象技术的模拟
12-10
一、引言 在C#和Java语言中，面向对象是以类的方式实现的，特别是继承这个特性，类的方式继承表现出了强大的功能，而且也易于学习。JavaScript不是纯的面向对象的语言，而是基于对象的语言，对象的继承是以原型函数...
Web程序开发：第14章 JavaScript面向对象.pdf
05-17
以上内容涵盖了JavaScript面向对象编程的基础知识，包括对象、类、实例化和创建对象的各种方法。理解这些概念对于编写高效、可维护的JavaScript代码至关重要。在实际开发中，开发者可以根据项目需求灵活选择适合的...
1010:游戏1010的面向对象JavaScript实现
04-29
**1010游戏概述** 1010是一款流行的益智类游戏，灵感来源于经典的俄罗斯方块。...通过阅读源码，我们可以学习到如何在实际项目中应用JavaScript的面向对象编程技巧，以及如何构建一个完整的交互式游戏。
使用JavaScript构建的面向对象CSS框架-JavaScript开发
05-26
ctr是使用JavaScript构建CSS框架，可提供面向对象的功能，以允许继承CSS组件具有丰富的层次结构，从而更好地促进类似于OOCSSCSS体系结构。 尽管ctr和OOCSS在应用程序上有很大的不同，但是您可以使用允许ct的真实对象...
TinyVue v3.17.0 正式发布，推出了一款基于 Quill 2.0 的富文本编辑器，功能强大、开箱即用！
OpenTiny的博客
07-17 1009
本文由体验技术团队Kagol老师原创~我们非常高兴地宣布，2024年6月26日，TinyVue 发布了 v3.17.0 🎉。TinyVue 每次大版本发布，都会给大家带来一些实用的新特性，上一个版本我们重构了 chart-core，新增 CircleProcessChart 圆环进度图等6个新的图表组件，并增加了 Statistic 数据统计组件。表格图片超链接复制粘贴插入表情文件上传@提醒斜杆菜单v-auto-tip。
博客前端项目学习day03——框架页
最新发布
qq_53237241的博客
07-19 242
【代码】博客前端项目学习day03——框架页。
自定义 Hooks 在 Vue3 中的应用和重要性
CodeQi技术小栈的博客
07-16 1004
自定义Hooks是Vue3提供的一种将可复用逻辑提取到独立函数中的方式。这不仅可以减少代码的重复，还能让你的代码更加清晰易读，维护起来也更加方便。在这篇文章中，我将通过详细的步骤和实例，带你深入了解如何在Vue3中使用自定义Hooks，以及它们在实际项目中的应用和重要性。首先，我们来看一下如何创建一个简单的自定义Hook。在Vue3中，自定义Hook本质上就是一个返回特定功能的函数。让我们从一个简单的计数器例子开始。
vue3前端开发-如何让自己的网站适合SEO排名规则
yrldjsbk的博客
07-17 155
我们大家都知道，原始出生的vue3项目，原始代码层面，是没有meta标签的，也就是说，不适合SEO排名规则。SEO排名规则，蜘蛛爬虫抓取网站页面的内容，就会把这种meta标签内容进行采集，匹配。但是，这个技术要求大家还是应该知道的。黑马教育，课程，前端课程案例项目：小兔鲜儿超市，vue3前端项目案例。想学习vue3前端开发，拿来练习，实战的朋友们，值得一看哦。这个代码，就是我自己手工录入的。录入后，再次在浏览器界面刷新请求服务器。返回的代码模块就可以看见了。自己刚刚手工录入的meta信息出现了。
现代JavaScript：面向对象编程实战
现代JavaScript面向对象编程是JavaScript语言发展的重要里程碑，尤其是在其经历了从早期简单脚本语言到功能强大的编程工具的转变之后。JavaScript最初设计时就具备面向对象特性，但随着时间的推移，它吸收了其他高级...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值