原型与原型链学习笔记1.文档类型声明cpp 位于文档中的最前面的位置，处于<html>标签之前 2.lang语言种类 e

prototype和 proto

对应名称：

prototype：原型
__proto__:原型链（链接点）从属关系：
prototype -> 函数的一个属性：（该属性是一个对象）对象{ }
__proto__ -> 是对象Object的一个属性：（该属性也是一个对象）对象{ } 对象的__proto__保存该对象的构造函数的prototype

function Test(){ /构造函数Test
	console.log(Test.prototype);
}
const test = new Test();/利用构造函数new一个对象test
console.log(Test.prototype.__proto__ === Object.prototype);
/Test构造函数的属性（prototype对象）的（__proto__对象原型)，应该指向构造（prototype对象）的构造函数的prototype
//所以说根据原型链，构造（prototype对象）的构造函数，应该是Object。当前prototype对象只是由属性关系被Test包含，并不是由其构造
console.log(Object.prototype.__ptoto__);//none
//而构造函数Object的（prototype对象）不能再去寻找构造该prototype对象的构造函数了
//所以Object是原型链的头顶

原型链与原型继承

function Test(){ /构造函数Test
	console.log(Test.prototype);
}
const test = new Test();/利用构造函数new一个对象test
test.a = 1;
test.b = 333;
Test.prototype.b = 2;
Object.prototype.c = 3;
/**
test{
	a: 1,
	b: 333,
	__proto__: Test.prototype = {
		b: 2,
		__proto__: Object.prototype = {
			c: 3
			(no another proto)
		}
	}
}
**/
console.log(test.a);//1
console.log(test.b);//333
console.log(test.c);//3

以上形象的原型链，原型链主要是以__proto__为节点进行连接，一层一层的指向更高一层的prototype对象而所谓原型的继承，是指test在查找元素时，本身对象内有就用本身的元素，没有就根据原型链通过__prototype__向上级查找

原型继承

//man和woman，公共的部分放到原型上
const Person = {
	eays: 2,
	head: 1//字面量创对象，用逗号
}
//构造函数想要继承Person
function Woman(){
	
}
//Woman 通过原型来继承Person
Woman.prototype = Person;
//指回原来的构造函数，因为上一步是直接覆盖了
Woman.prototype.constructor = Woman;
const red = new Woman();
//给女人添加一个方法 baby
Woman.prototype.baby = function(){
 console.log('baby');
}

但是这种引用类型会有问题，指向同一个对象，在一个修改person时，另一个中的person也会跟着变所以这时就不要用const声明固定的对象了，用构造函数声明对象

//构造函数 new出来的对象 结构一样，但是对象不一样
function Person(){
	this.eyes = 2;
	this.head = 1;//构造函数创对象，用；
}
function Woman(){

}
Woman.prototype= new Person();
Woman.prototype.constructor = Woman;

原型继承的使用[[13 面向对象封装消息提示插件]]

一个比较混乱的知识

Function 和 Object

Function本身即是函数又是对象
在新new一个对象时，底层是用的function构造的构造对象所使用的Object
在底层new function 时，就构造了Object函数（用来构造对象）

console.log(Test.__proto__ === Function.prototype);

console.log(Function.__proto__);//funciton
console.log(Function.prototype);//funciton
console.log(Function.__proto__ === Function.prototype)

console.log(typeof Object);//funciton
console.log(Object.__proto__ === Function.prototype);
console.log(Object.__proto__ === Function.__proto__);

y原型链关系图

Test ──__proto__──> Function.prototype <──__proto__─ Function
                                    ↑
Object ──__proto__──────────────────┘

所有函数（包括 Function 和 Object）的 __proto__ 均指向 Function.prototype。
Function.prototype 是原型链的根节点之一，与 Object.prototype 并列。
Function 是唯一一个 __proto__ 和 prototype 指向同一对象的构造函数。

两个内置查找方法

hasOwnProperty

查找当前对象内是否有该元素

console.lgo(test.hasOwnProperty('a'));

in test

查找原型链上是否有该元素

console.log('a' in test);

两方法都是返回true和false

constructor

指向当前函数或对象的构造函数 ![[Pasted image 20250412202808.png]]

constructor 总是指向构造函数（函数）：无论调用者是对象还是函数，constructor 属性最终指向一个函数。
函数对象的 constructor：所有函数（包括 Test、Object、Function）的 constructor 均指向 Function 构造函数，因为它们是 Function 的实例。
实例对象的 constructor：通过原型链继承自其构造函数的 prototype.constructor 属性。

原型与原型链学习笔记

prototype和 __ proto __