This is a quick article to discuss a point brought up in a recent comment. Which is the fastest way to increment: j++, ++j, or j+=1? Likewise, which is the fastest way to decrement? Below I will dispel the myth that there is any difference between them at all.

Here is what the comment claimed:

Also, for what it’s worth I hear (i += 1) is faster than (i++) in ActionScript.

This has been discussed elsewhere, too: FlashKit (no conclusion) and Kirupa (various claims). I don’t know why a decent performance test was never done, but I made one quite easily:

package
{
    import flash.text.*;
    import flash.utils.*;
    import flash.display.*;
 
    public class IncrementDecrementTest extends Sprite
    {
        private var __logger:TextField;
 
        public function IncrementDecrementTest()
        {
            __logger = new TextField();
            __logger.autoSize = TextFieldAutoSize.LEFT;
            addChild(__logger);
 
            const NUM_ITERATIONS:int = 100000000;
            var i:int;
            var j:int;
            var beforeTime:int;
 
            log("Increment:");
 
            j = 0;
            beforeTime = getTimer();
            for (i = 0; i < NUM_ITERATIONS; ++i)
            {
                j++;
            }
            log("\tPost-increment (j++): " + (getTimer()-beforeTime));
 
            j = 0;
            beforeTime = getTimer();
            for (i = 0; i < NUM_ITERATIONS; ++i)
            {
                ++j;
            }
            log("\tPre-increment (++j): " + (getTimer()-beforeTime));
 
            j = 0;
            beforeTime = getTimer();
            for (i = 0; i < NUM_ITERATIONS; ++i)
            {
                j += 1;
            }
            log("\tAdd 1 (j+=1): " + (getTimer()-beforeTime));
 
            log("Decrement:");
 
            j = int.MAX_VALUE;
            beforeTime = getTimer();
            for (i = 0; i < NUM_ITERATIONS; ++i)
            {
                j--;
            }
            log("\tPost-decrement (j--): " + (getTimer()-beforeTime));
 
            j = int.MAX_VALUE;
            beforeTime = getTimer();
            for (i = 0; i < NUM_ITERATIONS; ++i)
            {
                --j;
            }
            log("\tPre-decrement (--j): " + (getTimer()-beforeTime));
 
            j = int.MAX_VALUE;
            beforeTime = getTimer();
            for (i = 0; i < NUM_ITERATIONS; ++i)
            {
                j -= 1;
            }
            log("\tSubtract 1 (j-=1): " + (getTimer()-beforeTime));
        }
 
        private function log(msg:*): void
        {
            __logger.appendText(msg + "\n");
        }
    }
}

Here are my results:

Environment Post-Increment Pre-increment Add One Post-Decrement Pre-Decrement Subtract One
3.0 Ghz Intel Core 2 Duo 236 236 236 236 236 236

There is no difference at all, even with one hundred million operations. So just use whichever you prefer.