原型：
概念：执行构造函数代码时，js系统会给这个构造函数创建一个原型对象，构造函数中也包含一个prototype属性指向这个原型对象。
作用：
通过原型给系统构造函数添加一些特殊的方法，（数组的求和），这样通过Array创建出的对象都具有这个方法。
通过原型给自定义的构造函数添加属性，方法，创建出来的对象所对应的属性，方法就是原型中的属性，方法。不需要开辟新的空间，节约了内存。
prototype：构造函数中的一个属性，用类指向这个对象所对应的构造函数。
注：普通对象没有prototype,但有proto||[[prototype]]属性。
instanceof 可以判断出实例对象是属于哪一个构造函数
constructor 也可以判断实例对象是属于哪一个构造函数的。
constructor:构造函数中所对应的原型中的一个属性，用来指向这个实例对象所对应的构造函数。
实例对象中也有一个constructor属性，指向构造函数；
in ：判断该属性是否存在（实例对象， 原型对象）
// in ：判断该属性是否存在这个对象中（实例属性、原型属性），存在返回true，否则false
alert("name" in per1);
alert('gender' in per1);```
hasOwnProperty：判断属性时属于实例对象还是属于原型对象如果是实例对象返回true；如果是原型对象或者不存在 则返回false；
// hasOwnProperty:可以判断出属性是实例属性中还是原型属性。如果是实例属性，返回true;否则false
console.log(per1.hasOwnProperty("aaa"));
只是一个题目：
例子：判断一个对象是否含有某个属性，如果含有在判断是否是原型对象。如果是 则返回true；否则返回false； 这仅仅这取反
function isPrototpye (obj, proString) {
if (proString in obj) {
if (!obj.hasOwnProperty(proString)){
return true;
} else {
return false;
}
}
else {
return false;
}
}
console.log(isPrototpye(per1, "name"));
（2）
var name = "gender";
var a = (name in one);
//console.log(a);
if(a==true){
var b = (one.hasOwnProperty(name));
if(b==true){
console.log(false);
}
else{
console.log(true);
}
}else{
console.log(false);
}
原型的创建对象：
<!DOCTYPE html>
<html>
<head>
<title></title>
<meta charset="utf-8">
<script type="text/javascript">
//创建构造函数
function CreatePerson(name,age){
//1.1 把外部的参数绑定在实例属性上
this.name = name;
this.age = age;
}
//1.2把相同的属性或方法绑定在原型上
CreatePerson.prototype.gender = "男";
CreatePerson.prototype.sayHi=function(){
console.log("别说话，吻我！");
}
//创建对象
var one = new CreatePerson("张三",23);
console.log(one.name);
console.log(one.age);
one.sayHi();
var two = new CreatePerson("李四",21);
//instanceof 可以判断对象是属于哪一个构造函数的。
//constructor 也可以判断对象是属于哪一个构造函数的。(常用)
//实例对象中有一个constructor属性，指向他的构造函数。
console.log(one.constructor == CreatePerson);
//构造函数的原型中也有一个constructor属性，同时也指向构造函数。
console.log(CreatePerson.prototype.constructor == CreatePerson); //true;
console.log(one.constructor == Object); //false
//in的操作方法：判断该属性是否存在该对象中。（实例属性 原型属性）；
//alert("name" in one);
//hasownProperty() :用来判断某一个属性是属于实例属性 还是原型属性
//如果是实例属性返回true； 否则返回值为false；
//alert(one.hasOwnProperty("gender"));
var name = "gender";
var a = (name in one);
//console.log(a);
if(a==true){
var b = (one.hasOwnProperty(name));
if(b==true){
console.log(false);
}
else{
console.log(true);
}
}else{
console.log(false);
}
</script>
</head>
<body>
</body>
</html>
字面量创建原型对象并解决对象的归属感：
为了让属性和方法更好的体现封装的效果，并且减少不必要的书输入，原型的创建可以使用字面量的方式进行创建。
使用构造函数创建原型对象和字面量创建对象在使用上基本一致，但是还有一些区别，字面量创建的方式使用constructor属性不会指向实例，而是指向了Object 。构造函数的方式则相反；
例
<script type="text/javascript">
function B (){
}
console.log(B.prototype.constructor);
//（1）B 的prototype指向了原型对象。constructor属性又指向了原型对象所对应的构造函数
function C (){
}
C.prototype={ //重新定义了原型函数 原来的原型函数被覆盖
name="j"
}
console.log(C.prototype.constructor);
//（2）constructor 指向Object; 因为原来的原型对象被新的原型对象覆盖掉之后constructor被损毁。
//如果想要指向所对应的构造函数 需要用到强制指向 即constructor：函数中所创建的构造函数的名字
</script>```
字面量创建原型对象：
<script type="text/javascript">
function box(){}
box.prototype={ //创建一个对象
constructor:box, // 强制 指向 构造函数 指定他的归属。
name:"张三",
gender:"男",
sayBy:function(){
console.log('别说话,干掉你');
}
}
var box1 = new box();
console.log(box1.name);
box1.sayBy();
console.log("name" in box1);
console.log(box1.hasOwnProperty("name"));
</script>```
原型对象：构造函数对应的原型对象；
对象原型： 实例对象中的_proto_指向的原型。