Question

# array
C:> (1,2,3).count
3
C:> (1,2,3 | measure).count
3

# hashtable
C:> @{1=1; 2=2; 3=3}.count
3
C:> (@{1=1; 2=2; 3=3} | measure).count
1

# array returned from function
C:> function UnrollMe { $args }
C:> (UnrollMe a,b,c).count
3
C:> (UnrollMe a,b,c | measure).count
1
C:> (1,2,3).gettype() -eq (UnrollMe a,b,c).gettype()
True

The discrepancy with HashTables is fairly well known, although the official documentation only mentions it obliquely (via example).

The issue with functions, though, is news to me. I m kind of shocked it hasn t bitten me before now. Is there some guiding principle we scripters can follow? I know that when writing cmdlets in C# there s an overload of WriteObject where you can control enumeration explicitly, but AFAIK there s no such construct in the Posh language itself. As the final example shows, the Posh interpreter seems to believe there is no difference in the type of objects being piped. I suspect there may be some Object vs PSObject weirdness under the hood, but that s of little use when you re writing pure Posh and expect the script language to "just work."

/ EDIT /

Keith is correct to point out that in my example, I m passing in a single string[] argument rather than 3 string arguments. In other words, the reason Measure-Object says Count=1 is because it s seeing a single array-of-arrays whose first element is @("a", "b", "c"). Fair enough. This knowledge allows you to work around the issue in several ways:

# stick to single objects
C:> (UnrollMe a b c | measure).count
3

# rewrite the function to handle nesting
C:> function UnrollMe2 { $args[0] }
C:> (UnrollMe2 a,b,c | measure).count
3

# ditto
C:> function UnrollMe3 { $args | %{ $_ } }
C:> (UnrollMe3 a,b,c | measure).count
3

However, it doesn t explain everything...

# as seen earlier - if we re truly returning @( @("a","b","c") ) why not count=1?
C:> (UnrollMe a,b,c).count
3

# our theory must also explain these results:
C:> ((UnrollMe a,b,c) | measure).count
3
C:> ( @(@("a","b","c")) | measure).count
3
C:> ((UnrollMe a,b,c d) | measure).count
2

From what I can extrapolate there s another rule in play: if you have an array with exactly one element AND the parser is in expression mode, then the interpreter will "unwrap" said element. Any more subtleties I m missing?

Answer 1

$args is unrolled. Remember that function parameters are normally passed using space to separate them. When you pass in 1,2,3 you are passing in a single argument that is an array of three numbers that gets assigned to $args[0]:

PS> function UnrollMe { $args }
PS> UnrollMe 1 2 3 | measure

Count    : 3

Putting the results (an array) within a grouping expression (or subexpression e.g. $()) makes it eligible again for unrolling so the following unrolls the object[] containing 1,2,3 returned by UnrollMe:

PS> ((UnrollMe 1,2,3) | measure).Count
3

which is equivalent to:

PS> ((1,2,3) | measure).Count
3

BTW it doesn t just apply to an array with one element.

PS> ((1,2),3) | %{$_.GetType().Name}
Object[]
Int32

Using an array subexpression (@()) on something that is already an array has no effect no matter how many times you apply it. :-) If you want to prevent unrolling use the comma operator because it will always create another outer array which gets unrolled. Note that in this scenario you don t really prevent unrolling, you just work around the unrolling by introducing an outer "wrapper" array that gets unrolled instead of your original array e.g.:

PS> (,(1,2,3) | measure).Count
1

Finally, when you execute this:

PS> (UnrollMe a,b,c d) | %{$_.GetType().Name}
Object[]
String

You can see that UnrollMe returns two items (a,b,c) as an array and d as a scalar. Those two items get sent down the pipeline separately which is the resulting count is 2.

Answer 2

It seem to have something to do with how Measure-Object works and how objects are passed along the pipeline.

When you say

1,2,3 | measure

you get 3 Int32 objects passed onto the pipeline, measure object then counts each object it sees on the pipeline.

When you "unroll it" using your function, you get a single array object passed onto the pipeline which measure object counts as 1, it makes no attempt to iterate through the objects in the array, as shown here:

PS C:> (measure -input 1,2,3).count
1

A possible work-around is to "re-roll" the array onto the pipeline using foreach:

PS C:> (UnrollMe 1,2,3 | %{$_} | measure).count
3

友情链接