blocks|key|1254329|text|该方法不会重新编译。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1254330|每次调用外部方法时，Javascript解释器都会创建一个包含内部方法和局部变量的新闭包对象。|1254331|具体的实现取决于Javascript引擎。|1254332|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

The method is not recompiled.

The Javascript interpreter will create a new closure object containing inner methods and local variables every time you call the outer methods.

The exact implementation depends on the Javascript engine.

blocks|key|1254386|text|我猜它只编译一次...因为"this“关键字指的是执行上下文...因此，编译器不需要了解太多关于函数的知识就可以解释它。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1254387|此外，当您在函数的底部声明变量时，仍然可以在顶部访问该变量：|1254388|function+test()
{
++alert(hello);
++//+...
++var+hello+=+2;
}|code-block|syntax|javascript|1254389|函数也是如此。考虑到这两件事，我会相信它不会在每次调用A时都被重新编译。|1254390|麦克|1254391|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Q|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

I would guess it gets compiled only once... because the "this" keyword refer to the execution context... so the compiler doesn't need to know much about a function to interpret it.

Furthermore, when you declare a variable in the bottom of a function, it is still accessible at the top:

<pre><code>function test()
{
 alert(hello);
 // ...
 var hello = 2;
}
</code></pre>

It is the same thing with functions. I would believe with those 2 things in mind, that it doesn't get re-compiled every time a A gets called.

Mike

blocks|key|1039503|text|假设一个函数只是另一个对象，然后当你创建一个新的对象时，它只是一个旧对象的副本，其中一些数据变量发生了变化。您不需要重新解析对象的源代码即可实现此目的。一个很好的类比是C%2B%2B中的functionoids，Lua中的function+objects，而我并不了解很多其他语言。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1039504|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Imagine a function as just another object, and then when you create a new one, it's just a copy of the old one, with some data variable changed. You don't need to re-parse the object's source for that to happen. A good analogy is functionoids in C++, function objects in Lua, and I don't really know many other languages.

blocks|key|1039557|text|function+A(){
++var+foo+=+1;
++this.method+=+function(){
++++return+foo;
++}
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1039558|不能编译成|unstyled|1039559|function+method+=+function(){+return+this.foo;+}
function+A(){
++this.foo+=+1;
++this.method+=+method;
}|1039560|因为功能会发生变化。第一个示例有一个变量'foo‘，它只对构造函数'A’和名为'method‘的函数可见，而在第二个示例中，变量’foo‘对所有可以访问'A’实例的对象都是可访问的。|1039561|可以将它编译为|1039562|function+method+=+function(){+return+1;+}
function+A(){+
++this.method+=+method;
}|1039563|但我不认为有任何javascript引擎会走得那么远，但如果你能够预处理你的文件，并愿意付出额外的努力，如果google+closure+compiler用于高级模式，它可能会走得很远。|offset|length|1039564|entityMap|0|LINK|mutability|MUTABLE|url|http://code.google.com/closure/^0|0|0|0|0|0|0|1I|N|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|11|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|12|8|@]|9|@]|A|$B|C]]|$1|I|3|J|5|F|7|13|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|14|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|15|8|@]|9|@]|A|$B|C]]|$1|O|3|P|5|F|7|16|8|@]|9|@$Q|17|R|18|1|19]]|A|$]]|$1|S|3|-4|5|F|7|1A|8|@]|9|@]|A|$]]]|T|$U|$5|V|W|X|A|$Y|Z]]]]

<pre><code>function A(){
 var foo = 1;
 this.method = function(){
 return foo;
 }
}
</code></pre>

can't be compiled into

<pre><code>function method = function(){ return this.foo; }
function A(){
 this.foo = 1;
 this.method = method;
}
</code></pre>

because the functionality would change. The first example has a variable 'foo' that is only visible to the constructor 'A' and to the function called 'method' whereas in the second example the accessible to everything that has access to the instance of 'A'.

It is possible to compile it into 

<pre><code>function method = function(){ return 1; }
function A(){ 
 this.method = method;
}
</code></pre>

But I don't think that any javascript engine out there will go that far, but if you are able to preprocess your files and willing to put in an extra bit of effort, the <a href="http://code.google.com/closure/" rel="nofollow noreferrer">google closure compiler</a> could go pretty far if it's used in advanced mode.

Let's say we have this code (forget about prototypes for a moment):

<pre><code>function A(){
 var foo = 1;
 this.method = function(){
 return foo;
 }
}
var a = new A();
</code></pre>

is the inner function recompiled each time the function A is run? Or is it better (and why) to do it like this:

<pre><code>function method = function(){ return this.foo; }
function A(){
 this.foo = 1;
 this.method = method;
}
var a = new A();
</code></pre>

Or are the javascript engines smart enough not to create a new 'method' function every time? Specifically Google's v8 and node.js.

Also, any general recommendations on when to use which technique are welcome. In my specific example, it really suits me to use the first example, but I know thath the outer function will be instantiated many times.

Are closures in javascript recompiled

编译器

解释器

假设我们有这样的代码(暂时忘掉原型)：function A(){  var foo = 1;  this.method = function(){    return foo;  }}var a = new A();是否在每次运行函数A时重新编译内部函数？或者这样做更好(以及为什么)：function method =...

问javascript中的闭包是否已重新编译？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问javascript中的闭包是否已重新编译？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问javascript中的闭包是否已重新编译？
EN