PowerShell 脚本性能注意事项

直接利用 .NET 并避免管道的 PowerShell 脚本往往比惯用的 PowerShell 更快。惯用的 PowerShell 使用 cmdlet 和 PowerShell 函数，通常利用管道，并且仅在必要时才诉诸 .NET。

笔记

此处描述的许多技术都不是惯用的 PowerShell，并且可能会降低 PowerShell 脚本的可读性。建议脚本作者使用惯用的 PowerShell，除非性能另有要求。

抑制输出

有很多方法可以避免将对象写入管道。

• 分配或文件重定向到 $null
• 转换为 [void]
• 管道到Out-Null

分配给 $null、转换为 [void] 以及文件重定向到 $null 的速度几乎相同。但是，在大循环中调用 Out-Null 可能会明显变慢，尤其是在 PowerShell 5.1 中。

$tests = @{
    'Assign to $null' = {
        $arrayList = [System.Collections.ArrayList]::new()
        foreach ($i in 0..$args[0]) {
            $null = $arraylist.Add($i)
        }
    }
    'Cast to [void]' = {
        $arrayList = [System.Collections.ArrayList]::new()
        foreach ($i in 0..$args[0]) {
            [void] $arraylist.Add($i)
        }
    }
    'Redirect to $null' = {
        $arrayList = [System.Collections.ArrayList]::new()
        foreach ($i in 0..$args[0]) {
            $arraylist.Add($i) > $null
        }
    }
    'Pipe to Out-Null' = {
        $arrayList = [System.Collections.ArrayList]::new()
        foreach ($i in 0..$args[0]) {
            $arraylist.Add($i) | Out-Null
        }
    }
}

10kb, 50kb, 100kb | ForEach-Object {
    $groupResult = foreach ($test in $tests.GetEnumerator()) {
        $ms = (Measure-Command { & $test.Value $_ }).TotalMilliseconds

        [pscustomobject]@{
            Iterations        = $_
            Test              = $test.Key
            TotalMilliseconds = [math]::Round($ms, 2)
        }

        [GC]::Collect()
        [GC]::WaitForPendingFinalizers()
    }

    $groupResult = $groupResult | Sort-Object TotalMilliseconds
    $groupResult | Select-Object *, @{
        Name       = 'RelativeSpeed'
        Expression = {
            $relativeSpeed = $_.TotalMilliseconds / $groupResult[0].TotalMilliseconds
            [math]::Round($relativeSpeed, 2).ToString() + 'x'
        }
    }
}

这些测试在 Windows 11 计算机上使用 PowerShell 7.3.4 运行。结果如下所示：

Iterations Test              TotalMilliseconds RelativeSpeed
---------- ----              ----------------- -------------
     10240 Assign to $null               36.74 1x
     10240 Redirect to $null             55.84 1.52x
     10240 Cast to [void]                62.96 1.71x
     10240 Pipe to Out-Null              81.65 2.22x
     51200 Assign to $null              193.92 1x
     51200 Cast to [void]               200.77 1.04x
     51200 Redirect to $null            219.69 1.13x
     51200 Pipe to Out-Null             329.62 1.7x
    102400 Redirect to $null            386.08 1x
    102400 Assign to $null              392.13 1.02x
    102400 Cast to [void]               405.24 1.05x
    102400 Pipe to Out-Null             572.94 1.48x

时间和相对速度可能会有所不同，具体取决于硬件、PowerShell 版本以及系统上的当前工作负载。

数组加法

生成项目列表通常是使用带有加法运算符的数组来完成的：

$results = @()
$results += Get-Something
$results += Get-SomethingElse
$results

数组加法效率低下，因为数组的大小是固定的。数组的每次添加都会创建一个足够大的新数组，以容纳左右操作数的所有元素。两个操作数的元素都被复制到新数组中。对于小型集合，这种开销可能并不重要。对于大型集合，性能可能会受到影响。

有几种选择。如果您实际上不需要数组，请考虑使用类型化通用列表 ([List])：

$results = [System.Collections.Generic.List[object]]::new()
$results.AddRange((Get-Something))
$results.AddRange((Get-SomethingElse))
$results

使用数组加法对性能的影响随着集合大小和添加数量呈指数增长。此代码将显式向数组赋值与使用数组加法以及在 [List] 对象上使用 Add(T) 方法进行比较。它将显式分配定义为绩效基准。

$tests = @{
    'PowerShell Explicit Assignment' = {
        param($count)

        $result = foreach($i in 1..$count) {
            $i
        }
    }
    '.Add(T) to List<T>' = {
        param($count)

        $result = [Collections.Generic.List[int]]::new()
        foreach($i in 1..$count) {
            $result.Add($i)
        }
    }
    '+= Operator to Array' = {
        param($count)

        $result = @()
        foreach($i in 1..$count) {
            $result += $i
        }
    }
}

5kb, 10kb, 100kb | ForEach-Object {
    $groupResult = foreach($test in $tests.GetEnumerator()) {
        $ms = (Measure-Command { & $test.Value -Count $_ }).TotalMilliseconds

        [pscustomobject]@{
            CollectionSize    = $_
            Test              = $test.Key
            TotalMilliseconds = [math]::Round($ms, 2)
        }

        [GC]::Collect()
        [GC]::WaitForPendingFinalizers()
    }

    $groupResult = $groupResult | Sort-Object TotalMilliseconds
    $groupResult | Select-Object *, @{
        Name       = 'RelativeSpeed'
        Expression = {
            $relativeSpeed = $_.TotalMilliseconds / $groupResult[0].TotalMilliseconds
            [math]::Round($relativeSpeed, 2).ToString() + 'x'
        }
    }
}

这些测试在 Windows 11 计算机上使用 PowerShell 7.3.4 运行。

CollectionSize Test                           TotalMilliseconds RelativeSpeed
-------------- ----                           ----------------- -------------
          5120 PowerShell Explicit Assignment             26.65 1x
          5120 .Add(T) to List<T>                        110.98 4.16x
          5120 += Operator to Array                      402.91 15.12x
         10240 PowerShell Explicit Assignment              0.49 1x
         10240 .Add(T) to List<T>                        137.67 280.96x
         10240 += Operator to Array                     1678.13 3424.76x
        102400 PowerShell Explicit Assignment             11.18 1x
        102400 .Add(T) to List<T>                       1384.03 123.8x
        102400 += Operator to Array                   201991.06 18067.18x

当您处理大型集合时，数组添加比添加到要慢得多

List<T>

使用 [List] 对象时，您需要创建具有特定类型的列表，例如 [String] 或 [Int]。当您将不同类型的对象添加到列表中时，它们将被转换为指定的类型。如果它们无法转换为指定类型，该方法将引发异常。

$intList = [System.Collections.Generic.List[int]]::new()
$intList.Add(1)
$intList.Add('2')
$intList.Add(3.0)
$intList.Add('Four')
$intList

MethodException:
Line |
   5 |  $intList.Add('Four')
     |  ~~~~~~~~~~~~~~~~~~~~
     | Cannot convert argument "item", with value: "Four", for "Add" to type
     "System.Int32": "Cannot convert value "Four" to type "System.Int32".
     Error: "The input string 'Four' was not in a correct format.""

1
2
3

当您需要列表是不同类型对象的集合时，请使用[Object]作为列表类型来创建它。您可以枚举集合检查其中对象的类型。

$objectList = [System.Collections.Generic.List[object]]::new()
$objectList.Add(1)
$objectList.Add('2')
$objectList.Add(3.0)
$objectList | ForEach-Object { "$_ is $($_.GetType())" }

1 is int
2 is string
3 is double

如果您确实需要数组，可以调用列表上的 ToArray() 方法，也可以让 PowerShell 为您创建数组：

$results = @(
    Get-Something
    Get-SomethingElse
)

在此示例中，PowerShell 创建一个 [ArrayList] 来保存写入数组表达式内管道的结果。在分配给 $results 之前，PowerShell 会将 [ArrayList] 转换为 [Object[]]。

字符串加法

字符串是不可变的。对字符串的每次添加实际上都会创建一个足够大的新字符串来容纳左右操作数的内容，然后将两个操作数的元素复制到新字符串中。对于小字符串，这种开销可能并不重要。对于大字符串，这可能会影响性能和内存消耗。

至少有两种选择：

• -join 运算符连接字符串
• .NET [StringBuilder] 类提供可变字符串

以下示例比较了这三种构建字符串的方法的性能。

$tests = @{
    'StringBuilder' = {
        $sb = [System.Text.StringBuilder]::new()
        foreach ($i in 0..$args[0]) {
            $sb = $sb.AppendLine("Iteration $i")
        }
        $sb.ToString()
    }
    'Join operator' = {
        $string = @(
            foreach ($i in 0..$args[0]) {
                "Iteration $i"
            }
        ) -join "`n"
        $string
    }
    'Addition Assignment +=' = {
        $string = ''
        foreach ($i in 0..$args[0]) {
            $string += "Iteration $i`n"
        }
        $string
    }
}

10kb, 50kb, 100kb | ForEach-Object {
    $groupResult = foreach ($test in $tests.GetEnumerator()) {
        $ms = (Measure-Command { & $test.Value $_ }).TotalMilliseconds

        [pscustomobject]@{
            Iterations        = $_
            Test              = $test.Key
            TotalMilliseconds = [math]::Round($ms, 2)
        }

        [GC]::Collect()
        [GC]::WaitForPendingFinalizers()
    }

    $groupResult = $groupResult | Sort-Object TotalMilliseconds
    $groupResult | Select-Object *, @{
        Name       = 'RelativeSpeed'
        Expression = {
            $relativeSpeed = $_.TotalMilliseconds / $groupResult[0].TotalMilliseconds
            [math]::Round($relativeSpeed, 2).ToString() + 'x'
        }
    }
}

这些测试在 Windows 11 计算机上使用 PowerShell 7.4.2 运行。输出显示 -join 运算符最快，其次是 [StringBuilder] 类。

Iterations Test                   TotalMilliseconds RelativeSpeed
---------- ----                   ----------------- -------------
     10240 Join operator                      14.75 1x
     10240 StringBuilder                      62.44 4.23x
     10240 Addition Assignment +=            619.64 42.01x
     51200 Join operator                      43.15 1x
     51200 StringBuilder                     304.32 7.05x
     51200 Addition Assignment +=          14225.13 329.67x
    102400 Join operator                      85.62 1x
    102400 StringBuilder                     499.12 5.83x
    102400 Addition Assignment +=          67640.79 790.01x

时间和相对速度可能会有所不同，具体取决于硬件、PowerShell 版本以及系统上的当前工作负载。

处理大文件

在 PowerShell 中处理文件的惯用方法可能类似于：

Get-Content $path | Where-Object Length -GT 10

这可能比直接使用 .NET API 慢一个数量级。例如，您可以使用 .NET [StreamReader] 类：

try {
    $reader = [System.IO.StreamReader]::new($path)
    while (-not $reader.EndOfStream) {
        $line = $reader.ReadLine()
        if ($line.Length -gt 10) {
            $line
        }
    }
}
finally {
    if ($reader) {
        $reader.Dispose()
    }
}

您还可以使用[System.IO.File]的ReadLines方法，它包装了StreamReader，简化了读取过程：

foreach ($line in [System.IO.File]::ReadLines($path)) {
    if ($line.Length -gt 10) {
        $line
    }
}

在大型集合中按属性查找条目

通常需要使用共享属性来标识不同集合中的相同记录，例如使用名称从一个列表中检索 ID，从另一个列表中检索电子邮件。迭代第一个列表以在第二个集合中查找匹配记录的速度很慢。特别是对第二个集合的重复过滤，开销很大。

给定两个集合，一个具有 ID 和 Name，另一个具有 Name 和 Email：

$Employees = 1..10000 | ForEach-Object {
    [PSCustomObject]@{
        Id   = $_
        Name = "Name$_"
    }
}

$Accounts = 2500..7500 | ForEach-Object {
    [PSCustomObject]@{
        Name  = "Name$_"
        Email = "[email protected]"
    }
}

协调这些集合以返回具有 ID、Name 和 Email 属性的对象列表的常用方法可能如下所示：

$Results = $Employees | ForEach-Object -Process {
    $Employee = $_

    $Account = $Accounts | Where-Object -FilterScript {
        $_.Name -eq $Employee.Name
    }

    [pscustomobject]@{
        Id    = $Employee.Id
        Name  = $Employee.Name
        Email = $Account.Email
    }
}

但是，该实现必须为 $Employee 集合中的每个项目过滤一次 $Accounts 集合中的所有 5000 个项目。即使对于这种单值查找，这也可能需要几分钟的时间。

相反，您可以创建一个哈希表，使用共享的 Name 属性作为键，使用匹配的帐户作为值。

$LookupHash = @{}
foreach ($Account in $Accounts) {
    $LookupHash[$Account.Name] = $Account
}

在哈希表中查找键比按属性值过滤集合要快得多。 PowerShell 可以检查键是否已定义并使用其值，而不是检查集合中的每个项目。

$Results = $Employees | ForEach-Object -Process {
    $Email = $LookupHash[$_.Name].Email
    [pscustomobject]@{
        Id    = $_.Id
        Name  = $_.Name
        Email = $Email
    }
}

这要快得多。虽然循环过滤器需要几分钟才能完成，但哈希查找只需要不到一秒钟。

谨慎使用 Write-Host

仅当您需要将格式化文本写入主机控制台时，才应使用 Write-Host 命令，而不是将对象写入 Success 管道。

对于 pwsh.exe、 等特定主机，Write-Host 可能比 [Console]::WriteLine() 慢一个数量级>powershell.exe 或 powershell_ise.exe。但是，不保证 [Console]::WriteLine() 在所有主机上都能工作。此外，使用 [Console]::WriteLine() 写入的输出不会写入由 Start-Transcript 启动的记录中。

即时编译

PowerShell 将脚本代码编译为可解释的字节码。从 PowerShell 3 开始，对于在循环中重复执行的代码，PowerShell 可以通过即时 (JIT) 将代码编译为本机代码来提高性能。

少于 300 条指令的循环符合 JIT 编译的条件。大于该值的循环编译成本太高。当循环执行 16 次后，脚本将在后台进行 JIT 编译。当 JIT 编译完成时，执行将转移到已编译的代码。

避免重复调用函数

调用函数可能是一项昂贵的操作。如果您在长时间运行的紧密循环中调用函数，请考虑将循环移至函数内部。

考虑以下示例：

$tests = @{
    'Simple for-loop'       = {
        param([int] $RepeatCount, [random] $RanGen)

        for ($i = 0; $i -lt $RepeatCount; $i++) {
            $null = $RanGen.Next()
        }
    }
    'Wrapped in a function' = {
        param([int] $RepeatCount, [random] $RanGen)

        function Get-RandomNumberCore {
            param ($rng)

            $rng.Next()
        }

        for ($i = 0; $i -lt $RepeatCount; $i++) {
            $null = Get-RandomNumberCore -rng $RanGen
        }
    }
    'for-loop in a function' = {
        param([int] $RepeatCount, [random] $RanGen)

        function Get-RandomNumberAll {
            param ($rng, $count)

            for ($i = 0; $i -lt $count; $i++) {
                $null = $rng.Next()
            }
        }

        Get-RandomNumberAll -rng $RanGen -count $RepeatCount
    }
}

5kb, 10kb, 100kb | ForEach-Object {
    $rng = [random]::new()
    $groupResult = foreach ($test in $tests.GetEnumerator()) {
        $ms = Measure-Command { & $test.Value -RepeatCount $_ -RanGen $rng }

        [pscustomobject]@{
            CollectionSize    = $_
            Test              = $test.Key
            TotalMilliseconds = [math]::Round($ms.TotalMilliseconds,2)
        }

        [GC]::Collect()
        [GC]::WaitForPendingFinalizers()
    }

    $groupResult = $groupResult | Sort-Object TotalMilliseconds
    $groupResult | Select-Object *, @{
        Name       = 'RelativeSpeed'
        Expression = {
            $relativeSpeed = $_.TotalMilliseconds / $groupResult[0].TotalMilliseconds
            [math]::Round($relativeSpeed, 2).ToString() + 'x'
        }
    }
}

基本 for 循环示例是性能的基线。第二个示例将随机数生成器包装在一个在紧密循环中调用的函数中。第三个示例将循环移到函数内部。该函数仅被调用一次，但代码仍然生成相同数量的随机数。请注意每个示例的执行时间差异。

CollectionSize Test                   TotalMilliseconds RelativeSpeed
-------------- ----                   ----------------- -------------
          5120 for-loop in a function              9.62 1x
          5120 Simple for-loop                    10.55 1.1x
          5120 Wrapped in a function              62.39 6.49x
         10240 Simple for-loop                    17.79 1x
         10240 for-loop in a function             18.48 1.04x
         10240 Wrapped in a function             127.39 7.16x
        102400 for-loop in a function            179.19 1x
        102400 Simple for-loop                   181.58 1.01x
        102400 Wrapped in a function            1155.57 6.45x

避免包装 cmdlet 管道

大多数 cmdlet 都是针对管道实现的，这是一个顺序语法和过程。例如：

cmdlet1 | cmdlet2 | cmdlet3

初始化新管道的成本可能很高，因此您应该避免将 cmdlet 管道包装到另一个现有管道中。

考虑以下示例。 Input.csv 文件包含 2100 行。 Export-Csv 命令包装在 ForEach-Object 管道内。 ForEach-Object 循环的每次迭代都会调用 Export-Csv cmdlet。

$measure = Measure-Command -Expression {
    Import-Csv .\Input.csv | ForEach-Object -Begin { $Id = 1 } -Process {
        [PSCustomObject]@{
            Id   = $Id
            Name = $_.opened_by
        } | Export-Csv .\Output1.csv -Append
    }
}

'Wrapped = {0:N2} ms' -f $measure.TotalMilliseconds

Wrapped = 15,968.78 ms

对于下一个示例，Export-Csv 命令已移至 ForEach-Object 管道之外。在这种情况下，Export-Csv 仅调用一次，但仍会处理从 ForEach-Object 传出的所有对象。

$measure = Measure-Command -Expression {
    Import-Csv .\Input.csv | ForEach-Object -Begin { $Id = 2 } -Process {
        [PSCustomObject]@{
            Id   = $Id
            Name = $_.opened_by
        }
    } | Export-Csv .\Output2.csv
}

'Unwrapped = {0:N2} ms' -f $measure.TotalMilliseconds

Unwrapped = 42.92 ms

展开的示例快了 372 倍。另请注意，第一个实现需要 Append 参数，而后面的实现则不需要该参数。

使用 OrderedDictionary 动态创建新对象

在某些情况下，我们可能需要根据某些输入动态创建对象，这可能是创建新 PSObject 最常用的方法，然后使用 Add-Member添加新属性> cmdlet。使用此技术的小型集合的性能成本可能可以忽略不计，但对于大型集合来说，它可能会变得非常明显。在这种情况下，建议的方法是使用 [OrderedDictionary]，然后使用 [pscustomobject] 类型加速器将其转换为 PSObject。有关详细信息，请参阅 about_Hash_Tables 的创建有序字典部分。

假设您将以下 API 响应存储在变量 $json 中。

{
  "tables": [
    {
      "name": "PrimaryResult",
      "columns": [
        { "name": "Type", "type": "string" },
        { "name": "TenantId", "type": "string" },
        { "name": "count_", "type": "long" }
      ],
      "rows": [
        [ "Usage", "63613592-b6f7-4c3d-a390-22ba13102111", "1" ],
        [ "Usage", "d436f322-a9f4-4aad-9a7d-271fbf66001c", "1" ],
        [ "BillingFact", "63613592-b6f7-4c3d-a390-22ba13102111", "1" ],
        [ "BillingFact", "d436f322-a9f4-4aad-9a7d-271fbf66001c", "1" ],
        [ "Operation", "63613592-b6f7-4c3d-a390-22ba13102111", "7" ],
        [ "Operation", "d436f322-a9f4-4aad-9a7d-271fbf66001c", "5" ]
      ]
    }
  ]
}

现在，假设您想要将此数据导出到 CSV。首先，您需要创建新对象并使用 Add-Member cmdlet 添加属性和值。

$data = $json | ConvertFrom-Json
$columns = $data.tables.columns
$result = foreach ($row in $data.tables.rows) {
    $obj = [psobject]::new()
    $index = 0

    foreach ($column in $columns) {
        $obj | Add-Member -MemberType NoteProperty -Name $column.name -Value $row[$index++]
    }

    $obj
}

使用 OrderedDictionary，代码可以转换为：

$data = $json | ConvertFrom-Json
$columns = $data.tables.columns
$result = foreach ($row in $data.tables.rows) {
    $obj = [ordered]@{}
    $index = 0

    foreach ($column in $columns) {
        $obj[$column.name] = $row[$index++]
    }

    [pscustomobject] $obj
}

在这两种情况下，$result 输出都是相同的：

Type        TenantId                             count_
----        --------                             ------
Usage       63613592-b6f7-4c3d-a390-22ba13102111 1
Usage       d436f322-a9f4-4aad-9a7d-271fbf66001c 1
BillingFact 63613592-b6f7-4c3d-a390-22ba13102111 1
BillingFact d436f322-a9f4-4aad-9a7d-271fbf66001c 1
Operation   63613592-b6f7-4c3d-a390-22ba13102111 7
Operation   d436f322-a9f4-4aad-9a7d-271fbf66001c 5

随着对象和成员属性数量的增加，后一种方法的效率呈指数级增长。

以下是创建具有 5 个属性的对象的三种技术的性能比较：

$tests = @{
    '[ordered] into [pscustomobject] cast' = {
        param([int] $iterations, [string[]] $props)

        foreach ($i in 1..$iterations) {
            $obj = [ordered]@{}
            foreach ($prop in $props) {
                $obj[$prop] = $i
            }
            [pscustomobject] $obj
        }
    }
    'Add-Member'                           = {
        param([int] $iterations, [string[]] $props)

        foreach ($i in 1..$iterations) {
            $obj = [psobject]::new()
            foreach ($prop in $props) {
                $obj | Add-Member -MemberType NoteProperty -Name $prop -Value $i
            }
            $obj
        }
    }
    'PSObject.Properties.Add'              = {
        param([int] $iterations, [string[]] $props)

        # this is how, behind the scenes, `Add-Member` attaches
        # new properties to our PSObject.
        # Worth having it here for performance comparison

        foreach ($i in 1..$iterations) {
            $obj = [psobject]::new()
            foreach ($prop in $props) {
                $obj.PSObject.Properties.Add(
                    [psnoteproperty]::new($prop, $i))
            }
            $obj
        }
    }
}

$properties = 'Prop1', 'Prop2', 'Prop3', 'Prop4', 'Prop5'

1kb, 10kb, 100kb | ForEach-Object {
    $groupResult = foreach ($test in $tests.GetEnumerator()) {
        $ms = Measure-Command { & $test.Value -iterations $_ -props $properties }

        [pscustomobject]@{
            Iterations        = $_
            Test              = $test.Key
            TotalMilliseconds = [math]::Round($ms.TotalMilliseconds, 2)
        }

        [GC]::Collect()
        [GC]::WaitForPendingFinalizers()
    }

    $groupResult = $groupResult | Sort-Object TotalMilliseconds
    $groupResult | Select-Object *, @{
        Name       = 'RelativeSpeed'
        Expression = {
            $relativeSpeed = $_.TotalMilliseconds / $groupResult[0].TotalMilliseconds
            [math]::Round($relativeSpeed, 2).ToString() + 'x'
        }
    }
}

这些是结果：

Iterations Test                                 TotalMilliseconds RelativeSpeed
---------- ----                                 ----------------- -------------
      1024 [ordered] into [pscustomobject] cast             22.00 1x
      1024 PSObject.Properties.Add                         153.17 6.96x
      1024 Add-Member                                      261.96 11.91x
     10240 [ordered] into [pscustomobject] cast             65.24 1x
     10240 PSObject.Properties.Add                        1293.07 19.82x
     10240 Add-Member                                     2203.03 33.77x
    102400 [ordered] into [pscustomobject] cast            639.83 1x
    102400 PSObject.Properties.Add                       13914.67 21.75x
    102400 Add-Member                                    23496.08 36.72x