Unit 5: PowerShell Basics and Core Concepts - Subjective Questions

PowerShell is a cross-platform command-line shell, scripting language, and automation framework developed by Microsoft. It is built on the .NET platform.

Key differences include:

• Object-based processing: PowerShell passes structured .NET objects between commands, whereas traditional shells generally pass plain text.
• Cmdlets: It provides commands such as Get-Process and Get-Service that follow a consistent Verb-Noun naming convention.
• Powerful scripting: It supports variables, functions, loops, conditional statements, modules, and error handling.
• System administration: It can manage files, processes, services, the registry, networks, and remote computers.
• Cross-platform support: Modern PowerShell runs on Windows, Linux, and macOS.

Therefore, PowerShell combines interactive command execution with a full scripting environment for administration and automation.

The PowerShell Console is an interactive command-line interface in which commands can be entered and executed immediately.

• It is lightweight and starts quickly.
• It is suitable for running individual commands and short command sequences.
• It displays command output directly in the terminal.
• It is commonly used for routine administration and testing commands.

The PowerShell Integrated Scripting Environment (ISE) is a graphical environment for creating and testing Windows PowerShell scripts.

• It includes a script editor, command pane, and output pane.
• It provides syntax highlighting, tab completion, and debugging tools.
• It allows selected portions of a script to be executed.
• It is suitable for developing and troubleshooting longer scripts.

PowerShell ISE is Windows-specific and is no longer actively developed. For modern PowerShell development, Visual Studio Code with the PowerShell extension is generally preferred.

A PowerShell script is a text file with the .ps1 extension.

Steps to create and execute a script:

1. Open a text editor, PowerShell ISE, or Visual Studio Code.
2. Enter PowerShell statements, such as $name = Read-Host "Enter your name".
3. Save the file with a .ps1 extension, for example Greeting.ps1.
4. Open PowerShell and move to the script directory using Set-Location or cd.
5. Execute the script using ./Greeting.ps1 on PowerShell Core or .\Greeting.ps1 on Windows.

The execution policy controls the conditions under which PowerShell loads configuration files and runs scripts. Common policies include Restricted, RemoteSigned, AllSigned, and Bypass. The current policies can be inspected with Get-ExecutionPolicy -List.

Execution policy is a safety feature that helps prevent accidental script execution, but it is not a complete security boundary. Policy changes should follow the organization's security requirements.

A PowerShell variable begins with the $ symbol. A value is assigned using the assignment operator =.

Examples:

• $name = "Asha" stores a string.
• $age = 20 stores an integer.
• $isActive = $true stores a Boolean value.

PowerShell variable names are generally case-insensitive. Names should be meaningful and may contain letters, numbers, and underscores. Braces can remove ambiguity in complex names, as in ${student-name}.

PowerShell normally determines the data type automatically. The type can be examined using $age.GetType().

A type can also be specified explicitly:

• [int]$quantity = 5
• [string]$code = 101
• [datetime]$today = "2025-01-01"

Type casting converts a value to another compatible type. For example, [int]"25" converts the string "25" to an integer. An invalid conversion produces an error.

PowerShell commonly accepts interactive input through the Read-Host cmdlet. Since Read-Host normally returns a string, numeric input should be converted to a suitable numeric type.

Example script:

[double]$first = Read-Host "Enter the first number"
[double]$second = Read-Host "Enter the second number"
$sum = $first + $second
Write-Output "Sum = $sum"

Explanation:

• Read-Host displays a prompt and waits for the user to enter a value.
• [double] converts each input value to a number that can include a decimal part.
• The + operator adds the two numeric values.
• Write-Output sends the result to the PowerShell output stream.

Without numeric conversion, two string values could be concatenated instead of added. Production scripts should also validate the input or handle conversion errors.

PowerShell supports comments for documentation and for temporarily preventing code from being executed.

• Single-line comment: Begins with # and continues to the end of the line. Example: # Calculate the total.
• Block comment: Begins with <# and ends with #>. It can span several lines and is useful for longer explanations.
• Comment-based help: Uses specially recognized keywords inside a block comment to document a script or function.

A comment-based help section may contain:

• .SYNOPSIS for a brief description.
• .DESCRIPTION for detailed information.
• .PARAMETER for parameter documentation.
• .EXAMPLE for usage examples.
• .NOTES for additional information.

After comment-based help is added correctly, users can view it through Get-Help. Comments should explain the purpose or reasoning of code rather than merely repeat what each statement does.

A cmdlet is a lightweight PowerShell command designed to perform a specific operation. Cmdlets usually produce and consume structured objects.

PowerShell cmdlets use the Verb-Noun naming convention:

• The verb identifies the action, such as Get, Set, New, or Remove.
• The noun identifies the resource, such as Process, Service, or Item.

For example, Get-Process retrieves process objects. Parameters modify command behavior, as in Get-Process -Name powershell. Switch parameters represent Boolean choices, such as -Force.

An alias is an alternative short name for a command. For example, gci is an alias for Get-ChildItem. Full cmdlet names are preferable in scripts because they are clearer.

Useful discovery commands include:

• Get-Command to find commands.
• Get-Alias to inspect aliases.
• Get-Verb to list approved verbs.
• Get-Help to read command documentation.

The PowerShell pipeline uses the | operator to send output from one command to the next command. Unlike many traditional shells, PowerShell normally passes objects, including their properties and methods, rather than unstructured text.

Example:

Get-Process |
    Where-Object { $_.CPU -gt 10 } |
    Sort-Object CPU -Descending |
    Select-Object -First 5 Name, CPU

Pipeline stages:

• Get-Process creates process objects.
• Where-Object filters objects whose CPU property is greater than 10.
• $_ represents the current pipeline object.
• Sort-Object sorts the remaining objects by CPU usage.
• Select-Object returns the first five objects with only the Name and CPU properties.

Because object properties remain available in the pipeline, commands can filter, sort, group, measure, and export data without manually parsing formatted text.

PowerShell operators can be classified by their purpose.

• Arithmetic operators: +, -, *, /, and %. Example: $remainder = 17 % 5.
• Assignment operators: =, +=, -=, *=, and /=. Example: $total += 10.
• Comparison operators: -eq, -ne, -gt, -ge, -lt, and -le. Example: $age -ge 18.
• Logical operators: -and, -or, -not, and !. Example: ($age -ge 18) -and $hasID.
• String and pattern operators: -like, -notlike, -match, and -replace. Example: $name -like "A*".
• Containment operators: -contains, -notcontains, -in, and -notin. Example: $role -in @("Admin", "Editor").
• Type operators: -is, -isnot, and -as. Example: $value -is [int].

PowerShell comparison operators are case-insensitive by default. Prefixing them with c, as in -ceq, performs a case-sensitive comparison.

Conditional statements execute different blocks of code according to whether Boolean conditions are true or false. PowerShell evaluates if first, then each elseif in order, and finally else if no earlier condition is true.

Example:

[int]$score = Read-Host "Enter the score"

if ($score -lt 0 -or $score -gt 100) {
    $grade = "Invalid score"
}
elseif ($score -ge 80) {
    $grade = "A"
}
elseif ($score -ge 60) {
    $grade = "B"
}
elseif ($score -ge 40) {
    $grade = "C"
}
else {
    $grade = "Fail"
}

Write-Output "Grade: $grade"

The conditions are ordered from the highest score boundary to the lowest. Only the first matching block is executed. The initial condition prevents values outside the valid range from being graded.

The switch statement compares one or more input values against several conditions. It is often clearer than a long chain of elseif statements.

Exact matching:

switch ($choice) {
    "start" { "Starting service"; break }
    "stop"  { "Stopping service"; break }
    default { "Unknown choice" }
}

PowerShell also supports different matching modes:

• switch -Wildcard ($value) permits patterns such as "Error*".
• switch -Regex ($value) permits regular expressions such as "^ERR\d+$".
• switch -CaseSensitive ($value) performs case-sensitive matching.
• switch -File path evaluates each line of a file.

The automatic variable $_ represents the current input value inside a matching block. Unlike switch in some languages, PowerShell may execute multiple matching clauses. The break statement can stop further matching when only one result is required.

PowerShell provides several loop structures for repeated execution.

• for loop: Best when initialization, a continuation condition, and an update expression are known. Example: for ($i = 0; $i -lt 5; $i++) { $i }.
• foreach statement: Best for processing every item in a collection. Example: foreach ($name in $names) { $name }.
• while loop: Tests its condition before each iteration. It may execute zero times. Example: while ($count -lt 5) { $count++ }.
• do loop: Executes the body before testing its condition, so it runs at least once. It can use either do { } while (condition) or do { } until (condition).

break exits a loop immediately, whereas continue skips the remainder of the current iteration. A loop must update the state used in its condition; otherwise, it may become an infinite loop.

An array is an ordered collection of values. PowerShell arrays can contain values of the same type or mixed types.

Creation:

• $colors = @("Red", "Green", "Blue")
• $numbers = 1..5
• [int[]]$scores = 70, 80, 90

Access and inspection:

• $colors[0] returns the first element.
• $colors[-1] returns the last element.
• $colors[0..1] returns a range of elements.
• $colors.Count gives the number of elements.

An existing element can be changed using $colors[1] = "Yellow". An item can be appended using $colors += "Black", although repeated use of += can be inefficient for large collections because arrays have fixed size internally.

Arrays can be processed with foreach ($color in $colors) { $color } or through the pipeline. Methods and operators such as -contains, Where-Object, and Sort-Object can be used to search, filter, and arrange their elements.

A hashtable stores data as key-value pairs. It is useful when values need to be retrieved by meaningful keys rather than numeric indexes.

Creation:

$student = @{
    Name = "Ravi"
    Age = 20
    Course = "IT"
}

Operations:

• Access by key: $student["Name"] or $student.Name.
• Add or update a value: $student["Grade"] = "A".
• Update an existing value: $student.Age = 21.
• Check for a key: $student.ContainsKey("Course").
• Remove a key: $student.Remove("Course").
• Obtain keys or values: $student.Keys and $student.Values.

Enumeration:

foreach ($entry in $student.GetEnumerator()) {
    "entry.Key): entry.Value)"
}

A normal hashtable does not guarantee display order. An ordered dictionary can be created with [ordered]@{ Name = "Ravi"; Age = 20 } when insertion order matters.

A PowerShell function is a named reusable block of code. Parameters receive values from callers, and output is returned through the success output stream.

Example advanced function:

function Get-Square {
    [CmdletBinding()]
    param(
        [Parameter(Mandatory, ValueFromPipeline)]
        [ValidateRange(-1000, 1000)]
        [double]$Number
    )

    process {
        $Number * $Number
    }
}

2, 4, 6 | Get-Square

Explanation:

• function Get-Square declares the function.
• [CmdletBinding()] gives it advanced-function behavior.
• param defines its parameters.
• Mandatory requires a value when the function is called directly.
• ValueFromPipeline allows pipeline input.
• ValidateRange rejects values outside the permitted range.
• The process block runs once for each pipeline input object.
• $Number * $Number writes the calculated value to the output stream.

PowerShell functions usually should emit objects or values instead of presentation-only text so their output can be reused in pipelines.

A scope determines where a variable, function, or alias is visible and where it can be modified.

• Global scope: Created when PowerShell starts. An explicitly global variable can be referenced as $global:name.
• Script scope: Exists while a script file runs. A script-level variable can be referenced as $script:name.
• Local scope: Represents the current scope. Functions and script blocks generally create child local scopes. It can be referenced as $local:name.
• Private scope: Prevents an item from being visible to child scopes. A private variable can be declared as $private:name.

A child scope can normally read values from a parent scope, but assigning to an unqualified variable usually creates or changes a variable in the current scope. Scope modifiers should be used deliberately because excessive global state makes scripts difficult to test and maintain. Passing values through parameters and returning output is usually preferable.

PowerShell distinguishes between terminating and non-terminating errors. A try block handles terminating errors, while many cmdlets produce non-terminating errors by default.

Example:

try {
    $content = Get-Content -Path "data.txt" -ErrorAction Stop
    if ($content.Count -eq 0) {
        throw "The file is empty."
    }
    $content
}
catch {
    Write-Error "Operation failed: _.Exception.Message)"
}
finally {
    Write-Verbose "File operation completed."
}

Explanation:

• try contains code that may fail.
• -ErrorAction Stop converts a cmdlet's non-terminating error into a terminating error.
• throw creates a terminating error explicitly.
• catch handles the error, and $_ contains the current error record.
• finally runs whether the operation succeeds or fails, making it useful for cleanup.

Scripts should report useful context without silently hiding errors. Specific exception types may also be handled with typed catch blocks when different recovery actions are required.

PowerShell provides a built-in help system through the Get-Help cmdlet.

Common uses include:

• Get-Help Get-Process displays basic help for a cmdlet.
• Get-Help Get-Process -Detailed displays parameter descriptions and additional details.
• Get-Help Get-Process -Full displays the complete local help content.
• Get-Help Get-Process -Examples displays usage examples.
• Get-Help Get-Process -Parameter Name explains a specific parameter.
• Get-Help about_* lists conceptual help topics.
• Get-Help about_Arrays displays help about arrays.
• Get-Help Get-Process -Online opens online documentation when supported.

Help files can be downloaded or refreshed with Update-Help, which may require suitable permissions and network access. Get-Command complements the help system by locating commands before their exact names are known.

A PowerShell profile is a script that runs automatically when a PowerShell host starts. It can configure the user's working environment by defining functions, aliases, variables, prompt customization, or module imports.

The automatic variable $PROFILE contains the path of the current user and current host profile. Other profile paths are available as properties, such as $PROFILE.CurrentUserAllHosts and $PROFILE.AllUsersCurrentHost.

A profile can be created with:

if (-not (Test-Path $PROFILE)) {
    New-Item -ItemType File -Path $PROFILE -Force
}

It can then be opened in an editor, for example with notepad $PROFILE on Windows. Changes usually take effect in a new PowerShell session, although the file can be loaded immediately with . $PROFILE.

Profiles should remain fast, predictable, and free of untrusted code. Scripts should not depend on personal profile settings because profiles may not load in scheduled tasks, remote sessions, or automation hosts.

A reusable solution can accept service names as an array and return one object for each service.

Example script:

[CmdletBinding()]
param(
    [Parameter(Mandatory)]
    [string[]]$ServiceName
)

function Get-ServiceReport {
    param([string]$Name)

    try {
        $service = Get-Service -Name $Name -ErrorAction Stop
        [pscustomobject]@{
            Name = $service.Name
            DisplayName = $service.DisplayName
            Status = $service.Status
            Found = $true
        }
    }
    catch {
        [pscustomobject]@{
            Name = $Name
            DisplayName = $null
            Status = "Unknown"
            Found = $false
        }
    }
}

foreach ($name in $ServiceName) {
    Get-ServiceReport -Name $name
}

Concepts used:

• The script-level param block accepts an array of service names.
• foreach processes every array element.
• The function keeps the lookup and report-building logic reusable.
• Get-Service returns structured service objects.
• try and catch handle names that do not identify an installed service.
• [pscustomobject] produces consistent pipeline-friendly report objects.

The script could be executed as .\ServiceReport.ps1 -ServiceName Spooler, W32Time and its output could be piped to Format-Table, Export-Csv, or Where-Object.