Question

I want to share an Array which all classes can “get” and “change” data inside that array. Something like a Global array or Multi Access array. How this is possible with ActionScript 3.0 ?

Answer 1

There are a couple of ways to solve this. One is to use a global variable (as suggested in unkiwii’s answer) but that’s not a very common approach in ActionScript. More common approaches are:

Class variable (static variable)

Create a class called DataModel or similar, and define an array variable on that class as static:

public class DataModel {
    public static var myArray : Array = [];
}

You can then access this from any part in your application using DataModel.myArray. This is rarely a great solution because (like global variables) there is no way for one part of your application to know when the content of the array is modified by another part of the application. This means that even if your data entry GUI adds an object to the array, your data list GUI will not know to show the new data, unless you implement some other way of telling it to redraw.

Singleton wrapping array

Another way is to create a class called ArraySingleton, which wraps the actual array and provides access methods to it, and an instance of which can be accessed using the very common singleton pattern of keeping the single instance in a static variable.

public class ArraySingleton {
    private var _array : Array;

    private static var _instance : ArraySingleton;


    public static function get INSTANCE() : ArraySingleton {
        if (!_instance)
            _instance = new ArraySingleton();

        return _instance;
    }


    public function ArraySingleton() {
        _array = [];
    }


    public function get length() : uint {
        return _array.length;
    }

    public function push(object : *) : void {
        _array.push(object);
    }

    public function itemAt(idx : uint) : * {
        return _array[idx];
    }
}

This class wraps an array, and a single instance can be accessed through ArraySingleton.INSTANCE. This means that you can do:

var arr : ArraySingleton = ArraySingleton.INSTANCE;
arr.push('a');
arr.push('b');
trace(arr.length); // traces '2'
trace(arr.itemAt(0)); // trace 'a'

The great benefit of this is that you can dispatch events when items are added or when the array is modified in any other way, so that all parts of your application can be notified of such changes. You will likely want to expand on the example above by implementing more array-like interfaces, like pop(), shift(), unshift() et c.

Dependency injection

A common pattern in large-scale application development is called dependency injection, and basically means that by marking your class in some way (AS3 meta-data is often used) you can signal that the framework should “inject” a reference into that class. That way, the class doesn’t need to care about where the reference is coming from, but the framework will make sure that it’s there.

A very popular DI framework for AS3 is Robotlegs.