Array being turned into string in hash table

Question

I have an array being returned to me which I am stepping through with the foreach, I want to use one element of each member of that array in a hash table that will be converted to a json object. When I add the element to a powershell array object and then add it to the hash the strings are being combined instead of added as arrays.

Spec

"destinationInterclusterLifIps": [
  "172.31.5.119",
  "172.31.15.103"
]

Actual return:

"destinationInterclusterLifIps":  [
     "172.31.33.150172.31.42.41"
 ],

Building the array

if(!$destinationInterclusterLifIps){
    $destinationInterclusterLifIps =  @()
    foreach($record in $interclusterIpInfo.peerInterClusterLifs){
        $destinationInterclusterLifIps += $record.address
    }
}

Hash table

$body = @{
        destinationInterclusterLifIps = @($destinationInterclusterLifIps)
}

This has to be something simple with hash tables that I am missing

Answer 1

Your code alone doesn't explain the symptom, but your own answer hints at an interesting pitfall that is worth exploring:

• By default, a PowerShell variable can accept a value of any type, and values of different types can be assigned at any time:

  $var = 42   # $var now contains an [int]
  # ...
  $var = 'hi' # $var now contains a [string]
  

• However, you can type-constrain variables, in which case they only ever accept values of that type - or values that can automatically be converted to that type (PowerShell is very flexible when it comes to automatic conversions):

  # Create a type-constrained variable.
  [int] $var = 42  # $var now contains an [int] AND is locked into storing [int]s
  
  # Try to assign a [string] that CANNOT be converted to an [int]
  $var = 'hi' # FAILS: 'Cannot convert value "hi" to type "System.Int32"...'
  
  # Try to assign a [string] that CAN be converted to an [int]
  $var = ' 42  ' # OK - string was converted; $var now contains [int] 42
  

Typically, but not necessarily, parameter variables are type-constrained, as part of a script or function's list of declared parameters.

If you later reuse a type-constrained parameter variable by assigning a new value to it, it will enforce its original type, as described above.

The likeliest explanation in your case is that your $destinationInterclusterLifIps was declared as a type-constrained [string] $destinationInterclusterLifIps parameter, in which case a later attempt to assign an array resulted in implicit stringification of that array; to illustrate with a simple example:

function foo {
  param(
   # Type-constrained parameter.
   [string] $destinationInterclusterLifIps
  )

  # ...

  # Try to assign an *array*:
  # Instead of storing an array, the [string] type constraint 
  # converts the array to a *single string*, as a space-separated list of
  # its elements.
  $destinationInterclusterLifIps = 1, 2, 3

  # Output the value.
  $destinationInterclusterLifIps

}

# Call the function (no argument needed)
foo

This outputs:

1 2 3

i.e., the array converted to a string, as a space-separated list of its elements. (An array would print element by element, each on its own line).

Note that your problem was therefore unrelated to the use of hash table and its conversion to JSON - it's just where you happened to notice the problem.

---

Optional reading: Modifying / removing a variable's type constraint:

It is possible to later recreate a type-constrained variable with a different type; e.g.:

[int] $var = 42; [string] $var = 'hi'

While you can use Remove-Variable to effectively remove a type constraint by removing the variable first and then recreating it unconstrained, as TheIncorrigible1 suggests -
[int] $var = 42; Remove-Variable var; $var = 'hi' - you can use [object] $var = 'hi' as a shortcut, since type-constraining to [object] is tantamount to not constraining the value.

(Get-Variable var).Attributes contains a variable's attributes, and a type-constraint attribute is stored as a [System.Management.Automation.ArgumentTypeConverterAttribute] instance. If you're not concerned about removing all attributes, another simple, though obscure, option for removing a type constraint is to use (Get-Variable var).Attributes.Clear().

Answer 2

Looks like I was having a conflict with a variable. Maybe because it is being used as a param as well. Setting the variable to any other name cleared the issue.

if(!$sourceInterclusterLifIps){
    $InterclusterIPSource =  @()
    foreach($record in $interclusterIpInfo.interClusterLifs){
        $InterclusterIPSource += $record.address
    }
} else {
    $InterclusterIPSource = $sourceInterclusterLifIps
}

Answer 3

try using an ArrayList with .add(), It should do what you want.

$destinationInterclusterLifIps = New-Object System.Collections.ArrayList
if(!$destinationInterclusterLifIps){
$destinationInterclusterLifIps =  @()
foreach($record in $interclusterIpInfo.peerInterClusterLifs){
    $destinationInterclusterLifIps.add( $record.address )
}

}