Return array with single element in PowerShell

Question

This should be very simple - I need to return an array of hashtables from a function. This works when there is more than one hashtable, but when there is only one then the result is not an array. I'd rather not test if the result is an array or not.

function GetArrayWith1Hashtable()
{
    $array = @()

    $hashtable = @{}
    $hashtable["a"] = "a" 
    $hashtable["b"] = "b" 
    $hashtable["c"] = "c"
    $array += $hashtable 

    Write-Host "GetArrayWith1Hashtable array.Length =" $array.Length
    Write-Host "GetArrayWith1Hashtable array.Count" $array.Count
    Write-Host "GetArrayWith1Hashtable array[0].Keys" $array[0].Keys

    $array
}

function GetArrayWith2Hashtables()
{
    $array = @()

    $hashtable = @{}
    $hashtable["a"] = "a" 
    $hashtable["b"] = "b" 
    $hashtable["c"] = "c"
    $array += $hashtable 

    $hashtable2 = @{}
    $hashtable2["d"] = "d" 
    $hashtable2["e"] = "e"
    $hashtable2["f"] = "f"
    $array += $hashtable2 

    Write-Host "GetArrayWith2Hashtables array.Length = " $array.Length
    Write-Host "GetArrayWith2Hashtables array.Count = " $array.Count
    Write-Host "GetArrayWith2Hashtables array[0].Keys =" $array[0].Keys
    Write-Host "GetArrayWith2Hashtables array.Count = "$array[1].Keys

    $array
}

$result1 = GetArrayWith1Hashtable
# $result1.Length - not available
Write-Host "Result of GetArrayWith1Hashtable result1.Count = " $result1.Count                      # Count = 2 (would expect this to be 1)
# $result1[0] not available - not an array

$result2 = GetArrayWith2Hashtables
Write-Host "Result of GetArrayWith2Hashtables result2.Length = "    $result2.Length # Length = 2
Write-Host "Result of GetArrayWith2Hashtables result2.Count = "     $result2.Count # Count = 2
Write-Host "Result of GetArrayWith2Hashtables result2[0].Keys = "     $result2[0].Keys # Keys = c a b
Write-Host "Result of GetArrayWith2Hashtables result2[1].Keys = "     $result2[1].Keys # Keys = d e f

 <#
  FULL OUTPUT:

 GetArrayWith1Hashtable array.Length = 1
 GetArrayWith1Hashtable array.Count 1
 GetArrayWith1Hashtable array[0].Keys c a b

 Result of GetArrayWith1Hashtable result1.Count =  2

 GetArrayWith2Hashtables array.Length =  2
 GetArrayWith2Hashtables array.Count =  2
 GetArrayWith2Hashtables array[0].Keys = c a b
 GetArrayWith2Hashtables array.Count =  d e f

 Result of GetArrayWith2Hashtables result2.Length =  2
 Result of GetArrayWith2Hashtables result2.Count =  2
 Result of GetArrayWith2Hashtables result2[0].Keys =  c a b
 Result of GetArrayWith2Hashtables result2[1].Keys =  d e f

 #>

John C · Accepted Answer · 2022-03-19 21:24:55Z

9

Actually you would only add a comma in front of your returned item like so. This tells PowerShell to return it as is without trying to be smart about it. This also allows you to fix it in one place and not everywhere it was being called.

function GetArrayWith1Hashtable()
{
    $array = @()

    $hashtable = @{}
    $hashtable["a"] = "a" 
    $hashtable["b"] = "b" 
    $hashtable["c"] = "c"
    $array += $hashtable 

    Write-Host "GetArrayWith1Hashtable array.Length =" $array.Length
    Write-Host "GetArrayWith1Hashtable array.Count" $array.Count
    Write-Host "GetArrayWith1Hashtable array[0].Keys" $array[0].Keys

    # The only edit was to add the comma below
    ,$array
}

Update: Though, I don't think you are wanting this functionality, I will mention it so that others will understand the difference and make an educated choice for their approach.

To have your function be compatible to be used more efficiently within pipelines, the better approach would be to make a call to Write-Output for each item.

function GetArrayWith1Hashtable()
{
    Write-Output "a" 
    Write-Output "b" 
    Write-Output "c"
}

By using Write-Output, you are allowing PowerShell to call the next command's Process block in the pipeline, individually for each object. Otherwise it would call the next command and pass a single array object to it. You can read more about piping objects here

edited Mar 19, 2022 at 21:24

answered May 17, 2018 at 20:08

John C

2,0252 gold badges23 silver badges34 bronze badges

Sign up to request clarification or add additional context in comments.

5 Comments

PhilChuang Over a year ago

Upvoted this answer because although the accepted answer works, this answer solves the problem more cleanly and the calling code doesn't require any modifications.

mklement0 Over a year ago

True, @PhilChuang, the caller doesn't require modification, but on the flip side a function that emits arrays as single objects won't work as expected in pipelines.

John C Over a year ago

@mklement0 as I stated in my other response to you, you are assuming to much and not answering what the op asked. Not all functions are intended to be used in a pipe.

mklement0 Over a year ago

@JohnC: As stated in the comment on the other answer, your answer provides a solution for the question as asked (which is why I upvoted it), but the very point you just made deserves to be part of your answer: it's fine to use this approach for simple helper functions that aren't expected to be used in the pipeline. Equipped with that knowledge, readers can decide which approach is right for them.

JosefZ Over a year ago

The term 'Write-Object' is not recognized as the name of a cmdlet, function, script file, or operable program.

Martin Brandl · Accepted Answer · 2017-02-02 09:05:09Z

4

Just cast the return type to an array:

$result1 = @(GetArrayWith1Hashtable)

answered Feb 2, 2017 at 9:05

Martin Brandl

59.4k16 gold badges151 silver badges190 bronze badges

6 Comments

John C Over a year ago

This is not casting, that's not how you cast to a type. What you are doing here is adding the results to an entirely new array, potentially adding a array to an array.

mklement0 Over a year ago

Indeed not a cast, @JohnC, but an application of @(), the array-subexpression operator. However, it is an effective solution for a function that emits its output objects one by one, as in the question, by virtue of PowerShell's automatic enumeration of output objects. It's arguably better to let the caller ensure that something is an array, as shown here, because a function that emits arrays as single objects will not work as expected in a pipeline.

John C Over a year ago

@mklement0 You're assuming to much. Not all functions written are intended to be piped. The op wanted to return an array as a single object. This example, as i clearly stated already, could potentially return an array within a array. If they were to follow what you are referring to to work properly with pipelines, then all of these examples are incorrect and they should of just called write-object with each item rather than return an array all at once.

mklement0 Over a year ago

@JohnC: Yes, it could return an array within an array; that is, if you write a function that exhibits nonstandard behavior (returning an array as a single object). If that is your intent, then your solution is better - and then there's no need for also using @(). Yes, technically this answer doesn't do exactly what the OP asked for, but in the grand scheme of things it is better to avoid the nonstandard behavior; another simple solution with the original function definition would be to use [array] $result1 = GetArrayWith1Hashtable

John C Over a year ago

@mklement0 there is no standard that says what you are forced to return from a function. Not all functions are designed to be used in a pipe.

|

Nova · Accepted Answer · 2023-06-03 00:13:13Z

0

To force a function to return an array (no matter the size of the collection), I do this:

return Write-Output $array -NoEnumerate

I think that -NoEnumerate switch helps make it more explicit what I'm meaning to do.

answered Jun 3, 2023 at 0:13

Nova

1287 bronze badges

Collectives™ on Stack Overflow

Return array with single element in PowerShell

3 Answers 3

5 Comments

6 Comments

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

5 Comments

6 Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related