Les tables de hashage de ConvertFrom-json avoir différent type de powershells intégré dans les tables de hashage, comment dois-je faire de même?

J'ai un fichier json (test.json) qui ressemble à quelque chose comme ceci:

{
    "root":
    {
        "key":"value"
    }
}

Je suis le chargement dans powershell en utilisant quelque chose comme ceci:

PS > $data = [System.String]::Join("", [System.IO.File]::ReadAllLines("test.json")) | ConvertFrom-Json

root
----
@{key=value}

J'aimerais être en mesure d'énumérer les clés de la "table de hachage" comme objet qui est défini par le fichier json. Donc, Idéalement, je voudrais être en mesure de faire quelque chose comme:

$data.root.Keys

et obtenir ["clé"]. Je peux le faire avec le haut-tables de hachage dans powershell, mais le faire avec une table de hachage chargé de json est moins évident.

Dans ce dépannage, j'ai remarqué que les champs retournés par ConvertFrom-json ont des types différents que ceux de Powershell de tables de hachage. Par exemple, un appel .GetType() sur un intégré dans la table de hachage fait montre qu'il est de type "table de hachage':

PS > $h = @{"a"=1;"b"=2;"c"=3}
PS > $h.GetType()

IsPublic IsSerial Name                                     BaseType
-------- -------- ----                                     --------
True     True     Hashtable                                System.Object

faire la même chose pour mon objet json rendements PSCustomObject:

PS > $data.root.GetType()

IsPublic IsSerial Name                                     BaseType
-------- -------- ----                                     --------
True     False    PSCustomObject                           System.Object

Est-il possible de jeter ou de le transformer cet objet dans un typique powershell table de hachage?

J'ai vu ce lien (stackoverflow.com/questions/3740128/pscustomobject-to-hashtable) qui semble pertinent, mais n'a pas assez de travail pour moi.

OriginalL'auteur brad | 2014-02-25

json powershell

12

La ConvertFrom-Json applet de commande vous donne un objet personnalisé, de sorte que vous avez à y accéder en utilisant la notation point plutôt que comme un indice. Habituellement, vous devez savoir quels champs vous attendent dans le JSON donc c'est effectivement plus utile en général que d'obtenir une table de hachage. Plutôt que de combattre le système en conversion vers une table de hachage, je vous suggère de travailler avec elle.

Vous pouvez utiliser select avec des caractères génériques noms de propriété pour obtenir les propriétés:
```
PS D:\> $data = @"
{
    "root":
    {
        "key":"value", "key2":"value2", "another":42
    }
}
"@ | ConvertFrom-Json

PS D:\> $data.root | select * | ft -AutoSize

key   key2   another
---   ----   -------
value value2      42



PS D:\> $data.root | select k* | ft -AutoSize

key   key2  
---   ----  
value value2
```
et Get-Member si vous voulez extraire une liste de noms de propriété que vous pouvez parcourir:
```
PS D:\> ($data.root | Get-Member -MemberType NoteProperty).Name
another
key
key2
```
De le mettre dans une boucle donne un code comme ceci:
```
PS D:\> foreach ($k in ($data.root | Get-Member k* -MemberType NoteProperty).Name) {
    Write-Output "$k = $($data.root.$k)"
    }
key = value
key2 = value2
```
Merci Duncan c'était juste ce dont j'avais besoin!

OriginalL'auteur Duncan

Voici une petite fonction pour convertir un PSObject de retour dans une table de hachage (avec le soutien pour les objets imbriqués; conçu pour une utilisation avec DSC ConfigurationData, mais peut être utilisé partout où vous en avez besoin).

function ConvertPSObjectToHashtable
{
    param (
        [Parameter(ValueFromPipeline)]
        $InputObject
    )

    process
    {
        if ($null -eq $InputObject) { return $null }

        if ($InputObject -is [System.Collections.IEnumerable] -and $InputObject -isnot [string])
        {
            $collection = @(
                foreach ($object in $InputObject) { ConvertPSObjectToHashtable $object }
            )

            Write-Output -NoEnumerate $collection
        }
        elseif ($InputObject -is [psobject])
        {
            $hash = @{}

            foreach ($property in $InputObject.PSObject.Properties)
            {
                $hash[$property.Name] = ConvertPSObjectToHashtable $property.Value
            }

            $hash
        }
        else
        {
            $InputObject
        }
    }
}

OriginalL'auteur Dave Wyatt

L'exemple est pour un relativement faible de l'objet source (pas d'objets imbriqués dans les propriétés).

Voici une version qui sera 2 niveaux de profondeur dans l'objet source, et devrait travailler avec vos données:

$data = @{}

foreach ($propL1 in $x.psobject.properties.name)
   {
     $data[$propL1] = @{}
     foreach ($propL2 in $x.$propL1.psobject.properties.name)
        {
          $data[$PropL1][$PropL2] = $x.$propL1.$propL2
        }
    }


$data.root.keys

key

OriginalL'auteur mjolinor

J'ai mis cela ensemble pour gérer imbriquée json pour les tables de hashage

    function ConvertJSONToHash{
    param(
        $root
    )
    $hash = @{}

    $keys = $root | gm -MemberType NoteProperty | select -exp Name

    $keys | %{
        $key=$_
        $obj=$root.$($_)
        if($obj -match "@{")
        {
            $nesthash=ConvertJSONToHash $obj
            $hash.add($key,$nesthash)
        }
        else
        {
           $hash.add($key,$obj)
        }

    }
    return $hash
}

Je ne l'ai testé avec 4 niveaux mais récursive jusqu'à ce qu'il a terminée à la table de hachage.

Merci exactement Ce que je voulais. Je pense que cela doit avoir été accepté comme une réponse.

OriginalL'auteur Dave

@Duncan: Si vous avez besoin d'utiliser JSON Entrée pour une commande attend à une table de hachage (par exemple SET-ADUSER), essayez quelque chose comme ceci:

function SetADProperties{
    param($PlannedChanges)
    $UserName = $PlannedChanges.Request.User
    $Properties = @{}
    foreach ($key in ($PlannedChanges.SetADProperties | Get-Member -MemberType NoteProperty).Name)
    {
        $Properties[$key] = $PlannedChanges.SetADProperties.$key
    }
    # Call Set-ADUser only once, not in a loop
    Set-ADUser -Identity $UserName -Replace $Properties
}

$content = Get-Content -encoding UTF8 $FileName
$PlannedChanges = $content | ConvertFrom-Json
SetADProperties $PlannedChanges | Write-Output

Exemple JSON:

{"SetADProperties":{"postalCode":"01234","l":"Duckburg","employeenumber":"012345678"},
"Request":{"Action":"UserMove","User":"WICHKIND","Change":"CH1506-00023"}}

OriginalL'auteur MKesper

Vous devez vous connecter pour publier un commentaire.