On Feb 24, 1:31 am, "Manu Temmerman-Uyttenbroeck"

< manu.temmermanuyttenbro...gmail.com">manu.temmermanuyttenbro...gmail.com> wrote:

&gt; The basic example onhttp://prototypejs.org/api/ajax/requestalso has a

> closure, because the onSuccess callback function is defined inline, correct?
&gt; So if that 'new Ajax.Request' is in a function, then that url variable will
> not be released until that ajax request successfully finishes and that
>; onSuccess function runs?
> What happens then when the ajax request is not successfull and throws an
> exception. That url value will stay in memory until you navigate away from
> the page?

Unless the request object itself gets dereferenced.

If I'm inside a function and I say...

var foo = new Ajax.Request(/*...*/);

... then once the function goes out of scope, I won't be able to
obtain a reference to it again. (This is assuming that variable isn't
a part of *some other* closure created inside the function. The
browser knows this, so when the request has completed its life-cycle
(even by throwing exception), it'll GC the object if nothing
references it. And that would also GC the closure formed by attaching
that anonymous function to the object.

Now, if I say...

window.foo = new Ajax.Request(/*... */);

... then I've set a global reference that will never go out of scope.
That means my request object won't be GC'ed unless I explicitly
dereference later on (window.foo = null).

Let's make a diagram. Think of "window" (the global scope) as a big
circle in the middle of the page. Imagine everything -- strings,
numbers, objects, etc. -- as nodes. Now draw lines between nodes to
make references. (window connects to Ajax, Ajax connects to
Ajax.Request, etc.)

Anything that can be traced back to "window" must be kept in memory.
If I remove a reference to something, that erases a line from the
diagram, and any resulting "node island&quot; can be GC'd. Even if you've
got two objects that reference one another, if neither one of them can
be referenced from the global scope, they can be purged from memory,
since it's impossible to refer to them.

(Of course, IE has its own problem with circular references, which
brings me to your next question...)

> What happens when you didn't only store a url string, but let's say a
> reference to a collection of 200 dom objects and the ajax request fails.
>; Circular reference? Meaning a 'real&#39; memory leak. That memory won't be
> released even after navigating away from the page.

Yeah, and that's the sort of thing that can't easily be solved inside
the JS environment (except through cautious coding). Of course, IE7
claims to have fixed many of those leaks, so maybe you should make a
test page and find out.

Cheers,
Andrew

--~--~---------~--~----~------------~-------~--~----~
You received this message because you are subscribed to the Google Groups "Ruby on Rails: Spinoffs&quot; group.
To post to this group, send email to rubyonrails-spinoffsgooglegroups.com
To unsubscribe from this group, send email to rubyonrails-spinoffs-unsubscribegooglegroups.com
For more options, visit this group at http://groups.google.com/group/rubyonrails-spinoffs?hl=en
-~----------~----~----~----~------~----~------~--~---