[求助] javascript定义类的函数加prototype是什么意思？

Question

是否是允许该类的实例化对象能继承原型对象，如果不加prototype就不能继承原型对象中的函数？/*定义一个Test类，有A、B两个属性*/
function Test(a,b)
{
  this.A = a;
  this.B = b;
}/*定义一个函数sum，分别给属性A、B加上a、b的值*/
Test.sum(a,b) = function()
{
   return new Test(this.A + a, this.B + b);
}Test.prototype.update(a,b) = function()
{
   return new Test(a,b);
}var test = new Test(1,2);
test.sum(1,2);//test.A == 2，test.B == 4
test.update(1,2);//update对象不支持此属性或方法，意思就是不加prototype属性，实例化对象test就无法调用函数update??

Answer 1

prototype　是对象类型原型的引用　，看看他的英文主成：proto-type 嘿嘿就是主要类型的意思； 
都知道如果对于java此类的语言，String 类已经是final类了，没办法扩展他的属性和方法．但是js就不一样拉． 
他可以对类型进行属性和方法的扩展 
比如说： 
这里有我两个方法： 
//删除数组中指定位置的项并返回新书组
Array.prototype.remove = remove;
function remove(num){
var numc=parseInt(num);
if(numc<0||numc>this.length){return;}
var new1=this.slice(0,numc) 
var new2=this.slice(numc+1,this.length) 
return new1.concat(new2)
}
var ss=[];
ss.push(1)
ss.push(2)
ss.push(3)
ss.push(4)
ss.push(5)
var dd=ss.remove(2)
var innr="";
for(var a=0;a<dd.length;a++){
innr+=dd[a]
}
alert(innr)//获取字符串中指定位置的字符
String.prototype.getIndexof=getidof;
function getidof(i){
var ii=parseInt(i)
if(ii<0 || ii>this.length){return "";}
return this.substr(i-1,i);
}var ss="123456";
alert(ss.getIndexof(2))//新的obj
function Zobj(){this.title="新的obj";}
Zobj.prototype.getTitle= function(){
return this.title;
}var obj= new Zobj();
alert(obj.getTitle())prototype　方法主要是用来扩展或重写已有对象的内置方法或属性 
你如果新建一个对象也可以这样扩展它的属性和内置方法 

Answer 2

楼上说的已经很清楚了。此外prototype可以用来继承。

Answer 3

你测试过你的代码吗?错误很多额.修改后<script type="text/javascript">
function Test(a,b) 
{ 
  this.A = a; 
  this.B = b; 
} 
/*定义一个函数sum，分别给属性A、B加上a、b的值*/ 
Test.sum= function(a,b) 
{ 
  return new Test(this.A + a, this.B + b); 
} Test.prototype.update = function(a,b) 
{ 
  return new Test(a,b); 
} 
function hee(){
var test = new Test(1,2); 
test.sum(1,2);//test.A == 2，test.B == 4 
test.update(1,2);
}
</script>

Answer 4

那个sum不能被调用,给对象原型添加函数就是要用prototype,直接用Test.sum添加会报错.

Answer 5

非常感谢楼上各位的回答，我现在有一个疑问，如果不加prototype，那定义的函数就无法被实例化的对象调用，那这样定义有什么意义呢？

Answer 6

事实上，当一个对象被实例化的时候，新对象会将原对象的原型的方法作为构造的一部分．
也就是
var A=function(){this.value=0;};
A.prototype.get=function(){return this.value;}如果var a=new A();
那实际上，a去找到了A的原型,将其中的方法做为构造a=function(){
....
.....
this["get"]=A.prototype["get"];
}每一个对象都有他的原形，string number Function ...
但是只有Function 有prototype这个属性．
此属性指向其原型．　
（确切的说 a=c=b="123",并不代表a b c等于"123",
只是作为字面量的a b c都做为一个指针去指向"123"所在的内存空间）
大家可以用这么一种实例化的继承机制来实现继承．那就是上面说的，所有新对象都会去找原对象的原形，然后获取里面的方法．

Answer 7

Test.prototype.update = function(a,b) 
{ 
  return new Test(a,b); 
} 
这样写就相当与Test的private方法..Test.sum= function(a,b) 
{ 
  return new Test(this.A + a, this.B + b); 
} 
这样写的话为什么就不能调用呢??
他不能成为公共方法嘛??
直接执行Test.sum也是ok的啊!

Answer 8

Test.sum搞得像静态函数似的。

Answer 9

那么
Test.sum= function(a,b) 
{ 
  return new Test(this.A + a, this.B + b); 
}
这句话的意义在那里呢?? 

Answer 10

目前我所知道的，Test.sum可以像java或C#中的静态函数一样使用，也具有静态函数的特点，但我不知道其真正的意义所在。有高手知道吗？

Answer 11

对于Test.sum应该从理解javascript字面量上去理解．
function Test(){}//意思是声明一个名字为Test的方法．
等同于var Test=function(){}
Test代表了function(){}但却不是function(){}的本体．
也可以算是function(){}被实例出来的一个对象．
你可以测试一下for(var s in test)alert(s)；也就是说Test.sum仅仅是对Test这个进行了扩展．而不是函数本身．
对于继承关系，新对象是继承的对象的本体而不是他的字面量．

Answer 12

吓～！扁嘴的可不一定就是鸭子．
静态方法应该在静态类中，并且不可操作非静态方法．他的用法是　类.方法
Test.sum=function(a,b) 
{return new Test(this.A + a, this.B + b); }
里面的this.A 和this.B　，　LZ是想测试他们不是在操作Test的实例么？
这里面的this其实就是Test.sum,是不？怎么会有呢？
静态方法．直接单体就解决了．

Answer 13

javascript其实不是严格意义的OO语言，至少他没有很好地实现封装和继承，甚至javascript使用的是function式对象。因此，javascript有一个奇怪的东西就是prototype，javascript中约定了每个对象都可以包含一个prototype对象的引用（属性），
这个prototype对象在运行时是不可见的，也就是说，定义了之后，你无法直接使用prototype对象。那么，prototype对象有什么用呢？它的作用，就是当你去调用一个对象的函数或属性时，javascript首先会在这个对象的定义中查找，如果找不到，
他就会去找这个对象的prototype对象有没有这个定义，如果还找不到，他又会去找prototype对象的prototype，一直到对象没有prototype定义为止。是不是和函数继承的目的很象？这就是javascript的原型继承特性。
但是我们也看出了，这种查找方式，效率非常之低，尤其在prototype链很长的情况下。javascript 2.0会对此有所改进。另外，prototype的定义方式也很奇怪，他必须以一个对象实例（而不是类）的形式，绑定到其他类上。记得吗？prototype是定义时的，同时又是对象。

Answer 14

在强调一个问题，那就是Test.sum在新的事例化的对象上是没办法调用的
也就是var t=new Test(1,2);
t.num(2,1)这本身是错的－－－－－－－－－－－－－－－－－－－－－－－
原因在于：
Test.sum和Test.prototype.sum的区别在于什么？
可以看一下16楼 ．
Test.prototype.sum是Test的原型上附加sum方法
Test.sum是Test域附加sum方法
－－－－－－－－－－－－－－－－－－－－－－－－
首先，var Test=function(){....}等同function Test(){....}
他们都在他们所在的空间里声明了变量Test并将方法赋予他．
在这里有可能混淆的是认为Test就是function(){....}，
所以理所应当的认为Test.sum =..等同于
function Test (){
this.sum=....//当然能被实例化调用}　
事实完全不是这样．详细原因在11楼