What do you get with Print?

Instant access to your digital eBook copy whilst your Print order is Shipped

Paperback book shipped to your preferred address

Download this book in EPUB and PDF formats

Access this title in our online reader with advanced features

DRM FREE - Read whenever, wherever and however you want

Mastering Windows PowerShell Scripting

Chapter 1. Variables, Arrays, and Hashes

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

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 stored in variables

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

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.

Single-dimension arrays

The following table represents an array with a single dimension:

Index number	Position value
`0`	`Example 1`
`1`	`Example 2`
`2`	`Example 3`
`3`	`Example 4`
`4`	`Example 5`

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.

Jagged arrays

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
`0`	`Example 1`	`Red`
`1`	`Example 2`	`Orange`
`2`	`Example 3`	`Yellow`
`3`	`Example 4`	`Green`
`4`	`Example 5`	`Blue`

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].

Updating array values

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
`0`	`John`	`Doe`
`1`	`Jane`	`Smith`

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
`0`	`John`	`Doe`
`1`	`Jane`	`Smith`
`2`	`Sam`	`Smith`

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

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
`John.Doe`	`Jdoe`
`Jane.Doe`	`jdoe1`

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.

What you will learn

Utilize variables, hashes, and arrays to store data

Parse and manipulate different data types

Optimize code through the use of functions, switches, and looping structures

Create and implement regular expressions in PowerShell scripts

Leverage sessionbased remote management

Manage files, folders, and registries through the use of PowerShell

Discover the best practices to manage Microsoft systems

What do you get with Print?

Instant access to your digital eBook copy whilst your Print order is Shipped

Paperback book shipped to your preferred address

Download this book in EPUB and PDF formats

Access this title in our online reader with advanced features

DRM FREE - Read whenever, wherever and however you want

Frequently bought together

€32.99

€41.99

€36.99

Total € 111.97

Filter reviews by

All

Amazon verified reviews

Me May 23, 2015

I have numerous books on PowerShell and have been working with PowerShell for only a few months. But this is the first book on PowerShell that I can say truly speaks to me. The light bulb came on as I was reading this book. It is well written and organized in such a manner that I can honestly see myself taking my PowerShell skills to the next level. It is an absolutely great book that I would highly recommend to anyone who also wants to take their PowerShell skills to the next level. Each chapter made me want to continue reading more and had me looking forward to the next chapter. I am also looking forward to introducing this book to all of my co-workers with the hope that they also will build on their knowledge of PowerShell. This book has earned a permanent place on my bookshelf. Thank you for this book…

Amazon Verified review

Brenton Blawat May 07, 2015

After a years worth of work, I finally have the Mastering Windows PowerShell Scripting book complete. It is absolutely everything you need to know to become a PowerShell Master in your environment. I hope you enjoy the book as much as I enjoyed writing it!

Todd M. Williamsen Jun 15, 2016

I personally have worked with the author at a mutual client. Brenton is extremely willing to help at any costs, and he exhibits the same motive in this book.

Jason P Dec 02, 2015

I am starting out learning PowerShell for my job and this book helped me out a ton. Great book, well written, excellent guide.

Kenzo Sep 02, 2016

great foundational fountain of knowledge for powershell

Mastering Windows PowerShell Scripting: Master the art of automating and managing your Windows environment using PowerShell

What do you get with Print?

Mastering Windows PowerShell Scripting

Chapter 1. Variables, Arrays, and Hashes

Variables

Tip

Objects stored in variables

Arrays

Single-dimension arrays

Jagged arrays

Updating array values

Tip

Hashes

Deciding the best container for your scripts

Summary

Page 1 of 6

Description

What you will learn

Product Details

What do you get with Print?

Product Details

Frequently bought together

Table of Contents

Recommendations for you

Customer reviews

Filter reviews by

People who bought this also bought

About the author

FAQs

Mastering Windows PowerShell Scripting: Master the art of automating and managing your Windows environment using PowerShell

What do you get with Print?

Objects stored in variables

Description

What you will learn

Product Details

What do you get with Print?

Product Details

Packt Subscriptions

Frequently bought together

Table of Contents

Recommendations for you

Customer reviews

Filter reviews by

People who bought this also bought

About the author

FAQs