js中原型对象与原型的关系-阿里云开发者社区

js中原型对象与原型的关系

2023-08-20 58

版权

本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。

简介： js中原型对象与原型的关系

构造函数的应用

在我们类这个概念还没有出来之前，我们都是通过构造函数的方法来创建实例化对象。我们先来看看传统创建对象和构造函数创建的区别。

//1.通过对象字面量来创建。
var student = {
  name: "zhangsan",
  age: 18,
  gender: "male",
  sayHi: function () {
    console.log("hi,my name is " + this.name);
  },
};
//2.通过 new Object() 创建对象。
var student = new Object();
    student.name = "zhangsan",
    student.age = 18,
    student.gender = "male",
    student.sayHi = function () {
      console.log("hi,my name is " + this.name);
  };

上面两种都是简单的创建对象的方式，那如果是一个班的学生，n 个学生呢？显然如果这样做的话代码冗余率太高，是不可取的。我们也学过函数，所以简单方式的改进是：工厂函数。

//3.通过工厂函数来创建对象。
function createStudent(name, age, gender) {
  var student = new Object();
  student.name = name;
  student.age = age;
  student.gender = gender;
  student.sayHi = function () {
    console.log("hi,my name is " + this.name);
  };
  return student;
}
var s1 = createStudent("zhangsan", 18, "male");
var s2 = createStudent("lisi", 19, "male");

这样封装代码确实解决了代码冗余的问题，但是每次调用函数 createStudent()都会创建新函数sayHi()，也就是说每个对象都有自己的 sayHi() 版本，而事实上，每个对象都共享一个函数。为了解决这个问题，我们引入面向对象编程里的一个重要概念：构造函数。

//4.通过构造函数来创建对象。
function Student(name, age, gender) {
  this.name = name;
  this.age = age;
  this.gender = gender;
  this.sayHi = function () {
   console.log("hi,my name is " + this.name);
  };
}
var s1 = new Student("zhangsan", 18, "male");

来看看构造函数与工厂函数的区别： 1.首先在构造函数内没有创建对象，而是使用 this 关键字，将属性和方法赋给了 this 对象。 2.构造函数内没有 return 语句，this 属性默认下是构造函数的返回值。 3.函数名使用的是大写的 Student。 4.用 new 运算符和类名 Student 创建对象。

构造函数虽然科学，但仍然存在一些问题。我们使用前面的构造函数例子来讲解（修改了 sayHi() 方法）：

function Student(name, age, gender) {
  this.name = name;
  this.age = age;
  this.gender = gender;
  this.sayHi = function () {
    console.log("hi");
  };
}
//首先我们创建两个实例化对象：
var s1 = new Student("zhangsan", 18, "male");
s1.sayHi(); // 打印 hi
var s2 = new Student("lisi", 18, "male");
s2.sayHi(); // 打印 hi
console.log(s1.sayHi == s2.sayhi); // 结果为 false

由于每个对象都是由 new Student 创建出来的，因此每创建一个对象，函数 sayHi() 都会被重新创建一次，这个时候，每个对象都拥有一个独立的，但是功能完全相同的方法，这样势必会造成内存浪费。有的人可能会想，既然是一样的那我们就单独把它提出来，写一个函数，每次调用不就可以了吗？比如：

function sayHi() {
  console.log("hi");
}
function Student(name, age, gender) {
  this.name = name;
  this.age = age;
  this.gender = gender;
  this.sayHi = sayHi;
}
var s1 = new Student("zhangsan", 18, "male");
s1.sayHi(); // 打印 hi
var s2 = new Student("lisi", 18, "male");
s2.sayHi(); // 打印 hi
console.log(s1.sayHi == s2.sayHi); // 结果为 true

但是这样做会导致全局变量增多，可能会引起命名冲突，代码结果混乱，维护困难。通过使用原型可以很好的解决这个问题。

原型的作用

原型：prototype 在 JavaScript 中，每一个构造函数都有一个 prototype 属性，指向另一个对象。这个对象的所有属性和方法，都会被构造函数的实例继承。

function Star(uname,age) {
 this.uname = uname;
 this.age = age;
 }
 let dgl = new Star("戴古拉k",22);
 console.log(dgl);
 console.log(dgl.__proto__);

而在我们的实例对象中具有__proto__属性,它指向的是我们构造函数中的prototype原型对象

function Star(uname,age) {
  this.uname = uname;
  this.age = age;
  Star.prototype.movie = function() {
  console.log("极地追击");
  }
  }
  var dgl = new Star("戴古拉k",22);
  console.log(dgl);
  dgl.movie();

因此当我们调用的时候__proto__直接帮我们指向了prototype中的movie属性

在构造函数的prototype中存在一个constructor属性,它指向我们prototype原型对象所在的构造函数

注意我们使用prototype创建方法时都是prototype + .属性 ,如果我们使用的是对象添加方法则constructor会不一样

function Star(uname,age) {
 this.uname = uname;
 this.age = age;
 Star.prototype.movie = function() {
 console.log("极地追击");
 }        
}
 let dgl = new Star("戴古拉k",22);
  console.log(dgl);
  console.log(dgl.__proto__.constructor);

function Star(uname,age) {
 this.uname = uname;
 this.age = age;
 Star.prototype = {
  movie: function() {
  console.log("极地追击");
 }       
}          
}
 let dgl = new Star("戴古拉k",22);
 console.log(dgl);
 console.log(dgl.__proto__.constructor);