Returns whether the Array contains a particular item.

Example :

         import system.Arrays ;
         
         var ar:Array = [2, 3, 4] ;
         
         trace( Arrays.contains(ar, 3) ) ; // true
         trace( Arrays.contains(ar, 5) ) ; // false
         

Initializes a new Array with an arbitrary number of elements (index), with every element containing the passed parameter value or by default the null value.

Example :

   var test:Array  = Arrays.initialize( 3 ); //define [null,null,null]
   var test1:Array = Arrays.initialize( 3, 0 ); //define [0,0,0]
   var test2:Array = Arrays.initialize( 3, true ); //define [true,true,true]
   var test3:Array = Arrays.initialize( 3, "" ); //define ["","",""]
   

Apply a function simultaneously against two values of the array (from left-to-right) as to reduce it to a single value.

The reduce method executes the callback function once for each element present in the array, excluding holes in the array, receiving four arguments: the initial value (or value from the previous callback call), the value of the current element, the current index, and the array over which iteration is occurring.

This method reduce is an extension to the ECMA-262 standard; (see Javascript 1.8 new implementation) as such it may not be present in other implementations of the standard.

The call to the reduce callback would look something like this:

         function callback( previousValue:, currentValue:, index:uint , array:Array ):         {
             // ...
         }
         

The first time the function is called, the previousValue and currentValue can be one of two values. If an initialValue was provided in the call to reduce, then previousValue will be equal to initialValue and currentValue will be equal to the first value in the array. If no initialValue was provided, then previousValue will be equal to the first value in the array and currentValue will be equal to the second.

Basic example :

Example :

         import system.Arrays ;
         
         var ar:Array ;
         var result:;
         var callback:Function ;
         
         ////// only to debug in the the Array trace message
         Array.prototype.toString = function():String
         {
             return "[" + this.join(",") + "]" ;
         }
         //////
          
         ar = [0,1,2,3,4] ;
         
         callback = function( previousValue:, currentValue:, index:int, array:Array ):         {
             trace( "previousValue = " + previousValue + ", currentValue = " + currentValue + ", index = " + index ) ;
             return previousValue + currentValue ;
         } ;
         
         ////
         
         result = Arrays.reduce( ar , callback ) ;
          
         // previousValue = 0, currentValue = 1, index = 1 // First call
         // previousValue = 1, currentValue = 2, index = 2 // Second call
         // previousValue = 3, currentValue = 3, index = 3 // Third call
         // previousValue = 6, currentValue = 4, index = 4 // Fourth call
          
         trace( "value : " + result ) ;  // value : 10
         
         ////
         
         result = Arrays.reduce( ar , callback , 10 ) ;
          
         // previousValue = 10, currentValue = 0, index = 0
         // previousValue = 10, currentValue = 1, index = 1
         // previousValue = 11, currentValue = 2, index = 2
         // previousValue = 13, currentValue = 3, index = 3
         // previousValue = 16, currentValue = 4, index = 4
         
         trace( "value : " + result ) ;  // value : 20
         
         ////
         
         // array is always the object [0,1,2,3,4] upon which reduce was called
         trace( "ar : " + ar ) ; // ar : 0,1,2,3,4
         
         trace("--- Example: Sum up all values within an array") ;
         
         ar = [0, 1, 2, 3] ;
         
         callback = function( a:uint , b:uint , ...args:Array ):         {
             return a + b ; 
         }
         
         result = Arrays.reduce( ar , callback );
         trace("total : " + result ) ; // total == 6
         
         trace("--- Example: Flatten an array of arrays") ;
         
         ar = [[0,1], [2,3], [4,5]] ;
         callback = function( a:Array , b:Array , ...args:Array ):         {
             return a.concat( b ) ;
         }
         
         result = Arrays.reduce( ar , callback , [] ) ;
         trace("flattened is " + result ) ; // flattened is [0, 1, 2, 3, 4, 5]
         

Apply a function simultaneously against two values of the array (from right-to-left) as to reduce it to a single value.

The reduceRight method executes the callback function once for each element present in the array, excluding holes in the array, receiving four arguments: the initial value (or value from the previous callback call), the value of the current element, the current index, and the array over which iteration is occurring.

The call to the reduceRight callback would look something like this :

         function callback( previousValue:, currentValue:, index:uint , array:Array ):         {
             // ...
         }
         

The first time the function is called, the previousValue and currentValue can be one of two values. If an initialValue was provided in the call to reduceRight, then previousValue will be equal to initialValue and currentValue will be equal to the last value in the array. If no initialValue was provided, then previousValue will be equal to the last value in the array and currentValue will be equal to the second-to-last value.

Example :

         import system.Arrays ;
         
         var ar:Array ;
         var result:;
         var callback:Function ;
         
         ////// only to debug in the the Array trace message
         Array.prototype.toString = function():String
         {
             return "[" + this.join(",") + "]" ;
         }
         //////
         
         ar = [0,1,2,3,4] ;
         
         callback = function( previousValue:, currentValue:, index:int, array:Array ):         {
             trace( "previousValue = " + previousValue + ", currentValue = " + currentValue + ", index = " + index ) ;
             return previousValue + currentValue ;
         } ;
         
         result = Arrays.reduceRight( ar , callback ) ;
         // previousValue = 4, currentValue = 3, index = 3 // First call
         // previousValue = 7, currentValue = 2, index = 2 // Second call
         // previousValue = 9, currentValue = 1, index = 1 // Third call
         // previousValue = 10, currentValue = 0, index = 0 // Fourth call
         trace( "value : " + result ) ;  // value : 10
         
         result = Arrays.reduceRight( ar , callback , 10 ) ;
         // previousValue = 10, currentValue = 4, index = 4
         // previousValue = 14, currentValue = 3, index = 3
         // previousValue = 17, currentValue = 2, index = 2
         // previousValue = 19, currentValue = 1, index = 1
         // previousValue = 20, currentValue = 0, index = 0
         trace( "value : " + result ) ;  // value : 20
         
         // array is always the object [0,1,2,3,4] upon which reduce was called
         
         trace( "ar : " + ar ) ; // ar : [0,1,2,3,4]
         
         trace("--- Example: Sum up all values within an array") ;
         
         ar = [0, 1, 2, 3] ;
         
         callback = function( a:uint , b:uint , ...args:Array ):         { 
             return a + b ;
         }
         
         result = Arrays.reduceRight( ar , callback );
         trace("total : " + result ) ; // total == 6
         
         trace("--- Example: Flatten an array of arrays") ;
         
         ar = [[0,1], [2,3], [4,5]] ;
         
         callback = function( a:Array , b:Array , ...args:Array ):         {
             return a.concat( b ) ;
         }
         
         result = Arrays.reduceRight( ar , callback , [] ) ;
         trace("flattened is " + result ) ; // flattened is [4, 5, 2, 3, 0, 1]
         

Returns a new Array who contains the specified Array elements repeated count times.

Example :

         import system.Arrays ;
         
         var ar:Array = [2, 3, 4] ;
         
         trace( Arrays.repeat(ar, 0) ) ; // 2,3,4
         trace( Arrays.repeat(ar, 3) ) ; // 2,3,4,2,3,4,2,3,4
         

Splice one array into another. Like the python

     container[containerPosition:containerPosition + countReplaced] = inserted
     

     import system.Arrays ;
     
     var inserted:Array  ;
     var container:Array ;
     
     inserted  = [1, 2, 3, 4] ;
     container = [5, 6, 7, 8] ;
     
     trace( "inserted  : " + inserted  ) ;
     trace( "container : " + container ) ;
     
     trace("---") ;
     
     inserted  = [1, 2, 3, 4] ;
     container = [5, 6, 7, 8] ;
     
     Arrays.spliceInto( inserted, container ) ;
     trace( "Arrays.spliceInto( inserted, container, 0 , 0 ) : " + container ) ; // 1,2,3,4,5,6,7,8
     
     trace("---") ;
     inserted  = [1, 2, 3, 4] ;
     container = [5, 6, 7, 8] ;
     
     Arrays.spliceInto( inserted, container, 0 , 4 ) ;
     trace( "Arrays.spliceInto( inserted, container, 0 , 4 ) : " + container ) ; // 1,2,3,4
     
     trace("---") ;
     
     inserted  = [1, 2, 3, 4] ;
     container = [5, 6, 7, 8] ;
     
     Arrays.spliceInto( inserted, container, 0 , 2 ) ;
     trace( "Arrays.spliceInto( inserted, container, 0 , 4 ) : " + container ) ; // 1,2,3,4,7,8