PowerShell Scopes

In PowerShell, a scope refers to the context in which script elements such as variables, functions, aliases, and modules are defined and accessed. Scopes defines the visibility and accessibility for script elements.

PowerShell supports several types of scopes, each with its own level of visibility and accessibility.

Types of Scopes in PowerShell

There are four primary types of scopes in PowerShell.

• Global Scope: The global scope is the highest level of scope in PowerShell. Variables and functions defined in the global scope are accessible from anywhere within the script and persist for the entire session.
• Script Scope: The script scope applies to variables and functions defined within a script file. Script scope is available only within the script.
• Local Scope: Variables and functions defined within a function or script block have local scope and are accessible only within that function or block.
• Private Scope: Private scope is a special scope that allows you to limit the visibility of variables or functions to the current scope, preventing them from being accessed by any other scope.

Local Scope in PowerShell

To define the local scope in PowerShell, use the local: modifier. This scope refers to the current scope where a command or script is running.

$number = 10.23
$number

Result:

10.23

Global Scope in PowerShell

Script elements in the global scope are available everywhere.

To define an element as global, use the global: modifier.

$Global:RConstant = 8.3014
Write-Host "R-Constant:" $Global:RConstant

Result:

R-Constant: 8.3014

Private Scope in PowerShell

Script elements that are defined as private are not available outside the scope where they are defined.

To define an element private, use the private: modifier.

# Define a function with a private dynamic parameter
function Test-PrivateScope {
    param(
        [Parameter()]
        $privateParameter
    )

    # Access the private parameter within the function
    Write-Host "Private parameter value: $privateParameter"
}

Test-PrivateScope -privateParameter "Private Value"

Result:

Private parameter value: Private Value

In the above PowerShell script, we created a function named Test-PrivateScope(). This function takes input parameter $privateParameter and use Write-Host cmdlet to write the message to the console.

Cool Tip: How to create a function in PowerShell!

Script Scope in PowerShell

The Script scope is created when you run a script. To define the script scope, use the script: modifier.

# Define a variable in the script scope
$script:scriptVariable = "Script Value"

# Access the variable within the script
function Get-ScriptVariable {
    Write-Host "Script variable value: $scriptVariable"
}

Get-ScriptVariable

Result:

Script Value

Conclusion

I hope the above article on how to use scopes in PowerShell is helpful to you. Understanding and properly utilizing these scopes are essentials for writing effective and maintainable PowerShell scripts.

You can find more topics about Active Directory tools and PowerShell basics on the ActiveDirectoryTools home page.