CODEWITHSUNDEEP
actionscript-3
djip.co
djip.co

Reputation: 1037

How can I define a boolean function argument to be optional?

In ActionScript 3, is there a clean way to define a function that accepts an optional boolean argument ? As you may know, this is invalid : 

public function test(param:Boolean = null):void {
    trace(param);
}

This triggers the following error: VerifyError: Error #1102: Illegal default value for type Boolean. Since, Boolean is a primitive, I guess it makes sense that it cannot be set to null. The only workaround I found is to cast the parameter to an object : 

public function test(param:Object = null):void {
    trace(Boolean(param));
}

However, this does not feel very clean, particularly if you are developing libraries. ASDoc will generate API documentation that says the expected parameter is an Object whereas what is really needed is a Boolean.

Is there a better approach ?

Upvotes: 0

Views: 2137

Answers (4)

Marty
Marty

Reputation: 39456

There was a tonne of discussion on my previous answer, but this is the correct way to have a function that accepts one of three states. My previous answer attempted to retain the use of a Boolean value like you were requesting, but that is not the right way to go about it.

Create a class that defines three values:

class State
{
    public static const EMPTY:int = -1;
    public static const FALSE:int = 0;
    public static const TRUE:int = 1;
}

Your function will accept an int (the type of each of the three properties within your State class). It will deal with the three possible values. You can use concise commenting to notify the developer of what thee values the function is expecting, referencing the State class. The default value can be -1 aka State.EMPTY.

/**
 * Function description.
 * @param state One of three states, defined by State.
 */
function test(state:int = -1):void
{
    switch(state)
    {
        case State.EMPTY:
            // No value given.
        break;

        case State.TRUE:
            // True.
            //

        break;

        case State.FALSE:
            // False.
            //

        break;

        default:
            throw new ArgumentError("Unsupported value for test()");
        break;
    }
}

Upvotes: 0

djip.co
djip.co

Reputation: 1037

From the good suggestions and discussion above I think that, in a library scenario and for simplicity's sake, the best way remains to type the parameter as Object with a default value of null but to request a Boolean in the API documentation :

/**
 * @param param Boolean object or null
 */
public function test(param:Object = null):void {
    trace(Boolean(param));
}

This allow the user of the library to pass a either a Boolean or nothing at all. Thanks everyone.

Upvotes: 0

duTr
duTr

Reputation: 714

As you said Boolean can not be set to null value.

Therefore, you should specify a default value that is either true or false.

public function test(param:Boolean = false):void {
    trace(param);
}

But because you need the third case where nothing is set, one option could be to accept any Object but throw an exception if it is not null and not a boolean:

    public function test(param:* = null):void
    {
        if (param != null)
        {
            if ((param == true) || (param == false))
            {
                trace(Boolean(param).toString());
            }
            else
            {
                throw new CustomError("param should be a boolean");
            }
        }
        else
        {
            // Do nothing
        }
    }

Note that this solution also accept objects or primitives that can be compared to true or false such as 0, 1, or [].

Upvotes: 2

Marty
Marty

Reputation: 39456

When you say optional, I assume that you mean if there isn't a value supplied then something different should happen compared to if you had a default value of true or false.

You could make your own object to handle the three states that you need and maintain code readability by using a class like this:

public class Condition
{

    private var _value:* = null;


    public function Condition(initial:* = null)
    {
        value = initial;
    }


    public function set value(n:*):void
    {
        if(_value === null || _value === false || _value === true)
        {
            _value = n;
        }
    }


    public function get value():*{ return _value; }

}

And then your function could be:

function test(param:Condition = null):void
{
    if(param && param.value != null)
    {
        trace(param.value);
    }
}


test( new Condition() );
test( new Condition(true) );

Upvotes: 2

Related Questions