Errors in ActionScript

In ActionScript, error handling is typically done using try-catch blocks and throwing exceptions. While it doesn’t have a built-in error type like Go, we can create custom Error classes to achieve similar functionality.

package {
    import flash.display.Sprite;
    import flash.errors.IllegalOperationError;

    public class ErrorExample extends Sprite {
        // Custom Error classes
        public class TeaError extends Error {
            public function TeaError(message:String) {
                super(message);
            }
        }

        public class OutOfTeaError extends TeaError {
            public function OutOfTeaError() {
                super("No more tea available");
            }
        }

        public class PowerError extends TeaError {
            public function PowerError() {
                super("Can't boil water");
            }
        }

        // Function that may return an error
        public function f(arg:int):Object {
            if (arg == 42) {
                return {error: new Error("Can't work with 42")};
            }
            return {result: arg + 3};
        }

        // Function that may throw custom errors
        public function makeTea(arg:int):void {
            if (arg == 2) {
                throw new OutOfTeaError();
            } else if (arg == 4) {
                throw new PowerError();
            }
        }

        public function ErrorExample() {
            var args:Array = [7, 42];
            for each (var i:int in args) {
                var result:Object = f(i);
                if (result.error) {
                    trace("f failed:", result.error.message);
                } else {
                    trace("f worked:", result.result);
                }
            }

            for (var j:int = 0; j < 5; j++) {
                try {
                    makeTea(j);
                    trace("Tea is ready!");
                } catch (e:OutOfTeaError) {
                    trace("We should buy new tea!");
                } catch (e:PowerError) {
                    trace("Now it is dark.");
                } catch (e:Error) {
                    trace("Unknown error:", e.message);
                }
            }
        }
    }
}

In this ActionScript example, we’ve implemented error handling in a way that’s similar to the original code, with some adaptations to fit ActionScript’s language features:

We define custom Error classes (TeaError, OutOfTeaError, and PowerError) to represent different error types.
The f function returns an object with either a result or an error property, simulating Go’s multiple return values.
The makeTea function throws custom exceptions instead of returning errors.
In the main logic, we use try-catch blocks to handle exceptions, which is the idiomatic way to handle errors in ActionScript.
We use trace instead of fmt.Println for console output.

To run this ActionScript code, you would typically compile it into a SWF file and run it in the Flash Player or AIR runtime. The output would be similar to the original, showing how different errors are handled and reported.

This example demonstrates error handling, custom error types, and exception throwing and catching in ActionScript, providing functionality similar to the original Go code while using ActionScript’s language features and idioms.

Range Over Iterators in ActionScript

Custom Errors in ActionScript

Learn X By Example

Title here

Errors in ActionScript