当前位置：首页 > JavaScript

JS如何实现面向对象

2026-04-04 09:33:21JavaScript

使用构造函数

构造函数是创建对象的模板，通过 new 关键字调用。构造函数内部使用 this 绑定属性和方法。

function Person(name, age) {
  this.name = name;
  this.age = age;
  this.sayHello = function() {
    console.log(`Hello, my name is ${this.name}`);
  };
}

const person = new Person('Alice', 25);
person.sayHello();

使用原型链

原型链是 JavaScript 实现继承的核心机制。通过 prototype 属性共享方法和属性，减少内存消耗。

function Person(name, age) {
  this.name = name;
  this.age = age;
}

Person.prototype.sayHello = function() {
  console.log(`Hello, my name is ${this.name}`);
};

const person = new Person('Bob', 30);
person.sayHello();

使用 ES6 类语法

ES6 引入了 class 语法糖，简化了面向对象的实现。底层仍然是基于原型链。

class Person {
  constructor(name, age) {
    this.name = name;
    this.age = age;
  }

  sayHello() {
    console.log(`Hello, my name is ${this.name}`);
  }
}

const person = new Person('Charlie', 35);
person.sayHello();

实现继承

通过 extends 关键字实现继承，子类可以调用父类的构造函数和方法。

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

  speak() {
    console.log(`${this.name} makes a noise.`);
  }
}

class Dog extends Animal {
  speak() {
    console.log(`${this.name} barks.`);
  }
}

const dog = new Dog('Rex');
dog.speak();

使用闭包封装私有变量

通过闭包可以实现私有变量和方法的封装，避免直接暴露内部状态。

function Counter() {
  let count = 0;

  this.increment = function() {
    count++;
    console.log(count);
  };

  this.decrement = function() {
    count--;
    console.log(count);
  };
}

const counter = new Counter();
counter.increment();
counter.decrement();

使用工厂函数

工厂函数是一种创建对象的设计模式，无需使用 new 关键字。

function createPerson(name, age) {
  return {
    name,
    age,
    sayHello() {
      console.log(`Hello, my name is ${this.name}`);
    }
  };
}

const person = createPerson('Dave', 40);
person.sayHello();

使用 Object.create

Object.create 方法可以创建一个新对象，并指定其原型对象。

JS如何实现面向对象

const personPrototype = {
  sayHello() {
    console.log(`Hello, my name is ${this.name}`);
  }
};

const person = Object.create(personPrototype);
person.name = 'Eve';
person.age = 45;
person.sayHello();