Como Criar um Array JSON no PowerShell

1. Use ConvertTo-Json para Criar um Array JSON no PowerShell
2. Use ConvertTo-Json para Criar um Array JSON e Salvá-lo em um Arquivo no PowerShell
3. Use Here-Strings para Criar um Array JSON no PowerShell
4. Crie um Array de Objetos Personalizados para Criar um Array JSON no PowerShell
5. Conclusão

No PowerShell, JSON (Notação de Objetos JavaScript) é um formato comum de intercâmbio de dados usado para comunicação entre vários sistemas e aplicações. Um array JSON contendo pares de chave-valor é uma maneira estruturada de organizar dados.

Neste artigo, exploraremos diferentes métodos para criar um array JSON no PowerShell, juntamente com exemplos de código detalhados e explicações.

Use ConvertTo-Json para Criar um Array JSON no PowerShell

Neste exemplo, demonstramos como criar um simples array JSON usando PowerShell. Primeiro, organizamos o array JSON dentro de uma variável chamada $Body e depois a convertíamos em um array JSON usando o cmdlet ConvertTo-Json.

Exemplo 1:

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

Neste trecho de código, definimos um array usando @(), e dentro do array, criamos uma tabela hash (@{}) com pares de chave-valor representando os elementos de dados do nosso array JSON. As chaves na tabela hash correspondem aos nomes dos campos em nosso JSON, como FirstName e LastName.

Em seguida, usamos ConvertTo-Json para converter essa estrutura em um array JSON.

A saída JSON resultante pode ser vista abaixo.

Saída:

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

No nosso próximo exemplo, mostramos como criar um objeto JSON que contém sub-arrays.

A variável $Body é definida para conter um objeto JSON com duas propriedades: My Items e My details. Cada propriedade contém um array de itens.

Exemplo 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

Neste script, definimos uma tabela hash (@{}) e especificamos duas chaves: 'My Items' e 'My details'. O valor associado a 'My Items' é um array de nomes de itens, enquanto o valor associado a 'My details' é um array de tabelas hash representando detalhes sobre cada item.

Quando executamos ConvertTo-Json na variável $Body, ela converte a estrutura em um objeto JSON.

A saída JSON resultante pode ser vista abaixo.

Saída:

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

Neste objeto JSON, "My details" e "My Items" são as chaves, cada uma associada ao seu respectivo array de dados. A estrutura permite organizar dados relacionados de maneira hierárquica, que é um caso de uso comum ao trabalhar com JSON no PowerShell.

Também podemos criar um objeto PowerShell e depois convertê-lo diretamente em um array JSON usando o cmdlet ConvertTo-Json.

Dê uma olhada no exemplo abaixo:

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

$jsonOutput = $jsonArray | ConvertTo-Json

Write-Output $jsonOutput

Saída:

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

Aqui, o script de exemplo começa definindo uma variável chamada $jsonArray como um array de tabelas hash do PowerShell. Cada tabela hash representa uma pessoa com atributos para primeiro nome (FirstName) e sobrenome (LastName).

O script então converte este array de tabelas hash do PowerShell em um array JSON usando o cmdlet ConvertTo-Json e a atribui à variável $jsonOutput. Finalmente, usa Write-Output para exibir o array JSON resultante.

Em resumo, o script cria uma representação de array JSON de dois indivíduos com seus respectivos primeiros e sobrenomes usando tabelas hash do PowerShell, e então exibe este array JSON no console.

Use ConvertTo-Json para Criar um Array JSON e Salvá-lo em um Arquivo no PowerShell

Esse método é um pouco complexo. Vamos criar o array JSON passo a passo usando mais de uma variável.

Por favor, dê uma olhada no exemplo a seguir para entender melhor esse método.

Exemplo:

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

No início do script, uma tabela hash vazia chamada $jsonBase é criada. Esta servirá como a estrutura fundamental para o objeto JSON que construiremos.

Em seguida, outra tabela hash chamada $array é inicializada para representar o objeto array. Esta variável $array conterá os dados que constituem o array dentro da nossa estrutura JSON.

Depois, dados de usuário de exemplo são definidos usando uma tabela hash chamada $data, contendo pares de chave-valor como o nome do usuário e a cor. Esses dados serão posteriormente encapsulados dentro do array.

Em seguida, o script adiciona a tabela hash $data à tabela hash $array, associando-a à chave User. Isso estabelece a representação dos dados específicos do usuário dentro do array.

Continuando, o $array, que agora contém os dados do usuário, é adicionado à tabela hash $jsonBase usando a chave UserData. Essa etapa encapsula o array de dados do usuário dentro da estrutura JSON maior.

Por fim, o script converte a tabela hash $jsonBase para o formato JSON usando ConvertTo-Json. Note que o parâmetro -Depth controla o nível de recursão para conversão de estruturas aninhadas.

Finalmente, o cmdlet Out-File salva os dados JSON em um arquivo chamado sample.json no diretório atual.

Após a execução, um arquivo JSON chamado sample.json será gerado, contendo os dados do usuário sob a chave UserData e apresentando o nome e a cor do usuário dentro de uma estrutura aninhada sob a chave User.

Saída (sample.json):

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

Use Here-Strings para Criar um Array JSON no PowerShell

Usar here-strings no PowerShell é outra técnica útil para construir um array JSON bem formatado enquanto mantém o layout desejado. Uma here-string, denotada por @" ... "@, permite definir um bloco de texto no PowerShell enquanto preserva sua formatação, incluindo quebras de linha e indentação.

Podemos empregar here-strings para criar um array JSON diretamente como uma string.

Exemplo:

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

Write-Output $jsonArray

Saída:

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

Neste exemplo, usamos uma here-string (@" ... "@), que permite a criação direta de um array JSON como uma string.

Dentro desta here-string, definimos o array JSON usando a sintaxe apropriada:

• Usamos colchetes [...] para encapsular todo o array.
• Então, usamos chaves {...} para enclausurar cada objeto JSON individual.

Por fim, exibimos o array JSON usando Write-Output.

Essa abordagem simplifica o processo de construção de um array JSON com a estrutura e formato desejados. Como podemos ver, a saída mostra um array JSON bem formatado que alinha com a estrutura definida.

Crie um Array de Objetos Personalizados para Criar um Array JSON no PowerShell

Outro método que podemos usar para criar um array JSON envolve criar um array de objetos personalizados, cada um representando um elemento, e então convertê-lo em um array JSON. Objetos personalizados são instâncias do tipo [PSCustomObject] que nos permitem definir e estruturar dados.

[PSCustomObject] permite criar objetos com propriedades personalizadas. É um recurso fundamental no PowerShell que facilita a criação e manipulação de dados estruturados dentro de scripts e funções.

As propriedades personalizadas são definidas usando uma sintaxe semelhante a tabela hash onde especificamos nomes de propriedades e seus valores correspondentes, como o seguinte:

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

Aqui está um exemplo:

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

$jsonOutput = $jsonArray | ConvertTo-Json

Write-Output $jsonOutput

Saída:

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

No exemplo fornecido, um array chamado $jsonArray é criado, contendo objetos personalizados definidos com a sintaxe @{}. Temos as propriedades FirstName e LastName e seus respectivos valores.

Em seguida, o cmdlet ConvertTo-Json é utilizado para converter o array de objetos personalizados ($jsonArray) em um formato de array JSON. O array JSON resultante ($jsonOutput) agora contém cada objeto personalizado como um elemento, com as propriedades e valores definidos representados na sintaxe JSON.

Por fim, o array JSON é exibido usando Write-Output.

Conclusão

Em conclusão, o PowerShell fornece múltiplos métodos para criar um array JSON, cada um atendendo a necessidades e preferências específicas.

O cmdlet ConvertTo-Json é uma ferramenta versátil, permitindo a conversão direta de objetos ou arrays do PowerShell em representações JSON. Seja estruturando JSON diretamente, usando here-strings ou aproveitando objetos personalizados, o PowerShell oferece flexibilidade na geração de arrays JSON para intercâmbio e organização de dados eficientes entre várias aplicações e sistemas.