What about in ActionScript 3? Well, not so much. The String class in AS3 is, in my opinion, a bit lacking compared to languages like C# and Scala. What’s worse, you can’t augment prototypes easily like you can in JavaScript to add missing methods (see update at the end for more information on this).

So I needed to trim a string in AS3. A quick Google search showed a couple so-so methods. Then I got to thinking: Hey, doesn’t jQuery have a trim method? Aren’t they both ECMAScript languages? Shouldn’t something as basic as this be pretty similar in both languages?

The answer was yes to all those questions. So I popped open the jQuery source and did a quick search and found this a few lines into it:

// Used for trimming whitespace
rtrim = /^(\s|\u00A0)+|(\s|\u00A0)+$/g,

Perfect. I created a StringHelper AS3 file, plunked it in, and presto, we have an efficient trimmer in AS3:

public final class StringHelper
{               
    public function StringHelper() { }
 
    public static function trim(str:String):String {
        return str.replace(/^(\s|\u00A0)+|(\s|\u00A0)+$/g, "")
    }
 
    public static function trimStart(str:String):String {
        return str.replace(/^(\s|\u00A0)+/g, "");
    }
 
    public static function trimEnd(str:String):String {
        return str.replace(/(\s|\u00A0)+$/g, "");
    }
}

Update

After this was posted on Reddit, theillustratedlife made the following comment regarding the prototype chain in ActionScript:

You are supposed to be able to enhance the ECMAScript prototypes, but you might have to call a compiler flag when you do it. If you look in the docs, you’ll notice that there are ECMAScript prototypes and interchangeable native code classes for the primitive types.

After doing a bit more experimenting, it looks like you can fairly easily augment the prototype chain in ActionScript as well. However, there are some caveats when running AS3 in strict mode. For example, consider having the String class augmented like so:

String.prototype.trim = function():String {
    return StringHelper.trim(this);
}

If we try to call the trim() method in the usual way

var str:String = "foo";
str.trim();

we’ll get a compile-time error because the AS3 compiler can’t find the method in the String class definition. Fortunately, we can get around this by using a dynamic reference

var str:String = "foo";
str["trim"]();

It’s a lot uglier, but it works.

Sooo… I made my own simple library called SpriteFactory.

Here’s some example usage:

var factory:SpriteFactory = new SpriteFactory("assets/sprites");
factory.loadBitmap("grass", "block-grass.png");
var grass1:Sprite = factory.newSprite("grass");
var grass2:Sprite = factory.newSprite("grass");

Check out the project page for more information.

Since I’m toying around with the idea of sidescrollers, I did a search for “Flash sidescroller tutorial” and found this excellent 3-parter by devnote.org.  Unfortunately (for me), the tutorial expects that you’re using Adobe’s Flash IDE.  Thus, as a contribution to the web (and myself… mostly myself), I translated the tutorial to work with FlashDevelop.  Read on to see how I did it, or just grab the source here.

There are basically only 3 elements in the DevNote tutorial that require the Flash IDE.  They are the Boundaries, Player and StartMarker MovieClips.

As the StartMarker was just a point, I used the Point class to represent it (and called it _startPos instead). Since Boundaries and Player were basically sprites, I represented them using the Sprite class. Here is the pertinent code:

public class Main extends MovieClip 
{
    private var _startPos:Point;
    private var _player:Sprite;
    private var _boundaries:Sprite;    
    ...
    public function Main():void {
        // Assign defaults.
        _startPos = new Point(100, 10);
 
        _player = new Sprite();
        _player.graphics.beginFill(0xff0000);
        _player.graphics.drawRect(-10, -50, 20, 50);
        _player.graphics.endFill();
        _player.x = _startPos.x;
        _player.y = _startPos.y;
        addChild(_player);
 
        _boundaries = new Sprite();
        _boundaries.graphics.beginFill(0x0000ff);
        _boundaries.graphics.drawRect(40, 100, 110, 20);
        _boundaries.graphics.drawRect(100, 150, 110, 20);
        _boundaries.graphics.lineStyle(20, 0x0000ff);
        _boundaries.graphics.moveTo(200, 300);
        _boundaries.graphics.lineTo(500, 100);
        _boundaries.graphics.moveTo(500, 100);
        _boundaries.graphics.lineTo(600, 100);
        _boundaries.graphics.moveTo(800, 200);
        _boundaries.graphics.lineTo(500, 200);
        _boundaries.graphics.endFill();
        addChild(_boundaries);
        ...
    }    
    ...
}

I also change the code slightly in the case of the key handlers (I used constants for the key codes isntead of magic numbers) and used a do ... while loop for the collision detection.