PowerShell Variables and Arrays

In the previous article, named PowerShell Scripting Tutorial for Beginners, we explored how to use the PowerShell console to execute scripts and learned what cmdlets are, how to get their properties and how to use pipes to pass data from one cmdlet to another. In this article, we will move on to variables and arrays, including what they are and how we can create, remove and change them.

PowerShell Variables

A variable is a unit of memory in which values are stored. A variable in PowerShell begins with “$” (dollar sign) and its name can contain any letters, numbers and underscores. To assign a value to a variable, we use the “=” operator. To display the value of a variable, simply enter the variable. The following commands assign a value to a variable and then verify it:

$var1 = 777
$var1

PowerShell Variables and Arrays assign a value

You can perform arithmetic operations over numbers:

$var1 = 777
$var2 = 333
$var3 = $var1 + $var2
$var3

PowerShell_Variables_Assign_Value_Numbers

You can also combine strings using the “+” operator:

$var1 = "Complete"
$var2 = "Visibility"
$var3 = $var1 + $var2
$var3

PowerShell_Variables_Combine_Strings

If you add a number to a string, the number automatically becomes a string:

$var1 = "Netwrix"
$var2 = 2018
$var3 = $var1 + $var2
$var3

owerShell_Variables_Combine_Strings_Add_Plus

Variable Types

The PowerShell variable type is set automatically based on the value you assign to it, but you can also assign the type manually:

[string]$var1 = "Netwrix"

PowerShell_Variables_Assign type

To find out what type a variable is, we use the “GetType ()” parameter:

$var1 = "Netwrix"
$var1.GetType().FullName

As we can see, our $var1 variable has the “System.String” type.

Here are descriptions of all the PowerShell variable types:

Variable Type Description Example
[string]
System.String
Text string $var1 = "Netwrix"
[char]
System.Char
Symbol[char]$var1 = 0x265b
[bool]
System.Boolean
Boolean (value can be $true or $false)$var1 = $true
[int]
System.Int32
32-bit integer$var2 = 235235345
[long]
System.Int64
64-bit integer$var2 = 2352353457
[decimal]
System.Decimal
128-bit decimal number with the letter “d” at the end$var2 = 23523.53456d
[double]
System.Double
8-byte decimal floating point number[double]$var2 = 23523.53456
[single]
System.Single
32-bit floating point number[single]$var2 = 23523.53
[DateTime]
System.DateTime
Date and time $var3 = get-date
[array]
System.Object[]
Array (discussed in detail later in this article)$var3 = "first", "second", "third"
[hashtable]
System.Collections.Hashtable
Hash table
The difference between hash tables and arrays is that indexes are used in arrays, and named keys are used in hash tables. Hash tables are built using the following format: @ {key = "value"}
To add an item to a hash table, you can either assign it a key that does not already exist or use the Add () method. If the assignment is made to an existing key, the value of the key changes to the assigned one. To remove an item from a hash table, use the Remove () method.
$var3 = @{1="one"; 2="two"; 3="three"}

$var3.Add("4", "four")
$var3.5 = "five"
$var3.Remove("2")

You probably already understood that you can write to the variable not only some definite value and noticed the class System.Object [] in the table. To this variable you can write the output of any cmdlet.

Variable Scope

The variable scope in PowerShell can be either local or global. By default, a variable has a local scope. A variable is bounded by its current scope; for example, a local variable can be available in a current function or script, while a global variable is active throughout the current PowerShell session. To denote a global variable, use the format $Global: variable = value, as illustrated in the following command:

$Global:var4 = 12

PowerShell Variable Examples

List variables

To list all current available variables, run the ls variable:* command. Here is an example of the output:

PowerShell_Variables_List

Set variable

You can create a variable by simply assigning it a value. For example, the command $var4 = “variableexample” creates a variable named $var4 and assigns it a string value. The double quotes (” “) indicate that a string value is being assigned to the variable.

Get variable

This is very similar to the list variable command, just using another cmdlet:

Get-Variable | Out-String

Print variable

You can output a variable a .txt, .csv or HTML file.

To write to a .txt file, use the Out-File command:

$var5 = "Hello World!"
$var5 | Out-File C:\scripts\Hello_World.txt

To export data to a .csv file, use the Export-Csv command:

$var6 = Get-Process
$var6 | SELECT Name, Path | Export-Csv -Path C:\scripts\processes.csv

PowerShell_Variables_print

And to write to an HTML file, use the ConvertTo-Html command:

$var6 = Get-Process
$var6 | ConvertTo-Html -Property Name, Path > C:\scripts\processes.html

To read a file that we exported, we use the Get-Content cmdlet:

Get-Content C:\scripts\processes.csv

Clear variable

To clear the contents of a variable, use the Clear-Variable cmdlet:

Clear-Variable -name var6 #without $

Remove variable

To completely remove a variable, use the Remove-Variable cmdlet:

Remove-Variable -name var6 #without $

PowerShell Arrays

An array is a type of a variable. It is a set of components (array elements) arranged in a certain order. Elements of the array are numbered sequentially, and you access an element using its index number.

When creating arrays, be aware of the default PowerShell behavior. If you create an array with multiple elements, PowerShell will create an array, as you intend. For example, put a few numbers into an array and then check the data type of the variable:

$array1 = 1, 2, 3
$array1.GetType()

As you can see, in this case, PowerShell created an array (System.Array).

However, if you put just one value in a variable, then PowerShell will not create an array:

$array1 = 1
$array1.GetType()

PowerShell_Variables_One value

Of course, you cannot always tell in advance how many objects will be received as a result of executing a particular command, so you need to have code that will always treat the result as an array.

You can do this in many ways. For example, you can use the “,” operator. If a comma is used as a binary operator, then a normal array is created; if it is used as a unary operator, the array has just one element. For example, here is how we can get an array consisting of one element:

$array1 = ,1
$array1.GetType()

PowerShell_Variables_Array_one element

Alternatively, you can explicitly specify the data type for a variable:

[object[]]$array1 = 1
$array1.GetType()

Finally, you can also create an array using subexpression operator “@“, which forms an array even if no objects at all are specified. It is very convenient to initialize a variable as an array, and then add objects to it without worrying about their number.

$array3 = @()
$array3.GetType()

PowerShell_Variables_Create array

Note that each element of an array has its own data type, and the type object[] allows you to add any values to the array. If necessary, you can restrict the members of the array to a specific data type — then you’re creating a “typed array”. For example, you can specify that array elements must be integer values:

[int32[]]$array1 = 1
$array1.GetType()

And so we define system processes as array members:

[System.Diagnostics.Process[]]$array1 = Get-Process
$array1.GetType()

PowerShell_Variables_Define systems processes as array members

Array List

If you will modify or search an array frequently, you can use the ArrayList class, which is designed to let you easily add, remove, and search for items in it:

$array3 = New-Object System.Collections.ArrayList

Array Index

An index in the array is a value, typically a numeric integer used to identify and reference an array element. Array indexes start at either zero or one, depending on the programming language. Windows

PowerShell arrays are zero-based, so to refer to the first element of the array $var3 (“element zero”), you would write $var3 [0].

$var3 = "first", "second", "third"

PowerShell__Array_Element zero

Multidimensional Arrays

Multidimensional arrays are variables that can be used to store information in a table without having to write it to a real database. It looks like a hash table, but it can store different types of information, such as strings and integers. In fact, you can imagine a multidimensional array as a table with columns and rows, where each cell has its own index inside a PowerShell environment.

$mdarray1 = @()
$mdarray1_counter ++
$mdarray1 += ,@($mdarray1_counter, 'Earth',12742)
$mdarray1_counter ++
$mdarray1 += ,@($mdarray1_counter, 'Mars',6779)
$mdarray1_counterr ++
$mdarray1 += ,@($mdarray1_counter, 'Venus',12104)
$mdarray1_counter ++
$mdarray1 += ,@($mdarray1_counter, 'Saturn',116464)
foreach($array10 in $mdarray1)
    {
    Write-host ($array10)
    }

PowerShell_Multidimesional arrays

PowerShell Array Examples

Sort array

If an array contains only one data type, you can sort the values using the Sort method:

$array3 | Sort

To sort an array with more than one data type, you need to use the Sort-Object cmdlet.

Add to array

First, let’s create an array:

$array5 = "one", "two", "three", "four", "five"
$array5.gettype()

PowerShell_Add to array

To easily modify our array, we need to add it to the arraylist collection:

[System.Collections.ArrayList]$ArrayList1 = $array5
$ArrayList1.GetType()

PowerShell_Modify array

As you can see, the BaseType has changed and we can easily modify our array now:

$ArrayList1.Add("six")
$ArrayList1.Remove("three")
$ArrayList1

PowerShell_Modify array base type

Array length

To return the number of elements in array, use the .length parameter:

$array6 = 1,2,3,4,5,6
echo $array6.Length

PowerShell_Array length

Remove item from array

To remove an item, use the .Remove command. Again, it is better to use an arraylist:

[System.Collections.ArrayList]$ArrayList1 = $array5
$ArrayList1.GetType()
$ArrayList1.Remove("three")
$ArrayList1

PowerShell_Remove item from array

Array contains

If you want to see if any of the elements in an array contains a particular value, use the Contains method:

$array7 = 1,2,5,8,3,4,5
$array7.Contains(2)
$array7.Contains(12)

PowerShell__Array contains

Clear array

Even though most of the array operations in PowerShell are relatively easy to accomplish, there is no simply way to delete an array. The easiest way to get rid of an entire array is to assign the variable $null to it:

$array7 = $null
$array7

To check if our array is null, run the following script:

$array7 -eq $null

PowerShell_Clear array

In PowerShell, if a variable is null, you can’t apply any methods to it.

Print array

To print a whole array, we can use the same methods described for printing variables.

To write to a .txt file, use the Out-File command:

$var5 | Out-File C:\scripts\array.txt

To export to a .csv file, use the Export-Csv command:

$var6 | Export-Csv -Path C:\scripts\array.csv

And to write to an HTML file, use the ConvertTo-Html command:

$var6 | ConvertTo-Html > C:\scripts\processes.html

Loop through an array

In order to handle each element in an array one after another, we need to make a loop using the foreach operator. For example if we declare a string array and want to count the length of each word in the array, we should run the following script:

$array8 = @("Earth","Mercury","Venus","Jupiter","Saturn","Mars", "Neptune", "Pluto")

 foreach ($array in $array8) {
   "$array = " + $array.length
 }

PowerShell_Loop through an array

In this article, we learned about variables and their types. Then we explored one variable type — the array— in detail and learned how to play with it. With this information, you are ready to dive into PowerShell even deeper.