Tag: PowerShell

Preview 2 has dropped! Let’s look at some of the major things that are coming in this preview.

First – let’s look at the breaking changes:

Breaking Changes

• Adjustments have been made to the -OlderThan and -NewerThan parameters for Test-Path, addressing issues when used with PathType and a date range​
• The default CatalogVersion for New-FileCatalog has been changed to 2​​
• Restrictions have been added to block help from network locations in restricted remoting sessions​

And now to the improvements:

Tab Completion Improvements

• Efforts led by contributors like @ArmaanMcleod have refined tab completion, including preventing fallback to file completion when tab completing type names and adding argument completers for various cmdlets like Set-StrictMode, Get-Verb, Start-Process, and more​

Web Cmdlets Improvements

• Fixes have been made to Invoke-WebRequest to ensure accurate size reporting when the -Resume parameter is specified​
• Web Cmdlets have been adjusted to allow WinForm applications to work correctly​

Other Cmdlet Improvements

• A range of cmdlet improvements and fixes, including for Test-Connection, Get-Service, and adding new parameters to New-Guid. For instance, New-Guid now supports -Empty and -InputObject parameters​

Engine Improvements

• Enhancements in the engine include telemetry for module imports, adjustments to module load telemetry, and fixes for regressions introduced by the WDAC logging feature​

Experimental Features

• Introduction of tilde expansion for Windows native executables, demonstrating PowerShell’s ongoing evolution and adaptation​

​.

PowerShell 7 introduces several lesser-known features that can significantly enhance your scripting prowess. Let’s dive into these hidden gems.

Ternary Operator for Concise Conditional Logic

PowerShell 7 brings the ternary operator (?:), a shorthand for simple if-else statements, allowing for more concise and readable code.

$result = ($value -eq 10) ? "Equal to 10" : "Not equal to 10"

Pipeline Parallelization with ForEach-Object -Parallel

The -Parallel parameter in ForEach-Object can dramatically improve performance by executing script blocks in parallel. Note that it requires the use of the -ThrottleLimit parameter to control the number of concurrent threads.

1..50 | ForEach-Object -Parallel { $_ * 2 } -ThrottleLimit 10

Simplified Error Viewing with $ErrorView and Get-Error

PowerShell 7 introduces a new view for error messages through the $ErrorView variable, which can be set to ConciseView for a more streamlined error display. Additionally, Get-Error provides detailed error information, perfect for troubleshooting.

$ErrorView = 'ConciseView'
Get-Error

Null Conditional Operators for Handling $null

The null conditional operators ?. and ?[] provide a safe way to access properties and methods or index into arrays when there’s a possibility of $null values, preventing unnecessary errors.

$obj = $null
$name = $obj?.Name  # Returns $null without throwing an error
$value = $array?[0] # Safely attempts to access the first element

The switch Statement Enhancements

PowerShell 7 enhances the switch statement with the -Regex and -File options, allowing pattern matching against regex expressions and simplifying file content parsing.

switch -Regex ($inputString) {
    'error' { Write-Output 'Error found' }
    'warning' { Write-Output 'Warning found' }
}

Coalescing Operators for Default Values

The null coalescing operators ?? and ??= simplify the process of providing default values for potentially $null variables, reducing the need for verbose if statements.

$name = $null
$displayName = $name ?? 'Default Name'

Automatic Unwrapping of Single-Element Arrays

A subtle but handy feature; when a command or expression returns an array with a single element, PowerShell 7 automatically unwraps it, eliminating the need for manual indexing to access the single item.

Enhanced JSON Handling with ConvertFrom-Json and ConvertTo-Json

Improvements to ConvertFrom-Json and ConvertTo-Json cmdlets include better depth handling and the ability to work with PSCustomObject instances, streamlining JSON serialization and deserialization.

$json = '{"name": "PowerShell", "version": 7}'
$obj = $json | ConvertFrom-Json

Invoke DSC Resources Directly from PowerShell 7

Directly invoking Desired State Configuration (DSC) resources within PowerShell 7 scripts bridges traditional configuration management with modern PowerShell scripting, enhancing automation capabilities.

There ya go! Hope you find something in here that makes coding a bit more fun/easy!

Hey there, PowerShell aficionados! Whether you’re automating your morning coffee or deploying a fleet of VMs into the cloud, efficiency is key. Nobody wants to watch paint dry while their script runs in the background. So, let’s put some pep into that PowerShell script of yours. We’re diving straight into the realm of optimization – no fluff, just the good stuff.

Measure, Then Cut: Profiling Your Script

Before you start tweaking, let’s figure out where the bottlenecks are. PowerShell, being the Swiss Army knife it is, comes equipped with some nifty profiling tools like Measure-Command. This cmdlet lets you time how long it takes for a script or command to run. Use it to identify slow parts of your script:

Measure-Command { .\YourScript.ps1 }

Lean and Mean: Streamlining Execution

1. Filter Left, Format Right

One of the golden rules for optimizing PowerShell scripts is to do your filtering as early as possible. Use cmdlets like Where-Object and Select-Object judiciously to trim down your data before processing it further. Remember, processing less data means faster execution:

Get-Process | Where-Object { $_.CPU -gt 100 } | Select-Object Name, CPU

2. Avoid the Pipeline When Possible

While the pipeline is one of PowerShell’s most powerful features, it’s not always the most efficient. Each pipe operation adds overhead. For tight loops or operations that need to be as fast as possible, consider using .NET collections or array manipulations:

$processes = Get-Process
$highCpuProcesses = [System.Collections.ArrayList]@()
foreach ($process in $processes) {
    if ($process.CPU -gt 100) {
        [void]$highCpuProcesses.Add($process)
    }
}

3. Use Foreach-Object Carefully

Foreach-Object is versatile but can be slower than its foreach loop counterpart due to pipeline overhead. For large datasets, stick to foreach for better performance:

# Slower
Get-Process | Foreach-Object { $_.Kill() }

# Faster
foreach ($process in Get-Process) {
    $process.Kill()
}

The Need for Speed: Parallel Processing

When you’re dealing with tasks that can be run concurrently, PowerShell 7’s ForEach-Object -Parallel can be a game-changer. This allows you to run multiple operations at the same time, significantly speeding up processes:

1..10 | ForEach-Object -Parallel { Start-Sleep -Seconds $_; "Slept for $_ seconds" } -ThrottleLimit 10

A Parting Tip: Stay Up-to-Date

PowerShell and .NET are constantly evolving, with new features and performance improvements being added regularly. Make sure your PowerShell version is up-to-date to take advantage of these enhancements.

Wrap-Up

Optimizing PowerShell scripts can turn a sluggish sequence of commands into a streamlined process that runs at lightning speed. By measuring performance, refining your approach, and employing parallel processing, you can ensure your scripts are not only efficient but also maintainable. Happy scripting, and may your execution times always be minimal!