Question

我正在学习javascript并且无法理解下面解释中的第二部分。是否有可能让你们了解这件事情

“构造函数的实际原型是function.prototype，因为构造函数是函数。它的prototype属性将是通过它创建的实例的原型，但不是它自己的原型”

Answer 1

好的，这是一个例子：

function Widget() {
   console.log('Widget constructor invoked');
}


Function.prototype.sayHi = function() { console.log('Function prototype.sayHi invoked'); };

Widget.prototype.sayHi = function() { console.log('Widget prototype.sayHi invoked') };

var w = new Widget();

console.log('Calling w.sayHi()');
w.sayHi();    

console.log('Calling Widget.sayHi()');
Widget.sayHi();

这将产生以下日志输出：

调用了Widget构造函数

调用w.sayHi（）

Widget prototype.sayHi被调用

调用Widget.sayHi（）

调用函数prototype.sayHi

调用w.sayHi()调用Widget对象上的方法，而调用Widget.sayHi()则调用函数上的方法。他们有两种不同的原型。

Answer 2

我认为一系列的比较会帮助你解决这个问题。

构造函数的实际原型是function.prototype，因为构造函数是函数

function IamAConstructorFunc() {} // A constructor function

IamAConstructorFunc.constructor // function Function()

IamAConstructorFunc.constructor.prototype // function Empty()

IamAConstructorFunc.constructor.prototype === Function.prototype // True

IamAConstructorFunc.constructor.prototype === Object.prototy // False

它的prototype属性将是通过它创建的实例的原型

var IObj = new IamAConstructorFunc; // Instance of IamAConstructorFunc

IObj.__proto__ === IamAConstructorFunc.prototype // True

IObj.constructor === IamAConstructorFunc // True

IObj instanceof IamAConstructorFunc // True

但不是它自己的原型

IamAConstructorFunc有一个prototype，但它不是它自己的原型，它是Object的一个实例，该实例原型是：

IamAConstructorFunc.prototype.__proto__ === Object.prototype // True

Answer 3

这太复杂了。

可以使用函数创建对象。

function MyFunc(a, b) {
    this.a = a;
    this.b = b;
}

var myObj = new MyFunc(a, b);

函数的原型可用于创建对象上的函数。

MyFunc.prototype.sum = function() {
    return this.a + this.b;
}

var myObj = new MyFunc(2, 3);
var true = (myObj.sum() === (2 + 3));

查看示例可能更容易。

function Person(first, last) {
  this.first = first;
  this.last = last;
}

Person.prototype.fullName = function() {
   return this.first + " " + this.last; 
}

var fred = new Person("Fred", "Flintstone");
var barney = new Person("Barney", "Rubble");
var output = document.getElementById("output");

output.innerHTML += fred.fullName() + "<br>\n";
output.innerHTML += barney.fullName() + "<br>\n";

#output {
  color:blue;
  font-weight:bold;
}

<div id="output">
  
</div>

Answer 4

我认为问题是函数的prototype属性与每个对象所具有的内部原型之间的混淆。

每个函数都有prototype属性。此属性与任何对象的任何其他属性相同。唯一特别之处在于，它将被用作任何对象的内部原型，由该函数创建。

function A() {
}

//add property c to public prototype property of A
A.prototype.c = 1;

//create a new instance -> a will get A's prototype property as internal prototype
a = new A();

//a has therefore access to the property c, that was defined earlier
console.log(a.c); //1

由于函数也是JavaScript中的对象，因此它们也有内部原型。

function A() {}

//apply is part of A's prototype chain. 
//It's defined on its internal prototype objects,
//which was created by its own constructor, named "Function"
A.apply(this, []);

Answer 5

这句话几乎让我发疯，但我最终理解了它。实际上，在JavaScript中，构造函数在创建时会自动分配一个名为 prototype 的属性。

这个属性将被通过此构造函数创建的所有实例用作它们自己的原型，并且不会重新构建构造函数本身的实际原型。实际上，构造函数原型是Function.prototype。

var Cat = function() {};
Cat.__proto__ === Function.prototype; // true

var kitty = new Cat;
kitty.__proto__ === Cat.prototype; // true

这是正常的，因为Cat（我们的构造函数）本身就是一个函数，因此它派生自Function.prototype。并且kitty来自Cat上的新关键字调用，因此它来自Cat.prototype。

所以在声明中：

构造函数的实际原型是function.prototype，因为构造函数是函数。

实际原型引用构造函数（Cat）的__proto__属性。

它的prototype属性将是通过它创建的实例的原型，但不是它自己的原型。

其原型属性是指.prototype

javascript - 构造函数 - 原型 - proto

5 个答案:

javascript - 构造函数 - 原型 - __proto__

5 个答案:

javascript - 构造函数 - 原型 - proto