javascript call和apply最基本的作用

in Web前端 on javascript web 前端 - Hits()

<html>
<head>
<script language="javascript"> 

function Animal(){ 
   this.name = "a"; 
   this.showName = function(){ 
       alert(this.name); 
   } 
} 
function Cat(){
this.name = "c";
Animal.call(this);
} 
Cat.prototype = new Animal();
var cat = new Cat(); 
cat.showName();    //但是alert的是a而不是c,还不是完全的对象继承
alert(cat instanceof Animal);   //True

 
</script>
</head>
<body></body>
</html>

<html>
<head>
<script language="javascript"> 

function Animal(){ 
   this.name = "a"; 
   this.showName = function(){ 
       alert(this.name); 
   } 
} 
function Cat(){
Animal.call(this);//这一句应该在开头，因为这个操作会执行将Animal的属性赋值给Cat的操作,它会覆盖这一句之前的属性
this.name = "c";
} 
Cat.prototype = new Animal();
var cat = new Cat(); 
cat.showName();//alert的是c
alert(cat instanceof Animal);//True

 
</script>
</head>
<body></body>
</html>

apply and call
    它们的作用都是将函数绑定到另外一个对象上去运行，两者仅在定义参数方式有所区别：
     apply(thisArg,argArray);
     call(thisArg[,arg1,arg2…] ]);

知道这些也就差不多了
========================================================================

详解 http://www.javaeye.com/topic/155109

领悟 JavaScript 中的面向对象

 

注：读完本文后请务必接着看完所有回复！

JavaScript 是面向对象的。但是不少人对这一点理解得并不全面。

在 JavaScript 中，对象分为两种。一种可以称为“普通对象”，就是我们所普遍理解的那些：数字、日期、用户自定义的对象（如：{}）等等。

还有一种，称 为“方法对象”，就是我们通常定义的 function。你可能觉得奇怪：方法就是方法，怎么成了对象了？但是在 JavaScript 中，方法的确是被当成对象来处理的。下面是一个简单的例子：

Js代码
  1. function func() {alert('Hello!');} 
  2. alert(func.toString()); 

function func() {alert('Hello!');} alert(func.toString());
在这个例子中，func 虽然是作为一个方法定义的，但它自身却包含一个 toString 方法，说明 func 在这里是被当成一个对象来处理的。更准确的说，func 是一个“方法对象”。下面是例子的继续：

Js代码
  1. func.name = “I am func.”; 
  2. alert(func.name); 

func.name = “I am func.”; alert(func.name);
我们可以任意的为 func 设置属性，这更加证明了 func 就是一个对象。那么方法对象和普通对象的区别在哪里呢？首先方法对象当然是可以执行的，在它后面加上一对括号，就是执行这个方法对象了。

Js代码
  1. func(); 

func();
所以，方法对象具有二重性。一方面它可以被执行，另一方面它完全可以被当成一个普通对象来使用。这意味着什么呢？这意味着方法对象是可以完全独 立于其他对象存在的。这一点我们可以同 Java 比较一下。在 Java 中，方法必须在某一个类中定义，而不能单独存在。而 JavaScript 中就不需要。

方法对象独立于其他方法，就意味着它能够被任意的引用和传递。下面是一个例子：

Js代码
  1. function invoke(f) { 
  2.     f(); 
  3. } 
  4. invoke(func); 

function invoke(f) { f(); } invoke(func);
将一个方法对象 func 传递给另一个方法对象 invoke，让后者在适当的时候执行 func。这就是所谓的“回调”了。另外，方法对象的这种特殊性，也使得 this 关键字不容易把握。这方面相关文章不少，这里不赘述了。

除 了可以被执行以外，方法对象还有一个特殊的功用，就是它可以通过 new 关键字来创建普通对象。

话说每一个方法对象被创建时，都会自动 的拥有一个叫 prototype 的属性。这个属性并无什么特别之处，它和其他的属性一样可以访问，可以赋值。不过当我们用 new 关键字来创建一个对象的时候，prototype 就起作用了：它的值（也是一个对象）所包含的所有属性，都会被复制到新创建的那个对象上去。下面是一个例子：

Js代码
  1. func.prototype.name=”prototype of func”; 
  2. var f = new func(); 
  3. alert(f.name); 

func.prototype.name=”prototype of func”; var f = new func(); alert(f.name);
执行的过程中会弹出两个对话框，后一个对话框表示 f 这个新建的对象从 func.prototype 那里拷贝了 name 属性。而前一个对话框则表示 func 被作为方法执行了一遍。你可能会问了，为什么这个时候要还把 func 执行一遍呢？其实这个时候执行 func，就是起“构造函数”的作用。为了形象的说明，我们重新来一遍：

Js代码
  1. function func() { 
  2.     this.name=”name has been changed.” 
  3. } 
  4. func.prototype.name=”prototype of func”; 
  5. var f = new func(); 
  6. alert(f.name); 

function func() { this.name=”name has been changed.” } func.prototype.name=”prototype of func”; var f = new func(); alert(f.name);
你就会发现 f 的 name 属性不再是"prototype of func"，而是被替换成了"name has been changed"。这就是 func 这个对象方法所起到的“构造函数”的作用。所以，在 JavaScript 中，用 new 关键字创建对象是执行了下面三个步骤的：

  1. 创建一个新的普通对象；
  2. 将方 法对象的 prototype 属性的所有属性复制到新的普通对象中去。
  3. 以新的普通对象作为上下文来执行方法对象。

对 于“new func()”这样的语句，可以描述为“从 func 创建一个新对象”。总之，prototype 这个属性的唯一特殊之处，就是在创建新对象的时候了。

那么我们就可以利用这一点。比如有两个方法对象 A 和 B，既然从 A 创建的新对象包含了所有 A.prototype 的属性，那么我将它赋给 B.prototype，那么从 B 创建的新对象不也有同样的属性了？写成代码就是这样：

 

Js代码
  1. A.prototype.hello = function(){alert('Hello!');} 
  2. B.prototype = new A(); 
  3. new B().hello(); 

A.prototype.hello = function(){alert('Hello!');} B.prototype = new A(); new B().hello();
这就是 JavaScript 的所谓“继承”了，其实质就是属性的拷贝，这里利用了 prototype 来实现。如果不用 prototype，那就用循环了，效果是一样的。所谓“多重继承”，自然就是到处拷贝了。

JavaScript 中面向对象的原理，就是上面这些了。自始至终我都没提到“类”的概念，因为 JavaScript 本来就没有“类”这个东西。面向对象可以没有类吗？当然可以。先有类，然后再有对象，这本来就不合理，因为类本来是从对象中归纳出来的，先有对象再有类， 这才合理。像下面这样的：

Js代码
  1. var o = {}; // 我 发现了一个东西。 
  2. o.eat = function(){return "I am eating."}  // 我发现它会吃； 
  3. o.sleep = function(){return "ZZZzzz..."}  // 我 发现它会睡； 
  4. o.talk = function(){return "Hi!"} // 我发现它 会说话； 
  5. o.think = function(){return "Hmmm..."} // 我 发现它还会思考。 
  6.  
  7. var Human = new Function(); // 我决定给它起名叫“人”。 
  8. Human.prototype = o; // 这个东西就代表了所有“人”的概念。 
  9.  
  10. var h = new Human(); // 当我发现其他同它一样的东西， 
  11. alert(h.talk()) // 我就知道它也是“人”了！ 

var o = {}; // 我发现了一个东西。 o.eat = function(){return "I am eating."} // 我发现它会吃； o.sleep = function(){return "ZZZzzz..."} // 我发现它会睡； o.talk = function(){return "Hi!"} // 我发现它会说话； o.think = function(){return "Hmmm..."} // 我发现它还会思考。 var Human = new Function(); // 我决定给它起名叫“人”。 Human.prototype = o; // 这个东西就代表了所有“人”的概念。 var h = new Human(); // 当我发现其他同它一样的东西， alert(h.talk()) // 我就知道它也是“人”了！

 

=================================================================================

/**
作者认为第三种理解较正确，见最后
**/

javaScript prototype整理（网上的三种理解）

prototype属性，只有function对象中才具有的显式属性；

网上三种理解：
            1：通过构造函数创建的普通对象，通过其constructor属性引用它的构造函数对象，从而间接引用（拥有）了构造对象中的prototype对象；

如图：

此观点的文章：   参看 jimichan的文章：详解 javascript类继承机制的原理 中的： “（说成间接的是因为每个object 都有一个 constructor 属性指向它的构造函数）。”
非常感谢在此问题上，作者对我的回信；如有冒犯，敬请原谅；

            2：构造函数创建对象时，copy prototype中的属性和代码给所创建的对象。从而使创建的对象拥有了prototype中的所有功能和属性；

如图：

此观点的文章：   参看 yiding_he的文章：领悟 JavaScript 中的面向对象 中的：  “ 在 JavaScript 中，用 new 关键字创建对象是执行了下面三个步骤的：

   1. 创建一个新的普通对象；
   2. 将方法对象的 prototype 属性的所有属性复制到新的普通对象中去。
   3. 以新的普通对象作为上下文来执行方法对象。”
此观点在回贴中被 xieye反对

            3：构造函数在创建对象时，把构造函数中的prototype引用赋给创建的普通对象；也就是说由构造函数创建的对象，都有一个指针指向 prototype对象；

如图：

此观点的文章：   参看 李站的文章：悟透javascript中的" 我们已经知道，用 var anObject = new aFunction() 形式创建对象的过程实际上可以分为三步：第一步是建立一个新对象；第二步将该对象内置的原型对象设置为构造函数prototype引用的那个原型对象；第 三步就是将该对象作为this参数调用构造函数，完成成员设置等初始化工作。对象建立之后，对象上的任何访问和操作都只与对象自身及其原型链上的那串对象 有关，与构造函数再扯不上关系了"   以及  “语法甘露 中的：上面代码的最后一句证明，新创建的对象的constructor属性返回的是Object函数。其实新建的对象自己及其原型里没有 constructor属性，那返回的只是最顶层原型对象的构造函数，即Object。”

综上所述：根据贴子：领悟 JavaScript 中的面向对象 中作者 afcn0的回贴 “其实还有补充,就是如果构造函数返回object类型,那new对象无效,prototype问题是楼主还不 太了解prototype继承方式,__proto__属性,以及isPrototypeOf方法所至 ” 的提示，查阅了文章：javascript 中的继承

Html 代码
  1. 此文中提 到：jane = new Engineer("Doe, Jane", ["navigator", "javascript"], "belau"); 
  2.  
  3. 调用这句时，都发生了什么: 
  4.  
  5. 1 当js看见 new操作符，它创建一个新的普通对象,并且设置它的__proto__ 属性为Engineer.prototype。 
  6.  
  7. 2 new 操作符传递这个新的对象作为Engineer 构造器的this的值。 
  8.  
  9. 其实最主要做的事就是上面的两件，剩下的都是很简单的函数调用. 

根据上文的提示作了简单测试：

Javascript 代码
  1. function person(name,b){ 
  2.     this.name=name; 
  3. } 
  4.  
  5. person.prototype.sayHello=function(a){ 
  6.     //alert("hello,i am "+this.name); 
  7.     alert(this==a); 
  8.     } 
  9.  
  10.  
  11. function employee(name, salary) 
  12. { 
  13.     person.call(this, name);    //调用上层构造函数 
  14.     this.salary = salary;       //扩展的成员 
  15. }; 
  16.  
  17. var p=new person("yangsp",p); 
  18. //p.sayHello(p); 
  19. //alert(p.constructor); 
  20.  
  21. //下面两句验证了普通对象中确有_proto_属性，且引用的是prototype对象；（在ff下调试，ie下不 可）； 
  22. alert(p.__proto__==person); 
  23. alert(p.__proto__==person.prototype)) 
  24.  
  25. //alert("p有prototype属性吗? "+p.prototype);    //表明普通对象中没有 prototype属性;                              

总结：

Html 代码
  1. 比较赞同 第三种理解； 
  2.       即：prototype是function对象中专有的属 性。 
  3.           _proto_是普通对象的隐式属性，在new的时候，会指向 prototype所指的对象； 
  4.           普通对象中的constructor属性指向构造 函数，因此一个用构造函数创建的对象可能有两种方式关联到prototype.但继承应该是根据_proto_关联到prototype属性； 

另外：ecma-262中提到：every object created by that constructor has an implicit reference to the prototype (called the object's prototype) associated with its constructor 以及其图示；不敢肯定它的implicit reference间接还是隐式链接；



Total views.

© 2013 - 2024. All rights reserved.

Powered by Hydejack v6.6.1