I write this as PowerShell approaches its 10th birthday since its release. PowerShell has come a long way since that time.

For me, PowerShell has gone from being a speculative replacement for a mixture of VBScript, C#, and Perl to a complex language with a great community.

This book is split into a number of sections. Much of the book is intended to act as a reference. We will cover the following topics in this book:

• Exploring PowerShell fundamentals
• Working with data
• Automating with PowerShell
• Extending PowerShell

In the first section of this book, while exploring the PowerShell fundamentals, we will look at the use of language and cover as many building blocks as possible.

In this chapter, we will briefly look at a number of short, diverse topics:

• What is PowerShell?
• Quick reference
• PowerShell editors
• PowerShell on Linux

PowerShell is a mixture of a command line, a functional programming language, and an object-oriented programming language. PowerShell is based on Microsoft .NET, which gives it a level of open flexibility that was not available in Microsoft's scripting languages(such as VBScript or batch) before this.

PowerShell is an explorer's scripting language. With built-in help, command discovery, and with access to much of the .NET Framework, it is possible to dig down through the layers.

This book is based on PowerShell 5.1; some of the features discussed in the book may not be available in the earlier versions of PowerShell.

There is a wide variety of quick references available for PowerShell. This particular reference is intended to kick-start the book, as a lot of this is either not explicitly explained or used often before in a more detailed explanation.

Refer to the following table:

# This is a line comment

<#
This is a block or multi-line comment
#>

Refer to the following table:

Get-Command Get-Process; Get-Command Get-Help

& ‘Get-Process’   # Invoke the string as a command
& { Get-Process –Id $PID }    # Invoke the script block

. C:\script.ps1    # Execute the script in the current scope (instead of its own scope)

PowerShell uses a tick as a multipurposeescaped character.

A tick may be used as a line continuation character. Consider the following example:

'one' -replace 'o', 't' `       -replace 'n', 'w' `       -replace 'e', 'o'

When using a tick to split a long statement across several lines, the tick must be the last character (it cannot be followed by a space or any other character).

A tick is used to construct several characters that can be used in strings:

Thetab character, for example, may be included in a string:

PS> Write-Host "First`tSecond" First Second

Alternatively, the bell sound may be played in the PowerShell console (but not ISE):

Write-Host "`a"

Refer to the following table:

1 –eq 1    # Returns $true
1 –eq 2    # Returns $false

1 –ne 2    # Returns $true
1 –ne 1    # Returns $false

$true –and $true    # Returns $true
$true –and $false    # Returns $false
$false –and $false    # Returns $false

$true –or $true    # Returns $true
$true –or $false   # Returns $true
$false –or $false  # Returns $false

1 + 1            # Equals 2
“one” + “one”    # Equals oneone

“Culture is $($host.CurrentCulture)”
“Culture is $(Get-Culture)”

Refer to the following table:

$null = Get-Command

[Void](Get-Command)

Get-Command | Out-Null

Get-Command > $null

Refer to the following table:

$array = @()    # Empty array
$array = @(1, 2, 3, 4)

$array = 1, 2, 3, 4
$array = “one”, “two”, “three”, “four”

$hashtable = @{}    # Empty hashtable
$hashtable = @{Key1 = “Value1”}
$hashtable = @{Key1 = “Value1”; Key2 = “Value2”}

Refer to the following table:

“Value”
$greeting = “Hello”; “$greeting World”   # Expands variable

$one = ‘One’
@”
Must be opened on its own line.
This string will expand variables like $var.
Can contain other quotes like “ and ‘.
Must be closed on its own line with no preceding white space.
“@

‘Value’
‘$greeting World’    # Does not expand variable

@’
Must be opened on its own line.
This string will not expand variables like $var.
Can contain other quotes like “ and ‘.
Must be closed on its own line with no preceding white space.
‘@

“Double-quotes may be escaped with tick like `”.”
“Or double-quotes may be escaped with another quote ““.”
‘Single-quotes may be escaped with tick like `’.’
‘Or single-quotes may be escaped with another quote like ‘‘.’

Refer to the following table:

$Error[0]    # The last error

$object = [PSCustomObject]@{
Array = @(1, 2, 3, 4, 5)
}
$object    # Shows 1, 2, 3, and 4
$formatenumerationlimit = 1
$object    # Shows 1

$host
$host.UI.RawUI.WindowTitle

‘text’ –match ‘.*’
$matches

$arr = 1, 2, 3, 4
“Joined based on OFS: $arr”
$ofs = ‘, ‘
“Joined based on OFS: $arr”

Get-Process –Id $PID

$profile.AllUsersAllHosts
$profile.AllUsersCurrentHost
$profile.CurrentUserAllHosts
$profile.CurrentUserCurrentHost

$PSVersionTable.PSVersion

$PWD.Path

Refer to the following table:

While it is possible to write for PowerShell using the Notepad application alone, it is rarely desirable. Using an editor designed to work with PowerShell can save a lot of time.

Specialized PowerShell editors, at a minimum, offer automatic completion (IntelliSense) that reduces the amount of cross-referencing required while writing code. Finding a comfortable editor early is a good way to ease into PowerShell: memorizing commands and parameters is not necessary.

Two editors are discussed, as follows:

• PowerShell ISE
• Visual Studio Code

PowerShellIntegratedScriptingEnvironment (ISE) was introduced with PowerShell 2 in October 2009 and has been updated with every subsequent release.

ISE has an immediate advantage over other editors. It is installed along with PowerShell itself and is likely to be available in some form wherever PowerShell is. ISE consists of a text editor pane and a script pane, as shown in the following screenshot:

ISE is a rich editing environment that includes IntelliSense, built-in help, syntax checking, debugging, and so on.

Additional features are available for ISE from the following add-on tools website:

In PowerShell 5, the distribution model for ISE is in the process of changing. Until version 5, ISE was released as a part of theWindows Management Framework (WMF). New features were introduced with each version of WMF, but the time between the versions was long.

ISE Preview may be installed from the PowerShell gallery using the following command:

Install-Module -Name PowerShellISE-Preview

Once installed, theupdate-module command may be used to bring ISE up to par with the published version.

ISE Preview can coexist with the version of ISE installed by the WMF package.

ISE may be started from the start menu; however, running thepowershell_isecommand (from theRun dialog,cmd, or the search box) is sufficient. In PowerShell, the simplerisecommand is aliased topowershell_ise.exe.

If the preview version from the PowerShell gallery is being used, the following command will start that version of ISE:

Start-ISEPreview

This first preview version differs a little from the version of ISE shipping with WMF 5. If the distribution model is successful, the PowerShell team hopes to release a new version of ISE every month, with each release fixing bugs and/or adding new features.

VS Code does not come with the native PowerShell support. It must be added. Once VS Code is installed, open it, and select theEXTENSIONS button on the left-hand side.

TypePowerShell in the search dialog box, and install the PowerShell language support:

After installation, the extension providesSyntax highlighting, testing usingPowerShell Script Analyzer, debugging, and so on.

Unlike ISE, the console (or terminal, as it is named) in VS Code must be configured. By default, the terminal in code usescmd.exe.

The following process is used to make the terminal use PowerShell:

1. OpenUserSettings fromFileandPreferences. The same may be achieved by pressingF1 and typinguser settings followed by return.
2. This opens two windows: aDefault Settings file on the left and asettings.json on the right. The file on the right holds user-specific configuration that overrides or adds to the default.
3. Expand theIntegrated Terminal section inDefault Settings (by clicking on theo9 symbol) to show the default values.
4. On the right-hand side, enter the following between the curly braces:

"terminal.integrated.shell.windows": "C:\\Windows\\sysnative\\WindowsPowerShell\\v1.0\\powershell.exe"

5. Save the changes, then pressCtrl+Shift+' (apostrophe) to open a new PowerShell terminal.Ctrl +' (apostrophe) toggles the visibility of the terminal window.

Visual Studio Code comes with integrated support for Git version control. Git is a distributed version control system; each developer has a copy of the same repository.

Setting up a repository is simple, as follows:

1. Open a folder that contains a project. Then, select theGit button (or pressCtrl +Shift +G).
2. Click onInitialize git repository button as shown in the following screenshot:

3. Once you have done this, files may be added to version control when committing (applying a change).

Subsequent changes to files may be inspected before committing again:

PowerShell for Linux is, at least at the time of writing, in alpha. The current release is still worth installing even if only to see what having a unified shell may look like.

Some familiarity with Linux is assumed during this process.

Several of the followingused paths are specific to the installed release (in this case, alpha 12).

As with PowerShell on Windows, thePSHOME variable shows where PowerShell itself has been installed:

PS> $PSHOME /opt/microsoft/powershell/6.0.0-alpha.12

The paths for module installation may be viewed using the environment variables:

PS> $env:PSMODULEPATH -split ':' /home/psuser/.local/share/powershell/Modules /usr/local/share/powershell/Modules /opt/microsoft/powershell/6.0.0-alpha.12/Modules

Once installed, PowerShell is visible in the list of available shells:

chsh -l

Set PowerShell as the defaultshell for the current user:

chsh New shell [/bin/bash]: /usr/bin/powershell

The current user profile on Linux resides under the home directory:

~/.config/powershell

Two profiles can be created:CurrentUserCurrentHost (Microsoft.PowerShell_profile.ps1) andCurrent User (profile.ps1). Inspecting the automatic variable,$PROFILE shows the first of these:

1. The directory will need to be created prior to use; the following command creates it:

New-Item ~/.config/powershell -ItemType Directory

2. Create a simple profile file by sending a string to a file:

‘Write-Host “Welcome to PowerShell” -ForegroundColor Green’ |
    Out-File .config/powershell/profile.ps1

3. TheAllUser profile may be created under PowerShell's installation directory, in this case, alpha 12, as this is the version I have installed:

/opt/microsoft/powershell/6.0.0-alpha.12

4. Writing to this area of the filesystem requires theroot privileges:

sudo vi /opt/microsoft/powershell/6.0.0-alpha.12/profile.ps1

5. Insidevi, pressi to enter insert mode and then type the following:

Write-Host 'This is the system profile' -ForegroundColor Yellow

6. Once completed, pressEsc, then type:wq to save and quitvi.
7. As with PowerShell on Windows, this will be executed before a user-levelprofile that shows the following in the console when the shell is started:

This is the system profile Welcome to PowerShell

PowerShell on Linux (and macOS) has a long way to go to reach maturity. Our experience writing for these systems has to make a similar journey.

One of the most important facets is that Linux and macOS run PowerShell Core. It lacks some features we may have become used to when writing for Windows.

Windows editors, including ISE, tend to use a carriage return followed by linefeed (\r\n or`r`n) at the end of each line. Linux editors use linefeed only (\n or`n).

Line endings are less important if the only thing reading the file is PowerShell (on any platform). However, if a script is set to executable on Linux, a sha-bang must be included and the line-ending character used must be linefeed only.

For example, a created as follows namedtest.ps1 must use\n to end lines:

#!/usr/bin/env powershell Get-Process

The first line is the sha-bang and lets Linux know which parser to use when executing the shell script.

Once created,chmod may be used to make the script executable outside of PowerShell:

chmod +x test.ps1

After being made executable, the script may be executed frombash with the full path or a relative path:

./test.ps1

Windows editors, including ISE, tend to save files using what is commonly known as ANSI encoding; this is more correctly known as Windows-1252.

As Windows-1252 is a Microsoft native format, it may be more appropriate to save files in a universally accepted format such as UTF8.

Testing shows that PowerShell on Linux is forgiving about path separators; that is, Microsoft Windows uses the backslash (\), where Linux uses a forward slash (/).

If anything outside of PowerShell (including native commands) is to be used, a correct separator should be chosen.

TheJoin-Path command will merge path elements using the correct separator for each platform. Manual path construction (based on merging strings) should be avoided.

The following function uses theSystem.Net.NetworkInformation namespace to discover IPv4 address information. This allows us to return the same thing whether it is run on Windows or Linux.

If it were Windows only, we might have used WMI or theGet-NetIPConfiguration command. Creating something to work on both operating systems is more challenging:

function Get-IPConfig {     [System.Net.NetworkInformation.NetworkInterface]::GetAllNetworkInterfaces() | ForEach-Object {         $ipProperties = $_.GetIPProperties()                      $addresses = $ipProperties.UnicastAddresses |             Where-Object {                 $_.Address.AddressFamily -eq 'InterNetwork'             } | ForEach-Object {                 "$($_.Address) $($_.IPv4Mask)"             }          $gateway = $ipProperties.GatewayAddresses.Address |             Where-Object {                 $_.AddressFamily -eq 'InterNetwork' -and                  $_ -ne '0.0.0.0'             }          [PSCustomObject]@{             Name      = $_.Name             Id        = $_.Id             Addresses = $addresses             Gateway   = $gateway         }     } | Where-Object { $_.Addresses } } Get-IPConfig

This chapter featured a brief introduction to PowerShell itself and provided a quick reference for some of the syntax and features.

A reasonable PowerShell editor is a great tool to have for any scripting language. A number of excellent options are available for beginners and veterans alike.

Recently, PowerShell has moved onto GitHub as an open source project. At the same time, versions of PowerShell for Linux and macOS have been developed. Installation of PowerShell on CentOS was briefly demonstrated.