At some point when developing an application with ActionScript 3 you may need to pass a …(rest) parameter to a subsequent function call, and although at first this may appear to be pretty straightforward, doing so will not produce the results one might expect.
For example, consider the following method doSomething which accepts a single …rest parameter:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 | public function doSomething(...rest) : void { var n:int = rest.length; trace( "...rest.length = " + n ); for (var i:int = 0; i < n; i++) { trace( rest[i] ); } } doSomething("a","b","c"); // outputs: // ...rest.length = 3 // a // b // c |
Let’s say we also have another function we need to invoke called doSomethingElse which accepts a …(rest) parameter as well:
1 2 3 4 5 6 7 8 9 | public function doSomethingElse(...rest) : void { var n:int = rest.length; trace( "...rest.length = " + n ); for (var i:int = 0; i < n; i++) { trace( rest[i] ); } } |
Now suppose we need to pass the ...(rest) parameter from the doSomething function to the doSomethingElse function. The result would be as follows:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 | public function doSomething(...rest) : void { var n:int = rest.length; trace( "...rest.length = " + n ); for (var i:int = 0; i < n; i++) { trace( rest[i] ); } doSomethingElse( rest); } // doSomething outputs: // ...rest.length = 3 // a // b // c // doSomethingElse outputs: // ...rest.length = 1 // a,b,c |
So what went wrong? What happens is the original …rest parameter (passed to doSomething) is now being passed as a single parameter of type Array to the subsequent function (doSomethingElse), not as an Array of individual arguments as you may have expected.
This can easily be resolved by using Function.apply(); as can be seen in the following:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 | public function doSomething(...rest) : void { var n:int = rest.length; trace( "...rest.length = " + n ); for (var i:int = 0; i < n; i++) { trace( rest[i] ); } doSomethingElse.apply( null, rest); } // doSomething outputs: // ...rest.length = 3 // a // b // c // doSomethingElse outputs: // ...rest.length = 3 // a // b // c |
What we are doing is applying the call to the doSomethingElse function with the original rest parameter as if we were invoking the function directly. So keep this in mind should you ever need to pass a …rest parameter to a subsequent function.
Never needed that, but good to know for when it’ll happen 🙂
Thanks,
{Maz}
I typically have run into this problem when developing High Level APIs such as Managers or Wrapper classes whereas a method is essentially wrapping a composite object and passing the parameters to another method.
Enjoy,
Eric
Excelent !
i had the problem, and solve it using a switch with the rest length!
perfect
thanksCR
Eric,
This quick tip section of your blog rules.
Nice work,
-Augie
I like this one
Eric,
Thank for the tip. It is a shame I couldn’t get this to work when I was calling a Proxy.
Best,
al
Hi Eric,
You are a life saver. This cost me many hours of research until I found this blog entry. Thanks a million!