Why is i=i+1 faster than i++?

Question

Test this code in Flash:

var i:int = 0;
for (var j:int = 0; j < 5000000; j++)
{
    i=i+1;
}// use about 300ms.

i = 0;
for (var j:int = 0; j < 5000000         


        

Answer 1

I can't replicate this behavior all three appear to be about the same time for me

Attempt 1
loop 1: 378
loop 2: 396
loop 3: 382

Attempt 2
loop 1: 380
loop 2: 361
loop 3: 361

Attempt 3
loop 1: 375
loop 2: 373
loop 3: 355

Increasing the loops by a factor of 10 I got these times:

Attempt 1
loop 1: 3707
loop 2: 3663
loop 3: 3653

Attempt 2
loop 1: 3722
loop 2: 3632
loop 3: 3711

[TestLoopSpeed.as]

package
{
    import flash.display.Sprite;
    import flash.utils.getTimer;

    public class TestLoopSpeed extends Sprite
    {
        public function TestLoopSpeed()
        {
            var timeNow:Number = getTimer();
            var i:int = 0;

            var startOne:Number = getTimer();
            for (var j:int = 0; j < 5000000; j++)
            {
                i=i+1;
            }
            var endOne:Number = getTimer();


            var startTwo:Number = getTimer();
            i = 0;
            for (var j:int = 0; j < 5000000; j++)
            {
                i++;
            }
            var endTwo:Number = getTimer();

            var startThree:Number = getTimer();
            i = 0;
            for (var j:int = 0; j < 5000000; j++)
            {
                ++i;
            }
            var endThree:Number = getTimer();

            trace("loop 1: " + (endOne - startOne));
            trace("loop 2: " + (endTwo - startTwo));
            trace("loop 3: " + (endThree - startThree));
        }
    }
}

So far as I understand it i++ is ultimately equivalent to i = i+1; with the exception that if an assignment is occurring on that line then the current value of i would be used and a later instruction would add one to i. ++i simply means add 1 to i before doing any other operations on this line. Ultimately I don't think any of these options should really affect performance it appears from every test I've done that the CPU scheduling at any given moment for the flash process is having more of an effect than any given operator.

If there's something wrong with the code I'm using to test please point it out.

Edit

Updated the code to include the while loop option, still not seeing anything that looks like a positive significant difference:

loop 1: 3695
loop 2: 3698
loop 3: 3690
loop 4: 3711

loop 1: 3758
loop 2: 3651
loop 3: 3707
loop 4: 3676

[TestLoopSpeed.as] Updated with fancy while loop pre-increment action

package
{
    import flash.display.Sprite;
    import flash.utils.getTimer;

    public class TestLoopSpeed extends Sprite
    {
        public function TestLoopSpeed()
        {
            var timeNow:Number = getTimer();
            var i:int = 0;

            var startOne:Number = getTimer();
            for (var j:int = 0; j < 50000000; j++)
            {
                i=i+1;
            }
            var endOne:Number = getTimer();


            var startTwo:Number = getTimer();
            i = 0;
            for (var j:int = 0; j < 50000000; j++)
            {
                i++;
            }
            var endTwo:Number = getTimer();

            var startThree:Number = getTimer();
            i = 0;
            for (var j:int = 0; j < 50000000; j++)
            {
                ++i;
            }
            var endThree:Number = getTimer();

            var startFour:Number = getTimer();
            i = 0;
            var j:int = -1;
            while (++j < 50000000)
            {
                ++i;
            }
            var endFour:Number = getTimer();

            trace("loop 1: " + (endOne - startOne));
            trace("loop 2: " + (endTwo - startTwo));
            trace("loop 3: " + (endThree - startThree));
            trace("loop 4: " + (endFour - startFour));
        }
    }
}