On this page

Scalar Variables

Enrico Hochkoeppler Profile

By Enrico Hochkoeppler

Web Developer & TutoriaLibre Founder

A scalar variable in PowerShell is a variable that holds a single value at a time. The value can be of any type (string, integer, boolean, object, etc.), but the variable itself represents one item, not a collection. Scalar variables are the fundamental building blocks of PowerShell scripting, used to store intermediate results, configuration values, user input, and command output.


Declaring and assigning scalar variables​

Scalar variables are created by assigning a value to a name prefixed with $:


$number    = 42

$text      = "Hello, PowerShell"

$isEnabled = $true

$pi        = 3.14159

PowerShell is dynamically typed: the type of the variable is inferred from the assigned value. You can also declare the type explicitly:


[int]   $count = 10

[string]$name  = "Admin"

[bool]  $flag  = $false

Explicit typing is useful when you want to enforce a specific type or avoid implicit conversions.


Reading and updating scalar variables​

Scalar variables are referenced by name:


Write-Output $text

Write-Output $number

You can update their value at any time:


$number = $number + 1

$text   = $text + "!"

Each assignment replaces the previous value; the variable still holds a single value.


Scalars vs. collections​

A scalar variable holds one value, while a collection (such as an array) holds multiple values:


$scalar  = 5

$array   = 1, 2, 3, 4, 5

Even if a scalar variable receives the result of a command that returns multiple items, PowerShell still treats the variable itself as a single container:


$processes = Get-Process

Here, $processes is a scalar variable that holds a collection (an array-like object) of process objects. The variable is scalar; the value it contains is a collection. This distinction is important: scalar describes the variable’s role (one slot), not necessarily the nature of the value (single item vs. multiple items).


Common scalar types and usage​

Strings​

Strings store text:


$message = "Backup completed successfully."

$path    = "C:\Data\Report.txt"

Typical usage:

Integers and numeric types​

Numeric scalars store whole numbers or floating‑point values:


[int]   $retryCount = 3

[double]$threshold  = 0.75

Typical usage:

Booleans​

Booleans represent logical values:


[bool]$isAdmin   = $true

[bool]$isEnabled = $false

Typical usage:

Objects​

Scalar variables can hold complex objects:


$process = Get-Process -Name "powershell"

$user    = Get-LocalUser -Name "Administrator"

These variables still hold a single value, but that value is an object with properties and methods.


Scalar variables in expressions and operators​

Scalar variables are frequently used with operators:


$a = 10

$b = 20



$sum      = $a + $b

$isEqual  = ($a -eq $b)

$isGreater = ($a -gt 5)

Examples of usage:

Scalar variables participate directly in these expressions, and PowerShell performs type‑appropriate operations.


Scalar variables and command output​

Scalar variables often store the result of commands:


$currentUser = [System.Environment]::UserName

$service     = Get-Service -Name "Spooler"

$time        = Get-Date

These values are then reused in later commands:


Write-Output "Current user: $currentUser"

Write-Output "Service status: $($service.Status)"

Write-Output "Current time: $time"

This pattern—capture, store, reuse—is central to scripting.


Summary of main usage​

Scalar variables are used to:

They provide the basic “named storage” that makes scripts readable, maintainable, and expressive.

Found this helpful? Share the knowledge...

... or support this project to keep it alive!

Buy Me a Coffee

Previous

Variables & Types

Next

Arrays