PowerShell 的 -f 运算符的 RHS“到底”是如何工作的？

Question

顺便说一下，上次我感到困惑 PowerShell 急切地展开集合，Keith 总结其启发式如下：

将结果（数组）放入分组表达式（或子表达式，例如 $()）中，使其再次符合展开条件。

我已经牢记了这个建议，但仍然发现自己无法解释一些深奥的知识。特别是，Format 运算符似乎不遵守规则。

$lhs = "{0} {1}"

filter Identity { $_ }
filter Square { ($_, $_) }
filter Wrap { (,$_) }
filter SquareAndWrap { (,($_, $_)) }

$rhs = "a" | Square        
# 1. all succeed
$lhs -f $rhs
$lhs -f ($rhs)
$lhs -f $($rhs)
$lhs -f @($rhs)

$rhs = "a" | Square | Wrap       
# 2. all succeed
$lhs -f $rhs
$lhs -f ($rhs)
$lhs -f $($rhs)
$lhs -f @($rhs)

$rhs = "a" | SquareAndWrap       
# 3. all succeed
$lhs -f $rhs
$lhs -f ($rhs)
$lhs -f $($rhs)
$lhs -f @($rhs)

$rhs = "a", "b" | SquareAndWrap       
# 4. all succeed by coercing the inner array to the string "System.Object[]"
$lhs -f $rhs
$lhs -f ($rhs)
$lhs -f $($rhs)
$lhs -f @($rhs)

"a" | Square | % {
    # 5. all fail
    $lhs -f $_
    $lhs -f ($_)
    $lhs -f @($_)
    $lhs -f $($_)            
}

"a", "b" | Square | % {
    # 6. all fail
    $lhs -f $_
    $lhs -f ($_)
    $lhs -f @($_)
    $lhs -f $($_)            
}

"a" | Square | Wrap | % {
    # 7. all fail
    $lhs -f $_
    $lhs -f ($_)
    $lhs -f @($_)
    $lhs -f $($_)            
}

"a", "b" | Square | Wrap | % {
    # 8. all fail
    $lhs -f $_
    $lhs -f ($_)
    $lhs -f @($_)
    $lhs -f $($_)            
}

"a" | SquareAndWrap | % {
    # 9. only @() and $() succeed
    $lhs -f $_
    $lhs -f ($_)
    $lhs -f @($_)
    $lhs -f $($_)            
}

"a", "b" | SquareAndWrap | % {
    # 10. only $() succeeds
    $lhs -f $_
    $lhs -f ($_)
    $lhs -f @($_)
    $lhs -f $($_)            
}

应用我们在上一个问题中看到的相同模式，很明显为什么像 #1 和 #5 这样的情况表现不同：管道运算符向脚本引擎发出信号以展开另一个级别，而赋值运算符则不然。换句话说，两个 | 之间的所有内容都被视为分组表达式，就像它在 () 内部一样。

# all of these output 2
("a" | Square).count                       # explicitly grouped
("a" | Square | measure).count             # grouped by pipes
("a" | Square | Identity).count            # pipe + ()
("a" | Square | Identity | measure).count  # pipe + pipe

出于同样的原因，案例 #7 并没有比 #5 有所改进。任何添加额外Wrap的尝试都会立即被额外的管道破坏。同上 #8 与 #6。有点令人沮丧，但到目前为止我完全同意。

剩下的问题：

• 为什么案例#3 没有遭受与#4 相同的命运？ $rhs 应该保存嵌套数组 (,("a", "a")) 但它的外层正在展开......某处......
• 发生了什么事与 #9-10 中的各种分组运算符？为什么他们的行为如此不稳定，为什么需要他们？
• 为什么案例 #10 中的失败不会像案例 #4 那样优雅地降级？

Answer 1

嗯，这肯定有一个错误。 （实际上，我昨天刚刚在 PoshCode Wiki 上写了关于它的页面，并且有连接错误）。

首先回答，然后再回答更多问题：

要从具有 -f 字符串格式的数组获得一致的行为，您需要 100% 确定它们是 PSObject。我的建议是在分配它们时这样做。它应该由PowerShell自动完成，但由于某种原因，直到您访问属性或其他内容（如wiki 页面 和 错误）。例如（ <##> 是我的提示）：

<##> $a = 1,2,3
<##> "$a"
1 2 3

<##> $OFS = "-"  # Set the Output field separator
<##> "$a"
1-2-3

<##> "{0}" -f $a
1 

<##> $a.Length
3 

<##> "{0}" -f $a
1-2-3

# You can enforce correct behavior by casting:
<##> [PSObject]$b = 1,2,3
<##> "{0}" -f $a
1-2-3

请注意，当您这样做时，它们在传递给 -f 时不会展开，而是会正确输出 - 就像它们的方式一样如果您直接将变量放入字符串中，则会出现这种情况。

为什么案例#3 没有遭受与#4 相同的命运？ $rhs 应该保存嵌套数组 (,("a", "a")) 但它的外层正在展开...某处...

答案的简单版本是 #3 和 #4 都正在展开。不同之处在于，在 4 中，内部内容是一个数组（即使在展开外部数组之后）：

$rhs = "a" | SquareAndWrap
$rhs[0].GetType()  # String

$rhs = "a","b" | SquareAndWrap
$rhs[0].GetType()  # Object[]

#9-10 中的各种分组运算符是怎么回事？为什么他们的行为如此不稳定，为什么需要他们？

正如我之前所说，数组应该算作格式的单个参数，并且应该使用 PowerShell 的字符串格式规则输出（即：用 $OFS 分隔）就像您那样直接将 $_ 放入字符串 ...因此，当 PowerShell 正常运行时，如果 $lhs 包含两个占位符，$lhs -f $rhs 将失败。

当然，我们已经观察到其中存在错误。

但是，我没有发现任何不稳定的情况：据我所知，@() 和 $() 对于 9 和 10 的工作方式相同可以看到（事实上，主要区别是由 ForEach 展开顶级数组的方式引起的：

> $rhs = "a", "b" | SquareAndWrap
> $rhs | % { $lhs -f @($_); " hi " }
a a
 hi 
b b
 hi 

> $rhs | % { $lhs -f $($_); " hi " }
a a
 hi 
b b
 hi     

# Is the same as:
> [String]::Format( "{0} {1}", $rhs[0] ); " hi "
a a
 hi 

> [String]::Format( "{0} {1}", $rhs[1] ); " hi "
b b
 hi     

所以你看到的错误是 @() 或 $() 会导致数组作为 [object[]] 传递到字符串格式调用而不是作为具有特殊 to-string 值的 PSObject，

为什么案例 #10 中的失败不会像 #4 那样优雅地降级

？在 PowerShell 中显示为“System.Object[]”，除非您手动调用其本机 .ToString() 方法，或直接将它们传递给 String.Format() ...他们在 # 中这样做的原因4 是那个错误：PowerShell 在将它们传递给 String.Format 调用之前未能将它们扩展为 PSOjbects，

如果您在传递数组的属性之前访问它，或者将其转换为 PSObject（如我的原始示例中所示），您可以看到这一点。 。从技术上讲，#10 中的错误是正确的输出：您只将一个东西（数组）传递给 string.format，而它需要两个东西。如果您将 $lhs 更改为“{0}”，您会看到用 $OFS 格式化的数组，

---

但我想知道您喜欢哪种行为以及您认为哪种行为正确不同的错误行为）：

> "{0}" -f [object[]]$a
1

> "{0}, {1}" -f [object[]]$a  # just to be clear...
1,2

>  "{0}, {1}" -f [object[]]$a, "two"  # to demonstrate inconsistency
System.Object[],two

> "{0}" -f [int[]]$a
System.Int32[]

我确信很多脚本都是在不知不觉中利用这个错误编写的，但对我来说，仍然很清楚中发生的展开>需要明确的是示例不是正确的行为，但之所以发生，是因为在调用（在PowerShell的核心内部）.Net String.Format( "{0}", a ) ... $a 是一个 object[] ，这是 String.Format 所期望的，因为它是 Params 参数...

我认为必须修复它。如果想要保留展开数组的“功能”，应该使用 @ splatting 运算符来完成，对吧？

Answer 2

Square 和 Wrap 都不会执行您在 # 的 5 和 7 中尝试的操作。无论您是像在 Square 中那样将数组放在分组表达式 () 中，还是像在 Wrap 中那样使用逗号运算符，当您在管道中使用这些函数时，它们的输出会展开，因为它一次一个地馈送到下一个管道阶段。同样，在 6 和 8 中，您通过管道输入多个对象并不重要，Square 和 Wrap 都会一次将一个对象提供给您的 foreach 阶段。

案例 9 和 10 似乎表明 PowerShell 中存在错误。获取这个修改后的片段并尝试一下：

"a" | SquareAndWrap | % {    
    # 9. only @() and $() succeed  
    $_.GetType().FullName
    $_.Length
    $lhs -f [object[]]$_
    $lhs -f [object[]]($_)    
    $lhs -f @($_)   
    $lhs -f $($_)            
}

它有效。它还表明 foreach 已经接收到一个 object[] 大小 2，因此 $_ 应该可以工作，而无需转换为 [object[]] 或包装在子表达式或数组子表达式中。我们已经看到一些与 psobjects 未正确展开相关的 V2 错误，这似乎是另一个例子。如果您手动解开 psobject，它会起作用，例如 $_.psobject.baseobject。

我“认为”您在 Wrap 中的目标是：

function Wrap2 { Begin {$coll = @();} Process {$coll += $_} End {,$coll} }

这将累积所有管道输入，然后将其输出为单个数组。这适用于情况 8，但您仍然需要在前两次使用 -f 运算符时转换为 [object[]]。

顺便说一句，Square 和 Wrap 中的括号以及 SquareAndWrap 中的外部括号都是不必要的。