Problems parsing / accessing nested JSON / Hashtable data via variables in Powershell

When you write something like

$MyPSJson.Name

this will attempt to retrieve the member named Name from the object $MyPSJson. If there is no such member, you'll get $null.

Now, when you do that with variables for the member name:

$MyPSJson.$ShortJsonPath

this works pretty much identical in that the member with the name stored in $ShortJsonPath is looked up and its value retrieved. No surprises here.

When you try that with a member that doesn't exist on the object, such as

$MyPSJson.$NestedJsonPath
# equivalent to
# $MyPSJson.'NestedJSON.Version'

you'll get $null, as detailed before. The . operator will only ever access a member of the exact object that is the result of its left-hand-side expression. It will never go through a member hierarchy in the way you seem to expect it to do. To be frank, I'm not aware of a language that works that way.

The reason it works with Invoke-Expression is, that you effectively converting the $NestedJsonPath string into part of an expression resulting in:

$MyPSJson.NestedJSON.Version

which Invoke-Expression then evaluates.

You can, of course, define your own function that works that way (and I'd much prefer that instead of using Invoke-Expression, a cmdlet that should rarely, if ever, used (heck, it's eval for PowerShell – few languages with eval advocate its use)):

function Get-DeepProperty([object] $InputObject, [string] $Property) {
  $path = $Property -split '\.'
  $obj = $InputObject
  $path | %{ $obj = $obj.$_ }
  $obj
}

PS> Get-DeepProperty $MyPSJson NestedJson.Version
5,0

You could even make it a filter, so you can use it more naturally on the pipeline:

filter Get-DeepProperty([string] $Property) {
  $path = $Property -split '\.'
  $obj = $_
  $path | %{ $obj = $obj.$_ }
  $obj
}

PS> $MyPSJson | Get-DeepProperty nestedjson.version
5,0

I followed Joey's filter example. However, I found it did not support accessing arrays. Sharing the code that I got to work for this. Hopefully it will help others as well. Awesome thread!

filter Get-DeepProperty([string] $Property) {
$path = $Property -split '\.'
$obj = $_
    foreach($node in $path){
        if($node -match '.*\[\d*\]'){
            $keyPieces = $node -split ('\[')
            $arrayKey = $keyPieces[0]
            $arrayIndex = $keyPieces[1] -replace ('\]','')
            $obj = $obj.$arrayKey[$arrayIndex]
        } else { 
            $obj = $obj.$node 
        }
    }
$obj
}

Example usage:

$path = "nested.nestedtwo.steps[2]"
$payload | Get-DeepProperty $path

I had the same problem, so I wrote a function that does the trick. It enables accessing any level of the json by variable path (string):

function getNestedJsonValue() {
    param(
        [Parameter(Mandatory = $true, ValueFromPipeline)] [PSCustomObject] $inputObj,
        [Parameter(Mandatory = $true)] [string] $valuePath
    )
    if (($valuePath -eq $null) -or ($valuePath.length -eq 0) -or ($inputObj -eq $null)) {
        return $inputObj
    }

    [System.Array] $nodes = "$valuePath" -split '\.'
    foreach ($node in $nodes) {
        if (($node -ne $null) -and ($node.length -gt 0) -and ($inputObj -ne $null)) {
            $inputObj = $inputObj.$node
        } else {
            return $inputObj
        }
    }
    return $inputObj
}

• Usage: getNestedJsonValue -valuePath $nestedValuePath -inputObj $someJson
• Pipe usage: $someJson | getNestedJsonValue -valuePath $nestedValuePath
• An example nestedValuePath would be $nestedValuePath="some.nested.path"

Credit to wOxxOm for getting things on the right track.

Invoke-Expression does seem to work perfectly for this situation (if somewhat expensive, but that's fine in my personal example & situation), and it can cope with multiple levels of nesting.

So as examples for the above code snippet, the following will resolve just fine (Key point - pay attention to the initial back-tick. That caught me off guard):

Write-Host ("Single level JSON test ==> " + (iex "`$MyPSJson.$NestedJsonPath"))
Write-Host ("Double level JSON test ==> " + (iex "`$MyPSJson.$LongNestedJsonPath"))

That'll return our desired results:

Single level JSON test ==> 5.0
Double level JSON test ==> I am on the 2nd nested level

FoxDeploy's answer of using multi-level selects doesn't seem to work with 2+ levels of nesting, unfortunately for some bizarre reason.

Using:

($MyPSJson | select $_.DoubleNestedJSON | select FirstLevel)

We get the following back from Powershell:

FirstLevel    
---------- 

... it seems that Powershell doesn't resolve nested objects in its entirety? We get a similar results if we intentionally use something that doesn't exist:

($MyPSJson | select $_.DoubleNestedJSON | select Doesnotexist)

... also simply returns:

Doesnotexist  
------------ 

So - for now - it seems as if "Invoke-Expression" works most reliably (and most easily, as it's just a case of handing it a variable with the path'ed string).

I still can't explain the WHY of any of this so far (since I've used 'dotwalk'-ing with multiple variables through arrays quite happily), but at least there's a solution for now ... and that is Invoke-Expression !

The best (/least bad?) explanations for Invoke-Expression I've found so far are here (Microsoft's own description of the cmdlet doesn't really make a great job of hinting that it'd help in situations such as this):

• http://ss64.com/ps/invoke-expression.html
• https://www.adminarsenal.com/powershell/invoke-expression/