JavaScript -- 07. 面向对象编程

最新推荐文章于 2024-11-02 12:42:04 发布
最新推荐文章于 2024-11-02 12:42:04 发布
阅读量421 收藏
点赞数
分类专栏： # JavaScript 前端 文章标签： javascript 前端 vue.js
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46311811/article/details/128168031
版权

文章目录

面向对象编程

这部分视频讲解了JS中面向对象相关的知识。主要包括：类、属性、方法、构造函数、封装、多态、继承、对象的结构、原型、原型链、旧类、new运算符等内容。

1 面向对象编程介绍

面向对象编程（OOP, Object Oriented Programming）

  1. 程序是干嘛的？
  • 程序就是对现实世界的抽象（照片就是对人的抽象）
  1. 对象是干嘛的？
  • 一个事物抽象到程序中后就变成了对象
  • 在程序的世界中，一切皆对象
  1. 面向对象的编程
  • 面向对象的编程指，程序中的所有操作都是通过对象来完成
  • 做任何事情之前都需要先找到它的对象，然后通过对象来完成各种操作

  1. 事物和对象

    • 一个事物通常由两部分组成：数据和功能

    • 一个对象由两部分组成：属性和方法

    • 事物的数据到了对象中，体现为属性

    • 事物的功能到了对象中，体现为方法

例如对于人来说：

  • 数据：

    • 姓名

    • 年龄

    • 身高

    • 体重

  • 功能：

    • 睡

    • 吃

表现在代码中：

const five = {
    // 添加属性
    name:"王老五",
    age:48,
    height:180,
    weight:100,

    // 添加方法
    sleep(){
        console.log(this.name + "睡觉了~")
    },

    eat(){
        console.log(this.name + "吃饭了~")
    }
}

2 类

使用Object创建对象的问题：

  1. 无法区分出不同类型的对象
  2. 不方便批量创建对象

在JS中可以通过类（class）来解决这个问题：

  1. 类是对象模板，可以将对象中的属性和方法直接定义在类中
  2. 定义后，就可以直接通过类来创建对象
  3. 通过同一个类创建的对象，我们称为同类对象
  • 可以使用instanceof来检查一个对象是否是由某个类创建
  • 如果某个对象是由某个类所创建，则我们称该对象是这个类的实例

语法：

class 类名 {} // 类名要使用大驼峰命名
const 类名 = class {}

通过类创建对象：

const aa = new 类名()

例如：

// Person类专门用来创建人的对象
class Person{

}

// Dog类式专门用来创建狗的对象
class Dog{

}

const p1 = new Person()  // 调用构造函数创建对象
const p2 = new Person()

const d1 = new Dog()
const d2 = new Dog()

console.log(p1 instanceof Person) // true
console.log(d1 instanceof Person) // false

3 属性

  • 类是创建对象的模板，要创建第一件事就是定义类
  • 类的代码块，默认就是严格模式，
  • 类的代码块是用来设置对象的属性的，不是什么代码都能写
  • 分为实例属性和静态属性
    • 示例属性只能通过实例化后的对象访问：实例化对象.属性名
    • 静态属性只能通过类名访问：类名.属性名
class Person{
    name = "孙悟空" // Person的实例属性name p1.name
    age = 18       // 实例属性只能通过实例访问 p1.age

    // 使用static声明的属性，是静态属性（类属性） Person.test
    static test = "test静态属性" 
    // 静态属性只能通过类去访问 Person.hh
    static hh = "静态属性"   
}

const p1 = new Person()
const p2 = new Person()

console.log(p1)
console.log(p2)
console.log(p1.name, p1.test, Person.test)

image-20221202110721343

4 方法

定义方法和定义函数语法格式都是一样的，只不过可以省掉function关键字

方法中的this和原来一样，谁调用this指向的就是谁

class Person {

    name = "孙悟空"

    // 添加方法的一种方式，不推荐使用这种方式
    // sayHello1 = function () {
    //
    // } 

    // 添加方法（实例方法） 实例方法中this就是当前实例
    sayHello() {
        console.log('大家好，我是' + this.name)
    } 

    // 静态方法（类方法） 通过类来调用 静态方法中this指向的是当前类
    static test() {
        console.log("我是静态方法", this)
    } 
}

const p1 = new Person()

// console.log(p1)
Person.test()
p1.sayHello()

image-20221202111316892

5 构造函数

在前面的定义方法中，每个实例的属性都是我们预先定义好的，没法自定义去改变，唯一的改变方法就是通过下面这种方式，但是这种方式又不能提现类的便捷性

class Person {
    name = "孙悟空" // 当我们在类中直接指定实例属性的值时，意味着我们创建的所有对象的属性都是这个值
    age = 18
    gender = "男"

    sayHello() {
        console.log(this.name)
    }
}

const p1 = new Person()
p1.age = 19
p1.name = "zhangsan"

因此，我们介绍一种新的东西，叫做构造函数，使用方法如下：

  • 在类中可以添加一个特殊的方法constructor
  • 该方法我们称为构造函数（构造方法）
  • 构造函数会在我们调用类创建对象时执行
  • 我们通过new调用函数的时候调用的就是类中的构造函数
  • 默认会有一个无参构造函数
class Person {
    constructor(name, age, gender) {
        // console.log("构造函数执行了~", name, age, gender)
        // 可以在构造函数中，为实例属性进行赋值
        // 在构造函数中，this表示当前所创建的对象
        this.name = name
        this.age = age
        this.gender = gender
    }
}

const p1 = new Person("孙悟空", 18, "男")
const p2 = new Person("猪八戒", 28, "男")
const p3 = new Person("沙和尚", 38, "男")

console.log(p1)
console.log(p2)
console.log(p3)

6 封装

面向对象的特点：封装、继承、多态

封装 —— 安全性
继承 —— 扩展性
多态 —— 灵活性

  • 对象就是一个用来存储不同属性的容器

  • 对象不仅存储属性，还要负责数据的安全

  • 直接添加到对象中的属性，并不安全，因为它们可以被任意的修改

  • 如何确保数据的安全：

    1. 私有化数据
      • 将需要保护的数据设置为私有，只能在类内部使用
    2. 提供setter和getter方法来开放对数据的操作
      • 属性设置私有，通过getter setter方法操作属性带来的好处
        • 可以控制属性的读写权限
        • 可以在方法中对属性的值进行验证

  • 封装主要用来保证数据的安全

  • 实现封装的方式：

    1. 属性私有化在属性名前面加#
    2. 后面再使用的时候通过this.#name修改
    3. 私有化属性必须先声明再复制
    4. 通过getter和setter方法来操作属性
      1. 使用这种方式可以控制用户可以读写的属性
      2. 在修改属性的时候可以先对属性进行检查，如果不符合要求就不修改
    get 属性名(){
    return this.#属性
}

set 属性名(参数){
	this.#属性 = 参数
}

例子：

class Person {
    // #address = "花果山" // 实例使用#开头就变成了私有属性，私有属性只能在类内部访问

    #name
    #age
    #gender

    constructor(name, age, gender) {
        this.#name = name
        this.#age = age
        this.#gender = gender
    }

    sayHello() {
        console.log(this.#name)
    }

    // getter方法，用来读取属性
    getName(){
        return this.#name
    }

    // setter方法，用来设置属性
    setName(name){
        this.#name = name
    }

    getAge(){
        return this.#age
    }

    // 可以先检查要修改的值，如果不符合要求就不修改
    setAge(age){
        if(age >= 0){
            this.#age = age
        }
    }

    get gender(){
        return this.#gender
    }

    set gender(gender){
        this.#gender = gender
    }
}

const p1 = new Person("孙悟空", 18, "男")

// p1.age = "hello"

// p1.getName()
p1.setAge(-11) // p1.age = 11  p1.age

// p1.setName('猪八戒')

p1.gender = "女" // 等同于p1.setGender("女")
console.log(p1.gender)

7 多态

  • 在JS中不会检查参数的类型，所以这就意味着任何数据都可以作为参数传递
  • 要调用某个函数，无需指定的类型，只要对象满足某些条件即可
  • 如果一个东西走路像鸭子，叫起来像鸭子，那么它就是鸭子
  • 多态为我们提供了灵活性
class Person{
    constructor(name){
        this.name = name
    }
}

class Dog{
    constructor(name){
        this.name = name
    }
}

class Test{

}

const dog = new Dog('旺财')
const person = new Person("孙悟空")
const test = new Test()

function sayHello(obj){
    // if(obj instanceof Person){
    console.log("Hello, "+obj.name)
    // }
}

sayHello(dog)
sayHello(person)
sayHello(test)

image-20221202121524701

8 继承

  • 可以通过extends关键来完成继承
  • 当一个类继承另一个类时，就相当于将另一个类中的代码复制到了当前类中（简单理解）
  • 继承发生时，被继承的类称为 父类（超类），继承的类称为 子类
  • 通过继承可以减少重复的代码，并且可以在不修改一个类的前提对其进行扩展
class Animal{
    constructor(name){
        this.name = name
    }

    sayHello(){
        console.log("动物在叫~")
    }
}

class Dog extends Animal{
    
}

class Cat extends Animal{
    
}

class Snake extends Animal{

}

const dog = new Dog("旺财")
const cat = new Cat("汤姆")

dog.sayHello()
cat.sayHello()
console.log(dog)
console.log(cat)

但是在上面的代码中，各个动物的sayHello()都是一个东西，但是每个动物的叫声是不一样的，所以可以通过重写父类方法来修改方法

在子类中，可以通过创建同名方法来重写父类的方法

重写构造函数时，构造函数的第一行代码必须为super()

在方法中可以使用super来引用父类的方法，也就是说super指向的是父类对象

OCP 开闭原则：程序应该对修改关闭，对扩展开放

class Animal{
    constructor(name){
        this.name = name
    }

    sayHello(){
        console.log("动物在叫~")
    }
}

class Dog extends Animal{
    // 在子类中，可以通过创建同名方法来重写父类的方法
    sayHello(){
        console.log("汪汪汪")
    }
}

class Cat extends Animal{
    // 重写构造函数
    constructor(name, age){
        // 重写构造函数时，构造函数的第一行代码必须为super()
        super(name) // 调用父类的构造函数
        this.age = age
    }
    
    sayHello(){
        // 调用一下父类的sayHello, 也可以不调用
        super.sayHello() // 在方法中可以使用super来引用父类的方法
        console.log("喵喵喵")
    }
}

const dog = new Dog("旺财")
const cat = new Cat("汤姆", 3)

dog.sayHello()
cat.sayHello()
console.log(dog)
console.log(cat)

9 对象的内存结构

对象中存储属性的区域实际有两个：

  1. 对象自身
    • 直接通过对象所添加的属性，位于对象自身中：this.gender = "男"
    • 在类中通过 x = y 的形式添加的属性，位于对象自身中：name = "zhansgan"
  2. 原型对象（prototype）
    • 对象中还有一些内容，会存储到其他的对象里（原型对象）
    • 在对象中会有一个属性用来存储原型对象，这个属性叫做__proto__
    • 原型对象也负责为对象存储属性，
      • 当我们访问对象中的属性时，会优先访问对象自身的属性
      • 对象自身不包含该属性时，才会去原型对象中寻找
    • 会添加到原型对象中的情况：
      1. 在类中通过xxx(){}方式添加的方法，位于原型中
      2. 主动向原型中添加的属性或方法

image-20221202123950992

10 原型

访问一个对象的原型对象

  • 对象.__proto__
  • Object.getPrototypeOf(对象)
class Person {
    name = "孙悟空"
    age = 18

    sayHello() {
        console.log("Hello，我是", this.name)
    }
}

const p = new Person()
console.log(p.__proto__) // 访问原型对象
console.log(Object.getPrototypeOf(p))

image-20221202124337168

原型对象中的数据：

  1. 对象中的数据（属性、方法等）
  2. constructor （对象的构造函数）

10.1 原型链

注意：原型对象也有原型，这样就构成了一条原型链，根据对象的复杂程度不同，原型链的长度也不同

  • p对象的原型链：p对象 --> 原型 --> 原型 --> null

  • obj对象的原型链：obj对象 --> 原型 --> null

    image-20221202124937100

原型链：

  • 读取对象属性时，会优先对象自身属性，

    • 如果对象中有，则使用，没有则去对象的原型中寻找

    • 如果原型中有，则使用，没有则去原型的原型中寻找

    • 直到找到Object对象的原型（Object的原型没有原型（为null））

    • 如果依然没有找到，则返回undefined

  • 作用域链和原型链的比较

    • 作用域链，是找变量的链，找不到会报错
    • 原型链，是找对象属性的链，找不到会返回undefined

所有的同类型对象它们的原型对象都是同一个，也就意味着，同类型对象的原型链是一样的

class Person {
    name = "孙悟空"
    age = 18

    sayHello() {
        console.log("Hello，我是", this.name)
    }
}

class Dog {}

const p = new Person()
const p2 = new Person()
const d = new Dog()

console.log(p == p2) // false
console.log(p.__proto__ == p2.__proto__) // true
console.log(d == p) // false
console.log(d.__proto__ == p.__proto__) // false

image-20221202180308792

10.2 原型的作用：

  • 原型就相当于是一个公共的区域，可以被所有该类实例访问，
  • 可以将该类实例中，所有的公共属性（方法）统一存储到原型中
  • 这样我们只需要创建一个属性，即可被所有实例访问

JS中继承就是通过原型来实现的，当继承时，子类的原型就是一个父类的实例

在对象中有些值是对象独有的，像属性（name，age，gender）每个对象都应该有自己值，但是有些值对于每个对象来说都是一样的，像各种方法，对于一样的值没必要重复的创建

尝试：
函数的原型链是什么样子的？
Object的原型链是什么样子的？

11 修改原型

大部分情况下，我们是不需要修改原型对象

class Person {
    name = "孙悟空"
    age = 18

    sayHello() {
        console.log("Hello，我是", this.name)
    }
}

const p = new Person()
const p2 = new Person()

// 通过对象修改原型，向原型中添加方法，修改后所有同类实例都能访问该方法 不要这么做
p.__proto__.run = () => {
    console.log('我在跑~')
}

console.log(p)
console.log(p2)

p.run()
p2.run()

注意：千万不要通过类的实例去修改原型（类似上面这样）

  1. 通过一个对象影响所有同类对象，这么做不合适
  2. 修改原型先得创建实例，麻烦
  3. 危险

处理通过__proto__能访问对象的原型外，还可以通过类的prototype属性，来访问实例的原型，修改原型时，最好通过类去修改

Person.prototype === p.__proto__ //true

好处：

  1. 一修改就是修改所有实例的原型
  2. 无需创建实例即可完成对类的修改

原则：

  1. 原型尽量不要手动改
  2. 要改也不要通过实例对象去改
  3. 通过 类.prototype 属性去修改
  4. 最好不要直接给prototype去赋值

12 instanceof和hasOwn

12.1 instanceof

instanceof 用来检查一个对象是否是一个类的实例

  • instanceof检查的是对象的原型链上是否有该类实例，只要原型链上有该类实例，就会返回true

  • dog -> Animal的实例 -> Object实例 -> Object原型

  • Object是所有对象的原型，所以任何和对象和Object进行instanceof运算都会返回true

12.2 in

使用in运算符检查属性时，无论属性在对象自身还是在原型中，都会返回true

class Person {
    name = "孙悟空"
    age = 18

    sayHello() {
        console.log("Hello，我是", this.name)
    }
}

const p = new Person()
console.log("sayHello" in p) // true
console.log("name" in p) // true

12.3 hasOwnProperty

对象.hasOwnProperty(属性名)：用来检查一个对象的自身是否含有某个属性

不推荐使用

class Person {
    name = "孙悟空"
    age = 18

    sayHello() {
        console.log("Hello，我是", this.name)
    }
}

const p = new Person()
console.log(p.hasOwnProperty("sayHello")) // false
console.log(p.hasOwnProperty("name")) // true

12.4 hasOwn

Object.hasOwn(对象, 属性名) ：用来检查一个对象的自身是否含有某个属性

13 旧类

早期JS中，直接通过函数来定义类

  • 一个函数如果直接调用 xxx() 那么这个函数就是一个普通函数
  • 一个函数如果通过new调用 new xxx() 那么这个函数就是一个构造函数
// 等价于：class Person{}
function Person(name, age) {
    // 在构造函数中，this表示新建的对象
    this.name = name
    this.age = age
}

// 向原型中添加属性（方法）
Person.prototype.sayHello = function () {
    console.log(this.name)
}

// 静态属性
Person.staticProperty = "xxx"
// 静态方法
Person.staticMethod = function () {}

const p = new Person("孙悟空", 18)
console.log(p)

上面这种方式定义类比较分散，可以使用立即执行函数把他们写在一起，等价于以下代码

var Person = (function () {
    function Person(name, age) {
        // 在构造函数中，this表示新建的对象
        this.name = name
        this.age = age

        // this.sayHello = function(){
        //     console.log(this.name)
        // }
    }

    // 向原型中添加属性（方法）
    Person.prototype.sayHello = function () {
        console.log(this.name)
    }

    // 静态属性
    Person.staticProperty = "xxx"
    // 静态方法
    Person.staticMethod = function () {}

    return Person
})()

const p = new Person("孙悟空", 18)
console.log(p)

继承的实现方式

var Animal = (function(){
    function Animal(){

    }

    return Animal
})()


var Cat = (function(){
    function Cat(){

    }

    // 继承Animal
    Cat.prototype = new Animal()

    return Cat
})()

var cat = new Cat()

console.log(cat)

14 new运算符

new运算符是创建对象时要使用的运算符

  • 使用new时，到底发生了哪些事情：
    https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/new

  • 当使用new去调用一个函数时，这个函数将会作为构造函数调用，使用new调用函数时，将会发生这些事：

    1. 创建一个普通的JS对象（Object对象 {}）, 为了方便，称其为新对象

    2. 将构造函数的prototype属性设置为新对象的原型

    3. 使用实参来执行构造函数，并且将新对象设置为函数中的this

    4. 如果构造函数返回的是一个非原始值，则该值会作为new运算的返回值返回（千万不要这么做）

    如果构造函数的返回值是一个原始值或者没有指定返回值，则新的对象将会作为返回值返回

    所以一般不要写返回值

function MyClass() {
 	// 第一步
    var newInstance = {}
    // 第二步
    newInstance.__proto__ = MyClass.prototype
}
Hydrion-Qlz
关注
专栏目录
JavaScript 面向对象编程
gako15587481707的博客
06-18 1360
面向对象编程是一种程序设计思想，它具有 3 个显著的特征：封装、继承、多态。
complete-javascript-course-master.zip
11-15
随着课程的深入，将涉及面向对象编程（OOP）的概念，如类、构造函数、继承和封装，这将帮助学员编写更加模块化和可维护的代码。此外，还将涵盖闭包、作用域、原型链等高级特性，这些是JavaScript中的精髓，也是面试...
JavaScript经典教程（七）-- JavaScript初级
weixin_45097269的博客
05-10 605
DOM：节点，也就是html中的元素；DOM操作：其实就是节点元素的方法；
【JavaScript】编程范式详解---面向过程与面向对象编程
lph159的博客
09-15 859
面向过程编程是一种以步骤为导向的编程范式。程序被设计为一系列过程（或函数）的集合，每个过程执行特定的任务。它主要关注的是如何完成某个任务，即操作的步骤。代码执行是自上而下、按顺序进行的。面向对象编程是一种将程序中的数据与操作该数据的函数紧密关联的编程范式。数据被封装在对象中，对象包含属性（数据）和方法（操作数据的函数）。OOP 强调通过对象来组织程序，并支持代码的封装、继承、多态等特性。JavaScript 既支持面向过程编程，也支持面向对象编程，这使得开发者可以根据具体需求选择合适的编程范式。
JavaScript 进阶教程(1)--面向对象编程
热门推荐
AlbertYang的博客
08-16 2万+
1 学习目标 理解面向对象开发思想 掌握 JavaScript 面向对象开发相关模式 2 面向对象介绍 2.1什么是对象 Everything is object （一切皆对象） 我们可以从两个层次来理解对象： (1) 对象是单个事物的抽象。 一本书、一辆汽车、一个人都可以是对象，一个数据库、一张网页、一个与远程服务器的连接也可以是对象。当实物被抽象成对象，实物之间的关系就变成了对象之间的关系，从而就可以模拟现实情况，针对对象进行编程。 (2) 对象是一个.
面试题-javascript-面向对象编程
Shuuki
06-21 1194
function ClassA() { var value=4; this.getValue= function() { return value; } this.setValue= function(value) { this.value=value;
javascript知识巩固------面向对象编程
wennianzhu的博客
07-22 768
面向对象编程OOP(Object Oriented Programming) 面向对象是把事务分解成为一个个对象，然后由对象之间分工合作。（面向对象是以对象功能来划分问题，面向过程的编程思想是以具体步骤来划分问题） eg：用面向对象的做法把大象放进冰箱 1.大象对象：进去 2.冰箱对象：打开 关闭 3.使用大象和冰箱的功能 面向对象编程具有灵活、代码可复用、容易维护和开发的优点，更适合多人合作的大型软件项目。 OOP的特征有：封装性；继承性；多态性。 面向过程和面向对象的对比 面向过程： 优点：性能比
javascript---函数式编程
weixin_50402587的博客
04-04 1773
函数式编程与其他编程模式区别函数式一等公民函数可以储存在变量中高阶函数函数作为参数函数作为返回值常用的高阶函数闭包closure纯函数lodash 与其他编程模式区别 —与面向过程,面向对象编程并列 面向过程:按照步骤来实现我们想实现的功能 面向对象的思维方式:把现实社会中的事物抽象成程序世界中的类与对象,通过封装继承多态来演示事物的联系; 函数式编程:把现实社会中的事物抽象成程序世界中的运算过程 函数式开发库lodash; let num1=1; let num2=2; let sum=num1+num2
JavaScript高级教程（面向对象编程）
一只努力搬砖的打工妹纸
01-25 5348
面向对象编程 有两大编程思想：面向过程和面向对象； 面向过程编程POP(Process-oriented programming) 面向过程即分析出解决问题所需要的步骤，然后用函数将这些步骤一步步实现，使用的时候再一个个的一次调用就可以了； 即将大象装进冰箱，从面向过程来看，需要打开冰箱门、装进去大象、关上冰箱门 面向对象编程OOP(Object Oriented Programming) 面向对象即把事务分解成为一个个对象，然后由对象之间分工与合作；是以对象功能来划分问题，而不是步骤；在面向对
javascript面向对象编程练习------tab栏
Jdoit CW的博客
06-05 5931
本文用JavaScript面向对象思想写tab栏 本文旨在对JavaScript面向对象加深印象，练习下思路 本文核心知识点： JavaScript面向对象的思想 面向对象中this指向问题 1. 功能需求 点击 tab栏,可以切换效果. 点击 + 号, 可以添加 tab 项和内容项. 点击 x 号, 可以删除当前的tab项和内容项. 双击tab项文字或者内容项文字可以修改里面的文字内容 细节处做优化（避免tab填满溢出，删完报错等） 2.效果预览 3.demo准备 获取到标题元素 获取到内容元
JavaScript青少年简明教程：面向对象编程入门
cnds123的专栏
08-01 1268
JavaScript青少年简明教程：面向对象编程入门
javascript-978-1-7858-8910-3:掌握 JavaScript 面向对象编程
05-30
JavaScript，作为一种广泛应用于Web开发的动态编程语言，其面向对象编程是其核心概念之一。本资源，"javascript-978-1-7858-8910-3:掌握 JavaScript 面向对象编程"，显然是为了帮助开发者深入理解和熟练运用...
angluo-javascript-341240.zip
04-15
接着，"java"这个文件名虽然看似与Java编程语言相关，但在JavaScript的学习过程中，我们也会接触到与Java相似的概念，比如面向对象编程。JavaScript中的对象、类和原型链，以及构造函数、继承、封装等概念，这些都是...
JavaScript-CursodaRocketseat-master.rar
10-09
5. **面向对象编程**：JavaScript支持类和原型为基础的面向对象编程，理解构造函数、原型链、继承和封装是进阶学习的重要部分。 6. **ES6及以后的特性**：ECMAScript是JavaScript的标准，新的版本引入了许多新特性...
计算机软件-编程源码-Javascript语言教程.zip
05-23
对象则是一种键值对的数据结构，可以通过构造函数和原型链实现面向对象编程。 - **DOM操作**：JavaScript能与HTML文档对象模型（DOM）交互，用于动态修改网页内容，如增删改查元素，以及事件处理。 2. **...
一些常用的react hooks以及各自的作用
weixin_48602044的博客
11-01 332
关于react hooks的一些知识与应用
CesiumJS 案例 P12：添加指定长宽的图片图层并居中显示（圆点分别为图片图层的中心点、左上角顶点、右上角顶点、左下角顶点、右下角顶点）
weixin_52173250的博客
10-30 1137
CesiumJS 案例 P12：添加指定长宽的图片图层并居中显示（圆点分别为图片图层的中心点、左上角顶点、右上角顶点、左下角顶点、右下角顶点）
JavaScript 生成二维码
最新发布
qq_30049249的博客
11-02 202
我试过了，这一款js库支持中英文混合。进入网站后，可以直接点击运行哟～
基于vue框架的的汇生活家居商城的设计与实现bdjlq（程序+源码+数据库+调试部署+开发环境）系统界面在最后面。
h2345678的博客
10-29 1422
项目功能：商品分类,商品信息,用户。
现代JavaScript面向对象编程探索
"51CTO下载-javascript面向对象编程.pdf" 本文档主要介绍了现代JavaScript编程，特别是关于面向对象编程的概念。JavaScript作为一种强大的编程语言，经过多年的发展，已经成为构建复杂应用的首选工具。现代...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Hydrion-Qlz

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值