性能：内联与原型定义的方法？ [英] Performance: inline- vs. prototype-defined methods ?
问题描述
遇到了性能问题;情况如下所述（参见Version
Inline），我有一个javascript类项目，定义了很多方法
里面和每次调用 ; new item（）" js翻译人员必须查看所有方法定义（使用Venkman做个人资料）
，这对我来说需要太多时间..
如果我通过.prototype在
构造函数之外定义这些方法会有所不同（参见Version Prototype）??
版本内联：
item = function（）{
this.myMethod1 = function（）{..}
this .myMethod2 = function（）{..}
this.myMethod3 = function（）{..}
...
这个。 myMethod999 = function（）{..}
}
版本原型：
item = function（）{
}
item.prototype.myMethod1 = function（）{..}
item.prototype.myMethod2 = function （）{..}
item.prototype.myMethod3 = function（）{..}
...
item.prototype。 myMethod999 = function（）{..}
非常感谢提前!!
-
Gerald Stampfel
gs ******* @ sedisys.com
推荐答案
Gerald S写道：
Gerald S wrote:
得到了性能问题;情况如下所述（参见版本
内联），我有一个javascript类项目，内部定义了许多方法，每次调用new item（） js翻译必须查看所有方法定义（使用Venkman做了一个配置文件）
这对我来说需要花费太多时间..
如果我有所作为通过.prototype在
构造函数之外定义这些方法（参见Version Prototype）??
got a performance problem; situation is as described below (see "Version
Inline"), i''ve got a javascript class item with many methods defined
inside and with every call to "new item()" the js interpreter has to
look through all the method definitions (did a profile using Venkman)
which takes too much time for me ..
would it make a difference if i define these methods outside the
constructor via .prototype (see "Version Prototype") ??
是的，它会有所不同，因为你只会设置方法
一次而不是每次你创建一个对象，如果你有很多
对象，你将使用更少的内存，所以可能有一个增益。调用
的方法可能会稍微慢一点，但这不太可能是明显的。
Yes it will make a difference since you will only be setting up the methods
once instead of every time you create an object, also if you have a lot of
objects you will be using less memory so there may be a gain there. Calls
to the methods may be slightly slower but that is unlikely to be
noticeable.
Duncan Booth写道：
Duncan Booth wrote:
是的它会有所不同，因为你只会设置一次方法而不是每次创建一个对象，如果你有很多
对象你将使用更少的内存，因此可能会有所收获。对方法的调用可能会稍慢但不太可能明显。
Yes it will make a difference since you will only be setting up the methods
once instead of every time you create an object, also if you have a lot of
objects you will be using less memory so there may be a gain there. Calls
to the methods may be slightly slower but that is unlikely to be
noticeable.
ok，谢谢!!
但如果我这样做.prototype-way，还有另外一个问题。考虑
以下情况：
item = function（）{
var privateVar;
function doInternalStuff（）;
}
item.prototype.myMethod1 = function（）{..}
item.prototype .myMethod2 = function（）{..}
item.prototype.myMethod3 = function（）{..}
...
item.prototype.myMethod999 = function（）{..}
两个问题：
1）我无法从myMethodXXX方法访问privateVar（或者我可以吗？ ）
2）我不能用我的myMethodXXX方法调用doInternalStuff（）
i可能会暴露给公众，但有没有办法保持他们
私人并使用它们。任何模式？
再次感谢..
-
Gerald Stampfel
gs ******* @ sedisys.com
Gerald S写道：
Gerald S wrote:
但如果我这样做.prototype-way，还有另一个问题。考虑以下情况：
item = function（）{
var privateVar;
函数doInternalStuff（）;
}
item.prototype.myMethod1 = function（）{..}
item.prototype.myMethod2 = function（）{..}
item.prototype.myMethod3 = function（）{ ..}
...
item.prototype.myMethod999 = function（）{..}
两个问题：
1）我无法访问privateVar来自myMethodXXX方法（或者我可以吗？）2）我不能用myMethodXXX方法调用doInternalStuff（）
我可以向公众公开，但是有没有让他们保持私密并使用它们的方法。任何模式？
but if i do it the .prototype-way, there is another problem. consider
the following situation:
item = function () {
var privateVar;
function doInternalStuff();
}
item.prototype.myMethod1 = function() { .. }
item.prototype.myMethod2 = function() { .. }
item.prototype.myMethod3 = function() { .. }
...
item.prototype.myMethod999 = function() { .. }
two issues:
1) i can''t access privateVar from my myMethodXXX methods (or can i?)
2) i can''t call doInternalStuff() from my myMethodXXX methods
i could expose both to the public, but is there a way to keep them
private AND use them. any patterns ?
Javascript并不真正支持私有变量。你最好的行动是
只是使用一些约定来表明它们是私有的（例如，
在名称上引出下划线），然后不从外部访问它们/>
适当的功能。
Javascript doesn''t really support private variables. Your best action is
simply to use some convention to indicate that they are private (e.g. a
leading underscore on the name) and then not access them from outside the
appropriate functions.
这篇关于性能：内联与原型定义的方法？的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！
