To define a literal string (one in which no variable or escape expansion occurs), enclose it in single quotes:

$myString = 'hello `t $ENV:SystemRoot'

$myString gets the actual value of hello `t $ENV:SystemRoot.

To define an expanding string (one in which variable and escape expansion occurs), enclose it in double quotes:

$myString = "hello `t $ENV:SystemRoot"

$myString gets a value similar to hello C:\WINDOWS.

To include a single quote in a single-quoted string, or a double quote in a double-quoted string, include two of the quote characters in a row:

PS > "Hello ""There""!"
Hello "There"!
PS > 'Hello ''There''!'
Hello 'There'!

$prompt = "$(get-location) >"

$output =
    "Current script name is: $($myInvocation.MyCommand.Path)"

To define a here string (one that may span multiple lines), place the two characters @" at the beginning, and the two characters "@ on their own line at the end.

For example:

$myHereString = @"
This text may span multiple lines, and may
contain "quotes".
"@

Here strings may be of either the literal (single quoted) or expanding (double quoted) variety.

Windows PowerShell supports escape sequences inside strings, as listed in Table A.4, “Windows PowerShell escape sequences”.

To define a variable that holds numeric data, simply assign it as you would other variables. PowerShell automatically stores your data in a format that is sufficient to accurately hold it.

$myInt = 10

$myInt gets the value of 10, as a (32-bit) integer.

$myDouble = 3.14

$myDouble gets the value of 3.14, as a (53-bit, 9 bits of precision) double.

To explicitly assign a number as a long (64-bit) integer or decimal (96-bit, 96 bits of precision), use the long and decimal suffixes:

$myLong = 2147483648L

$myLong gets the value of 2147483648, as a long integer.

$myDecimal = 0.999D

$myDecimal gets the value of 0.999.

PowerShell also supports scientific notation:

$myPi = 3141592653e-9

$myPi gets the value of 3.141592653.

The data types in PowerShell (integer, long integer, double, and decimal) are built on the .NET data types of the same name.

Since computer administrators rarely get the chance to work with numbers in even powers of ten, PowerShell offers the numeric constants of pb, tb, gb, mb, and kb to represent petabytes (1125899906842624), terabytes (1099511627776), gigabytes (1073741824), megabytes (1048576), and kilobytes (1024), respectively:

PS > $downloadTime = (1gb + 250mb) / 120kb
PS > $downloadTime
10871.4666666667

To directly enter a hexadecimal number, use the hexadecimal prefix 0x:

$myErrorCode = 0xFE4A

$myErrorCode gets the integer value 65098.

The PowerShell scripting language does not natively support other number bases, but its support for interaction with the .NET Framework enables conversion to and from binary, octal, decimal, and hexadecimal:

$myBinary = [Convert]::ToInt32("101101010101", 2)

$myBinary gets the integer value of 2901.

$myOctal = [Convert]::ToInt32("1234567", 8)

$myOctal gets the integer value of 342391.

$myHexString = [Convert]::ToString(65098, 16)

$myHexString gets the string value of fe4a.

$myBinaryString = [Convert]::ToString(12345, 2)

$myBinaryString gets the string value of 11000000111001.

PowerShell arrays hold lists of data. The @() (array cast) syntax tells PowerShell to treat the contents between the parentheses as an array. To create an empty array, type:

$myArray = @()

To define a nonempty array, use a comma to separate its elements:

$mySimpleArray = 1,"Two",3.14

Arrays may optionally be only a single element long:

$myList = ,"Hello"

Or, alternatively (using the array cast syntax),

$myList = @("Hello")

Elements of an array do not need to be all of the same data type, unless you declare it as a strongly typed array. In the following example, the outer square brackets define a strongly typed variable (as mentioned in the section called “Variables”), and int[] represents an array of integers:

[int[]] $myArray = 1,2,3.14

In this mode, PowerShell generates an error if it cannot convert any of the elements in your list to the required data type. In this case, it rounds 3.14 to the integer value of 3.

PS > $myArray[2]
3

Arrays can also be multidimensional jagged arrays: arrays within arrays:

$multiDimensional = @(
      (1,2,3,4),
      (5,6,7,8)
   )

$multiDimensional[0][1] returns 2, coming from row 0, column 1

$multiDimensional[1][3] returns 8, coming from row 1, column 3

To define a multidimensional array that is not jagged, create a multidimensional instance of the .NET type. For integers, that would be an array of System.Int32:

$multidimensional = New-Object "Int32[,]" 2,4
$multidimensional[0,1] = 2
$multidimensional[1,3] = 8

To access a specific element in an array, use the [] operator. PowerShell numbers your array elements starting at zero. Using $myArray = 1,2,3,4,5,6 as an example:

$myArray[0]

Returns 1, the first element in the array.

$myArray[2]

Returns 3, the third element in the array.

$myArray[-1]

Returns 6, the last element of the array.

$myArray[-2]

Returns 5, the second-to-last element of the array.

You can also access ranges of elements in your array:

PS > $myArray[0..2]
1
2
3

Returns elements 0 through 2, inclusive.

PS > $myArray[-1..2]
6
1
2
3

Returns the final element, wraps around, and returns elements 0 through 2, inclusive. PowerShell wraps around because the one number in the range is positive, and the second number in the range is negative.

PS > $myArray[-1..-3]
6
5
4

Returns the last element of the array through to the third-to-last element in array, in decreasing order. PowerShell does not wrap around (and therefore scans backward in this case) because both numbers in the range share the same sign.

You can combine several of the above statements at once to extract more complex ranges from an array. Use the + sign to separate array ranges from explicit indexes:

$myArray[0,2,4]

Returns the elements at indices 0, 2, and 4.

$myArray[0,2+4..5]

Returns the elements at indices 0, 2, and 4 through 5, inclusive.

$myArray[,0+2..3+0,0]

Returns the elements at indices 0, 2 through 3 inclusive, 0, and 0 again.

$myArray = ,0+2..3+0,0

PowerShell hashtables (also called associative arrays) let you associate keys with values. To define a hashtable, use the syntax:

$myHashtable = @{}

You can initialize a hashtable with its key/value pairs when you create it. PowerShell assumes that the keys are strings, but the values may be any data type.

$myHashtable = @{ Key1 = "Value1"; "Key 2" = 1,2,3; 3.14 = "Pi" }

To access or modify a specific element in an associative array, you may use either the array-access or property-access syntax:

$myHashtable["Key1"]

Returns "Value1".

$myHashtable."Key 2"

Returns the array 1,2,3.

$myHashtable["New Item"] = 5

Adds "New Item" to the hashtable.

$myHashtable."New Item" = 5

Also adds "New Item" to the hashtable.

The arithmetic operators let you perform mathematical operations on your data, as shown in Table A.5, “Windows PowerShell arithmetic operators”.

PS > [Math]::Pow([Math]::E, [Math]::Pi)
23.1406926327793

$leftValue + $rightValue

$leftValue - $rightValue

$leftValue * $rightValue

$leftValue / $rightValue

$leftValue % $rightValue

$variable operator= value

$variable = $variable operator value.

The logical operators let you compare Boolean values, as shown in Table A.6, “Windows PowerShell logical operators”.

$leftValue -and $rightValue

$value1 –and $value2 -and $value3 …

$leftValue -or $rightValue

$value1 -or $value2 -or $value3 ...

$leftValue -xor $rightValue

-not $value

The binary operators, listed in Table A.7, “Windows PowerShell binary operators”, let you apply the Boolean logical operators bit by bit to the operator's arguments. When comparing bits, a 1 represents $true, while a 0 represents $false.

$leftValue -band $rightValue

PS > $boolean1 = "110110110"
PS > $boolean2 = "010010010"
PS > $int1 = [Convert]::ToInt32($boolean1, 2)
PS > $int2 = [Convert]::ToInt32($boolean2, 2)
PS > $result = $int1 -band $int2
PS > [Convert]::ToString($result, 2)
10010010

$leftValue -bor $rightValue

PS > $boolean1 = "110110110"
PS > $boolean2 = "010010010"
PS > $int1 = [Convert]::ToInt32($boolean1, 2)
PS > $int2 = [Convert]::ToInt32($boolean2, 2)
PS > $result = $int1 -bor $int2
PS > [Convert]::ToString($result, 2)
110110110

$leftValue -bxor $rightValue

PS > $boolean1 = "110110110"
PS > $boolean2 = "010010010"
PS > $int1 = [Convert]::ToInt32($boolean1, 2)
PS > $int2 = [Convert]::ToInt32($boolean2, 2)
PS > $result = $int1 -bor $int2
PS > [Convert]::ToString($result, 2)
100100100

-bnot $value

PS > $boolean1 = "110110110"
PS > $int1 = [Convert]::ToInt32($boolean1, 2)
PS > $result = -bnot $int1
PS > [Convert]::ToString($result, 2)
11111111111111111111111001001001

PowerShell supports several other simple operators, as listed in Table A.8, “Other Windows PowerShell operators”.

"target" -replace "pattern","replacement"

PS > "Hello World" -replace "(.*) (.*)",'$2 $1'
World Hello

"Format String" -f Values

PS > "{0:n0}" -f 1000000000
1,000,000,000

$value -as [Type]

PS > 3/2 -as [int]
2
PS > $result = "Hello" -as [int]
PS > $result -eq $null
True

-split "Input String"

PS > -split "  Hello    World   "
Hello
World

"Input String" -split "delimiter",maximum,options
"Input String" -split { Scriptblock },maximum

PS > "1a2B3" -split "[a-z]+",0,"IgnoreCase"
1
2
3

-join ("item1","item2",...,"item_n")

PS > -join ("a","b")
ab

("item1","item2",...,"item_n" -join Delimiter

PS > "a","b" -join ", "
a, b

if(condition)
{
   statement block
}
elseif(condition)
{
   statement block
}
else
{
   statement block
}

If condition evaluates to $true, then PowerShell executes the statement block you provide. Then, it resumes execution at the end of the if / elseif / else statement list. PowerShell requires the enclosing braces around the statement block even if the statement block contains only one statement.

If condition evaluates to $false, then PowerShell evaluates any following (optional) elseif conditions until one matches. If one matches, PowerShell executes the statement block associated with that condition, then resumes execution at the end of the if / elseif / else statement list.

For example:

$textToMatch = Read-Host "Enter some text"
$matchType = Read-Host "Apply Simple or Regex matching?"
$pattern = Read-Host "Match pattern"
if($matchType -eq "Simple")
{
    $textToMatch -like $pattern
}
elseif($matchType -eq "Regex")
{
    $textToMatch -match $pattern
}
else
{
    Write-Host "Match type must be Simple or Regex"
}

If none of the conditions evaluate to $true, PowerShell executes the statement block associated with the (optional) else clause, and then resumes execution at the end of the if / elseif / else statement list.

switch options expression
{
   comparison value           { statement block }
   -or-
   { comparison expression }  { statement block }
   (...)
   default                    { statement block }
}

or:

switch options -file filename
{
   comparison value           { statement block }
   -or
   { comparison expression }  { statement block }
   (...)
   default                    { statement block }
}

When PowerShell evaluates a switch statement, it evaluates expression against the statements in the switch body. If expression is a list of values, PowerShell evaluates each item against the statements in the switch body. If you specify the –file option, PowerShell treats the lines in the file as though they were a list of items in expression.

The comparison value statements let you match the current input item against the pattern specified by comparison value. By default, PowerShell treats this as a case-insensitive exact match, but the options you provide to the switch statement can change this, as shown in Table A.10, “Options supported by PowerShell switch statements”.

The { comparison expression } statements let you process the current input item, which is stored in the $_ variable, in an arbitrary script block. When it processes a { comparison expression } statement, PowerShell executes the associated statement block only if { comparison expression } evaluates to $true.

PowerShell executes the statement block associated with the (optional) default statement if no other statements in the switch body match.

When processing a switch statement, PowerShell tries to match the current input object against each statement in the switch body, falling through to the next statement even after one or more have already matched. To have PowerShell discontinue the current comparison (but retry the switch statement with the next input object), include a continue statement as the last statement in the statement block. To have PowerShell exit a switch statement completely after it processes a match, include a break statement as the last statement in the statement block.

For example:

$myPhones = "(555) 555-1212","555-1234"

switch -regex ($myPhones)
{
  { $_.Length -le 8 }  { "Area code was not specified"; break }
  { $_.Length -gt 8 }  { "Area code was specified" }
  "\((555)\).*"        { "In the $($matches[1]) area code" }
}

Produces the output:

Area code was specified
In the 555 area code
Area code was not specified

By default, PowerShell treats this as a case-insensitive exact match, but the options you provide to the switch statement can change this.

:loop_label for (initialization; condition; increment)
{
   statement block
}

When PowerShell executes a for statement, it first executes the expression given by initialization. It next evaluates condition. If condition evaluates to $true, PowerShell executes the given statement block. It then executes the expression given by increment. PowerShell continues to execute the statement block and increment statement as long as condition evaluates to $true.

For example:

for($counter = 0; $counter -lt 10; $counter++)
{
    Write-Host "Processing item $counter"
}

The break and continue statements can specify the loop_label of any enclosing looping statement as their target.

:loop_label foreach (variable in expression)
{
   statement block
}

When PowerShell executes a foreach statement, it executes the pipeline given by expression—for example, Get-Process | Where-Object {$_.Handles -gt 500} or 1..10. For each item produced by the expression, it assigns that item to the variable specified by variable and then executes the given statement block. For example:

$handleSum = 0;
foreach($process in Get-Process |
    Where-Object { $_.Handles -gt 500 })
{
   $handleSum += $process.Handles
}
$handleSum

The break and continue statements (discussed later in the chapter) can specify the loop_label of any enclosing looping statement as their target. In addition to the foreach statement, PowerShell also offers the Foreach-Object cmdlet with similar capabilities. For more information, see the section called “Repeat Operations with Loops”.

:loop_label while(condition)
{
   statement block
}

When PowerShell executes a while statement, it first evaluates the expression given by condition. If this expression evaluates to $true, PowerShell executes the given statement block. PowerShell continues to execute the statement block as long as condition evaluates to $true. For example:

$command = "";
while($command -notmatch "quit")
{
   $command = Read-Host "Enter your command"
}

The break and continue statements can specify the loop_label of any enclosing looping statement as their target.

:loop_label do
{
   statement block
} while(condition)

or

:loop_label do
{
   statement block
} until(condition)

When PowerShell executes a do…while or do…until statement, it first executes the given statement block. In a do…while statement, PowerShell continues to execute the statement block as long as condition evaluates to $true. In a do…until statement, PowerShell continues to execute the statement as long as condition evaluates to $false. For example:

$validResponses = "Yes","No"
$response = ""
do
{
   $response = read-host "Yes or No?"
} while($validResponses -notcontains $response)
"Got it."

$response = ""
do
{
   $response = read-host "Yes or No?"
} until($validResponses -contains $response)
"Got it."

The break and continue statements can specify the loop_label of any enclosing looping statement as their target.

PowerShell supports two statements to help you control flow within loops: break and continue.

for($counter = 0; $counter -lt 5; $counter++)
{
    for($counter2 = 0; $counter2 -lt 5; $counter2++)
    {
        if($counter2 -eq 2)
        {
            break
        }

        Write-Host "Processing item $counter,$counter2"
    }
}

Processing item 0,0
Processing item 0,1
Processing item 1,0
Processing item 1,1
Processing item 2,0
Processing item 2,1
Processing item 3,0
Processing item 3,1
Processing item 4,0
Processing item 4,1

:outer_loop for($counter = 0; $counter -lt 5; $counter++)
{
    for($counter2 = 0; $counter2 -lt 5; $counter2++)
    {
        if($counter2 -eq 2)
        {
            break outer_loop
        }

        Write-Host "Processing item $counter,$counter2"
    }
}

Processing item 0,0
Processing item 0,1

for($counter = 0; $counter -lt 5; $counter++)
{
    for($counter2 = 0; $counter2 -lt 5; $counter2++)
    {
        if($counter2 -eq 2)
        {
            continue
        }

        Write-Host "Processing item $counter,$counter2"
    }
}

Processing item 0,0
Processing item 0,1
Processing item 0,3
Processing item 0,4
Processing item 1,0
Processing item 1,1
Processing item 1,3
Processing item 1,4
Processing item 2,0
Processing item 2,1
Processing item 2,3
Processing item 2,4
Processing item 3,0
Processing item 3,1
Processing item 3,3
Processing item 3,4
Processing item 4,0
Processing item 4,1
Processing item 4,3
Processing item 4,4

:outer_loop for($counter = 0; $counter -lt 5; $counter++)
{
    for($counter2 = 0; $counter2 -lt 5; $counter2++)
    {
        if($counter2 -eq 2)
        {
            continue outer_loop
        }

        Write-Host "Processing item $counter,$counter2"
    }
}

Processing item 0,0
Processing item 0,1
Processing item 1,0
Processing item 1,1
Processing item 2,0
Processing item 2,1
Processing item 3,0
Processing item 3,1
Processing item 4,0
Processing item 4,1

To call a static method on a class, type:

[ClassName]::MethodName(parameter list)

For example:

PS > [System.Diagnostics.Process]::GetProcessById(0)

gets the process with the ID of 0 and displays the following output:

Handles  NPM(K)    PM(K)      WS(K) VM(M)  CPU(s)     Id ProcessName
-------  ------    -----      ----- -----  ------     -- -----------
      0       0        0         16     0              0 Idle

To call a method on an instance of an object, type:

$objectReference.MethodName(parameter list)

For example:

PS > $process = [System.Diagnostics.Process]::GetProcessById(0)
PS > $process.Refresh()

This stores the process with ID of 0 into the $process variable. It then calls the Refresh() instance method on that specific process.

To access a static property on a class, type:

[ClassName]::PropertyName

or:

[ClassName]::PropertyName = value

For example, the [System.DateTime] class provides a Now static property that returns the current time:

PS > [System.DateTime]::Now
Sunday, July 16, 2006 2:07:20 PM

Although rare, some types let you set the value of some static properties.

To access an instance property on an object, type:

$objectReference.PropertyName

or:

$objectReference.PropertyName = value

For example:

PS > $today = [System.DateTime]::Now
PS > $today.DayOfWeek
Sunday

This stores the current date in the $today variable. It then calls the DayOfWeek instance property on that specific date.

The two primary avenues for learning about classes and types are the Get-Member cmdlet and the documentation for the .NET Framework.

Get-Member -InputObject $objectReference

classname members

When you specify a type name, PowerShell lets you use a short form for some of the most common types, as listed in Table A.12, “PowerShell type shortcuts”.

$objectReference = New-Object TypeName parameters

Although static methods and properties of a class generate objects, you will often want to create them explicitly yourself. PowerShell's New-Object cmdlet lets you create an instance of the type you specify. The parameter list must match the list of parameters accepted by one of the type's constructors, as documented on MSDN.

For example:

$webClient = New-Object Net.WebClient
$webClient.DownloadString("http://search.msn.com")

If the type represents a generic type, enclose its type parameters in square brackets:

PS > $hashtable = New-Object "System.Collections.Generic.Dictionary[String,Bool]"
PS > $hashtable["Test"] = $true

Most common types are available by default. However, many are available only after you load the library (called the assembly) that defines them. The MSDN documentation for a class includes the assembly that defines it.

To load an assembly, use the -AssemblyName parameter of the Add-Type cmdlet:

PS > Add-Type -AssemblyName System.Web

PS > [Web.HttpUtility]::UrlEncode("http://www.bing.com")
http%3a%2f%2fwww.bing.com

PowerShell lets you access methods and properties on COM objects the same way you would interact with objects from the .NET Framework. To interact with a COM object, use its ProgId with the –ComObject parameter (often shortened to –Com) on New-Object:

PS > $shell = New-Object -Com Shell.Application
PS > $shell.Windows() | Select-Object LocationName,LocationUrl

For more information about the COM objects most useful to system administrators, see Appendix H, Selected COM Objects and Their Uses.

PowerShell supports two ways to add your own methods and properties to any type: the Add-Member cmdlet and a custom types extension file.

PS > $testObject = [PsObject] "Test"
PS > $testObject | Add-Member "AliasProperty" Count Length
PS > $testObject.Count
4

PS > $testObject = [PsObject] "Test"
PS > $testObject | Add-Member NoteProperty Reversed tseT
PS > $testObject.Reversed
tseT

PS > $testObject = [PsObject] ("Hi" * 100)
PS > $testObject | Add-Member ScriptProperty IsLong {
>>       $this.Length -gt 100
>>    }
>> $testObject.IsLong
>>
True

PS > $testObject = [PsObject] [DateTime]::Now
PS > $collection = New-Object `
>>        Collections.ObjectModel.Collection``1[System.String]
>> $collection.Add("Month")
>> $collection.Add("Year")
>> $testObject | Add-Member PropertySet MonthYear $collection
>> $testObject | select MonthYear
>>

Month                                   Year
-----                                   ----
    3                                   2010

PS > $testObject = [PsObject] "Hello"
PS > $testObject | Add-Member ScriptMethod IsLong {
>>       $this.Length -gt $args[0]
>>    }
>> $testObject.IsLong(3)
>> $testObject.IsLong(100)
>>
True
False

$typesFile = Join-Path (Split-Path $profile) "Types.Custom.Ps1Xml"
Update-TypeData -PrependPath $typesFile

There are two ways to execute a command (script, function, or script block): by invoking it or by dot-sourcing it.

c:\temp\Invoke-Commands.ps1 parameter1 parameter2 ...
Invoke-MyFunction parameter1 parameter2 ...

.\Invoke-Commands.ps1 parameter1 parameter2 ...

& "C:\Script Directory\Invoke-Commands.ps1" parameter1 parameter2 ...
& Invoke-MyFunction parameter1 parameter2 ...

$scriptBlock = { "Hello World" }
& $scriptBlock parameter1 parameter2 ...

$module = Get-Module PowerShellCookbook
& [$module] Invoke-MyFunction parameter1 parameter2 ...
& $module $scriptBlock parameter1 parameter2 ...

. "C:\Script Directory\Invoke-Commands.ps1" Parameters
. Invoke-MyFunction parameters
. $scriptBlock parameters

. .\Invoke-Commands.ps1 Parameters

Set-ExecutionPolicy RemoteSigned

$module = Get-Module PowerShellCookbook
. [$module] Invoke-MyFunction parameters
. $module $scriptBlock parameters

$parameters = @{
   Path = "c:\temp"
   Recurse = $true
}

Get-ChildItem @parameters

PowerShell offers several options for processing input to a command.

$firstArgument = $args[0]
$secondArgument = $args[1]
$argumentCount = $args.Count

param(
    [TypeName] $variableName = Default,
    ...
)

[CmdletBinding(cmdlet behavior customizations)]
param(
    [Parameter(Mandatory = $true, Position = 1, ...)]
    [Alias("MyParameterAlias"]
    [...]
    [TypeName] $variableName = Default,
    ...
)

foreach($element in $input)
{
   "Input was: $element"
}

$inputArray = @($input)

param(...)

begin
{
   ...
}
process
{
   ...
}
end
{
   ...
}

PowerShell provides three primary ways to retrieve output from a command.

any command

"Text Output"
5*5

return value

return $false

$false
return

exit errorlevel

PowerShell automatically generates help content out of specially-tagged comments in your command:

<#

.SYNOPSIS
Runs a ...

.EXAMPLE
PS > ...

#>

param(
   $param1
)

Help-specific comments must be the only comments in a comment block. If PowerShell discovers a non-help comment, it discontinues looking for comments in that comment block. If you need to include non-help comments in a comment block, place them in a separate block of comments. The following are the most typical help comments used in a comment block:

Most errors are nonterminating errors, in that they do not halt execution of the current cmdlet, script, function, or pipeline. When a command outputs an error (via PowerShell's error-output facilities), PowerShell writes that error to a stream called the error output stream.

You can output a nonterminating error using the Write-Error cmdlet (or the WriteError() API when writing a cmdlet).

The $ErrorActionPreference automatic variable lets you control how PowerShell handles nonterminating errors. It supports the following values, as shown in Table A.14, “ErrorActionPreference automatic variable values”.

Most cmdlets let you configure this explicitly by passing one of the above values to its ErrorAction parameter.

A terminating error halts execution of the current cmdlet, script, function, or pipeline. If a command (such as a cmdlet or .NET method call) generates a structured exception (for example, if you provide a method with parameters outside their valid range), PowerShell exposes this as a terminating error. PowerShell also generates a terminating error if it fails to parse an element of your script, function, or pipeline.

You can generate a terminating error in your script using the throw keyword:

throw message

You can intercept terminating errors through the try, catch and finally statements, as supported by many other programming languages:

try
{
    statement block
}
catch [exception type]
{
    error handling block
}
catch [alternate exception type]
{
    alternate error handling block
}
finally
{
    cleanup block
}

After a try statement, you must provide a catch statement, a finally statement, or both. If you specify an exception type (which is optional), you may specify more than one catch statement to handle exeptions of different types. If you specify an exception type, the catch block applies only to terminating errors of that type.

PowerShell also lets you intercept terminating errors if you define a trap statement before PowerShell encounters that error:

trap [exception type]
{
   statement block
   [continue or break]
}

If you specify an exception type, the trap statement applies only to terminating errors of that type.

If specified, the continue keyword tells PowerShell to continue processing the rest of your script, function, or pipeline after the point at which it encountered the terminating error.

If specified, the break keyword tells PowerShell to halt processing the rest of your script, function, or pipeline after the point at which it encountered the terminating error. Break is the default mode, and applies if you specify neither break nor continue at all.

The Windows PowerShell user interface offers several features to make your shell experience more efficient.

Windows PowerShell automatically runs the four scripts listed in Table A.18, “Windows PowerShell profiles” during startup. Each, if present, lets you customize your execution environment. PowerShell runs anything you place in these files as though you had entered it manually at the command line.

PowerShell makes editing your profile script simple by defining the automatic variable, $profile. By itself, it points to the "current user, PowerShell.exe" profile. In addition, the $profile variable defines additional properties that point to the other profile locations:

PS > $profile | Format-List -Force


AllUsersAllHosts       : C:\Windows\System32\WindowsPowerShell\v1.0\profil
                         e.ps1
AllUsersCurrentHost    : C:\Windows\System32\WindowsPowerShell\v1.0\Micros
                         oft.PowerShell_profile.ps1
CurrentUserAllHosts    : E:\Lee\WindowsPowerShell\profile.ps1
CurrentUserCurrentHost : E:\Lee\WindowsPowerShell\Microsoft.PowerShell_pro
                         file.ps1

To create a new profile, type:

New-Item -Type file -Force $profile

To edit this profile, type:

notepad $profile

To customize your prompt, add a prompt function to your profile. This function returns a string. For example:

function Prompt
{
    "PS [$env:COMPUTERNAME] >"
}

For more information about customizing your prompt, see also the section called “Customize Your Shell, Profile, and Prompt”.

You may define a TabExpansion function to customize the way that Windows PowerShell completes properties, variables, parameters, and files when you press the Tab key.

Your TabExpansion function overrides the one that PowerShell defines by default, though, so you may want to use its definition as a starting point:

Get-Content function:\TabExpansion

As its arguments, this function receives the entire command line as input, as well as the last word of the command line. If the function returns one or more strings, PowerShell cycles through those strings during tab completion. Otherwise, it uses its built-in logic to tab-complete file names, directory names, cmdlet names, and variable names.