Export (0) Print
Expand All
Expand Minimize

about_Arrays

Updated: August 9, 2012

Applies To: Windows PowerShell 2.0, Windows PowerShell 3.0

TOPIC
    about_Arrays

SHORT DESCRIPTION
    Describes arrays, which are data structures designed to store 
    collections of items.

LONG DESCRIPTION
    An array is a data structure that is designed to store a collection 
    of items. The items can be the same type or different types.

    Beginning in Windows PowerShell 3.0, a collection of zero or one
    object has some properties of arrays. 


 CREATING AND INITIALIZING AN ARRAY
    To create and initialize an array, assign multiple values to a variable.
    The values stored in the array are delimited with a comma and separated
    from the variable name by the assignment operator (=). 

    For example, to create an array named $A that contains the seven
    numeric (int) values of 22, 5, 10, 8, 12, 9, and 80, type:

        $A = 22,5,10,8,12,9,80

    You can also create and initialize an array by using the range 
    operator (..). For example, to create and initialize an array named 
    "$B" that contains the values 5 through 8, type:

        $B = 5..8

    As a result, $B contains four values: 5, 6, 7, and 8.

    When no data type is specified, Windows PowerShell creates each array as
    an object array (type: System.Object[]). To determine the data type of an array, 
    use the GetType() method. For example, to determine the data type of the
    $a array, type:

        $a.GetType()

    To create a strongly typed array, that is, an array that can contain only
    values of a particular type, cast the variable as an array type, such 
    as string[], long[], or int32[]. To cast an array, precede the variable
    name with an array type enclosed in brackets. For example, to create a
    32-bit integer array named $ia containing four integers (1500, 2230, 3350,
    and 4000), type:

        [int32[]]$ia = 1500,2230,3350,4000

    As a result, the $ia array can contain only integers.

    You can create arrays that are cast to any supported type in the
    Microsoft .NET Framework. For example, the objects that Get-Process 
    retrieves to represent processes are of the System.Diagnostics.Process 
    type. To create a strongly typed array of process objects, enter the 
    following command:

        [Diagnostics.Process[]]$zz = Get-Process

 THE ARRAY SUB-EXPRESSION OPERATOR
    The array sub-expression operator creates an array, even if it 
    contains zero or one object.

    The syntax of the array operator is as follows:
        @( ... )

    You can use the array operator to create an array of zero or 
    one object. 

        PS C:\>$a = @("One")
        PS C:\>$a.Count
        1

        PS C:\>$b = @()
        PS C:\>$b.Count
        0

    The array operator is particularly useful in scripts when
    you are getting objects, but do not know how many objects 
    you will get. 

        PS C:\> $p = @(Get-Process Notepad)

 
    For more information about the array sub-expression operator,
    see about_Operators.

 
  READING AN ARRAY
    You can refer to an array by using its variable name. To display all 
    the elements in the array, type the array name. For example:

$a

    You can refer to the elements in an array by using an index, beginning
    at position 0. Enclose the index number in brackets. For example,
    to display the first element in the $a array, type:

        $a[0]

    To display the third element in the $a array, type:

        $a[2]

    Negative numbers count from the end of the array. For example, "-1" 
    refers to the last element of the array. To display the last three elements
    of the array, type:

        $a[-3..-1]

    However, be cautious when using this notation.

        $a[0..-2]

    This command does not refer to all the elements of the array, except for 
    the last one. It refers to the first, last, and second-to-last elements
    in the array.
   
    You can use the range operator to display a subset of all the values in an 
    array. For example, to display the data elements at index position 1 
    through 3, type:

        $a[1..3]

    You can use the plus operator (+) to combine a range with a list of
    elements in an array. For example, to display the elements at index
    positions 0, 2, and 4 through 6, type:

        $a[0,2+4..6]

    To determine how many items are in an array, use the Length property
    or its Count alias.

        $a.Count


    You can also use looping constructs, such as ForEach, For, and While loops,
    to refer to the elements in an array. For example, to use a ForEach loop
    to display the elements in the $a array, type: 

        foreach ($element in $a) {$element}
 
    The Foreach loop iterates through the array and returns each value in
    the array until reaching the end of the array.

    The For loop is useful when you are incrementing counters while examining
    the elements in an array. For example, to use a For loop to  return every
    other value in an array, type:

        for ($i = 0; $i -le ($a.length - 1); $i += 2) {$a[$i]}

    You can use a While loop to display the elements in an array until a 
    defined condition is no longer true. For example, to display the elements
    in the $a array while the array index is less than 4, type:

        $i=0
        while($i -lt 4) {$a[$i]; $i++}



 GET THE MEMBERS OF AN ARRAY

    To get the properties and methods of an array, such as the Length 
    property and the SetValue method, use the InputObject parameter of the
    Get-Member cmdlet. 

    When you pipe an array to Get-Member, Windows PowerShell sends the items 
    one at a time and Get-Member returns the type of each item
    in the array (ignoring duplicates). 

    When you use the InputObject parameter, Get-Member returns the
    members of the array. 

    For example, the following command gets the members of the array in the
    $a variable.

        Get-Member -InputObject $a

    You can also get the members of an array by typing a comma (,) before
    the value that is piped to the Get-Member cmdlet. The comma makes the 
    array the second item in an array of arrays. Windows PowerShell pipes
    the arrays one at a time and Get-Member returns the members of the array. 

        ,$a | Get-Member

        ,(1,2,3) | Get-Member


 MANIPULATING AN ARRAY
    You can change the elements in an array, add an element to an array, and
    combine the values from two arrays into a third array.

    To change the value of a particular element in an array, specify the
    array name and the index of the element that you want to change, and then
    use the assignment operator (=) to specify a new value for the element. For
    example, to change the value of the second item in the $a array (index
    position 1) to 10, type:

        $a[1] = 10

    You can also use the SetValue method of an array to change a value. The
    following example changes the second value (index position 1) of the $a
    array to 500:

        $a.SetValue(500,1)

    You can use the += operator to add an element to an array. When you use
    it, Windows PowerShell actually creates a new array with the values of the
    original array and the added value. For example, to add an element with a 
    value of 200 to the array in the $a variable, type:

        $a += 200

    It is not easy to delete elements from an array, but you can create a new
    array that contains only selected elements of an existing array. For
    example, to create the $t array with all the elements in the $a array 
    except for the value at index position 2, type:

        $t = $a[0,1 + 3..($a.length - 1)]

    To combine two arrays into a single array, use the plus operator (+). The
    following example creates two arrays, combines them, and then displays
    the resulting combined array.

        $x = 1,3
        $y = 5,9
        $z = $x + $y

    As a result, the $z array contains 1, 3, 5, and 9.


    To delete an array, assign a value of $null to the array. The following
    command deletes the array in the $a variable. 

        $a = $null

    You can also use the Remove-Item cmdlet, but assigning a value of $null
    is faster, especially for large arrays.



 ARRAYS OF ZERO OR ONE
    Beginning in Windows PowerShell 3.0, a collection of zero or one object 
    has the Count and Length property. Also, you can index into an array of
    one object. This feature helps you to avoid scripting errors that occur 
    when a command that expects a collection gets fewer than two items.

    The following examples demonstrate this feature.    
    
    #Zero objects
        $a = $null
        $a.Count
        0
        $a.Length
        0

    #One object
        $a = 4
        $a.Count
        1
        $a.Length
        1
        $a[0]
        4
        $a[-1]
        4


SEE ALSO
    about_Assignment_Operators
    about_Hash_Tables
    about_Operators
    about_For
    about_Foreach
    about_While



Was this page helpful?
(1500 characters remaining)
Thank you for your feedback
Show:
© 2014 Microsoft