原型的知识点

深拷贝

代码如下：

var person = {
			age,
			name,
			func1:()=>{
				// console.log(this);
				// console.log(this.name);
				// this.name = "黄俊杰";
				person.name = "刘弘博";
			},
			func(){
				setTimeout(()=>{
					// console.log(this);
					person.func1();
					console.log(this.name);
					
				})
			}
		};

浅拷贝

代码如下：

Object.assign(target, source_1, ···)
		let obj1 = {a:1};
		let obj2 = {b:{d:2}};
		let obj3 = {c:3};
		Object.assign(obj3,obj1,obj2);
		obj3.b.d = 99;
		console.log(obj3);
		console.log(obj2);

知识点：Array.isArray(obj)判断是数组或对象。

js判断对象是否拥有某个key

两种判断方法

方法一 ：“key” in obj ，结果为 false，表示不包含；否则表示包含
方法二 ：obj.hasOwnProperty(“key”)，obj 表示对象，结果为 false 表示不包含；否则表示包含

递归！！！

示例代码：

let arr = [11,[22,33],[44,[55,[66,77],88],99]];
		let arr2 = {};
		let arr3 = 10;
		let arr1 = [];
		function func(user){
			if(Array.isArray(user)==false){
				box1.style.display = "block";
				return;
			}
			for(let i=0;i<user.length;i++){
				// console.log(arr[i]);
				if(Array.isArray(user[i])==false){
					// console.log(`值---${arr[i]}`);
					arr1.push(user[i]);
				}else{
					func(user[i])
				}
			}
		}
		func(arr);
		console.log(arr1);

下面讲了一下原型 !

原型模式

JS实现继承的方式是通过原型和原型链实现的，JS中没有类

每个函数都有prototype(原型)属性，这个属性是一个指针，指向一个对象，
这个对象的用途是包含特定类型的所有实例共享的属性和方法，
即这个原型对象是用来给实例共享属性和方法的。
 而每个实例内部都有一个指向原型对象的指针(proto)。

function Star(uname,age){
			// console.log(this);
			this.uname=uname;
			this.age=age;
			this.sing=function(){
				console.log('唱歌')
			}
		}

静态方式添加

Star.sex = “男”;
Star.prototype.constructor.ids = 99;

通过原型方式添加

		Star.prototype.myFunc = function(){
			console.log(11111111111);
		}
		Function.prototype.somFunc = function(){
			console.log(33333333333);
		}
		Object.prototype.somFunc = function(){
			console.log(444444444);
		}

var ldh=new Star('刘德华',18);
console.log(ldh);
constructor获取静态方法存储的值
console.log(ldh.__proto__.constructor.sex);
console.log(ldh.__proto__.constructor.ids);
ldh.__proto__.constructor.func1 = function(){
console.log(9999999999999);
}
Star.prototype.constructor.func1();

原型链

理解：每一个引用类型都有__proto__,每一个函数都有prototype,引用类型的__proto__与它构造函数的prototype指向同一个对象；调用引用类型时，如果其本身并没有调用的方法或属性，就会去__proto__（也就是它构造函数的prototype）去找，没有的话会继续找prototype的__proto__，到顶级Object的原型指向null为止

原型查找机制

1. 当访问一个对象的属性或方法时，首先查找这个对象自身有没有
2. 如果没有就查找它的原型（也就是 proto 指向的prototype 原型对象 ）
3. 如果还没有找到就查找原型对象的原型（Object的原型对象）
4. 依次类推一直找到Object为止（ null ）
5. proto 对象原型的意义就在于为对象成员查找机制提供一个方向，或者说一条线路

使用原型方式创建数组的pops（），pushs（），shifts()，unshifts（）的方法

实例代码展示：

Array.prototype.pops = function(){
			this.length = this.length-1;
		}
		var arr = [11,22,33];
		arr.pops();
		console.log(arr);

Array.prototype.pushs = function(user){
			this[this.length] = user
		}
		var arr = [11,22,33];
		arr.pushs(44);
		console.log(arr);

Array.prototype.shifts = function(){
			for(var i=0;i<this.length-1;i++){
				this[i] = this[i+1];
			}
			this.length = this.length-1;
		}
		var arr = [11,22,33];
		arr.shifts();
		console.log(arr);

Array.prototype.unshifts = function(user){
			this.length = this.length+1;
			for(var i=this.length-1;i>=0;i--){
				this[i] = this[i-1];
			}
			this[0] = user;
		}
		var arr = [11,22,33];
		arr.unshifts(44);
		console.log(arr);

call()方法原理

Function.prototype.calls = function(user,...a){
			if(!user||user==null||user==undefined){
				user = window;
			}
			let fn = Symbol();
			user[fn] = this;
			return user[fn](...a);
		}
		let obj = {
			func(a,b){
				console.log(this);
				console.log(this.age);
				console.log(a);
				console.log(b);
			}
		}
		let obj1 = {
			age:"张三"
		}
		obj.func.calls(obj1,1,2);

bind()原理

Function.prototype.myBind = function(context) {
			// 如果没有传或传的值为空对象 context指向window
			if (typeof context === "undefined" || context === null) {
				context = window
			}
			let fn = mySymbol(context)
			context[fn] = this //给context添加一个方法 指向this
				// 处理参数 去除第一个参数this 其它传入fn函数
			let arg = [...arguments].slice(1) //[...xxx]把类数组变成数组，arguments为啥不是数组自行搜索 slice返回一个新数组
			context[fn](arg) //执行fn
			delete context[fn] //删除方法

		}

apply原理一致 只是第二个参数是传入的数组

Function.prototype.myApply = function (context, args) {
		  if (!context || context === null) {
		    context = window;
		  }
		  // 创造唯一的key值  作为我们构造的context内部方法名
		  let fn = Symbol();
		  context[fn] = this;
		  // 执行函数并返回结果
		  return context[fn](...args);
		};

2.改变this指向的方法有哪些

(1）在指定位置定义this存为变量
(2）使用箭头函数
(3）使用setTimeout
(4）使用call()方法
(5）使用bind()方法
(6）使用applay()方法

所学的判断方法

1.switch(){case:}
2.!非
3.is
4.typeof 检测
5.instanceof 检测数组和对象
6.constructor()==[];

示例：
var arr1={}
var arr2=function(){}
var arr3=10;
var arr4="abc";
var arr5=false;
console.log(arr instanceof Array)
console.log(arr1 instanceof Object)
console.log(arr2 instanceof function(){})
console.log(arr3 instanceof Number)
console.log(arr4 instanceof String)
console.log(arr5 instanceof Boolean) 
console.log(arr1.constructor())

以上就是所学原型的知识点，如有错误，请纠正！