For some developers that’s not a problem since memory use is quite low on lots of web sites, and all the memory is freed when a user leaves the web site anyway. However, with the development of rich applications on the web and in Air, garbage collection is becoming an issue that more developers need to understand.

I was going to write a long post explaining garbage collection, but Grant Skinner got there two years before me. Here’s his useful series about resource management in Flash.

When you’ve read that, this more recent post by Sean Christmann adds further insight – Kick starting the garbage collector.

Now there’s no excuse for leaving trash lying around.

addEventListener( MouseEvent.CLICK, clickHandler );

function clickHandler( event:MouseEvent ):void
{
	// function body here
}

What the documentation says

The (usually excellent) Flash and Flex help isn’t much help here. In the Actionscript 3 language reference, it states that the parentheses "Surrounds one or more parameters and passes them to the function that precedes the parentheses", which doesn’t explain why (or even if) the parentheses are necessary when no parameters are passed to the function.

Elsewhere in the help, it states that "If you are calling a function with no parameters, you must use an empty pair of parentheses". No explanation – just do it. Which inevitably leads to developers wondering why they mustn’t do it when assigning event handlers.

Colin Moock’s Essential Actionscript 3 (also usually excellent) takes a similar approach, simply stating "Notice the important and mandatory use of the parentheses operator following the method name".

People learn things better if they understand them, so here’s my attempt at an explanation. If you’re confused about when to use the parentheses operator this should help. If not, come back tomorrow when I’ll post something a lot more advanced about programmatic skins in Flex.

What the parentheses operator does

A function is a portion of code that performs a specific task or set of tasks within your application. The function may be something you have defined, or it may be an intrinsic function (a function built-in to the flash player, like the trace function). When a function is a property of an object, it’s usually called a method. Here’s a trivial example function definition.

function sayHello():void
{
	someTextField.text = "Hello";
}

The code inside the function is run by calling the function, like this.

sayHello();

The parentheses could perhaps be better named as the function calling operator since that is what they do. We use the function’s name to refer to the function, and then we use the parentheses to run the function we have identified.

If the function needs some additional information in order to run (the parameters) then that information goes inside the parentheses.

function saySomething( thingToSay:String ):void
{
	someTextField.text = thingToSay;
}

saySomething( "This is a boring example" );

But the parentheses, with or without parameters, are the operator that calls the function.

What happens without the parentheses

If that’s what the parentheses are for, what happens if we leave them out? Like this

sayHello;

Well, first of all, you won’t get an error. sayHello exists (it’s defined above) so the code is valid. But, it doesn’t do anything. We have used the name of the function (“sayHello”) to refer to the function, then we’ve done nothing with it. When you put the parenthesis after the function you are indicating that you want to call the function now. Without the parenthesis, you’re not running the function. But calling a function is not the only thing we can do with it.

For example, we can assign it to a variable, like this

var myFunction:Function = sayHello;

Now we can refer to the function via the variable. So if we used the parenthesis operator on the variable, it would call the function, like this

myFunction();

Or we could continue to use it’s original name, like this

sayHello();

Event handlers

When we set up an event handler, we don’t want to call the function straight away, we want the event handler to call the function later, when the event happens. So, we define an appropriate function

function clickHandler( event:MouseEvent ):void
{
	someTextField.text = "The mouse was clicked";
}

Then we assign the function as a listener for the event

addEventListener( MouseEvent.CLICK, clickHandler );

When we assign the function as a listener, we don’t want to call the function, so we don’t use the parentheses operator. Later, when the event actually happens, the flash player will call the function for us. There’s some code inside the EventDispatcher class that uses the parentheses operator to call the function when the event happens.

If you make the mistake of using the parentheses operator when assigning the event handler, like this

addEventListener( MouseEvent.CLICK, clickHandler() );

then the event handler will be called immediately (you’ve told it to do so by using the parentheses). This will usually generate an error since you haven’t assigned a parameter for the event argument.

So that’s the parenthesis operator. Personally, I like the way that C++ names the parentheses operator the "function operator" – it’s the operator that calls a function.

for( var i:uint = 5; i >= 0; i-- )
{
    // do something here
}

The answer, of course, is never. The loop continues indefinitely because a uint can never be less than 0. Doh!