PowerShell provides a variety of mechanisms to store, retrieve, and manipulate data used in your scripts. These storage "containers" are referred to as variables, arrays, and hashes. They can be used as containers to store strings, integers, or objects. These containers are dynamic as they automatically detect what type of data is being placed within them. Unlike other object-oriented languages, there is no need to declare the container prior to use. To declare one of these containers, you use the dollar sign ($) and the container name.
An example of a container would look like this:
$myVariable
During this chapter, you will learn the following concepts:
Variables
Arrays
Hashes
Deciding the best container for your scripts
When you are creating names for containers, it is industry best practice to use names that are representative of the data they are storing. While containers are not case sensitive in PowerShell, it is a common practice to use camelCase when writing container names. camelCase is achieved by keeping the first letter of the container lowercase and the subsequent first letters of each word capitalized. Some variations of camelCase permit the first letter to be capitalized. This formatting aids in easy reading of the containers.
An example of a container using camelCase would look like this:
$webServerIPAddress
Variables are one of the most widely used containers in PowerShell due to their flexibility. A variable is a container that is used to store a single value or an object. Variables can contain a variety of data types including text (string), numbers (integers), or an object.
If you want to store a string, do the following:
$myString = "My String Has Multiple Words" $myString
The output of this is shown in the following screenshot:
The preceding variable will now contain the words My String Has Multiple Words. When you output the $myString variable, as shown in the preceding screenshot, you will see that the string doesn't contain the quotations. This is because the quotations tell the PowerShell command-line interpreter to store the value that is between the two positions or quotations.
Tip
You are able to reuse variables without deleting the content already inside the variable. The PowerShell interpreter will automatically overwrite the data for you.
Subsequently, if you want to store a number, do the following:
$myNumber = 1 $myNumber
The output of this is shown in the following screenshot:
This method differentiates while storing a string as you do not use quotations. This will tell the PowerShell interpreter to always interpret the value as a number. It is important to not use quotations while using a number, as you can have errors in your script if the PowerShell interpreter mistakes a number for a string.
An example of what happens when you use strings instead of integers can be seen here:
$a = "1" $b = "2" $c = $a + $b $c
The output of this is shown in the following screenshot:
The $c variable will contain the value of 12. This is due to PowerShell interpreting your $a string of 1 and $b string of 2 and putting the characters together to make 12.
The correct method to do the math would look like this:
$a = 1 $b = 2 $c = $a + $b $c
The output of this is shown in the following screenshot:
Since the $a and $b variables are stored as numbers, PowerShell will perform the math on the numbers appropriately. The $c variable will contain the correct value of 3.
Objects are vastly different than strings and numbers. Objects in PowerShell are data structures that contain different attributes such as properties and methods with which one can interact. Object properties are descriptors that typically contain data about that object or other related objects. Object methods are typically sections of code that allow you to interact with that object or other objects on a system. These objects can easily be placed in variables. You can simply place an object in a variable by declaring a variable and placing an object in it. To view all of the object's attributes, you can simply call the variable containing the object, use a pipe character |, and use the get-member cmdlet.
To place an object in a variable and retrieve its attributes, you need to do this:
$date = get-date $date $date | get-member
The output is shown in the following screenshot:
In this example, you will learn how to place an object into a variable. You first start by declaring the $date variable and setting it equal to the output from the get-date cmdlet. When you execute this, the get-date cmdlet references the System.Date class, and the $date variable inherits all of that object's attributes. You then call the $date variable and you see that the output is the date and time from when that command was run. In this instance, it is displaying the DateTime ScriptProperty attribute on the screen. To view all of the attributes of the System.Date object in the $date variable, you pipe those results to the get-member cmdlet. You will see all of the attributes of that object displayed on the screen.
If you want to use the properties and method attributes of that object, you can simply call them using dot notation. This is done by calling the variable, followed by a period, and referencing the property or method.
To reference an object's properties and method attributes, you need to do this:
$date = get-date $date.Year $date.addyears("5")
The output of this is shown in the following screenshot:
This example shows you how to reference an object's properties and method attributes using dot notation. You first start by declaring the $date variable and setting it equal to the output from the get-date cmdlet. When you execute this, the get-date cmdlet references the System.Date class, and the $date variable inherits all of that object's attributes. You then leverage dot notation to reference the Year property attribute by calling $date.Year. The attribute will return 2015 as the Year property. You then leverage dot notation to use the AddYears() method to increase the years by 5. After entering the $date.addyears("5") command, you will see an output on the screen of the same month, day, and time; however, the year is incremented by 5 years.
Arrays are the second most used containers in PowerShell. An array, in simple terms, is a multi-dimensional variable or a variable containing more than one value. The two core components to an array are the index number and the position value. When you use an array, you reference an index number and it will return the position value.
The following table represents an array with a single dimension:
|
Index number |
Position value |
|---|---|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
When you are storing, manipulating, or reading the data in an array, you have to reference the position in the array the data is residing. The numbers populated in the table's Index number column are representative of the location within the array. You will see that array's numbering starts at the number 0, and so the first data would be in cell 0. If you call the array at position 0, the result would be the position value of Example 1. When building the array, you will see that each value in the array values is separated by a comma. This tells the PowerShell interpreter to set a new array value.
First, you can start by building the array in the preceding table by entering the following command:
$myArray = "Example 1", "Example 2", "Example 3", "Example 4", "Example 5" $myArray
The output of this is shown in the following screenshot:
The preceding example displays how to create an array of strings. You first start by declaring a variable named $myArray. You then place multiple strings of text separated by commas to build the array. After declaring the array, you call the $myArray array to print the values to the console. It will return Example 1, Example 2, Example 3, Example 4, and Example 5.
Retrieving data at a specific position in an array is done through the use of brackets. To retrieve the value of 0 from the array, you would do the following:
$myArray = "Example 1", "Example 2", "Example 3", "Example 4", "Example 5" $myArray[0]
The output of this is shown in the following screenshot:
The preceding example displays how you can obtain array data at a specific position. You first start by declaring a variable named $myArray. You then place multiple strings of text separated by commas to build the array. After declaring the array, you call $myArray[0] to access the position value of index number 0 from the array. The preceding example returns the value of Example 1 for the index number 0.
Arrays can become more complex as you start adding dimensions. The following table represents a jagged array or an array of arrays:
|
Index number |
Position value 0 |
Position value 1 |
|---|---|---|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
While accessing data in a jagged array, you will need to read the cell values counting at 0 for both dimensions. When you are accessing the data, you start reading from the index number first and then the position value. For example, the Example 1 data is in the index number of 0 and the position value of 0. This would be referenced as position [0][0]. Subsequently, the data
Blue is in the index number of 4 and position value of 1. This would be referenced as position [4][1].
To do this for yourself, you can build the preceding table by entering the following command:
$myArray = ("Example 1","Red"), ("Example 2","Orange"), ("Example 3", "Yellow"), ("Example 4", "Green"), ("Example 5", "Blue") $myArray[0][0] $myArray[4][1]
The output is shown in the following screenshot:
This example displays how to create a jagged array and accessing values in the array. You first start building the jagged array by declaring the first array of "Example 1" "Red", second array of "Example 2" "Orange", third array of "Example 3" "Yellow", fourth array of "Example 4" "Green", and fifth array of "Example 5" "Blue". After building the array, you access the word Example 1 by referencing $myArray[0][0]. You then access the word Blue by referencing $myArray[4][1].
After you create an array, you may need to update the values inside the array itself. The process for updating values in an array is similar to retrieving data from the array. First you need to find the cell location that you want to update, and then you need to set that array location as equal to the new value:
|
Index number |
Position value 0 |
Position value 1 |
|---|---|---|
|
|
|
|
|
|
|
|
Given the preceding table, if Jane's last name needed to be updated to display Doe instead of Smith, you would first need to locate that data record. That incorrect last name is located at index number 1 and position value 1, or [1][1]. You will then need to set that data location equal (=) to Doe.
To do this, you need to enter the following command:
$myArray = ("John","Doe"), ("Jane","Smith") $myArray $myArray[1][1] = "Doe" $myArray
The output of this is shown in the following screenshot:
This example displays how you can create an array and update a value in the array. You first start by defining $myArray and use "John","Doe", "Jane", and "Smith" as the array values. After calling the variable to print the array to the screen, you update the value in index number 1, position value 1, or $myArray[1][1]. By setting this position equal to Doe, you change the value from Smith to Doe:
|
Index number |
Position value 0 |
Position value 1 |
|---|---|---|
|
|
|
|
|
|
|
|
|
|
|
|
In instances where you want to append additional values to the array, you can call the array variable with the += command and the data you want to add to the array. This looks like $array += "New Array Values". The += command is a more efficient method of performing the commands $array = $array + "New Array Values".
To add data into an array and make the preceding table, you can do the following operation:
# Create the Array $myArray = ("John","Doe"), ("Jane","Smith") $myArray # Append Data to the Array $myArray += ("Sam","Smith") $myArray
The output of this is shown in the following screenshot:
In this example, you add values to an existing array. You first start by defining an array of $myArray. You then print the existing contents of the array to the screen. You then add additional content by setting the array += to the new array data of ("Sam","Smith"). After reprinting the contents of the array to the screen, you see the values Sam and Smith added to the array.
Tip
To search and remove items from an array, you will need to create a ForEach loop to cycle through all of the index numbers and position values. Chapter 4, Functions, Switches, and Loop Structures, explores the ForEach looping structure.
Hashes are used like arrays. The main difference is that they use the values as indexes versus sequentially numbered indexes. This provides easy functionality to add, remove, modify, and find data contained in the hash table. Hash tables are useful for static information that needs a direct correlation to other data:
|
Name |
Value |
|---|---|
|
|
|
|
|
|
A good example of a hash table would be in the instance of an Active Directory migration. In most Active Directory migrations, you would need to correlate old usernames to new usernames. The preceding table represents a username mapping table for these types of migrations. While a traditional array would work, a hash table makes this much easier to do.
To create the preceding hash table, enter the following command:
$users = @{"john.doe" = "jdoe"; "jane.doe" = "jdoe1"} $users
The output of this is shown in the following screenshot:
After you create the table, you may want to find a specific user. You can search a hash table by using the hash's indexing function. This is done by calling $hashName["value"]. An example of this would look like the following command:
$users = @{"john.doe" = "jdoe"; "jane.doe" = "jdoe1"} $users["john.doe"]
The output of this is shown in the following screenshot:
After entering the command, you will see that $users["john.doe"] returns jdoe as the correlating value in the hash.
One of the most popular methods to use with hash tables is the add method. The add method allows you to enter new values within the hash table. You can use this while building the hash table, as most hash tables are built within a script. If you want to add another user to the hash table, use the add method as shown here:
$users = @{"john.doe" = "jdoe"; " jane.doe" = "jdoe1"} $users $users.add("John.Smith", "jsmith") $users
The output of this is shown in the following screenshot:
You will see that John.Smith with the value of jsmith is now added to the hash table.
You can also update values in a hash by leveraging the hash's index. This is done by searching for a value and then setting its correlating hash value equal to a new value. This looks like $arrayName["HashIndex"] = "New value". An example of this is given here:
$users = @{"john.doe" = "jdoe"; "jane.doe" = "jdoe1"} $users $users["jane.doe"] = "jadoe" $users
The output of this is shown in the following screenshot:
You will see that the mapped value for Jane.Doe now reads jadoe. This is vastly different from an array, where you would have to search for a specific value location to replace the value.
If you want to remove a user from the hash table, use the remove method, as shown here:
$users = @{"john.doe" = "jdoe"; "jane.doe" = "jdoe1"} $users $users.remove("Jane.Doe") $users
The output of this is shown in the following screenshot:
You will see that Jane.Doe is now removed from the hash table. This method is helpful when you need to remove specific values, which meet certain criteria, from the hash table.
When you are scripting, it is important to put consideration into what kind of container you will be using. Sometimes the simplicity of creating a singular variable and updating that variable is less complex than creating an array or hash table to search through. At other times, it may be more efficient to pull the whole dataset and use individual pieces of that data within your script.
Single-line variables can be used for:
Math operations that require calculations of single or multiple values
Catching single-line output from executing a non-PowerShell command
Tracking current position in a loop like "percent complete"
Arrays are best used for:
Storing a list of items for individual processing within a script
Dumping error information from a PowerShell cmdlet
Hashes are best used for:
This chapter explores the use of a variety of containers. You learned that variables, arrays, and hashes have the commonality of being able to store data, but they do it in different ways. You learned that different types of data can be stored in these containers. These types of data include numbers, strings, and objects.
This chapter explored that variables are best used for the storage of single-dimensional datasets. These datasets can contain strings but also include mathematical equations that PowerShell has the ability to inherently calculate. You also now know that arrays are primarily used in situations where you want to store more than one set of data. You are able to navigate, add, and remove values in the array based off of a starting value of 0. Last, you learned that hashes are best used while correlating data from one value to another. You are able to add, remove, and search data contained in the hash tables with the use of simple commands. In the next chapter, you will learn techniques to perform data parsing and manipulation by leveraging variables and arrays.
