public function t()
{
  if(xxx)return xxx;
  //don't return anything
}

How to define the return type for such method?

A function either has to return nothing, or return something - it can't do both. The reason being, what if you write this code:

var someValue = someFunction();

How would this code be handled if sometimes someFunction returned a value, and sometimes it didn't?

Your problem is a really common one, though, and there are several ways to work around it.

Sentinel Values

You can return special-case values that you treat as non-values (such as null, NaN, "", or -1). These special-case values are called sentinel values. The users of your function (maybe your own code) would check the result after calling it. If it gets one of the sentinel values back, it doesn't use the result.

Try-style Functions

You could also use a pattern commonly used in C#/.Net that they call "Try-methods", but you can call "Try-functions". Actionscript doesn't work exactly like C#, but we can get close enough for this pattern to work.

To do this, return Boolean, returning true if you have a value, and false if you don't. Then give your function an Object parameter, and populate a property with the actual return value:

function trySomeFunction(result:Object) : Boolean
{
    if(xxx)
    {
        result.Value = xxx;
        return true;
    }

    return false;
}

// ...

var result:Object = { Value:null };

if(trySomeFunction(result))
{
    // Do something with the value here
}

Exceptions

If your method failed to do what it promised to do, you can throw an exception. Then you don't have to worry about what gets returned, because your code just dies.

Exceptions are great because people who call your code don't have to learn as much. They don't have to know that your function only succeeded if it doesn't return some magic value that is different for every function, they don't need to check if your function returns true/false, and they don't need to know that some property gets populated on an object when the function succeeded.

Without exceptions, if they forget to check for your special value, or the result of a "Try-function", an error might happen further on in the program. Or it might not happen at all, and the program will continue running, but be broken. In these cases, it is much harder to track down the problem.

With exceptions, your code just blows up the second it detects a problem, and gives you the line of code where your program realized it couldn't work correctly.

If it is normal and okay for your function to fail, though, you probably shouldn't throw an exception. You should probably use a "Try-function" or a sentinel value instead.

more