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.