Comment créer un tableau JSON dans PowerShell

1. Utiliser ConvertTo-Json pour créer un tableau JSON dans PowerShell
2. Utiliser ConvertTo-Json pour créer un tableau JSON et l’enregistrer dans un fichier dans PowerShell
3. Utiliser des chaînes ici pour créer un tableau JSON dans PowerShell
4. Créer un tableau d’objets personnalisés pour créer un tableau JSON dans PowerShell
5. Conclusion

Dans PowerShell, JSON (JavaScript Object Notation) est un format d’échange de données courant utilisé pour la communication entre divers systèmes et applications. Un tableau JSON contenant des paires clé-valeur est un moyen structuré d’organiser les données.

Dans cet article, nous allons explorer différentes méthodes pour créer un tableau JSON dans PowerShell, avec des exemples de code détaillés et des explications.

Utiliser ConvertTo-Json pour créer un tableau JSON dans PowerShell

Dans cet exemple, nous démontrons comment créer un simple tableau JSON en utilisant PowerShell. Nous organisons d’abord le tableau JSON à l’intérieur d’une variable appelée $Body, puis nous le convertissons en tableau JSON à l’aide du cmdlet ConvertTo-Json.

Exemple 1 :

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

Dans ce morceau de code, nous définissons un tableau en utilisant @(), et à l’intérieur du tableau, nous créons une table de hachage (@{}) avec des paires clé-valeur représentant les éléments de données de notre tableau JSON. Les clés dans la table de hachage correspondent aux noms de champs dans notre JSON, tels que FirstName et LastName.

Nous utilisons ensuite ConvertTo-Json pour convertir cette structure en un tableau JSON.

La sortie JSON résultante peut être vue ci-dessous.

Sortie :

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

Dans notre prochain exemple, nous présentons la création d’un objet JSON qui contient des sous-tableaux.

La variable $Body est définie pour contenir un objet JSON avec deux propriétés : My Items et My details. Chaque propriété contient un tableau d’éléments.

Exemple 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

Dans ce script, nous définissons une table de hachage (@{}) et spécifions deux clés : 'My Items' et 'My details'. La valeur associée à 'My Items' est un tableau de noms d’éléments, tandis que la valeur associée à 'My details' est un tableau de tables de hachage représentant les détails de chaque élément.

Lorsque nous exécutons ConvertTo-Json sur la variable $Body, il convertit la structure en un objet JSON.

La sortie JSON résultante peut être vue ci-dessous.

Sortie :

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

Dans cet objet JSON, "My details" et "My Items" sont les clés, chacune associée à son tableau de données respectif. La structure permet d’organiser les données connexes de manière hiérarchique, ce qui est un cas d’utilisation courant lors de la manipulation de JSON dans PowerShell.

Nous pouvons également créer un objet PowerShell et ensuite le convertir directement en un tableau JSON en utilisant le cmdlet ConvertTo-Json.

Regardez l’exemple ci-dessous :

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

$jsonOutput = $jsonArray | ConvertTo-Json

Write-Output $jsonOutput

Sortie :

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

Ici, le script d’exemple commence par définir une variable nommée $jsonArray en tant que tableau de tables de hachage PowerShell. Chaque table de hachage représente une personne avec des attributs pour le prénom (FirstName) et le nom de famille (LastName).

Le script convertit ensuite ce tableau PowerShell de tables de hachage en un tableau JSON en utilisant le cmdlet ConvertTo-Json et l’assigne à la variable $jsonOutput. Enfin, il utilise Write-Output pour afficher le tableau JSON résultant.

En résumé, le script crée une représentation de tableau JSON de deux individus avec leurs prénoms et noms de famille respectifs en utilisant des tables de hachage PowerShell, puis il affiche ce tableau JSON dans la console.

Utiliser ConvertTo-Json pour créer un tableau JSON et l’enregistrer dans un fichier dans PowerShell

Cette méthode est un peu complexe. Nous allons créer le tableau JSON étape par étape en utilisant plus d’une variable.

Veuillez jeter un œil à l’exemple suivant pour mieux comprendre cette méthode.

Exemple :

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

Au début du script, une table de hachage vide nommée $jsonBase est créée. Cela servira de structure fondamentale pour l’objet JSON que nous allons construire.

Ensuite, une autre table de hachage nommée $array est initialisée pour représenter l’objet tableau. Cette variable $array contiendra les données qui constituent le tableau dans notre structure JSON.

Ensuite, des données utilisateurs d’exemple sont définies à l’aide d’une table de hachage nommée $data, contenant des paires clé-valeur telles que le nom et la couleur de l’utilisateur. Ces données seront ensuite encapsulées dans le tableau.

Le script ajoute ensuite la table de hachage $data à la table de hachage $array, l’associant à la clé User. Cela établit la représentation des données spécifiques à l’utilisateur dans le tableau.

En continuant, le $array, qui contient maintenant les données utilisateur, est ajouté à la table de hachage $jsonBase en utilisant la clé UserData. Cette étape encapsule le tableau de données utilisateur dans la plus grande structure JSON.

Vers la fin, le script convertit la table de hachage $jsonBase au format JSON en utilisant ConvertTo-Json. Notez que le paramètre -Depth contrôle le niveau de récursion pour convertir les structures imbriquées.

Enfin, le cmdlet Out-File enregistre les données JSON dans un fichier nommé sample.json dans le répertoire courant.

Après exécution, un fichier JSON nommé sample.json sera généré, contenant les données utilisateur sous la clé UserData et présentant le nom et la couleur de l’utilisateur dans une structure imbriquée sous la clé User.

Sortie (sample.json) :

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

Utiliser des chaînes ici pour créer un tableau JSON dans PowerShell

Utiliser des chaînes ici dans PowerShell est une autre technique pratique pour construire un tableau JSON bien formaté tout en maintenant la mise en page souhaitée. Une chaîne ici, désignée par @" ... "@, nous permet de définir un bloc de texte dans PowerShell tout en préservant son formatage, y compris les sauts de ligne et l’indentation.

Nous pouvons utiliser des chaînes ici pour créer un tableau JSON directement sous forme de chaîne.

Exemple :

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

Write-Output $jsonArray

Sortie :

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

Dans cet exemple, nous avons utilisé une chaîne ici (@" ... "@), qui permet la création directe d’un tableau JSON sous forme de chaîne.

Dans cette chaîne ici, nous avons défini le tableau JSON en utilisant la syntaxe appropriée :

• Nous avons utilisé des crochets [...] pour encapsuler l’ensemble du tableau.
• Puis, nous avons utilisé des accolades {...} pour enfermer chaque objet JSON individuel.

Enfin, nous avons affiché le tableau JSON en utilisant Write-Output.

Cette approche simplifie le processus de construction d’un tableau JSON avec la structure et le format souhaités. Comme nous pouvons le voir, la sortie montre un tableau JSON bien formaté qui correspond à la structure définie.

Créer un tableau d’objets personnalisés pour créer un tableau JSON dans PowerShell

Une autre méthode que nous pouvons utiliser pour créer un tableau JSON implique de créer un tableau d’objets personnalisés, chacun représentant un élément, puis de le convertir en tableau JSON. Les objets personnalisés sont des instances du type [PSCustomObject] qui nous permettent de définir et de structurer des données.

[PSCustomObject] nous permet de créer des objets avec des propriétés personnalisées. C’est une fonctionnalité fondamentale dans PowerShell qui facilite la création et la manipulation de données structurées dans des scripts et des fonctions.

Les propriétés personnalisées sont définies à l’aide d’une syntaxe de table de hachage où nous spécifions les noms des propriétés et leurs valeurs correspondantes, comme suit :

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

Voici un exemple :

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

$jsonOutput = $jsonArray | ConvertTo-Json

Write-Output $jsonOutput

Sortie :

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

Dans l’exemple fourni, un tableau nommé $jsonArray est créé, contenant des objets personnalisés définis à l’aide de la syntaxe @{}. Nous avons les propriétés FirstName et LastName et leurs valeurs respectives.

Ensuite, le cmdlet ConvertTo-Json est utilisé pour convertir le tableau d’objets personnalisés ($jsonArray) en un format de tableau JSON. Le tableau JSON résultant ($jsonOutput) contient maintenant chaque objet personnalisé en tant qu’élément, avec les propriétés et valeurs définies représentées dans la syntaxe JSON.

Enfin, le tableau JSON est affiché à l’aide de Write-Output.

Conclusion

En conclusion, PowerShell fournit plusieurs méthodes pour créer un tableau JSON, chacune répondant à des besoins et préférences spécifiques.

Le cmdlet ConvertTo-Json est un outil polyvalent, permettant une conversion simple des objets ou tableaux PowerShell en représentations JSON. Que ce soit en structurant JSON directement, en utilisant des chaînes ici, ou en tirant parti d’objets personnalisés, PowerShell offre une flexibilité dans la génération de tableaux JSON pour un échange et une organisation efficaces des données entre diverses applications et systèmes.