Cómo crear un arreglo JSON en PowerShell

1. Usar ConvertTo-Json para crear un arreglo JSON en PowerShell
2. Usar ConvertTo-Json para crear un arreglo JSON y guardarlo en un archivo en PowerShell
3. Usar Here-Strings para crear un arreglo JSON en PowerShell
4. Crear un arreglo de objetos personalizados para crear un arreglo JSON en PowerShell
5. Conclusión

En PowerShell, JSON (Notación de Objetos de JavaScript) es un formato de intercambio de datos común utilizado para la comunicación entre varios sistemas y aplicaciones. Un arreglo JSON que contiene pares clave-valor es una forma estructurada de organizar datos.

En este artículo, exploraremos diferentes métodos para crear un arreglo JSON en PowerShell, junto con ejemplos de código detallados y explicaciones.

Usar ConvertTo-Json para crear un arreglo JSON en PowerShell

En este ejemplo, demostramos cómo crear un arreglo JSON simple usando PowerShell. Primero organizamos el arreglo JSON dentro de una variable llamada $Body y luego lo convertimos en un arreglo JSON usando el cmdlet ConvertTo-Json.

Ejemplo 1:

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

En este fragmento de código, definimos un arreglo usando @(), y dentro del arreglo, creamos una tabla hash (@{}) con pares clave-valor que representan los elementos de datos de nuestro arreglo JSON. Las claves en la tabla hash corresponden a los nombres de campo en nuestro JSON, como FirstName y LastName.

Luego usamos ConvertTo-Json para convertir esta estructura en un arreglo JSON.

La salida JSON resultante se puede ver a continuación.

Salida:

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

En nuestro siguiente ejemplo, mostramos la creación de un objeto JSON que contiene sub-arreglos.

La variable $Body se define para contener un objeto JSON con dos propiedades: Mis Artículos y Mis detalles. Cada propiedad contiene un arreglo de artículos.

Ejemplo 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

En este script, definimos una tabla hash (@{}) y especificamos dos claves: 'Mis Artículos' y 'Mis detalles'. El valor asociado con 'Mis Artículos' es un arreglo de nombres de artículos, mientras que el valor asociado con 'Mis detalles' es un arreglo de tablas hash que representan detalles sobre cada artículo.

Cuando ejecutamos ConvertTo-Json sobre la variable $Body, convierte la estructura en un objeto JSON.

La salida JSON resultante se puede ver a continuación.

Salida:

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

En este objeto JSON, "Mis detalles" y "Mis Artículos" son las claves, cada una asociada con su respectivo arreglo de datos. La estructura permite organizar datos relacionados de manera jerárquica, que es un uso común al trabajar con JSON en PowerShell.

También podemos crear un objeto PowerShell y luego convertirlo directamente a un arreglo JSON usando el cmdlet ConvertTo-Json.

Echa un vistazo al ejemplo a continuación:

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

$jsonOutput = $jsonArray | ConvertTo-Json

Write-Output $jsonOutput

Salida:

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

Aquí, el script de ejemplo comienza definiendo una variable llamada $jsonArray como un arreglo de tablas hash de PowerShell. Cada tabla hash representa a una persona con atributos para el primer nombre (FirstName) y el apellido (LastName).

El script luego convierte este arreglo de tablas hash de PowerShell en un arreglo JSON usando el cmdlet ConvertTo-Json y lo asigna a la variable $jsonOutput. Finalmente, usa Write-Output para mostrar el arreglo JSON resultante.

En resumen, el script crea una representación de un arreglo JSON de dos individuos con sus respectivos nombres y apellidos usando tablas hash de PowerShell, y luego muestra este arreglo JSON en la consola.

Usar ConvertTo-Json para crear un arreglo JSON y guardarlo en un archivo en PowerShell

Este método es un poco complejo. Crearemos el arreglo JSON paso a paso usando más de una variable.

Por favor, echa un vistazo al siguiente ejemplo para entender mejor este método.

Ejemplo:

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

Al inicio del script, se crea una tabla hash vacía llamada $jsonBase. Esto servirá como la estructura fundamental para el objeto JSON que construiremos.

A continuación, otra tabla hash llamada $array se inicializa para representar el objeto de arreglo. Esta variable $array contendrá los datos que constituyen el arreglo dentro de nuestra estructura JSON.

Luego, se definen datos de usuario de muestra usando una tabla hash llamada $data, que contiene pares clave-valor como el nombre y color del usuario. Estos datos se encapsularán más tarde dentro del arreglo.

A continuación, el script añade la tabla hash $data a la tabla hash $array, asociándola a la clave Usuario. Esto establece la representación de los datos específicos del usuario dentro del arreglo.

Continuando, el $array, que ahora contiene los datos del usuario, se añade a la tabla hash $jsonBase usando la clave UserData. Este paso encapsula el arreglo de datos del usuario dentro de la estructura JSON más grande.

Hacia el final, el script convierte la tabla hash $jsonBase a formato JSON usando ConvertTo-Json. Ten en cuenta que el parámetro -Depth controla el nivel de recursión para convertir estructuras anidadas.

Finalmente, el cmdlet Out-File guarda los datos JSON en un archivo llamado sample.json en el directorio actual.

Después de ejecutar, se generará un archivo JSON llamado sample.json, que contendrá los datos del usuario bajo la clave UserData y presentará el nombre y color del usuario dentro de una estructura anidada bajo la clave Usuario.

Salida (sample.json):

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

Usar Here-Strings para crear un arreglo JSON en PowerShell

Usar here-strings en PowerShell es otra técnica útil para construir un arreglo JSON bien formateado mientras se mantiene el diseño deseado. Un here-string, denotado por @" ... "@, nos permite definir un bloque de texto en PowerShell mientras preservamos su formato, incluidos los saltos de línea y la sangría.

Podemos emplear here-strings para crear un arreglo JSON directamente como un string.

Ejemplo:

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

Write-Output $jsonArray

Salida:

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

En este ejemplo, usamos un here-string (@" ... "@), que permite crear directamente un arreglo JSON como un string.

Dentro de este here-string, definimos el arreglo JSON usando la sintaxis apropiada:

• Usamos corchetes cuadrados [...] para encapsular todo el arreglo.
• Luego, usamos llaves {...} para encerrar cada objeto JSON individual.

Por último, mostramos el arreglo JSON utilizando Write-Output.

Este enfoque simplifica el proceso de construir un arreglo JSON con la estructura y formato deseados. Como podemos ver, la salida muestra un arreglo JSON bien formateado que se alinea con la estructura definida.

Crear un arreglo de objetos personalizados para crear un arreglo JSON en PowerShell

Otro método que podemos usar para crear un arreglo JSON implica crear un arreglo de objetos personalizados, cada uno representando un elemento, y luego convertirlo en un arreglo JSON. Los objetos personalizados son instancias del tipo [PSCustomObject] que nos permiten definir y estructurar datos.

[PSCustomObject] nos permite crear objetos con propiedades personalizadas. Es una característica fundamental en PowerShell que facilita la creación y manipulación de datos estructurados dentro de scripts y funciones.

Las propiedades personalizadas se definen usando una sintaxis similar a la de una tabla hash donde especificamos nombres de propiedades y sus valores correspondientes, como los siguientes:

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

Aquí hay un ejemplo:

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

$jsonOutput = $jsonArray | ConvertTo-Json

Write-Output $jsonOutput

Salida:

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

En el ejemplo proporcionado, se crea un arreglo llamado $jsonArray, que contiene objetos personalizados definidos usando la sintaxis @{}. Tenemos las propiedades FirstName y LastName y sus respectivos valores.

Luego, se usa el cmdlet ConvertTo-Json para convertir el arreglo de objetos personalizados ($jsonArray) en un formato de arreglo JSON. El arreglo JSON resultante ($jsonOutput) ahora contiene cada objeto personalizado como un elemento, con las propiedades y valores definidos representados en sintaxis JSON.

Finalmente, se muestra el arreglo JSON utilizando Write-Output.

Conclusión

En conclusión, PowerShell proporciona múltiples métodos para crear un arreglo JSON, cada uno atendiendo a necesidades y preferencias específicas.

El cmdlet ConvertTo-Json es una herramienta versátil, que permite la conversión directa de objetos o arreglos de PowerShell en representaciones JSON. Ya sea estructurando JSON directamente, usando here-strings o aprovechando objetos personalizados, PowerShell ofrece flexibilidad para generar arreglos JSON para un intercambio y organización eficientes de datos en diversas aplicaciones y sistemas.