忽然间茫然之javascript函数和对象 - ITeye问答
大家不要笑话我 前天晚上睡觉时候忽然想到这个问题 javascript对象是由函数构造的 可是我感觉貌似用函数就够了 使用对象就是为了多个继承吗& 我发现自己很多时候用函数就够了& 到底什么时候是必须用函数的呢&
唉 脑子很乱 这样写也不知道大家看的懂我的意思不···
问题补充：谢谢大家啦& 看着大家都回复感觉无比幸福& 继续研究研究 不急结贴 呵呵
问题补充：lqixv 写道看了你的疑惑后，我认为，你不明白的是为什么要使用对象，而不是JavaScript实现对象的方法。
也就是说，你的思想里还没有面向对象设计的思想，而是在用面向过程设计的的思维。这与那种程序语言无关。
要真正解决你的疑惑，你觉得你要学习一些面向对象设计方面的书，去理解面向对象的思想，而不是看其如何实现面向对象的。
感谢好像是的& 我很喜欢我学的第一个语言&& C
问题补充：但是 对象应该是比函数强大的啊& 可惜我没体会到～～
问题补充：lqixv 写道等元旦放假的时候，写篇文章把我的理解写一下。你再看一下吧。
期待中& 一定要写啊！！ 先支持下！！
采纳的答案
引用蔡老师说：“至于Object与Function的区别，感觉最大的还是在于原型”
我的理解是
Object和Function的原型都是挂接在Function.prototype上，挂在同一原型上没有区别。
对象和函数才是有区别的！
var obj = new Object();//对象
obj的原型是挂在Object.prototype上
var fn = new Function("参数","//code")；
fn的原型是挂在Function.prototype上
应该是：
fn 和obj有区别因为原型不同（Object.prototype 与 Function.prototype有区别）
话说是Object与Function的区别，其实真正说的是其实例的区别。
Object与Function本身是没什么区别的，其两者都既是函数又是对象。
Object instanceof Function =& true
Function instanceof Object =& true
我认为两者的区别在于Object.prototype产生的是{}，而Function.prototype产生的是function(){}。所以我赞成你的那句话。
其实质还是在于{}与function(){}不同。主要因为{}不是一个Function，所以也没有prototype。通常可以看成一个简单的数据集合。如:
{} instanceof Object =& true
(function(){}) instanceof Object =& true
{} instanceof Function =& false
(function(){}) instanceof Function =& true
由上可以看出，Object实例{}并不是一个Function。因为Function有个很大的特色就是原型链，所以Object实例并没有继承这个特色。
var a = {};
var b = function(){};
var c = new a(); //Error
var d = new b();
var e = a. //undefined
var f = b. //Object
因此，{}与function(){}的区别在于function(){}可以看做一个Function对象，用来生成新的实例，而{}不能。所以上例中var c = new a();会抛出错误。
引用貌似用右手就可以了，找个老婆就是为了释放右手吗？我发现很多时候使用右手就可以了，到底什么时候是必须用右手的呢
哈哈，经典！
JavaScript中函数(function)也是一种数据类型，跟数字(number)、字符串(string)一样,将一个函数实例化，就会产生一个对象(object)类型，这些都可以通过typeof函数还求的当前变量的数据类型。
function a() {
this.property1 = "circleName";
this.property2 = 2;
function compute (r) {
return 3.14*r*r;
this.getArea = function() {
return compute(this.property2);
var myCircle = new a();
alert(typeof(myCircle.property1));
alert(typeof(myCircle.getArea()));
alert(typeof(myCircle));
alert(typeof(a));
上面代码中四个alert分别显示：
number string object function
感觉说的还是比较浅显易懂的。我们可以把JavaScript中函数理解成java中的类，虽然JavaScript不是面向对象的语言，我们也不经常使用它的基于对象的特性，但是JavaScript中的函数还是和java中的类有许多相似之处的，比如都有成员属性（类如a函数中的property1），成员方法（例如a函数中的getArea）。只是我们在实际编程中函数式编程习惯用的多一些，像这种基于对象的编程用的比较少，让我们忽略它的基于对象特性，其实JavaScript稍加改造，也是可以实现面向对象中继承之类的操作的，这些就超出了几天的讨论范围了。
读大学的时候，我感觉JS是最难的，等明白了，其实也那样的。熟悉了就好
我的理解是在JS中函数和对象的区别很微弱, 为什么用函数来构建对象, 其原因主要在于:
1. 用函数构建的对象, 可以使用new来创建, 因此我们更习惯接受这种方式创建对象.
var a = {}, b = function(){};
var c = new a();//error
var d = new b();
2. 用函数构建的对象, 可以实现私有和公有方法, 这与我们平时认识到的对象特性相符.
var clazz = function(){
var privateMethod = function(){alert('This is a private method');};
this.publicMethod = function(){alert('This is a public method')};
this.invokPrivateMethod = function(){privateMethod();};
var instance = new clazz();
instance.publicMethod();//alert'This is a private method'
instance.invokPrivateMethod();//alert'This is a public method'
instance.privateMethod();//error
3. 通过对Function的pototype进行改造, 可以加入构造函数, 通过反射实现的继承, 与我们平时理解的继承特性几乎一致.
由于涉及代码较多, 这里没有举例, 如果有兴趣可以参考ExtJs的实现. 在ExtJs中, 继承, 也就是扩展时(Extend), 将方法写在构造函数中(Constructor), 全都是公有的, 如果只是写在继承或者扩展里(Extend), 则仅在此对象内部有效, 即全为私有.
4. 另外通过函数可以实现闭包, 也可以实现代理, 使用{}对象中不行.
因此, 如果仅仅是承载数据, 类似于json的话, 直接使用{}对象, 不然都使用function吧, 优点多多.
其实是不同方法的不同表现
对象是由属性构成的 不是函数
函数方法只是作用在这些属性上
以上的话和语言无关
另外 js不是面向对象的 是基于对象
深奥，需要睡觉的时候，人静的时候思考。何时该用对象，何时该用函数。。如果，可以替换，可能还是对js不够了解。
面向对象的思想
可能你明白面向对象跟面向过程的区别，就会发现他的好处
上面写错一句话，应改为:
1、对象往往是一些属性与方法（函数）的集合体，二者没有可比性。
你的问题：
1、“但是 对象应该是比函数强大的啊& 可惜我没体会到～～”
答案是：对象并不比函数强大！
2、“感谢好像是的& 我很喜欢我学的第一个语言&& C ”
面向对象设计与语言没有关系，有差异的是面向对象设计的语言与面向过程设计的语言。一句话，就是语言的不同。
以上的原因解释：
1、对象往往是一些属性与方法（函数的集合体），二者没有可比性。
2、你注意没有，你常常会看到这样的词语“面向对象设计”，“面向过程设计”，这两个词语真正的共同点，或说其想表达的中心在于“设计”！而“面向对象”和“面向过程”，只是其实现“设计”的方法的不同。既然其目的是“设计”，那你用什么语言来设计，都是可以的。因此，很多人如果没有建立起面向对象设计的思想，那他即使使用面向对象设计的语言去设计系统，他也只是使用面向过程式的思想去设计系统。那么同样的，一个人如果有很强的面向对象设计的思想，那他完全可以用过程式的语言，甚至用汇编语言，同时用面向对象的思想去设计他的系统。
但要阐述清楚面向对象与面向过程的思想，不是这几句话区分得了的。等元旦放假的时候，写篇文章把我的理解写一下。你再看一下吧。
ECMAScript5标准中的bind方法确实可以让你不再用函数构造对象。
比如
& var a = function(x,y){return this.base*(x+y)}
& var b = a.bind({base: 3})
不要忘记：万物皆对象。那么函数本身也就是对象。函数对象区别于普通对象的唯一差距就是函数式对象可以执行。
看了你的疑惑后，我认为，你不明白的是为什么要使用对象，而不是JavaScript实现对象的方法。
也就是说，你的思想里还没有面向对象设计的思想，而是在用面向过程设计的的思维。这与那种程序语言无关。
要真正解决你的疑惑，你觉得你要学习一些面向对象设计方面的书，去理解面向对象的思想，而不是看其如何实现面向对象的。
引用关键是这个
Function instanceof Object =& true
先判断Function._proto_ == Object.prototype 发现不匹配
于是Function._proto_ == Object.prototype._proto_ //
你说反了
Function instanceof Object的依据不是
Function._proto_ == Object.prototype._proto_
而是
Function.prototype._proto_ == Object._proto_
Object instanceof Function =& true
Function instanceof Object =& true
这个写法曾经困扰我很久
instanceof 是如何判断的呢？
假设 obj =
那么 obj instanceof fn //
最初我一直认为instanceof是这样判断的
obj.constructor ===fn 所以true
后来我发现是这样的！
找到obj的内置原型,用它和构造函数的原型进行比较（obj._proto_==fn.prototype)
如果发现不匹配 就在原型中找上一级原型(fn.prototype._proto_)
如果还找不到 就继续找上一级原型(fn.prototype._proto_._proto_)
原理说了，接下来再看
Object instanceof Function =& true //这个很好理解
Object = new Function("","");//Object是由Function构造出来的
Object._proto_ === Function.prototype //ture&
关键是这个
Function instanceof Object =& true
先判断Function._proto_ == Object.prototype 发现不匹配
于是Function._proto_ == Object.prototype._proto_ //
不知道我有没有表达清楚&_&
哇塞，居然有蔡老师的留言^_^,增加了我学js的动力
我的理解：
1.函数只包含操作，比如要做什么处理，可以写个函数。
2.对象是包含数据的，比如json数据，就是对象的形式。
应该是两个不同的东西吧，如果要把数据以函数的形式写，那估计也别扭。
我的理解：
1.javascript本身是个函数式语言，所以只写函数也ok。
2.javascript也有对象，不说具体，举个例子window本身就是对象。
3.所有的javascript变量可以声明为var xx = zz。这样的形式，可以不放在函数里面，那么它本质上是被定义到了window.xx作为全局属性。所以本质上还是对象。
4.比较重要的一点是，javascript可以采用对象形式。那么你会不会选择用呢？
&&& 如果你只是界面的简单的显示逻辑，那用它不会有什么好处的。
那假如你写过几千行或者上万行的js来表达一个很富有逻辑的代码段。你会使用函数，你要用多少个函数，多少个全局变量来保存多少种信息，你觉得你写出的那成千上百的函数和变量，最后你自己还清楚吗。
&&& 用辩证法角度来看，什么都有好有坏，择其优而用。
首先,从概念上理解吧....
对象---&有属性有执行体(函数);
函数---&可以理解为一个单一的执行过程;
javaScript 个人认为语法相当的灵活.虽然可以通过函数去构造对象,但是完全使用函数有其局限性;
比如说:
你去描述一个人的时候
var person = {};
person.age = 20;
person.sex = "f";
person.fire = function(/***/){};
........
然后你就可以直接调用.....如果你用函数的话也完全可以实现,但是麻烦的很多吧???
把这个认真的看完就明白了：
/topic/155109
看你封装的程度了，方法级别的就函数级别就够了，当你想封装组件级别的面向对象更能体现整体。
javaeye为什么时常不能正常访问呢？到底是为什么？谁能告诉我啊？
面向对象而不是过程~
这个时期，一般都有过，很多人由于工作原因（用不到），没有继续走下去。希望楼主可以继续深入的研究下去。建议你读一下《悟透JavaScript》。可以提高你的JavaScript的段位。
这篇文章读完以后，就是要实践了，在你接触的系统中，如何巧妙的运用JavaScript是就需要你一点点的积累和总结了。希望楼组精益求精。
当程序的复杂度是你倍感苦恼，当你想追求简单时，就可以考虑使用对象了。
蔡老师说：“至于Object与Function的区别，感觉最大的还是在于原型”
我的理解是
Object和Function的原型都是挂接在Function.prototype上，挂在同一原型上没有区别。
对象和函数才是有区别的！
var obj = new Object();//对象
obj的原型是挂在Object.prototype上
var fn = new Function("参数","//code")；
fn的原型是挂在Function.prototype上
应该是：
fn 和obj有区别因为原型不同（Object.prototype 与 Function.prototype有区别）
感觉直接写函数的话，相对于对象少了些对象特有的属性，二用new来声明就可以使用这些属性，还有上面说到的原型，在js里也很重要。
javascript对象是由函数构造的
还有一句话是：
javascript的函数也是由函数构造的
var Object = new Function("","[native]code");//这个是构造过程
另外补充一点：由Function构造函数构造出来的对象可以用new关键字继续创建对象
所以上面创建的对象其实就是：
function Object(){
& //[native]code
}
然后我们new Object就创建出了对象。
最后说下个人理解：
javascript对象和函数 都是由 Function函数构造出来的。
函数主要是完成一些功能，声明一个对象传递参数更方便。声明对象的方法可以区别同名函数。
如果你仅仅是指
function(){}
的定义方法。
那么使用Object定义方式也行的，基本上没区别，不用钻牛角尖。
至于Object与Function的区别，感觉最大的还是在于原型
貌似用右手就可以了，找个老婆就是为了释放右手吗？我发现很多时候使用右手就可以了，到底什么时候是必须用右手的呢
已解决问题
未解决问题您的位置： >>
　　在中我们提到，用构造函数创建的对象里面，每个对象之间都是独立的，这样就会降低系统资源的利用率，解决这样问题，我们就要用到下面提到的原型对象。
　　一 原型对象
　　原型对象实际上就是构造函数的一个实例对象，和普通的实例对象没有本质上的区别。可以包含特定类型的所有实例的共享属性或者方法。这样，如果我们需要修改所有实例中的属性或者方法，就只需要修改一处，就能够影响到所有实例了。因为原型中的属性和方法是共享的。我们可以看下两个图示：
& & & 构造函数方式
原型模式方式
　　从上面的图示中我们就不难看出，为何下面的代码中"user1.show == user2."返回的是ture，因为show方法是所有由User构造函数创建的对象所共享的，而不是每个对象都各自创建了一个show方法。
　　每个JavaScript函数都有prototype属性，这个属性引用了一个对象，这个对象就是原型对象。原型对象初始化的时候是空的，我们可以在里面自定义任何属性和方法，这些方法和属性都将被该构造函数所创建的对象继承。
　　在原型中添加属性和方法可以参照如下代码：
function User(name,age){//构造方法
this.name =//对象属性
this.age =
User.prototype.addr = '湖北武汉';//在原型中添加属性
User.prototype.show = function(){//在原型中添加方法
alert(this.name+'|'+this.age);
var user1 = new User('ZXC',22);//创建实例
var user2 = new User('CXZ',21);
user1.show();//调用show()方法
user2.show();
alert(user1.show == user2.show);//返回 true 说明show方法是共享的
alert(user1.addr);//'湖北武汉'
alert(user2.addr);//'湖北武汉'
　　但是有个问题是：如果我们既在构造方法中添加了一个属性、又在原型中添加了该属性，还在实例中添加了该属性，那么我们访问的究竟 是哪一个属性呢？我们先看看下面的代码：
function User(name,age){//构造方法
this.name =//对象属性
this.age =
this.addr = '湖北恩施';
User.prototype.addr = '湖北武汉';//在原型中添加属性
var user1 = new User('ZXC',22);//创建实例
var user2 = new User('CXZ',21);
alert(user1.addr);//'湖北恩施'
delete user1.//删除对象属性
alert(user1.addr);//'湖北武汉'
delete User.prototype.
alert(user1.addr);//'undefined'
user2.addr = '武汉';
alert(user2.addr);//'武汉'
　　从上面的代码可以看出，如果我们同时申明了对象属性、原型属性和实例属性，那么调用时显示的优先级应该是：实例属性&对象属性&原型属性。这就是采用了就近原则：调用时首先查找实例中是否直接定义了这个属性，有则返回实例属性；如果实例属性中没有就去构造函数中查找，有则返回；如果前面两者都没有就去原型对象中查找，如果没有则返回undefined。
　　二 动态原型模式
　　有人可能会觉得上面代码中的写法感觉很别扭，因为原型中的方法和属性与构造函数中定义的对象属性和方法不在一块儿，要是能封装在一起就更加直观，如果要解决这个问题，就要用到动态原型模式；
//动态原型模式
function User(name,age){//构造方法
this.name =//属性
this.age =
this.addr = '湖北恩施';
User.prototype.addr = '湖北武汉';//在原型中添加属性
User.prototype.show = function(){//在原型中添加方法
alert(this.name+'|'+this.age+'|'+this.addr);
var user1 = new User('ZXC',22);//创建实例
var user2 = new User('CXZ',21);
user1.show();//调用show()方法
user2.show();
alert(user1.show==user2.show);//返回 true
　　上面的代码看起来要更加直观。但是这样还是会有一些小的问题，就是我们在创建多个实例的时候，没创建一个实例就会在原型中重新创建一次原型中的方法。先来测试一下：
alert('开始创建show&&');
User.prototype.show = function(){//在原型中添加方法
alert(this.name+'|'+this.age+'|'+this.addr);
alert('结束创建show&&');
　　如果我们添加上面的alert()，运行时发现，没创建一个实例都会弹出两次对话框。这就证明了上面提到的重新创建的问题，虽然这样来说空间没有额外增加，但是时间却是增加了，因为每次都要重新创建。
　　要解决这个问题，我们的思路是：首先判断show方法是否存在，如果不存在则创建，如果已经存在就不在重新创建。改进代码如下：
if(this.show==undefined){//如果run方法还没有被创建
alert('开始创建show&&');
User.prototype.show = function(){//在原型中添加方法
alert(this.name+'|'+this.age+'|'+this.addr);
alert('结束创建show&&');
　　运行发现，不管创建多少个实例都只会弹出两次对话框，这样就避免了不必要的开销。
　　三&使用字面量方式创建原型
　　除了上面提到的创建原型的方式，我们还可以用字面量方式创建，代码如下：
//使用字面量方式创建原型
function User(name,age){//构造方法
this.name =//属性
this.age =
User.prototype = {
addr : '湖北武汉',
show : function(){
alert(this.name+'|'+this.age+'|'+this.addr);
var user1 = new User('ZXC',22);//创建实例
var user2 = new User('CXZ',21);
user1.show();//调用show()方法
user2.show();
　　这里要说明的是：使用字面量方式创建后，不能再使用字面量的方式重写原型，一旦重写了原型，原来的原型中定义的所有属性和方法都将被清除。如下：
//使用字面量方式创建原型
function User(name,age){//构造方法
this.name =//属性
this.age =
User.prototype = {
addr : '湖北武汉',
show : function(){
alert(this.name+'|'+this.age+'|'+this.addr);
//重写了原型
User.prototype = {
other : '暂时没有说明&&',
show : function(){
alert(this.addr);
var user1 = new User('ZXC',22);//创建实例
var user2 = new User('CXZ',21);
user1.show();//返回 undefined
user2.show();
　　可见，一旦我们重写了原型，那么开始原型中定义的变量和方法都没有保存下来。但是，我们说的是不能用字面量的方式重写原型，那我们可不可以添加新的方法或者属性呢？答案是可以的，比如：
User.prototype.addr1 = '武汉';
　　这样就不会清楚原来原型中定义的方法和属性了。
　　四 总结
　　这里主要是介绍了原型的一些基本的知识，原型可以用来实现方法和属性的共享，也可以用来扩展对象的方法。比如我们可以用原型方法来扩展内置对象String的方法，让它具有VB的left()/right()功能，是实现截取字符串左边或者右边的功能。
　　原型中还有一些其他的知识，这里没有涉及到，以后有时间继续讨论研究~~
Web前端热门文章
Web前端最新文章JavaScript中函数与对象的关系 -- 简明现代魔法
专注于互联网主流的各种技术
JavaScript中函数与对象的关系
在ajax兴起以前，很多人写JavaScript可以说都是毫无章法可言的，基本上是想到什么就写什么，就是一个接一个的函数function，遇到重复的还得copy，如果一不小心函数重名了，还真不知道从何开始查找错误，因为大家总是用面向过程的编程思想来写JavaScript代码，而且也由于网络上充斥了太多小“巧”的JavaScript代码段，很多都是随意而为，很不规范，这也就造成了大家对JavaScript的“误解”，一味的认为它就是一个辅助的小东东，而不适合做大的东西开发。但是自从ajax兴起后，大量的JavaScript代码编写要求人们具备像写Java类似的代码一样，能够面向对象进行开发。
所以下面就结合我自己的体会和所学习的东东和大家一起来学习在JavaScript中如何使用面向对象的编程。其实使用JavaScript进行面向对象开发也不是很难的事情，因为在JavaScript中每一个function就是一个对象，比如下一个函数：
function HelloWorld() {
alert('hello world!');
那么我们在使用的时候就可以把它当成一个对象来使用，比如使用如下的测试函数：
function _test() {
var obj = new HelloWorld();
那么在调用_test方法后就会弹出hello world！的提示框，也就是调用了HelloWorld()对象（函数）。在这里HelloWorld这个对象没有任何属性和方法，它只有一个构造方法HelloWorld()，我们可以把它想象成JAVA中的一个没有任何属性和方法的类，当使用new进行对象创建的时候，就调用了它的构造方法。这也是我们最简单的对象了，当然了，一个对象肯定是要赋予它属性和方法的，在JS中我们使用prototype原型关键字进行赋值，比如我要给HelloWorld对象增加一个sayHello方法和一个name属性，那么就可以这样添加：
HelloWorld.prototype = {
name : 'JavaScript',
sayHello : function() {
alert(this.name);
那么就可以为HelloWorld添加了一个name属性和sayHello方法，我们再改一下_test方法，如下：
function _test() {
var obj = new HelloWorld();
obj.sayHello();
调用_test方法后就会先后打印hello wordl!和JavaScript（一个是构造方法中的alert，一个是sayHello方法中的alert）。注意sayHello方法中的alert引用了this关键字，该关键字表示的就是HelloWorld对象，即默认指向该对象，和JAVA中的this关键字一样。对于向一个对象添加实例方法和属性，我们可以采用上述的方式，即使用prototype关键字进行赋值，格式如下：
对象名称.prototype = {
属性一 : 属性值,
属性二 : 属性值,
方法一 : function(参数列表) {
方法二 : function(参数列表) {
可以按照如上方式对一个对象进行多个属性和方法的定义，这样在new一个对象后，就可以使用实例名称.属性或方法来获取属性或执行方法了。
在上面的方法中，大家不知道发现没有对象的属性是可以直接访问的，比如访问HelloWorld对象的name属性就可以使用obj.name直接获取。这就好比我们JAVA中的公有属性了，而且我们还可以直接对name属性进行赋值操作。所以现在有一个问题了，我们如何给一个对象赋一个私有成员变量呢？那我们就可能要改一下HelloWorld类的声明方式了，不使用prototype进行类的属性和方法声明，而是直接使用内嵌函数和属性进行声明，修改的HelloWorld如下，我们命名为HelloWorld2：
function HelloWorld2() {
var privateProp = 'hello world 2!';
this.method = function() {
alert(privateProp);
看到HelloWorld2的类申明方式了没？是直接在函数内部进行了函数嵌套申明，而且我们还设置了一个局部变量privateProp，即我们的私有成员变量，该变量只能被HelloWorld2内部的函数进行访问，外部访问是不允许的，这样我们就可以通过使用变量的作用域来巧妙的设置类的私有变量了。我们应用如下：
function _test2() {
var obj2 = new HelloWorld2();
obj2.method();
// 调用该方法将打印'hello world 2!
alert(obj2.privateProp); // 将打印undefined
上面所说的都是如何定义一个类，以为如何为一个类定义属性和方法，由于采用prototype方式进行定义清晰明了，所以一般都是使用该方式进行类的定义，而且现在很多AJAX框架中都使用了类似的类声明方式。而且类的私有成员变量却只能在类的构造方式中的函数进行访问，这样类的prototype声明的方法就不能访问该私有成员变量了，而且可读性方面也没有prototype方式好。
好了，上面所说的都是定义一个类的实例方法和属性。在JAVA中类有实例方法和属性与类方法和属性之分。所谓类属性和方法就是该类的所有实例都只维护一份类属性和类方法的副本，而不是每个实例都维护一套，这和实例属性和实例方法是不一样的。那么在JS中如何为一个类定义静态类方法和类属性呢？我们可以直接为类添加静态属性和静态方法，比如为HelloWorld类添加一个age的静态属性和一个hello的静态方法，那么声明如下：
HelloWorld.age = 22;
HelloWorld.hello = function() {
alert(HelloWorld.age);
那么这样就为类HelloWorld声明了静态属性age和静态方法hello了。在使用的时候就直接使用类名进行访问了，但是不能使用实例进行访问，这点与JAVA中的是一致的，测试如下：
function _test() {
var obj = new HelloWorld();
obj.sayHello();
// 正确，实例方法，可以通过实例进行访问
HelloWorld.hello(); // 正确，静态方法，通过类名进行直接访问
obj.hello(); // 错误，不能通过实例访问静态方法。会报JS错误！
随机文章推荐
(44) (105) (232) (53) (34) (314) (39) (35) (21) (4) (1) (9) (14) (56) (66) (1) (160) (27) (57) (31) (77) (31) (12) (7) (18) (61)
注：如需转载本文，请注明出处（原文链接），谢谢。更多精彩内容，请进入首页。
你也许还会对以下文章感兴趣
喜欢本文，就分享它吧
您的名字：
您的邮件：
您的网站：
copyright (C) 2009 简明现代魔法 && 学习、分享、进步
power by Gonn 感谢所有关心和支持本站的朋友们