PowerShell Variable Naming Conventions

When writing scripts in PowerShell, following to a set of naming conventions can significantly enhance the readability and maintainability of your PowerShell script. PowerShell Variable naming conventions, in particular, are essential to consider as they can make your scripts more intuitive to understand and work with. This tutorial will discuss the best practices for naming variables in PowerShell, covering local, script, constant, and global variables.

PowerShell Variable Naming Conventions

Let’s explore some generic rules and best practices for naming variables in PowerShell.

  1. Use Descriptive Names: Variable names should be descriptive enough to convey their purpose without needing additional comments. For example, $numberOfUsers is more descriptive than $n.
  2. Keep It Short but Meaningful: While variables should be descriptive, they should also be concise to avoid overly long code lines that are hard to read. For instance, $maxTimeout is preferable to $maximumAmountOfTimeBeforeTimeoutOccurs.
  3. Avoid Using Special Characters: It’s a good practice to use only alphanumeric characters and underscores in variable names. Special characters like hyphens or spaces can lead to errors or unexpected behavior.
  4. Start with a Letter: Variable names should begin with a letter and not a number or special character. This ensures compatibility and avoids conflicts with PowerShell’s automatic variables which start with a dollar sign followed by a special character (e.g., $_ or $?).
  5. Avoid Reserved Words: Do not use PowerShell reserved words or cmdlets as variable names, such as IfFunction, or Switch, which can cause confusion or script errors.
  6. Consider Scope Indicators: For script and global variables, consider using scope modifiers like $script: or $global: to make the variable scope explicit and clear.

PowerShell Local Variable Naming Convention

PowerShell Local variables are those that are declared within a function or a scope and are only accessible within that context. The best practice for naming local variables in PowerShell is to use camelCase. This means that the first letter of the variable name is lowercase, and each subsequent word starts with an uppercase letter.

For example:

$localVariable = "I am a local variable"

By using camelCase, you can quickly identify local variables within your script, keeping the code clean and consistent.

PowerShell Script Variable Naming Convention

PowerShell Script variables are declared at the script scope and accessible from anywhere within the script. The recommended approach for PowerShell script variables is similar to local variables, using camelCase for readability.


$scriptVariable = "I am accessible throughout the script"

However, for greater clarity, it’s sometimes suggested to prefix script variables with script: to emphasize their scope, such as $script:scriptVariable.

PowerShell Constant Variable Naming Convention

Constants in PowerShell are variables whose values cannot be changed after they are set. While PowerShell does not have a built-in constant variable type, you can emulate constants by setting a variable value and then not changing it throughout the script.

For constant variables, using PascalCase is a common convention in PowerShell. This is where each word in the variable name starts with an uppercase letter, including the first word.


$ConstantValue = "My value will not change"

This naming convention helps to differentiate constants from other variable types at a glance.

PowerShell Global Variable Naming Convention

PowerShell Global variables are accessible from any part of the script or session. The best practice for naming global variables is to use PascalCase and to explicitly declare them as global using the $Global: scope modifier.


$Global:GlobalVariable = "I am available everywhere in the session"

This convention makes it clear that the variable is global and should be used cautiously, as PowerShell global variables can affect the entire session and may lead to unexpected behavior if not managed properly.


Adopting a consistent naming convention for your PowerShell variables can significantly improve the readability and maintainability of your scripts. By using camelCase for local and script variables, PascalCase for constants, and explicitly declaring global variables with $Global: and PascalCase, you establish a clear and intuitive system for yourself and others who may work with your code.

In this PowerShell tutorial, we discussed everything about the PowerShell variable naming conventions, including:

  • PowerShell local variable naming convention
  • PowerShell script variable naming convention
  • PowerShell constant variable naming convention
  • PowerShell global variable naming convention

You may also like: