Table of contents
TOC
Collapse the table of content
Expand the table of content

About Language Keywords

JuanPablo Jofre|Last Updated: 2/13/2017
|
4 Contributors

about_Language_Keywords

SHORT DESCRIPTION

Describes the keywords in the Windows PowerShell scripting language.

LONG DESCRIPTION

Windows PowerShell has the following language keywords. For more information, see the about topic for the keyword and the information that follows the table.

Keyword Reference


Begin about_Functions, about_Functions_Advanced Break about_Break, about_Trap Catch about_Try_Catch_Finally Continue about_Continue, about_Trap Data about_Data_Sections Do about_Do, about_While DynamicParam about_Functions_Advanced_Parameters Else about_If Elseif about_If End about_Functions, about_Functions_Advanced_Methods Exit Described in this topic. Filter about_Functions Finally about_Try_Catch_Finally For about_For ForEach about_ForEach From Reserved for future use. Function about_Functions, about_Functions_Advanced If about_If In about_ForEach InlineScript about_InlineScript Hidden about_Hidden Parallel about_Parallel, about_ForEach-Parallel Param about_Functions Process about_Functions, about_Functions_Advanced Return about_Return Sequence about_Sequence Switch about_Switch Throw about_Throw, about_Functions_Advanced_Methods Trap about_Trap, about_Break, about_Try_Catch_Finally Try about_Try_Catch_Finally Until about_Do While about_While, about_Do Workflow about_Workflows

Language Keywords

Begin

Specifies one part of the body of a function, along with the DynamicParam, Process, and End keywords. The Begin statement list runs one time before any objects are received from the pipeline.

Syntax:

function <name> {
DynamicParam {<statement list>}
begin {<statement list>}
process {<statement list>}
end {<statement list>}
}

Break

Causes a script to exit a loop.

Syntax:

while (<condition>) {
   <statements>
   ...

   break
   ...

   <statements>
}

Catch

Specifies a statement list to run if an error occurs in the accompanying Try statement list. An error type requires brackets. The second pair of brackets indicates that the error type is optional.

Syntax:

try {<statement list>}
catch [[<error type>]] {<statement list>}

Continue

Causes a script to stop running a loop and to go back to the condition. If the condition is met, the script begins the loop again.

Syntax:

while (<condition>) {
   <statements>
   ...

   continue
   ...

   <statements>
}

Data

In a script, defines a section that isolates data from the script logic. Can also include If statements and some limited commands.

Syntax:

data <variable> [-supportedCommand <cmdlet-name>] {<permitted content>}

Do

Used with the While or Until keyword as a looping construct. Windows PowerShell runs the statement list at least one time, unlike a loop that uses While.

Syntax for While:

do {<statement list>} while (<condition>)

Syntax for Until:

do {<statement list>} until (<condition>)

DynamicParam

Specifies one part of the body of a function, along with the Begin, Process, and End keywords. Dynamic parameters are added at run time.

Syntax:

function <name> {
   DynamicParam {<statement list>}
   begin {<statement list>}
   process {<statement list>}
   end {<statement list>}
}

Else

Used with the If keyword to specify the default statement list.

Syntax:

if (<condition>) {<statement list>}
else {<statement list>}

Elseif

Used with the If and Else keywords to specify additional conditionals. The Else keyword is optional.

Syntax:

if (<condition>) {<statement list>}
elseif (<condition>) {<statement list>}
else {<statement list>}

End

Specifies one part of the body of a function, along with the DynamicParam, Begin, and End keywords. The End statement list runs one time after all the objects have been received from the pipeline.

Syntax:

function <name> {
   DynamicParam {<statement list>}
   begin {<statement list>}
   process {<statement list>}
   end {<statement list>}
}

Exit

Causes Windows PowerShell to exit a script or a Windows PowerShell instance.

When you run 'powershell.exe -File ', you can only set the %ERRORLEVEL% variable to a value other than zero by using the exit statement. In the following example, the user sets the error level variable value to 4 by adding 'exit 4' to the script file test.ps1.

C:\Users\bruce\documents\test>type test.ps1
1

2

3

exit 4

C:\Users\bruce\documents\test>powershell -file ./test.ps1
1

2

3


C:\Users\bruce\documents\test>echo %ERRORLEVEL%
4

When you use powershell.exe with the File parameter, the .ps1 (script) file itself should include instructions for handling any errors or exceptions that occur while the script is running. You should only use the exit statement to indicate the post-execution status of the script.

Syntax:

exit
exit <exit code>

Filter

Specifies a function in which the statement list runs one time for each input object. It has the same effect as a function that contains only a Process block.

Syntax:

filter <name> {<statement list>}

Finally

Defines a statement list that runs after statements that are associated with Try and Catch. A Finally statement list runs even if you press CTRL+C to leave a script or if you use the Exit keyword in the script.

Syntax:

try {<statement list>}
catch [<error type] {<statement list>}
finally {<statement list>}

For

Defines a loop by using a condition.

Syntax:

for (<initialize>; <condition>; <iterate>) { <statement list> }

ForEach

Defines a loop by using each member of a collection.

Syntax:

ForEach (<item> in <collection>) { <statement list> }

From

Reserved for future use.

Function

Creates a named statement list of reusable code. You can name the scope a function belongs to. And, you can specify one or more named parameters by using the Param keyword. Within the function statement list, you can include DynamicParam, Begin, Process, and End statement lists.

Syntax:

function [<scope:>]<name> {
   param ([type]<$pname1> [, [type]<$pname2>])
   DynamicParam {<statement list>}
   begin {<statement list>}
   process {<statement list>}
   end {<statement list>}
}

You also have the option of defining one or more parameters outside the statement list after the function name.

Syntax:

function [<scope:>]<name> [([type]<$pname1>, [[type]<$pname2>])] {
   DynamicParam {<statement list>}
   begin {<statement list>}
   process {<statement list>}
   end {<statement list>}
}

If

Defines a conditional.

Syntax:

if (<condition>) {<statement list>}

Hidden

Hides class members from the default results of the Get-Member cmdlet, and from IntelliSense and tab completion results.

Syntax:

Hidden [data type] $member_name

In

Used in a ForEach statement to create a loop that uses each member of a collection.

Syntax:

ForEach (<item> in <collection>){<statement list>}

InlineScript

Runs workflow commands in a shared Windows PowerShell session. This keyword is valid only in a Windows PowerShell Workflow.

Syntax:

workflow <verb>-<noun>
{
   InlineScript
   {
      <Command/Expression>
      ...

   }
}

The InlineScript keyword indicates an InlineScript activity, which runs commands in a shared standard (non-workflow) session. You can use the InlineScript keyword to run commands that are not otherwise valid in a workflow, and to run commands that share data. By default, the commands in an InlineScript script block run in a separate process.

For more information, see about_InlineScript and Running Windows PowerShell Commands in a Workflow.

Param

Defines the parameters in a function.

Syntax:

function [<scope:>]<name> {
   param ([type]<$pname1>[, [[type]<$pname2>]])
   <statement list>
}

Parallel

Runs workflow commands concurrently and in an undefined order. This keyword is valid only in a Windows PowerShell Workflow.

The Parallel keyword indicates a Parallel script block. The commands in a Parallel script block can run at the same time and in any order. This feature significantly improves the performance of a workflow.

Syntax:

workflow <verb>-<noun>
{
   Parallel
   {
      <Activity>
      <Activity>
      …

   }
}

The Parallel parameter of the ForEach keyword processes the items in a collection in parallel. The activities in the script block run sequentially on each item, but the script block can run on multiple items at the same time and the items are processed in an undefined order.

Syntax:

workflow <verb>-<noun>
{
   ForEach -Parallel (<item> in <collection>)
   {
      <Activity>
      <Activity>
      ...

   }
}

For more information, see: about_Parallel, about_ForEach-Parallel

Process

Specifies a part of the body of a function, along with the DynamicParam, Begin, and End keywords. When a Process statement list receives input from the pipeline, the Process statement list runs one time for each element from the pipeline. If the pipeline provides no objects, the Process statement list does not run. If the command is the first command in the pipeline, the Process statement list runs one time.

Syntax:

function <name> {
   DynamicParam {<statement list>}
   begin {<statement list>}
   process {<statement list>}
   end {<statement list>}
}

Return

Causes Windows PowerShell to leave the current scope, such as a script or function, and writes the optional expression to the output.

Syntax:

return [<expression>]

Sequence

Runs workflow commands sequentially in a Parallel script block. This keyword is valid only in a Windows PowerShell Workflow.

Syntax:

workflow <verb>-<noun>
{
   Parallel
   {
      Sequence
      {
         <Activity>
      }
   }
}

The Sequence keyword creates a sequence block within a Parallel script block. The commands in the Sequence script block run sequentially and in the order defined.

For more information, see: about_Sequence

Switch

Specifies a variety of actions to be performed on items from the pipeline or from a file. You can use either of the following syntax models.

Syntax 1:

switch [-regex|-wildcard|-exact][-casesensitive] ( pipeline )
{
   <string>|<number>|<variable>|{ <expression> } {<statement list>}
   <string>|<number>|<variable>|{ <expression> } {<statement list>}
   ...

   default {<statement list>}
}

Syntax 2:

switch [-regex|-wildcard|-exact][-casesensitive] -file filename
{
   <string>|<number>|<variable>|{ <expression> } {<statement list>}
   <string>|<number>|<variable>|{ <expression> } {<statement list>}
   ...

   default {<statement list>}
}

Throw

Throws an object as an error.

Syntax:

throw [<object>]

Trap

Defines a statement list to be run if an error is encountered. An error type requires brackets. The second pair of brackets indicates that the error type is optional.

Syntax:

trap [[<error type>]] {<statement list>}

Try

Defines a statement list to be checked for errors while the statements run. If an error occurs, Windows PowerShell continues running in a Catch or Finally statement. An error type requires brackets. The second pair of brackets indicates that the error type is optional.

Syntax:

try {<statement list>}
catch [[<error type]] {<statement list>}
finally {<statement list>}

Until

Used in a Do statement as a looping construct where the statement list is executed at least one time.

Syntax:

do {<statement list>} until (<condition>)

While

Used in a Do statement as a looping construct where the statement list is executed at least one time.

Syntax:

do {<statement list>} while (<condition>)

Workflow

Creates a script-based Windows PowerShell workflow, that is, a workflow written in the Windows PowerShell language.

A Windows PowerShell workflow is a Windows PowerShell command type that is supported by Windows PowerShell and Windows Workflow Foundation. Workflows are designed for complex, long-running tasks that affect multiple computers. Workflows can be recovered if interrupted, such as by a network outage, and you can suspend and resume them without losing state or data.

Workflows can be written in XAML, the native language of Windows Workflow Foundation, or in the Windows PowerShell language.

The syntax of a script-based workflow is similar to the syntax of a function. However, the unit of execution in a workflow is an activity, instead of a command. Cmdlets (and other commands) that are used in script-based workflows are implicitly converted to activities.

Some language elements that are permitted in scripts and functions are not permitted in workflows. Similarly, workflows can include elements that are not found in scripts and functions, such as "persistence points" (checkpoints), self-suspension, and parallel processing. In addition, all workflows have a set of common parameters that are added by Windows PowerShell when you use the Workflow keyword.

Syntax:

workflow <verb-noun>
{
   param
   (
        [type]<$pname1>
        [, [type]<$pname2>]
    )
   <statement list>
}

workflow <verb-noun>
{
   [CmdletBinding(<Attributes>)]
   Param
   (
      [Parameter(<Arguments>)] $Param1
      ...
   )

   <statement list>
}

For more information about workflows, see about_Workflows and "Getting Started with Windows PowerShell Workflow" (http://go.microsoft.com/fwlink/?LinkID=252592) in the TechNet Library.

SEE ALSO

© 2017 Microsoft