JS 中 讨厌的 prototype constructor _pro_ 理解

这几天一直在看着块,哎,看的人头都大了,差不多明白了,总结一下。

prototype:创建的每一个函数都有一个prototype属性,这个属性指向一个prototype对象。即他是通过构造函数而创建的实例对象的原型对象(属性存在于构造函数中)。

constructor:这个属性在原型对象中,指向函数中的prototype属性。(存在于原型对象中,原型对象===原型)

_proto_:这个属相存在于实例中,指向原型。

举个栗子:

function ljd(){
this.name="ljd";
}

ljd.prototype.age=20;
a=new ljd();

a.age;
ljd.prototype.constructor;

这段简单的代码会打印出什么呢》、??

大家思考明白这个问题应该就会理解这里面恩怨纠葛了。

然后还有一个注意点:

这样重新定义原型,他的constructor属性会指向Obcject;

function ljd() {
  this.name = ‘ljd‘;
}
ljd.prototype.age = 20;
ljd.prototype = {
  sex:
  ‘male‘,
  job: ‘student‘
};

ljd.prototype.constructor;

这个呢 是输出Object()的。

还有这样写原型中就木有age属性了,完全重构。

其实也好理解,这个语法 x={} 相当于创建了个obcjec实例啦~~。

原型对象存在的问题:

举个栗子:原型对象中有一个数组,第一个实例push 进一个元素后,第二个实例的数组中也会有该元素。

再来谈谈JS中的继承问题:

先说说 new  创建一个实例有以下三个步骤  a1=new A;

1、新建一个对象并赋值给变量a1:var a1 = {};

2、把这个对象的[[Prototype]]属性指向函数A的原型对象:a1.[[Prototype]] = A.prototype

3、调用函数A,同时把this指向1中创建的对象a1,对对象进行初始化:A.apply(a1,arguments)

 function SuperType() {
        this.property = true;
    }

    SuperType.prototype.getSuperValue = function() {
      return this.property;
    };

    function SubType() {
        this.subproperty = false;
    }

    //继承了SuperType
    SubType.prototype = new SuperType();
    SubType.prototype.getSubValue = function() {
        return this.subproperty;
    };

    var instance = new SubType();

注意这句

SubType.prototype = new SuperType();  //相当于重写了SubType.prototype,所以就像上面提到的constructor属性改变

SubType.prototype.constructor ==Super.

好了  太晚了 今天就先到这。。。晚安

突然忘了,还有这段代码,大家看下学下JS中的组合继承。

<script>
    function Par(name,value){
        if(!arguments.length) return;
        this.name = name;
        this.value = value;
    }
    function Job(name,value,job){
        if(!arguments.length) return;
        Par.apply(this,arguments);
        this.job = job;
    }
    function Age(name,value,job,age){
        if(!arguments.length) return;
        Job.apply(this,arguments);
        this.age = age;
    }
    Par.prototype.showName = function(){
        alert(this.name);
    };
    Job.prototype = new Par();
    Job.prototype.showJob = function(){
        alert(this.job);
    };
    Age.prototype = new Job();
    Age.prototype.showAge= function(){
        alert(this.age)
    };

    var a = new Age(‘123‘,‘dw2‘,‘sad‘,21);

    a.showName()
    //alert(a.constructor)
</script>
时间: 2024-08-25 21:29:52

JS 中 讨厌的 prototype constructor _pro_ 理解的相关文章

关于js中__proto__和prototype的一些理解&lt;转&gt;

var Person = function(name) {     this.name = name; } var p = new Person(); new操作符的操作是 var p = {} p.__proto__ =  Person.prototype Person.call(p) var p={}; 也就是说,初始化一个对象p. p.__proto__ = Person.prototype; Person.call(p);也就是说构造p,也可以称之为初始化p. 关键在于第二步,我们来证明

js中__proto__和prototype的区别和联系

作者:苏墨橘来源:知乎 备注:本篇文章比较清楚的解释了__proto__属性.prototype.instanceof,秉持一贯风格,好文收藏,贴在这里供大家学习. __proto__(隐式原型)与prototype(显式原型) 1.是什么 显式原型 explicit prototype property: 每一个函数在创建之后都会拥有一个名为prototype的属性,这个属性指向函数的原型对象.Note:通过Function.prototype.bind方法构造出来的函数是个例外,它没有pro

js中__proto__和prototype的区别和关系?

_proto__(隐式原型)与prototype(显式原型) 1.是什么 显式原型 explicit prototype property: 每一个函数在创建之后都会拥有一个名为prototype的属性,这个属性指向函数的原型对象.Note:通过Function.prototype.bind方法构造出来的函数是个例外,它没有prototype属性.(感谢 @陈禹鲁 同学的答案让我知道这一点) NOTE Function objects created using Function.prototy

说一说js中__proto__和prototype以及原型继承的那些事

在面试中遇到过,问js如何实现继承,其实最好的方式就是构造函数+原型,今天在讨论中,发现自己以前理解上的一些误区,特地写出来,最近都比较忙,等手上的项目做完,可以来做个总结. 先说我以前没有认识到位的地方 1 __proto__这个不是标准实现的,但是各大浏览器和node都采用了,ECMA6计划标准化它,__proto__对应于标准中的[[prototype]],也就是所谓的内置原型属性,要把它和函数的prototype的相区别,其实,__proto__最终是指向Function.prototy

js中对类和对象的理解

类 :对一群具有相同特征的对象的集合的描述:对象:真实存在的对象个体: **面向对象,而不是面向类. 1.一切皆对象,继承靠原型链,多态靠弱类型,封装--虽然可以靠闭包,但我个人更推崇和python一样的,下划线代表私有的风格 2.比如人类,指的是一个范围: 对象:比如某个人,指的是这个范围中具体的对象 3.Javascript中的function作为构造函数时,就是一个类,搭配上new操作符,可以返回一个对象.当然,要生成一个对象,也可以用字面量的形式,例如var obj = {x: 1, y

js中的原型prototype

var arr1 = new Array(12,34,98,43,38,79,56,1); arr1.sum=function (){ var result = 0; for(var i=0; i<this.length; i++){ result += this[i]; } return result; }; alert(arr1.sum()); 如果现在还有个arr1 对象也要求和 var arr2 = new Array(54,29,1,10); 那么还要给 arr2再添加一个求个的方法

JS中的call()和apply()方法理解和使用

1.方法定义call方法: 语法:obj.method.call(thisObj[,arg1[, arg2[, [,.argN]]]]) 定义:调用对象(obj)的一个方法(method),以另一个对象(thisObj)替换当前对象(obj). 说明: call 方法可以用来代替另一个对象调用一个方法.call 方法可将一个函数的对象上下文从初始的上下文改变为由 thisObj 指定的新对象(方法内的this的指向传入的thisObj) . 如果没有提供 thisObj 参数,那么 Global

理解js中__proto__和prototype的区别和关系

首先,要明确几个点:1.在JS里,万物皆对象.方法(Function)是对象,方法的原型(Function.prototype)是对象.因此,它们都会具有对象共有的特点.即:对象具有属性__proto__,可称为隐式原型,一个对象的隐式原型指向构造该对象的构造函数的原型,这也保证了实例能够访问在构造函数原型中定义的属性和方法. 2.方法(Function)方法这个特殊的对象,除了和其他对象一样有上述_proto_属性之外,还有自己特有的属性--原型属性(prototype),这个属性是一个指针,

转载-对js中new、prototype的理解

说明:本篇文章是搜集了数家之言,综合的结果,应向数家致谢 说到prototype,就不得不先说下new的过程. 我们先看看这样一段代码: <script type="text/javascript"> var Person = function (){ }; var p = new Person();</script> 很简单的一段代码,我们来看看这个new究竟做了什么?我们可以把new的过程拆分成以下三步: <1> var p={}; 也就是说,初