Passing …(rest) parameters between functions

http://www.ericfeminella.com/blog/2008/04/22/passing-rest-parameters-between-functions/

 

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:

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

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 ] ) ;      } } 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:

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] ); } }

1 2 3 4 5 6 7 8 9 10 11 12

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:

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

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

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:

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

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

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.