Discover published sets by community

PowerShell can respond to system events using Register-ObjectEvent. Syntax: `Register-ObjectEvent -InputObject $timer -EventName Elapsed -Action { Write-Host 'Timer elapsed!' }`$

Variables store data that can be used and manipulated throughout a PowerShell script. Syntax: `$variableName = 'value'`$

HashTables are a collection of key-value pairs and are created using @{}. Syntax: `$myHashtable = @{Key1 = 'Value1'; Key2 = 'Value2'}`$

Functions are blocks of code designed to perform a particular task and can be reused. Syntax: `function Verb-Noun { ... }`

Modules are packages of related PowerShell cmdlets, functions, variables, and more. Syntax to import a module: `Import-Module ModuleName`

Cmdlet Sort-Object sorts objects by property values. Syntax: `Get-Process | Sort-Object -Property CPU`

Providers allow access to data stores, such as the file system, registry, or environment variables. Syntax: `Get-Item -Path Env:Path`

PowerShell supports various data types like integers, strings, booleans, and arrays. Syntax for array: `$array = @(1, 2, 3)`$

Arithmetic operators include +, -, *, /, % for calculations. Syntax: `$sum =$first + $second`$

Conditional statements control the flow of execution based on conditions. Syntax: `if($condition) { ... } elseif($condition) { ... } else { ... }`

For loops execute a block of code a set number of times. Syntax: `for ($i = 0;$i -lt 10; i++) { Write-Host i }`

While loops continue executing as long as a condition is true. Syntax: `while ($condition) { ... }`$

Profiles in PowerShell are scripts that run at startup. Syntax to view your profile: `echo $PROFILE`$

Filtering objects based on their properties is commonly done using Where-Object. Syntax: `Get-Process | Where-Object {_.WorkingSet -gt 100MB}`

Cmdlets are built-in PowerShell functions that perform an action. Syntax: `Get-Command`, `Set-Location C:\`

Do-While loops execute the block at least once and then repeat as long as a condition is true. Syntax: `do { ... } while ($condition)`$

Foreach loops iterate over each item in a collection. Syntax: `foreach ($item in$collection) { Write-Host item }`

Strings can be manipulated with operators like -concat, -join, -split. Syntax for join: `'-'.join('a', 'b', 'c')`

PowerShell has several cmdlets to format output, such as Format-Table, Format-List. Syntax: `Get-Process | Format-Table -Property ID, CPU, Name`

Script parameters allow passing arguments to a PowerShell script from the command line. Syntax: `param ([type]$param1, [type]$param2)`

Logical operators -and, -or, -not are used to combine multiple conditions. Syntax: `$condition1 -and$condition2`

Arrays hold a collection of items. You can define an array with @(). Syntax: `$myArray = @(1, 'two', 3)`$

PowerShell supports transactions which allows for a group of commands to be treated as a single unit of work. Syntax: `Start-Transaction; ...; Complete-Transaction`

Data can be output to the screen or to another command via Write-Host, Write-Output, or simply using the object. Syntax: `Write-Host 'Hello World!'`

PowerShell enables management of remote systems via cmdlets like Invoke-Command, Enter-PSSession. Syntax: `Invoke-Command -ScriptBlock { ... } -ComputerName Computer`

Jobs in PowerShell allow for asynchronous script execution. Syntax to start a job: `Start-Job -ScriptBlock { ... }`

Comments are used to add descriptive text in the script that is ignored during execution. Single-line Syntax: `# Comment`; Multi-line Syntax: `<# Comment #>`

Regular expressions are used for pattern matching. Syntax: `$string -match '^[a-zA-Z]+$'`

Try-Catch blocks are used for catching and handling exceptions. Syntax: `try { ... } catch { ... }`

Parameters are variables used to pass data into functions. Syntax: `function MyFunction([type]$param1, [type]$param2) { ... }`

Assignment operators are used to assign values to variables. The most common one is =. Syntax: `$var = 5`$

PowerShell can perform file operations with cmdlets like Get-Content, Set-Content. Syntax: `Get-Content file.txt`

Script blocks enclose a collection of statements or expressions that can be passed as a unit of work. Syntax: `${ ... }`$

Pipelines pass the output of one cmdlet as the input to another. Syntax: `Get-Process | Where-Object {_.CPU -gt 100}`

PowerShell provides operators for comparing values, such as -eq (equals), -ne (not equals), -gt (greater than), etc. Syntax: `$var -eq 'value'`$

Serialization converts objects to a format that can be stored or transmitted. PowerShell uses cmdlets like Export-Clixml. Syntax: `Get-Process | Export-Clixml -Path processes.xml`