Which of these options will lead to better/more performant ActionScript code?

Question

I've been reading about about code optimization (to be more precise, code optimization for ActionScript 3), and I have a few questions.

Which is better, negative loops (i.e. counting backwards in loops and checking if you reach zero) or foreach loops? Both options seem to be better than normal "for" loops, but which is faster of the two?
Which is better, using Numbers or ints?
Does constant really decrease your performance?

I've tried writing a simple code and testing those myself, but the results were all over the place, and some of the websites I visited kinda had contradicting opinions!

None of this will make your code faster, or maybe only by 0.00001%. Just use control structures and types that are appropriate for your program and don't worry about how fast they are. Doing this kind of optimizations only make the code less readable and less maintainable (and harder to optimize when it really matters). — laurent, Sep 10 '11 at 02:27
@Laurent: That's not always true - it's pretty much dependent on the complexity of the algorithm. Let's say that you iterate over thousands of elements in an array (maybe a particle effect system), then creating an anonymous function on every iteration is going to be quite expensive (and I'd guess an optimization would make it > 0.00001% faster). — Demian Brecht, Sep 10 '11 at 02:35
Also, having best practices in mind that are in turn mindful of optimization (within reason, of course) is far from a bad thing. — Demian Brecht, Sep 10 '11 at 02:36

score 2 · Accepted Answer · answered Sep 10 '11 at 11:32

"1) Which is better, negative loops (i.e. counting backwards in loops and checking if you reach zero) or foreach loops? Both options seem to be better than normal "for" loops, but which is faster of the two?"

By foreach, I'm going to assume you mean for..each or for..in loops. As Demian pointed out, forEach is pretty slow. For the others, doing a simple for loop is always quicker (you can early out of all of them except forEach I think) by just returning when you hit the check you need). Whether you do i++ or i-- makes no difference. for..each and for..in loops have their benefits though. for..in is the only way you can loop through Dictionary and Object objects, while for..each performs the cast for you, meaning you write less code. As in:

for each( var s:Sprite in this.m_mySpriteVector )
    ...

vs.

var len:int = this.m_mySpriteVector.length;
for( var i:int = 0; i < len; i++ )
    var s:Sprite = this.m_mySpriteVector[i];

(on a side note, if you're doing a normal for loop, taking out the length is the best thing you can do to speed it up). Also note that the speed difference in for loops only really matter if they're large loops. If you're doing a loop of 10, then it doesn't really make any difference which one you pick.

"2) Which is better, using Numbers or ints?"

If you mean in loops, then always go for the int. In other general terms, use the class that represents what you need. If you only need whole numbers, then use int or uint. If you need decimals, then go for Number. Use the wrong type and you do incur a small penalty, but not a huge one. Also, depending on what you hold in the variable, it mightn't be the type you think: http://jacksondunstan.com/articles/1357

"3) Does constant really decrease your performance?"

I've not really tested it, but probably not enough to really matter. Make a simple loop using 1,000,000 iterations or something and see if it makes a difference. Using a static const will incur a small penalty as it has to perform the class lookup, but it's not harsh

The final point to be made is to be careful about optimisation. Also have it in your head so you don't write code that sucks, but be careful where you apply it. Optimised code usually takes longer to write and is less readable than other code (the for..each loops being a good example).

Take into account where each piece of code is used. If it's what's called performance critical code - code that's called all the time (ENTER_FRAME, or common functions) then that's where you should focus your efforts. If it's a function that's called once, or not very often, then the time you spend optimising it will be a waste as you're getting very little benefit from it.

I think doing i-- or i++ does make a difference, here is an example: counter = variable; while(counter--) { //do something } it should be faster than normal loops, since checking if something is zero is faster than checking if something is smaller/bigger than something else (modern CPUs have that command built in, while to do a comparison, they usually subtract the numbers and check if its equals to zero) — r3x, Sep 10 '11 at 14:20
Here is a link about reverse looping, I know it says javascript, but I would persume its the same for actionscript more or less. http://stackoverflow.com/questions/1340589/javascript-are-loops-really-faster-in-reverse. Anyways, thanks for the tips =) — r3x, Sep 10 '11 at 14:52
here's a link comparing ++ and -- and other variations: http://jacksondunstan.com/articles/1258 - remember, the benefits are only really noticeable over *huge* loops. for normal use, the benefit is negligible - you'll get more benefit from trying to early out and taking the length check out of the loop. Check out jackson's site; it's a treasure trove of optimisation techniques — divillysausages, Sep 10 '11 at 16:40

score 1 · Answer 2 · answered Sep 10 '11 at 02:14

1) which is better, negative loops (i.e. counting backwards in loops and checking if you reach zero) or foreach loops. Both options seem to be better than normal "for" loops, but I want to know which is faster of the two?

It all depends on your logic. If you have a exit condition that will be met sooner when decrementing, then negative is the way to go. As for forEach, I assume that it depends on how you use it. Take the following as an example:

A

var vec:Vector.<String> = new Vector.<String>();
vec.forEach(function(s:String, idx:int, v:Vector.<String>):void {
    trace(s);
});

B

function onIteration(s:String, idx:int, v:Vector.<String>):void {
    trace(s);
}
var vec:Vector.<String> = new Vector.<String>();
vec.forEach(onIteration);

In A, unless the Flash compiler does some amazing optimizations (and I'm pretty sure it doesn't), a new anonymous function is created on every iteration, which will obviously be more expensive than a simple for loop.

B already has the function defined, so it's just an extra lookup for the function call. I would assume that performance differences between this and a normal for loop are minimal, if existent at all (haven't profiled it though).

2) Which is better, using Numbers or ints?

It depends on your specific case. If you require a floating point number, then use Number. Otherwise, use int. If your value will never be negative, use uint. I would assume that AVM2 calculations would be faster with ints and uints than Number as there's no floating point ops that take place, but I haven't profiled it, so I'm not 100% sure.

3) Does constant really decrease your performance?

I've never heard anything on the subjet. I couldn't see how as it makes the variable read-only. If there is any difference, it would be next to nothing.

Which of these options will lead to better/more performant ActionScript code?

2 Answers2