将 PowerShell 数组分割成更小的数组组

Question

我想根据变量将单个数组转换为一组较小的数组。因此，当大小为 3 时，0,1,2,3,4,5,6,7,8,9 将变为 0,1,2、3,4,5、6,7,8、9。

我目前的做法：

$ids=@(0,1,2,3,4,5,6,7,8,9)
$size=3

0..[math]::Round($ids.count/$size) | % { 

    # slice first elements
    $x = $ids[0..($size-1)]

    # redefine array w/ remaining values
    $ids = $ids[$size..$ids.Length]

    # return elements (as an array, which isn't happening)
    $x

} | % { "IDS: $($_ -Join ",")" }

生产：

IDS: 0
IDS: 1
IDS: 2
IDS: 3
IDS: 4
IDS: 5
IDS: 6
IDS: 7
IDS: 8
IDS: 9

我希望它是：

IDS: 0,1,2
IDS: 3,4,5
IDS: 6,7,8
IDS: 9

我错过了什么？

Answer 1

您可以使用 ,$x 而不仅仅是 $x。

文档中的 about_Operators 部分是这样的：

, Comma operator                                                  
   As a binary operator, the comma creates an array. As a unary
   operator, the comma creates an array with one member. Place the
   comma before the member.

Answer 2

cls
$ids=@(0,1,2,3,4,5,6,7,8,9)
$size=3

<# 
Manual Selection:
    $ids | Select-Object -First 3 -Skip 0
    $ids | Select-Object -First 3 -Skip 3
    $ids | Select-Object -First 3 -Skip 6
    $ids | Select-Object -First 3 -Skip 9
#>

# Select via looping
$idx = 0
while ($($size * $idx) -lt $ids.Length){

    $group = $ids | Select-Object -First $size -skip ($size * $idx)
    $group -join ","
    $idx ++
}

Answer 3

为了完整起见：

function Slice-Array
{

    [CmdletBinding()]
    param (
        [Parameter(Mandatory=$true, Position=0, ValueFromPipeline=$True)]
        [String[]]$Item,
        [int]$Size=10
    )
    BEGIN { $Items=@()}
    PROCESS {
        foreach ($i in $Item ) { $Items += $i }
    }
    END {
        0..[math]::Floor($Items.count/$Size) | ForEach-Object { 
            $x, $Items = $Items[0..($Size-1)], $Items[$Size..$Items.Length]; ,$x
        } 
    }
}

用法：

@(0,1,2,3,4,5,6,7,8,9) | Slice-Array -Size 3 | ForEach-Object { "IDs: $($_ -Join ",")" }

Answer 4

向添加解释：

输出数组等集合^[1] 隐式或使用return发送它的元素通过pipeline单独；也就是说，集合是 enumerated（展开）：

# Count objects received.
PS> (1..3 | Measure-Object).Count
3   # Array elements were sent *individually* through the pipeline.

使用 , (comma; the array-construction operator) 的一元形式来防止枚举 是一种方便简洁但有些晦涩的方法 workaround:

PS> (, (1..3) | Measure-Object).Count 
1   # By wrapping the array in a helper array, the original array was preserved.

也就是说，, <collection>围绕原始集合创建一个瞬态单元素辅助数组，以便枚举仅应用于辅助数组，按原样输出封闭的原始集合，作为单个对象.

一种概念上更清晰，但更冗长且更慢的方法是使用Write-Output -NoEnumerate，这清楚地表明了将集合 作为单个对象输出 .

PS> (Write-Output -NoEnumerate (1..3) | Measure-Object).Count 
1   # Write-Output -NoEnumerate prevented enumeration.

关于视觉检查的陷阱:

在输出用于显示时，多个数组之间的边界被看似再次擦除：

PS> (1..2), (3..4) # Output two arrays without enumeration
1
2
3
4

也就是说，即使两个 2 元素数组分别作为单个对象发送，输出通过在各自的行上显示每个元素，使其看起来像是收到了一个平面 4 元素数组。

一个简单的解决方法是 stringify 每个数组，将每个数组变成一个包含 space 分隔的元素列表的字符串。

PS> (1..2), (3..4) | ForEach-Object { "$_" }
1 2
3 4

现在很明显收到了两个单独的数组。

^{[1]枚举了哪些数据类型:

实现IEnumerable接口的数据类型的实例会被自动枚举，但也有例外：

也实现 IDictionary 的类型，例如 hashtables，是 not 枚举，也不是 XmlNode 实例。

相反，DataTable（未实现 IEnumerable）的实例被枚举（作为其 .Rows 集合的元素）- 参见 and the source code.

此外，请注意外部程序的 stdout 输出是逐行枚举的。}

Answer 5

Craig 自己方便地将拆分（分区）功能包装在 :

让我提供一个性能更好的演变（PSv3+语法，重命名为Split-Array），其中：

使用可扩展的 System.Collections.Generic.List[object]] 集合更有效地收集输入对象。
在拆分期间不修改集合，而是从中提取范围的元素。

function Split-Array {
    [CmdletBinding()]
    param (
        [Parameter(Mandatory, ValueFromPipeline)]
        [String[]] $InputObject
        ,
        [ValidateRange(1, [int]::MaxValue)]
        [int] $Size = 10
    )
    begin   { $items = New-Object System.Collections.Generic.List[object] }
    process { $items.AddRange($InputObject) }
    end {
      $chunkCount = [Math]::Floor($items.Count / $Size)
      foreach ($chunkNdx in 0..($chunkCount-1)) {
        , $items.GetRange($chunkNdx * $Size, $Size).ToArray()
      }
      if ($chunkCount * $Size -lt $items.Count) {
        , $items.GetRange($chunkCount * $Size, $items.Count - $chunkCount * $Size).ToArray()
      }
    }
}

对于小的输入集合，优化不会有太大影响，但一旦你进入数千个元素，加速就会非常显着：

为了大致了解性能改进，使用 Time-Command:

$ids = 0..1e4 # 10,000 numbers
$size = 3 # chunk size

Time-Command { $ids | Split-Array -size $size }, # optimized
             { $ids | Slice-Array -size $size }  # original

单核 Windows 10 VM Windows 5.1 的示例结果（绝对时间并不重要，但因素很重要）：

Command                        Secs (10-run avg.) TimeSpan         Factor
-------                        ------------------ --------         ------
$ids | Split-Array -size $size 0.150              00:00:00.1498207 1.00
$ids | Slice-Array -size $size 10.382             00:00:10.3820590 69.30

注意未优化的函数是如何慢了将近 70 倍的。

将 PowerShell 数组分割成更小的数组组

Slice a PowerShell array into groups of smaller arrays

arrays

powershell

data-partitioning