# 1. Get JSON data from a file or some other source:
$file = Get-Content -Path "data.json" -Raw
$json = @" 
    <# For example copy 'n' paste the JSON sample data from the page linked above #>
"@

# 2. Convert JSON to a PowerShell data structure (PSCustomObject):
$file_data = ConvertFrom-Json -InputObject $file
$data      = ConvertFrom-Json -InputObject $json

# 3. Display from that data strcuture a value, modify it, then show the changend value:
# Example A:
$data.'Key 7'[3].'Entry A'
$data.'Key 7'[3].'Entry A' = 1024
$data.'Key 7'[3].'Entry A'
# Example B:
($data.'Product Information'[3].'Products'[2].Details | ? { $_.'Name' -eq 'Bar'}).Version
($data.'Product Information'[3].'Products'[2].Details | ? { $_.'Name' -eq 'Bar'}).Version = 2
($data.'Product Information'[3].'Products'[2].Details | ? { $_.'Name' -eq 'Bar'}).Version

# 4. Convert the data back to proper JSON and save it to a new file:
$new_data = ConvertTo-Json -InputObject $data -Depth 100
Set-Content -Encoding utf8 -Value $new_data -Path outfile.json

{
    "Clients":
    {
        "Client 1":
        {
            "Domain": "client1.example.net",
            "Foo": "Bar",
            "Data": ["a", "b", "c"]
        },

        "Client 2":
        {
            "Domain": "client2.example.net",
            "Foo": "Bar",
            "Data": [1, 2, 3]
        },

        "Client 3":
        {
            "Domain": "client3.example.net",
            "Foo": "Bar",
            "Data": ["x", "y", "z"]
        }
    }
}

{
    "Clients":
    {
        "Client 1":
        {
            "Roles":
            {
                "Role 1":
                {
                    "ADGroups":
                    [
                        "Grp-R1-ABC",
                        "Grp-R1-XYZ"
                    ]
                },

                "Role 2":
                {
                    "ADGroups": ["Grp-R2-ABC", "Grp-R2-XYZ"]
                }
            }
        }
    }
}

$base       = ConvertFrom-Json -InputObject (Get-Content -Raw -Path cfg.json)
$roles      = ConvertFrom-Json -InputObject (Get-Content -Raw -Path cfgRoles.json)

# Using the base data as a starting point for the final result:
new-variable -Name CFG -Visibility Public -Scope Global -Value $base

# Loop over all clients and add the roles (if available for that client) as a new NoteProperty:
$base.Clients.PSObject.Properties | % {
    try { Add-Member -InputObject $CFG.Clients.($_.Name) `
                     -MemberType NoteProperty `
                     -Name "Roles" `
                     -Value $roles.Clients.($_.Name).Roles
    }
    catch {}
}

# Example/Test of the end result:
try
{
    $CFG.Clients.'Client 1' | fl
    $CFG.Clients.'Client 1'.Roles.'Role 2'.ADGroups
}
catch { write-error $_.Exception.Message }

$Files = Get-ChildItem -Filter *.json | % { get-content $_ | ConvertFrom-Json }
$var   = @{}

ForEach ($File in $Files)
{
    ForEach ($i in ($File.psobject.properties | ? { $_.MemberType -eq 'NoteProperty' }))
    {
        if ([bool] $i.Value)
        {
            if ($var.ContainsKey($i.Name)) {}
            else                           { $var[$i.Name] += $i.Value }
        }
        else
        {
            if ($var.ContainsKey($i.Name)) {}
            else                           { $var.Add($i.Name, @{}) }
        }
    }
}

# --------------------

Remove-Variable -name SingleVar -scope global
New-Variable -name SingleVar -scope global -value $var

"`r`n-------- `$global:SingleVar --------"
$global:SingleVar

$Algorithm = 'SHA256'

# ---- Content of the JSON file: ----
# Read the file's content and get rid of any superfluous formatting and layout stuff with '-Compress':
$DataA   = Get-Content -Path .\foo.json -Encoding UTF8 | ConvertFrom-Json | ConvertTo-JSON -Depth 100 -Compress
$StreamA = [System.IO.MemoryStream]::new([System.Text.Encoding]::UTF8.GetBytes($DataA))
$HashA   = Get-FileHash -InputStream $StreamA -Algorithm $Algorithm

write-host ("{0} Hash of file  : {1}" -f $Algorithm, $HashA.hash)

# ---- Data structure for JSON in memory: ----
$DataB = @{
    Foo = @{
        Bar = "123"
        Baz = "ABC"
    }
}

# Like with the file data: Use '-Compress' to normalize the value for comparison:
$DataB   = $DataB | ConvertTo-JSON -Depth 100 -Compress
$StreamB = [System.IO.MemoryStream]::new([System.Text.Encoding]::UTF8.GetBytes($DataB))
$HashB   = Get-FileHash -InputStream $StreamB -Algorithm $Algorithm

write-host ("{0} Hash of string: {1}" -f $Algorithm, $HashB.hash)

# ---- Comparing both hash values: ----
if ($HashA.hash -eq $HashB.hash) { write-host "[V] Hashes are equal"     -ForegroundColor Green }
else                             { write-host "[X] Hashes are not equal" -ForegroundColor Red }