javascript 原型 是什么？javascript 基础 js类和原型到底是什么
其实javascript 原型 是什么的问题并不复杂，但是又很多的朋友都不太了解javascript 基础 js类和原型到底是什么，因此呢，今天小编就来为大家分享javascript 原型 是什么的一些知识，希望可以帮助到大家，下面我们一起来看看这个问题的分析吧！
javascript 基础 js类和原型到底是什么
其实简单来说，原型就是一个对象对另一个对象的引用。
然后其是怎么联系起来的呢，是通过prototype。对就是这个，给你一个例子
varobj={
a:2
}
varmyObj=Object.create(obj);
console.log(myObj.a);//2
console.log(myObj===obj);//false
console.log(Object.getPrototypeOf(myObj)===obj);//true
Object.getPrototypeOf(myObj).a=4
console.log(obj.a);//4
通过上面的例子，你可以看到，myObj的原型就是obj！然后obj的原型是哪个呢，是Object.prototype。实际上通过上面，你就能知道，原型原理上是对于另一个对象的引用，通过引用吧几个对象给串联起来调用。
那么你的第二个问题马上又来了，可能也是你关心的问题，类和原型的关系是啥呢？
实际上，类在实例化的时候，也就是通过new来创建一个对象的时候，是分为以下几步的：
创建一个全新的对象
这个新对象会被执行prototype连接
新对象绑定到函数调用的this
如果函数没有返回其他对象，那么new表达式中的函数调用会自动返回这个新对象
这个就是new实例化的时候，所做的一些步骤，那么你其中有几个需要注意的点：
如果有return并且返回的是一个对象的话，则直接返回return后的那个对象。
反之，则新建一个对象。
并且吧函数的prototype引用到新建对象的prototype中。
这个怎么理解呢？再给你一个例子，可能例子更直观一些：
varprotoObj={
b:10
}
functionFoo(){}
Foo.prototype=protoObj;
vara=newFoo();
console.log(Object.getPrototypeOf(a)===Foo.prototype);//true
console.log(Object.getPrototypeOf(a)===protoObj);//true
console.log(a.b);//10
通过这个例子，你可以看出来，实际上类实例化的过程，其中有一项，就是把其构造好的对象的prototype和类的prototype做关联。因为做好了引用关联，所以构造好的对象可以使用原类里面的原型方法。
这个也讲完了，那么你可能会对class比较感兴趣，想知道class是怎么做的，实际上，class更多，我理解上就是上面类似于Foo()类的一种语法糖，当然也不仅仅是语法糖，但是大体原理是没啥区别的，所以，上面所说的，对于class也同样适用
好啦，如果你对原型和类实例化有更多想了解的，可以给你两篇文章，参考一下：
Javascript基础之-原型（prototype）
Javascript基础之-this
JavaScript原型,原型链 有什么特点
1.1一切皆为对象
JavaScript里所有的东西都是对象.对象是属性的集合.数字,字符串,布尔值等原始值是"伪对象",它们同样拥有属性,但是是在栈上分配并按值传递.而其他的对象是堆上分配并按引用传递.
一个很重要的概念是,函数也是对象,能够作为变量的值,返回值,参数或者属性的值.函数对象特殊的地方是能通过"xxx()"语法执行包含在xxx函数对象内的代码.因为这一特殊性, typeof xxx将会返回function,但这只是一种便利设施.
1.2对象的属性可以动态添加和删除
varfoo=newObject();
//为foo对象添加bar属性
foo.bar="foobar";
alert(foo.bar);//foobar
//删除foo对象的bar属性
deletefoo.bar;
alert(foo.bar);//undefined
1.3除了宿主对象,其它对象皆由构造函数创建
要有对象,就先要有创建对象的方法.
在C++/Java等语言,这个方法就是实例化XXX类的一个实例xxx.
而在JavaScript的世界里实际没有类的东西,当然仍然可以用"类"和"实例"等惯用语来描述JavaScript中类似的行为,但其机制是完全不同的. JavaScript的对象是由构造函数创建的,每个对象都有constructor属性表示创建该对象的构造函数:
functionTest(){this.a="hello";}
vartest=newTest();//由Test构造函数创建
alert(test.constructor);
varo={a:"hello"};
//实际相当于
varo_=newObject();
o_.a="hello";//由Object构造函数创建
alert(o.constructor);
构造函数也是对象,那构造函数是由什么创建?内建的Function函数:
functionTest(a, b)
{
alert(a+b);
}
//相当于:
Test=newFunction(["a","b"],"alert(a+b);");
Function函数又是由什么创建?实际上Function是本机代码实现的固有对象.不过为了一致性, Function也有constructor属性,该属性指向它自己.接上面的代码:
/*输出functionFunction(){
[nativecode]
}
*/
alert(Test.constructor);
alert(Test.constructor.constructor===Test.constructor);//true
alert(Test.constructor===Object.constructor);//true
2原型prototype
2.1 prototype的概念
prototype是构造函数的一个属性,该属性指向一个对象.而这个对象将作为该构造函数所创建的所有实例的基引用(base reference),可以把对象的基引用想像成一个自动创建的隐藏属性.当访问对象的一个属性时,首先查找对象本身,找到则返回;若不,则查找基引用指向的对象的属性(如果还找不到实际上还会沿着原型链向上查找,直至到根).只要没有被覆盖的话,对象原型的属性就能在所有的实例中找到.
原型默认为Object的新实例,由于仍是对象,故可以给该对象添加新的属性:
//prototype默认为newObject();为了方便,记为p_obj
functionPerson(name){
this.name=name;
}
//为p_obj增加sayName属性
Person.prototype.sayName=function(){
alert(this.name);
}
varjohn=newPerson("John");//john的basereference指向p_obj
vareric=newPerson("Eric");//eric的basereference也是指向p_obj
//注意sayName代码中的this将指向实例化后的对象(this绑定)
john.sayName();//john对象本身没有sayName属性,于是访问原型对象p_obj的sayName属性
eric.sayName();//访问同一个原型对象p_obj的sayName属性
vartmp=Person.prototype;
tmp.boss="David";
//于这个运行点,p_obj已经被修改
//根据上述属性访问流程,新的修改(boss属性)能反映到所有的实例,包括已经创建和即将创建的
alert("John'sbossis"+john.boss);
alert("Eric'sbossis"+eric.boss);
//hisCar和sayCar属性将增加到john对象而不是p_obj对象..
john.hisCar="Audi";
john.sayCar=function(){
alert(this.name+"hasacarof"+this.hisCar);
}
john.sayCar();
//..因此下一句将错误,因为eric对象本身和原型p_obj都没有sayName属性
/*eric.sayCar();*/
2.2原型链
除了能修改prototype指向的对象,还能修改prototype指向哪一个对象,即为prototype赋予一个不同的对象.这可以实现一种简单的继承:
functionSuperman(){}
Superman.prototype.sayHello=function(){
alert("I'masuperman.");
}
functionSupermanCan(skill){
this.skill=skill;
}
//为prototype赋予Superman的实例..
SupermanCan.prototype=newSuperman();
//..再动态添加新的属性
SupermanCan.prototype.sayMore=function(){
this.sayHello();//调用"父类"的方法
alert("Ican"+this.skill);
}
vardavid=newSupermanCan("fly");
//output:I'masuperman.Icanfly
david.sayMore();
如果先实例化出一个对象,再为构造函数prototype赋予一个不同的对象,将会:已经创建的对象的基引用不变,将来创建的对象的基引用为新的原型对象:
varf1={echo:function(){alert("sound");}};
functionFoo(){};
varfoo=newFoo();//foo的基引用指向Object实例
Foo.prototype=f1;
/*未定义,因为这是"foo对象自己或者基引用指向的对象有echo属性吗?"
而不是"foo对象自己或者Foo.prototype指向的对象有echo属性吗?"*/
alert(foo.echo);
varfoo2=newFoo();//foo2的基引用指f1对象
foo2.echo();//output:sound
所有的构造函数的prototype都不能为空,就是说Superman.prototype= null会被解释引擎无视;另一方面, Object构造函数也有prototype属性(该属性是只读的,可以为原型增加属性,但不能赋予不同的对象),故因此可以有多层的原型链,但原型链的根必定会是Object.prototype.这意味着给Object.prototype增加属性影响到所有对象:
Object.prototype.echo=function(){
alert("hello");
}
//echo属性将增加到所有对象固有对象和自定义对象
vararr=newArray();
arr.echo();
Array.echo();
functionObjCons(){
this.dummy="d";
}
varobj=newObjCons();
obj.echo();
ObjCons.echo();
3.构造函数和new的实质
构造函数是一个地地道道的函数,一个函数之所以能成为构造函数,是因为new运算符:
this.msg="window";
functionTest()
{
alert(this.msg);
}
Test();//window
vartest=newTest();//undefined.因为test对象没有定义msg属性
二者区别在于如何切入对象: Test()在某个对象(例子中为window)的上下文上执行代码,即this指向这个对象; new Test()创建一个新对象,并以这个新的对象为上下文(this指向新对象)执行代码,然后返回这个新对象.
假如有个函数:
functionTest(){
vardummy="havemoney";
this.wish=dummy;
doSomeThing();
}
结合以上的所有论述,可以推测new Test()行为的伪代码表示为:
创建一个新对象temp;
temp.constructor= Test;
temp.(base reference)= Test.prototype;//这一句先于代码体执行,意味着构造函数里的this.xxx能访问原型对象的属性xxx
bind: this=temp;//将this绑定到temp对象
//开始执行函数代码
var dummy="have money";
this.wish= dummy;//为temp对象添加wish属性
doSomeThing();
....
//结束执行函数代码
return temp;
这个未必会符合内部的二进制实现,但却能很好地解释了JavaScript的特性.
javascript原型,原型链 有什么特点
javascript原型，原型链特点：原型链实现了继承。
JS中每个函数都存在有一个原型对象属性prototype。并且所有函数的默认原型都是Object的实例。每个继承父函数的子函数的对象都包含一个内部属性proto。该属性包含一个指针，指向父函数的prototype。若父函数的原型对象的_proto_属性为再上一层函数。在此过程中就形成了原型链。
原型链的作用是用来实现继承,比如我们新建一个数组,数组的方法就是从数组的原型上继承而来的。
var arr= [];
arr.map=== Array.prototype.map//arr.map
是从arr.__proto__上继承下来的，arr.__proto__也就是Array.prototype。
扩展资料：
1.JS中每个函数都存在有一个原型对象属性prototype。并且所有函数的默认原型都是Object的实例。
2.每个继承父函数的子函数的对象都包含一个内部属性_proto_。该属性包含一个指针，指向父函数的prototype。若父函数的原型对象的_proto_属性为再上一层函数。在此过程中就形成了原型链。
3.原型链实现了继承。原型链存在两个问题：a包含引用类型值的原型属性会被所有实例共享。b在创建子类型时，无法向超类型的构造函数中传递参数。
参考资料：百度百科-javascript
好了，关于javascript 原型 是什么和javascript 基础 js类和原型到底是什么的问题到这里结束啦，希望可以解决您的问题哈！