This weekend finally, I found some time to pick up that project again and finish it. Ok, try it out yourselves at the following little sub-page:

http://www.weltenkonstrukteur.de/games/phlocks/

throw expression

According to that, the following code is perfectly valid and outputs “Test” :

public function Main()
{
	try
	{
		throwSomething();
	}
	catch ( e:String )
	{
		trace(e);
	}
}
 
private function throwSomething():void
{
	throw new String("Test");
}

However, this is not the normal case. In actionscript you should always throw Error Objects. So, ideally above’s code should be look like this:

public function Main()
{
	try
	{
		throwSomething();
	}
	catch ( e:Error )
	{
		trace(e.message);
	}
}
 
private function throwSomething():void
{
	throw new Error("Test");
}

Of course, you could write your own exception classes which derives from the Error class like you would do it in other languages with the Exception class. Apart from that difference, Actionscript’s Exception handling is pretty straight-forward and sticks to the general paradigm.

This became boring after a while so I searched the web for a solution to execute PHP code dynamically on the fly. Unfortunately, I did not find any good solution that’s why I started this little project. I named it Dynamic PHP Executor.

What is it about ?

It’s a  little PHP page that allows you to enter PHP code and execute it directly on the fly. This way you can test little PHP snippets without saving them to disc.

The Dynamic PHP Executor comes in a single file, ie. it does need not any additional include files.

A quick note to CSS/Javascript/HTML designers

In general, I know that this is not a good habbit to put CSS styles,  javascript code et cetera into a single file. However in this case, it helps to keep this project small and compact.

How does it work ?

The core functionality consists of one PHP line only actually

eval(stripslashes($_POST['phpCode']));

So, the request data contains the PHP code. This is evaluated. The function stripslahes is required since all quotations are escaped when posted. Here is screenshot of how it looks in action.

Be careful though!

Only use this script in a secure environment. The user of the tool can run any PHP code he wants on your machine. Please keep this in mind and read the disclaimer inside the file.

Try it

Download the source, read the disclaimer and comments inside the file. Then simply run it through a PHP enabled web server.

Name: Dynamic Php Executor
Size: 2.58 KB
Hits: 359

First of all, the elements of an array in actionscript can be of different types. That means, you can put various types of elements in the same array. Following small example illustrates that:

public function Main()
{
	var arr:Array = [ 1, "Two", { id:3 } ];
 
	for (var i:uint = 0; i < arr.length; i++)
	{
		trace(typeof(arr[i]));
	}
	// Will result in the following output:
	// number
	// string
	// object
}

Above’s code extract creates an array called arr which holds three elements. All elements are of a different type.The element at index 0 is of type Number, index 1 is of type String and finally index 2 is an object.

Another special thing about arrays in actionscript is that the memory of arrays are allocated automatically. That means, that you do not have to care about reserving memory if you want to add elements e.g. So theroretically each array has an unlimited amount of elements. Accessing an element which actually has never been created does not resolve in an error like in other programming languages (Array index out of bounce). Refer to the following example:

// Create an array which holds 2 elements
var arr:Array = new Array(2);
 
// Now try to access the third element
// This does not result in an error like in
// other programming languages
trace(arr[2]);

Although above’s code creates an array which should hold only 2 elements, we still can try to access the third element without retrieving an error. The third element is simply undefined (i.e. equals null). Keeping this in mind, the length property returns actually the index of the last used element instead of the real amount of elements of the array. The final piece of code demonstrates the return values of length:

var arr:Array = new Array();
trace(arr.length);
arr[0] = 1;
trace(arr.length);
arr[100] = 2;
trace(arr.length);
// This code outputs:
// 0
// 1
// 101

For example, in C++ NULL is defined as the number zero :

#define NULL 0

In PHP however, NULL is a datatype. The only possible value of NULL is NULL. That means if you assign NULL to a variable you unset the variable while assigning to it the value and type NULL - and not zero. The trapfall however is, that you need to be careful if you are checking a variable for a NULL value/type.

$var = NULL;
if ( NULL == $var ) echo "Var is NULL";
// outputs Var is NULL

The if-clause is true in this case - but this check is error-prone. Look at the following check:

$var = 0;
if ( NULL == $var ) echo "Var is NULL";
// outputs Var is NULL

This if-clause is true as well, since PHP just checks if the value of NULL and $var is equal. The converted integer value of NULL is 0

echo (int)NULL;
// outputs 0

Therefore the if clause is true. To really test if the values are equal and the type is identical you need to use the “===”-comparison operator of PHP.

Alternatively, you can use the php function is_null() to determine if a variable is of type NULL.

var age:uint;

Whenever you assign to that variable a value of another type the compiler will throw type mismatch errors.

// This will result in a type mismatch error
age = -10;

Actionscript provides untyped variables. You can set them explicitly with the datatype “*“, e.g.:

var anything:*;
anything = 10;
anything = "Test";
anything = new Array();

Above code will not throw any type mismatch errors, because the variable is declared as an untyped variable. So you can assign values of any kind to it.

From my personal point of view however, you should avoid using untyped variables whenever you can.

Here is a short example of a nested function.

private function doCalculation():void
{
	for (var i:uint; i < 10; i++)
	{
		// Do some serious calculation
		nestedLog("Calculation " + i + " done");
	}
 
	// Nested function
	function nestedLog(logTxt:String):void
	{
		trace(logTxt);
	}
}

The function defined in line 10 is only accessible in the scope of the method doCalculation(). Therefore, it is illegal to add any control access modifiers (public, private, protected) to the function.

Nested functions may be used to store some method-specific subroutines.

functionname.arguments

Since this array is created by default, actually you would not need to declare any parameters anymore. But of course it is more convenient to name parameters in the function signature with a variable name.

However, there might be situations where you do not know the exact amount of parameters which are passed to your function. Have a look at the following piece of code which is the equivalent of the actionscript function of the previous post:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

function showFavouriteMovies(name)
{
    var retString = name + "'s favourite movies are: ";
 
    // Loop through all arguments starting from index 1.
    // Note: index 0 contains the value for given explicit parameter 'name'
    for (var i = 1; i < showFavouriteMovies.arguments.length; i++)
    {
        retString += showFavouriteMovies.arguments[i];
 
        // Add comma to list
        if ( i < (showFavouriteMovies.arguments.length-1) )
        {
            retString += ", ";
        }
    }
 
    alert(retString + ".");
}

On line #07 you see how to access the functions’ arguments array. We simply loop through it. Remember that we start in our example at index 1. Index 0 contains the first parameter name which equals showFavouriteMovies.arguments[0].

As you can see, functions in javascript with an unknown number of parameters are easily possible, however a big disadvantage in javascript is in my eyes that you cannot judge by a function’s signature if it processes arbitrary parameters or not. In other languages like Actionscript for example an arbitrary amount of parameters are symbolized by a “…args:Array”-parameter in the function signature.

private function showFavouriteMovies( name:String, ...movies:Array ):void
{
	var retString:String = name + "'s favourite movies are: ";
 
	for (var i:uint = 0; i < movies.length; i++)
	{
		retString += movies[i];
		if ( i < (movies.length-1) )
		{
			retString += ", ";
		}
	}
 
	trace(retString + ".");
}

The created method called showFavouriteMovies() takes two arguments. The first parameter called “name” is a normal parameter of type String. The second parameter “…movies” defines an array to hold any arguments passed to the method. The name after the “…”-construct defines the name of the array (here it is “movies”).

So, calling the function for example with the following paramters:

showFavouriteMovies("Joshua", "Wargames", "13th Floor", "The beach");

will result in:


Joshua's favourite movies are: Wargames, 13th Floor, The beach.


You see that the first named paramter called “name” can be used normally. The list of movies are stored in an indexed array where the first element (i.e. index 0) is the left-most value of the method call (in our example it is “Wargames”) proceeding to the right.

Always keep in mind, that the “…”-construct must be the last parameter in your method’s signature.

Ok, enough introductional text - let’s start:

First topic is Getter and Setter. Well, I do no want to start the discussion again if they are useful or not - here it is how they are supported in Actionscript3.0:

package
{
	public class GetterSetter
	{
		private var hiddenName:String = "OLD: Joshua";
 
		public function get name():String
		{
			return this.hiddenName;
		}		
 
		public function set name(newName:String):void
		{
			this.hiddenName = "NEW: " + newName;
		}
	}
 
}

On line #05, we have the class property called hidden name we want to make accessible via getter and setters. Therefore, we create two methods one line #07 and line #12 which are identified by the keyword get and set followed by the same methodname name(). With this construct you create a faked public class property called name of the class GetterSetter. You access it like a normal property using the following syntax:

var gs:GetterSetter = new GetterSetter();
trace(gs.name);
gs.name = "Joshua";
trace(gs.name);

The output of that would be:

OLD: Joshua
NEW: Joshua

That means that when you access the faked class property you actually call the respective get- or set- method. So you have the easiness of simulating direct access of a property value but still have the chance to keep control of it.

Nevertheless, this technique has some drawbacks. First, it is not possible that the property has the same name as the get/set methodname. So, if we would have named our property “name” instead of “hiddenName” it would resulted in a compile-time error. In addition, whenever you call the set method - the get method is called automatically as the result of the set method call. This hidden “feature” could also causes some confusion if you do not know that.

In the end it is up to your personal taste if you want to use this feature of actionscript or not. Of course you could implement getters and setters in the standard way writing methods like getHiddenName() and setHiddenName().