PowerShell is a cross-platform task automation solution made up of a command-line shell, a scripting language, and a configuration management framework. It runs on Windows, Linux, and macOS.

Primary Purpose:

• Automation: It allows administrators to automate repetitive tasks (e.g., creating users, managing updates) using scripts.
• Configuration Management: It helps in managing the configuration of systems (Infrastructure as Code).
• Object-Oriented: Unlike traditional shells that pass text, PowerShell passes objects, making data manipulation easier and more precise.
• Interoperability: It works seamlessly with .NET objects, COM, and WMI.

PowerShell Console:

• This is the standard command-line interface (CLI).
• It is primarily used for running single commands or executing pre-written scripts.
• It has limited editing capabilities compared to an IDE.
• It consumes fewer system resources.

PowerShell ISE:

• This is a graphical host application.
• It provides a script editor with syntax highlighting, tab completion, and a visual debugging tool.
• It allows users to write, test, and debug scripts in a GUI environment.
• It supports multiple tabs for working on different scripts simultaneously.

Cmdlets (pronounced "command-lets") are lightweight commands used in the PowerShell environment. They perform specific functions and return objects to the pipeline.

Naming Convention (Verb-Noun):
PowerShell uses a strict Verb-Noun syntax to make commands easy to learn and predict.

• Verb: Indicates the action to be performed (e.g., Get, Set, New, Remove).
• Noun: Indicates the resource the action is performed on (e.g., Service, Process, Item).

Examples:

• Get-Process: Retrieves a list of running processes.
• New-Item: Creates a new file or directory.
• Remove-Item: Deletes a file or directory.

Defining Variables:
In PowerShell, variables are text strings that begin with the $ symbol. Values are assigned using the assignment operator =.

Syntax:
powershell
$VariableName = Value

Example:
powershell
$MyNumber = 10
$Greeting = "Hello World"

Dynamic Typing:
PowerShell is dynamically typed, meaning you do not have to explicitly declare the data type of a variable. The system determines the type based on the value assigned to it.

• If you assign 10, it becomes an Int32.
• If you assign "Text", it becomes a String.
• However, you can enforce strong typing if needed: [int]$Number = 5.

The Pipeline (|):
The pipeline is a mechanism that connects the output of one command to the input of another. It allows users to chain commands together to perform complex tasks.

How it works:

1. Command A executes and generates output.
2. The pipeline operator (|) passes this output immediately to Command B.
3. Command B processes the input and passes it to Command C, and so on.

Difference from Text-based Shells (e.g., Bash):

• Text-based (Bash): Passes raw text (strings). Parsing requires tools like awk or sed to extract specific data.
• Object-based (PowerShell): Passes complete .NET objects. This means properties and methods of the object are preserved. For example, if you pipe a process object, the next command receives the actual Process object, allowing access to properties like ProcessName or Id directly without text parsing.

Unlike many programming languages that use symbols (like >, <, ==), PowerShell uses hyphenated codes for comparison operators. They are case-insensitive by default.

Common Operators:

• -eq (Equal to): Returns true if values are equal. (e.g., b)
• -ne (Not equal to): Returns true if values are not equal.
• -gt (Greater than): Returns true if the left value is greater than the right.
• -lt (Less than): Returns true if the left value is less than the right.
• -ge (Greater than or equal to): Returns true if greater or equal.
• -le (Less than or equal to): Returns true if less or equal.
• -like: Performs wildcard matching (e.g., "PowerShell" -like "Power*").

The if statement allows scripts to make decisions based on logical tests.

Syntax:
powershell
if (condition) {

Code to run if condition is true

} elseif (another_condition) {

Code to run if the second condition is true

} else {

Code to run if no conditions are met

}

Example:
powershell
$Score = 85

if ($Score -ge 90) {
Write-Host "Grade: A"
} elseif ($Score -ge 80) {
Write-Host "Grade: B"
} else {
Write-Host "Grade: C"
}

In this example, since $Score is 85, the output will be "Grade: B".

The Switch statement is a selection structure used to handle multiple conditions more efficiently than a long series of if-elseif statements.

Syntax:
powershell
switch ($variable) {
value1 { action1 }
value2 { action2 }
Default { default_action }
}

Preference:

• Readability: It is cleaner and easier to read when testing a single variable against many possible values.
• Performance: It can be slightly faster for many conditions.
• Features: It supports advanced matching, including wildcards, regex, and file processing (processing a file line by line).

While Loop:

• Type: Entry-controlled loop.
• Logic: The condition is evaluated before the code block is executed.
• Consequence: If the condition is false initially, the code block inside the loop may never execute.
• Syntax: while (condition) { code }

Do-While Loop:

• Type: Exit-controlled loop.
• Logic: The code block is executed first, and then the condition is evaluated.
• Consequence: The code block is guaranteed to execute at least once, regardless of the condition.
• Syntax: do { code } while (condition)

Arrays are data structures used to store collections of items. In PowerShell, arrays are zero-indexed.

Declaration:
Arrays can be created using the comma operator or the range operator.

• Explicit: $Numbers = 1, 2, 3, 4, 5
• Range: $Numbers = 1..5
• Empty Array: $MyArray = @()

Accessing Elements:
Elements are accessed using square brackets [] containing the index number.

• First element: $Numbers[0] (Returns 1)
• Third element: $Numbers[2] (Returns 3)
• Last element: $Numbers[-1] (Returns 5)

Adding Elements:
Arrays in PowerShell are fixed size. Adding an element typically creates a new array copy.
$Numbers += 6

Hashtable:
A hashtable (also known as a dictionary or associative array) is a data structure that stores data in Key-Value pairs.

Syntax:
powershell
$User = @{
Name = "John Doe";
ID = 123;
Department = "IT"
}

Difference from Array:

• Indexing: Arrays use numerical indices (0, 1, 2) to access data. Hashtables use unique keys (strings or objects) to access values.
• Structure: Arrays are ordered lists. Hashtables are collections of named properties.
• Usage: Arrays are best for lists of similar items. Hashtables are best for structured data representing a single object with multiple properties (like a record).

Here is the implementation of the Get-Square function using a param block and the multiplication operator.

powershell
function Get-Square {

Define input parameters

param (
    [int]$Number
)

# Calculate the square
Number * $Number

# Return the result
return $Square

}

Example Usage:

$Result = Get-Square -Number 5
Write-Host "The square of 5 is: $Result"

Explanation:

1. function Get-Square: Declares the function name.
2. **param ([int]Number enforced as an integer.
3. Number: Performs the math logic.
4. return: Sends the output back to the caller.

Scope determines the visibility and accessibility of variables and functions.

1. Global Scope:

   • The highest level. Variables defined here are accessible anywhere in the current PowerShell session.
   • Example: $Global:VarName = "Value"

2. Script Scope:

   • Created when a script file executes. Variables are visible only within that specific script file.
   • Example: $Script:VarName = "Value"

3. Local Scope:

   • The current scope. If you are inside a function, Local is the function scope. If you are in the console, Local is Global.

4. Private Scope:

   • Variables defined as Private are visible in the current scope but generally not inherited by child scopes (functions called within the scope).
   • Example: $Private:VarName = "Hidden"

PowerShell uses structured error handling to manage exceptions (terminating errors) gracefully.

• Try Block:

  • Contains the code that might generate an error.
  • PowerShell monitors this block for exceptions.

• Catch Block:

  • Executes only if an error occurs in the Try block.
  • You can specify different Catch blocks for different error types.
  • This is where you log errors or provide fallback logic.

• Finally Block:

  • Executes regardless of whether an error occurred or not.
  • Used for cleanup tasks, such as closing file streams or database connections.

Example:
powershell
try {
$content = Get-Content "nonexistent.txt" -ErrorAction Stop
}
catch {
Write-Host "File not found!"
}
finally {
Write-Host "Operation Complete."
}

PowerShell Profiles:
A profile is a startup script (.ps1 file) that runs automatically when you start a PowerShell session. It acts like a login script for the shell environment.

Usage:

• Customization: It allows users to customize their environment (colors, prompt text, window size).
• Aliases & Functions: You can define commonly used aliases and custom functions in the profile so they are always available.
• Module Loading: Automatically import necessary modules upon startup.
• Variables: Set permanent environment variables.

There are different profile types affecting different scopes (e.g., Current User, All Users). The most common is Current User, Current Host.

Read-Host:

• Purpose: Takes input from the user via the console.
• Mechanism: It pauses execution and waits for the user to type text and press Enter.
• Security: Can use -AsSecureString to mask input (e.g., for passwords).
• Example: $Name = Read-Host "Enter your name"

Write-Host:

• Purpose: Writes output directly to the console screen (host).
• Mechanism: It displays text but does not send objects to the pipeline. It is purely for display.
• Formatting: Allows customization of text color (-ForegroundColor) and background color.
• Example: Write-Host "Success!" -ForegroundColor Green

Comments are non-executable text used to document code.

1. Single-Line Comments:

• Start with the hash symbol #.
• Everything to the right of the # on that line is ignored by the interpreter.
• Example:
  powershell
  $x = 5 # This sets x to 5

  This is a comment

2. Multi-Line (Block) Comments:

• Start with <# and end with #>.
• Used for long descriptions or commenting out blocks of code.
• Example:
  powershell
  <#
  This script calculates the area of a circle.
  Author: Admin
  Date: 2023

  >

Significance:
The Help System is a built-in documentation tool that allows users to discover commands and learn how to use them without leaving the console. It encourages self-learning and reduces reliance on external web searches.

Using Get-Help:
The Get-Help cmdlet retrieves information about cmdlets, functions, scripts, and concepts.

Key Parameters:

• Basic Usage: Get-Help Get-Process (Shows syntax and description).
• -Examples: Get-Help Get-Process -Examples (Shows practical usage scenarios).
• -Detailed: Provides parameter descriptions.
• -Full: Shows all available information.
• -Online: Opens the latest documentation in a web browser.

1. Foreach Statement (Loop):

• Syntax: foreach (collection) { ... }
• Memory: Loads the entire collection into memory before processing starts. Faster for small collections but memory-intensive for large ones.
• Usage: Used inside scripts for standard iteration logic.

2. ForEach-Object Cmdlet (Pipeline):

• Syntax: $collection | ForEach-Object { ... } (Alias: %)
• Memory: Processes items one by one as they pass through the pipeline (streaming). Uses less memory.
• Usage: Used in pipelines for real-time processing of data streams.

Key Difference: The Statement requires all data upfront; the Cmdlet processes data as it arrives.

Logical operators allow you to connect multiple conditions or expressions to form complex logic statements. They return Boolean values (True or False).

Common Operators:

• -and: Returns TRUE only if both operands are true.
  • Example: (a -lt 10)
• -or: Returns TRUE if at least one of the operands is true.
  • Example: (a -eq 2)
• -not (or !): Reverses the boolean value. Returns TRUE if the statement is false.
  • Example: -not ($a -eq 5)
• -xor (Exclusive OR): Returns TRUE if only one of the operands is true, but not both.