Come creare un array JSON in PowerShell

1. Usa ConvertTo-Json per creare un array JSON in PowerShell
2. Usa ConvertTo-Json per creare un array JSON e salvarlo in un file in PowerShell
3. Usa Here-Strings per creare un array JSON in PowerShell
4. Crea un Array di Oggetti Personalizzati per Creare un Array JSON in PowerShell
5. Conclusione

In PowerShell, JSON (JavaScript Object Notation) è un formato comune di interscambio dati utilizzato per la comunicazione tra vari sistemi e applicazioni. Un array JSON contenente coppie chiave-valore è un modo strutturato per organizzare i dati.

In questo articolo, esploreremo diversi metodi per creare un array JSON in PowerShell, insieme a esempi di codice dettagliati e spiegazioni.

Usa ConvertTo-Json per creare un array JSON in PowerShell

In questo esempio, dimostriamo come creare un semplice array JSON utilizzando PowerShell. Innanzitutto, organizziamo l’array JSON all’interno di una variabile chiamata $Body e poi lo convertiamo in un array JSON utilizzando il cmdlet ConvertTo-Json.

Esempio 1:

$Body = @(
    @{
        FirstName ='Alen'
        LastName  ='Walker'
    }
)
ConvertTo-Json -InputObject $Body

In questo frammento di codice, definiamo un array utilizzando @(), e all’interno dell’array, creiamo un hashtable (@{}) con coppie chiave-valore che rappresentano gli elementi dati del nostro array JSON. Le chiavi nell’hashtable corrispondono ai nomi dei campi nel nostro JSON, come FirstName e LastName.

Utilizziamo quindi ConvertTo-Json per convertire questa struttura in un array JSON.

L’output JSON risultante può essere visto qui sotto.

Output:

[
    {
        "LastName":  "Walker",
        "FirstName":  "Alen"
    }
]

Nel nostro prossimo esempio, illustriamo la creazione di un oggetto JSON che contiene sotto-array.

La variabile $Body è definita per contenere un oggetto JSON con due proprietà: My Items e My details. Ogni proprietà contiene un array di elementi.

Esempio 2:

$body = @{
    'My Items'   = @(
        "Item 1",
        "Item 2",
        "Item 3",
        "Item 4"
    )

    'My details' =@(
        @{
            "Name" = "Alen"
            "Id"   = "0001"
        },
        @{
            "Name" = "Mycle"
            "Id"   = "0002"
        }
    )
}
ConvertTo-Json -InputObject $Body

In questo script, definiamo un hashtable (@{}) e specificiamo due chiavi: 'My Items' e 'My details'. Il valore associato a 'My Items' è un array di nomi degli elementi, mentre il valore associato a 'My details' è un array di hashtable che rappresentano i dettagli su ciascun elemento.

Quando eseguiamo ConvertTo-Json sulla variabile $Body, converte la struttura in un oggetto JSON.

L’output JSON risultante può essere visto qui sotto.

Output:

{
    "My details":  [
                       {
                           "Id":  "0001",
                           "Name":  "Alen"
                       },
                       {
                           "Id":  "0002",
                           "Name":  "Mycle"
                       }
                   ],
    "My Items":  [
                     "Item 1",
                     "Item 2",
                     "Item 3",
                     "Item 4"
                 ]
}

In questo oggetto JSON, "My details" e "My Items" sono le chiavi, ciascuna associata al proprio rispettivo array di dati. La struttura consente di organizzare dati correlati in modo gerarchico, che è un uso comune quando si lavora con JSON in PowerShell.

Possiamo anche creare un oggetto PowerShell e poi convertirlo direttamente in un array JSON utilizzando il cmdlet ConvertTo-Json.

Dai un’occhiata all’esempio qui sotto:

$jsonArray = @(
    @{
        FirstName = 'John'
        LastName  = 'Doe'
    },
    @{
        FirstName = 'Jane'
        LastName  = 'Smith'
    }
)

$jsonOutput = $jsonArray | ConvertTo-Json

Write-Output $jsonOutput

Output:

[
    {
        "LastName":  "Doe",
        "FirstName":  "John"
    },
    {
        "LastName":  "Smith",
        "FirstName":  "Jane"
    }
]

Qui, lo script di esempio inizia definendo una variabile chiamata $jsonArray come un array di hashtable di PowerShell. Ogni hashtable rappresenta una persona con attributi per il nome di battesimo (FirstName) e il cognome (LastName).

Lo script poi converte questo array PowerShell di hashtable in un array JSON utilizzando il cmdlet ConvertTo-Json e lo assegna alla variabile $jsonOutput. Infine, utilizza Write-Output per visualizzare l’array JSON risultante.

In sintesi, lo script crea una rappresentazione di array JSON di due individui con il rispettivo nome di battesimo e cognome utilizzando hashtable di PowerShell e poi restituisce questo array JSON alla console.

Usa ConvertTo-Json per creare un array JSON e salvarlo in un file in PowerShell

Questo metodo è un po’ complesso. Creeremo l’array JSON passo dopo passo utilizzando più di una variabile.

Ti prego di dare un’occhiata al seguente esempio per capire meglio questo metodo.

Esempio:

$jsonBase = @{}
$array = @{}
$data = @{"Name" = "Mycle"; "Colour" = "Alen"; }
$array.Add("User", $data)
$jsonBase.Add("UserData", $array)
$jsonBase | ConvertTo-Json -Depth 10 | Out-File ".\sample.json"

All’inizio dello script, viene creata un’hashtable vuota chiamata $jsonBase. Questa servirà come struttura fondamentale per l’oggetto JSON che costruiremo.

Successivamente, viene inizializzata un’altra hashtable chiamata $array per rappresentare l’oggetto array. Questa variabile $array conterrà i dati che costituiscono l’array all’interno della nostra struttura JSON.

Poi, vengono definiti dati utente di esempio utilizzando un’hashtable chiamata $data, contenente coppie chiave-valore come il nome e il colore dell’utente. Questi dati saranno in seguito racchiusi all’interno dell’array.

Successivamente, lo script aggiunge l’hashtable $data all’hashtable $array, associandola alla chiave User. Questo stabilisce la rappresentazione dei dati specifici per l’utente all’interno dell’array.

Proseguendo, l’array $array, che ora contiene i dati dell’utente, viene aggiunto all’hashtable $jsonBase utilizzando la chiave UserData. Questo passaggio racchiude l’array dei dati degli utenti all’interno della struttura JSON più ampia.

Verso la fine, lo script converte l’hashtable $jsonBase in formato JSON utilizzando ConvertTo-Json. Si noti che il parametro -Depth controlla il livello di ricorsione per la conversione delle strutture nidificate.

Infine, il cmdlet Out-File salva i dati JSON in un file chiamato sample.json nella directory corrente.

Dopo l’esecuzione, verrà generato un file JSON chiamato sample.json, contenente i dati dell’utente sotto la chiave UserData e presentando il nome e il colore dell’utente all’interno di una struttura nidificata sotto la chiave User.

Output (sample.json):

{
    "UserData":  {
                     "User":  {
                                  "Name":  "Mycle",
                                  "Colour":  "Alen"
                              }
                 }
}

Usa Here-Strings per creare un array JSON in PowerShell

Utilizzare gli here-strings in PowerShell è un’altra tecnica utile per costruire un array JSON ben formattato mantenendo il layout desiderato. Un here-string, denotato da @" ... "@, ci consente di definire un blocco di testo in PowerShell mantenendo il proprio formato, inclusi i ritorni a capo e l’indentazione.

Possiamo impiegare gli here-strings per creare un array JSON direttamente come stringa.

Esempio:

$jsonArray = @"
[
    {
        "FirstName": "John",
        "LastName": "Doe"
    },
    {
        "FirstName": "Jane",
        "LastName": "Smith"
    }
]
"@

Write-Output $jsonArray

Output:

[
    {
        "FirstName": "John",
        "LastName": "Doe"
    },
    {
        "FirstName": "Jane",
        "LastName": "Smith"
    }
]

In questo esempio, abbiamo utilizzato un here-string (@" ... "@), che consente la creazione diretta di un array JSON come stringa.

All’interno di questo here-string, abbiamo definito l’array JSON utilizzando la sintassi appropriata:

• Abbiamo utilizzato parentesi quadre [...] per racchiudere l’intero array.
• Poi, abbiamo utilizzato parentesi graffe {...} per racchiudere ciascun oggetto JSON individuale.

Infine, abbiamo visualizzato l’array JSON utilizzando Write-Output.

Questo approccio semplifica il processo di costruzione di un array JSON con la struttura e il formato desiderati. Come possiamo vedere, l’output mostra un array JSON ben formattato che si allinea con la struttura definita.

Crea un Array di Oggetti Personalizzati per Creare un Array JSON in PowerShell

Un altro metodo che possiamo utilizzare per creare un array JSON implica la creazione di un array di oggetti personalizzati, ciascuno dei quali rappresenta un elemento, e poi convertirlo in un array JSON. Gli oggetti personalizzati sono istanze del tipo [PSCustomObject] che ci consentono di definire e strutturare i dati.

[PSCustomObject] ci consente di creare oggetti con proprietà personalizzate. È una funzione fondamentale in PowerShell che facilita la creazione e la manipolazione di dati strutturati all’interno di script e funzioni.

Le proprietà personalizzate sono definite utilizzando una sintassi simile a quella dell’hashtable dove specifichiamo i nomi delle proprietà e i loro valori corrispondenti, come segue:

[PSCustomObject]@{
    Property1 = 'Value1'
    Property2 = 'Value2'
}

Ecco un esempio:

$jsonArray = @(
    [PSCustomObject]@{
        FirstName = 'John'
        LastName  = 'Doe'
    },
    [PSCustomObject]@{
        FirstName = 'Jane'
        LastName  = 'Smith'
    }
)

$jsonOutput = $jsonArray | ConvertTo-Json

Write-Output $jsonOutput

Output:

[
    {
        "FirstName":  "John",
        "LastName":  "Doe"
    },
    {
        "FirstName":  "Jane",
        "LastName":  "Smith"
    }
]

Nell’esempio fornito, viene creato un array chiamato $jsonArray, contenente oggetti personalizzati definiti utilizzando la sintassi @{}. Abbiamo le proprietà FirstName e LastName e i loro rispettivi valori.

Successivamente, il cmdlet ConvertTo-Json viene utilizzato per convertire l’array di oggetti personalizzati ($jsonArray) in un formato di array JSON. L’array JSON risultante ($jsonOutput) ora contiene ciascun oggetto personalizzato come elemento, con le proprietà e i valori definiti rappresentati nella sintassi JSON.

Infine, l’array JSON viene visualizzato utilizzando Write-Output.

Conclusione

In conclusione, PowerShell fornisce più metodi per creare un array JSON, ciascuno dei quali si adatta a specifiche esigenze e preferenze.

Il cmdlet ConvertTo-Json è uno strumento versatile, che consente una conversione semplice di oggetti PowerShell o array in rappresentazioni JSON. Che si tratti di strutturare JSON direttamente, utilizzare here-strings o sfruttare oggetti personalizzati, PowerShell offre flessibilità nella generazione di array JSON per un’efficiente interscambio e organizzazione dei dati attraverso varie applicazioni e sistemi.