Como usar Arrays no Powershell

Introdução

Um array é uma estrutura de dados que pode conter mais de um valor por vez. Pense nisso como uma coleção ou uma lista de itens do mesmo tipo ou de tipos de dados diferentes. Arrays são usados em muitas linguagens de script e programação, incluindo Windows PowerShell.

Vamos mergulhar em como criar e usar um array in PowerShell.

Criando um Array de Objetos

Por padrão, cada item em um array é um objeto, em vez de outro tipo de dado como string ou inteiro. Aqui está um exemplo de como criar um array de objetos adicionando explicitamente objetos:

      $people = @(

    [PSCustomObject]@{Name='Alice'; Age=30},

    [PSCustomObject]@{Name='Bob'; Age=25}
      

Criando um Array com Apenas Um Elemento

Se você colocar apenas um valor em uma variável, então o PowerShell não criará um array. Para confirmar isso, vamos usar dois scripts e exibir os tipos de dados deles.

Primeiro, vamos criar um array no PowerShell com cinco elementos:

      $array = @(1, 2, 3, 4, 5)

$array1.GetType()
      

Agora vamos tentar usar um script semelhante para criar um array com apenas um elemento:

      $array1 = 1

$array1.GetType()
      

Como você pode ver na saída abaixo, o PowerShell criou um array (System.Array) para o primeiro script de exemplo, mas não para o segundo.

Este comportamento é particularmente preocupante se você deseja criar um array ao recuperar objetos executando um comando específico, pois você não sabe antecipadamente quantos objetos serão retornados nos resultados.

Para contornar esse problema, você pode usar o operador , (vírgula). Se uma vírgula for usada como operador binário, então um array normal é criado; se for usada como operador unário, o array terá apenas um elemento.

Por exemplo, aqui está como podemos obter um array consistindo de um elemento:

      $array1 = ,1

$array1.GetType()
      

Podemos confirmar a criação do array com a saída mostrada abaixo:

Criando um Array Vazio

No PowerShell, você também pode criar um array — incluindo um array vazio — usando o operador @. Se você especificar @(), você obtém um array sem nenhum objeto, você pode criar um. É uma maneira conveniente de inicializar variáveis como arrays e depois adicionar objetos aos arrays sem se preocupar com o número deles.

      $array3 = @()

$array3.GetType()
      

Criando um Array Fortemente Tipado

Por padrão, os elementos de um array podem ter diferentes tipos de dados. Mas você também pode criar arrays que aceitam apenas valores de um único tipo designado. Tentar adicionar um valor de um tipo diferente resultará em erro. Aqui está como criar os arrays fortemente tipados mais comuns:

Inteiro:

      [int[]]$intArray = 1, 2, 3
      

String:

      [string[]]$strArray = "one", "two", "three"
      

Data/Hora:

[datetime[]]$dateArray = (Get-Date), (Get-Date).AddDays(1)

Criando um Array Multidimensional (Matriz)

Ao aninhar arrays usando vírgulas, você pode criar um arranjo estruturado de dados em linhas ou colunas. Aqui criamos uma matriz 3×3:

$twoDArray = @(

@(1, 2, 3),

@(4, 5, 6),

@(7, 8, 9)

)

Comparando, Agrupando, Selecionando e Ordenando Arrays

Outros cmdlets úteis do PowerShell para trabalhar com arrays incluem:

• Compare-Object — Compara dois arrays e retorna as diferenças.
• Group-Object — Agrupa elementos de um array com base nos valores das propriedades.
• Select-Object — Seleciona propriedades especificadas de um objeto ou conjunto de objetos e também pode ser usado para selecionar um número específico de elementos de um array.
• Sort-Object — Utilizado para ordenar arrays que contêm apenas um tipo de dado, conforme mostrado abaixo:

      $array = @(3, 1, 4, 2)
$sortedArray = $array | Sort-Object
      

Percorrendo um Array

Para manipular cada elemento de um array um após o outro, precisamos criar um loop usando o operador foreach. Por exemplo, se declararmos um array de strings e quisermos contar o comprimento de cada palavra no array, devemos executar o seguinte script:

      $array8 = @("Earth","Mercury","Venus","Jupiter","Saturn","Mars", "Neptune", "Pluto")
foreach ($array in $array8) {
 "$array = " + $array.length
}
      

O resultado será assim:

Usando um Pipeline

O pipeline é usado no PowerShell para passar a saída de um comando como entrada para outro. Ao trabalhar com arrays, você pode usar o pipeline para processar e manipular os dados no array e atribuir os resultados a um novo array ou modificar o existente.

Aqui vamos multiplicar cada item do array por 2:

      $numbers = 1,2,3,4,5

$doubled = $numbers | ForEach-Object { $_ * 2 }
      

Adicionando a um Array

O tamanho de um array no PowerShell é imutável assim que é definido. No entanto, o operador += permite que você crie um novo array ao acrescentar itens a um array existente — essencialmente criando um novo array combinado.

      $array = @(1, 2, 3)
$array += 4
      

Criando um ArrayList

Para arrays grandes ou adições frequentes, o uso de += pode ser uma preocupação de desempenho, pois toda vez que o utiliza, um novo array é criado, os elementos antigos são copiados e o novo elemento é adicionado ao final. Nestes casos, você pode querer usar um ArrayList.

O tamanho de um ArrayList é mutável, então você pode adicionar ou remover itens sem ter que recriar toda a coleção. Como um array padrão, um ArrayList pode conter itens de diferentes tipos de dados.

Aqui está o cmdlet para criar um ArrayList:

      $array3 = New-Object System.Collections.ArrayList

      

Removendo um item de um array

Agora vamos usar um ArrayList para remover um item de um array. Primeiro vamos criar um array.

      $array5 = "one", "two", "three", "four", "five"
$array5.gettype()
      

Agora vamos adicioná-lo a um ArrayList para que possamos modificá-lo facilmente.

      [System.Collections.ArrayList]$ArrayList1 = $array5

$ArrayList1.GetType()
      

Em seguida, usaremos o comando .Remove.

      $ArrayList1.Remove("three")

      

Limpando um Array

Não há uma maneira definida de deletar um array, mas existem várias maneiras de se livrar do conteúdo de um array (limpá-lo). Uma delas é atribuir a variável $null ao array:

      $array7 = $null
$array7
      

Aqui está outra forma de limpar um array:

      $array = @("element1", "element2", "element3")

$array = @()
      

Aqui está como limpar um ArrayList:

      $arrayList = New-Object System.Collections.ArrayList
$arrayList.Add("element1")
$arrayList.Add("element2")
$arrayList.Clear()
      

Imprimindo um Array

A maneira mais fácil de exibir o conteúdo de um array é simplesmente referenciar a variável do array. O exemplo abaixo mostra como incluir o texto “Elemento:” antes de cada item no array:

Para escrever em um arquivo .txt, use o comando Out-File:

      $var5 | Out-File C:scriptsarray.txt

      

Para exportar para um arquivo .csv, utilize o comando Export-Csv:

      $var6 | Export-Csv -Path C:scriptsarray.csv

      

Filtrando um Array

Podemos usar o cmdlet Where-Object para recuperar apenas os números pares de um array:

      $numbers = 1,2,3,4,5,6

$evenNumbers = $numbers | Where-Object { $_ % 2 -eq 0 }

$evenNumbers
      

Alternativamente, podemos usar o método .Where() que não requer um pipeline:

      $numbers = 1,2,3,4,5,6

$evenNumbers = $numbers.Where({ $_ % 2 -eq 0 })

$evenNumbers

      

Verificando o comprimento de um array

Para retornar o número de elementos em um array, use o parâmetro .length :

      $array6 = 1,2,3,4,5,6
echo $array6.Length
      

Verificando se um Array Contém um Valor Específico

Se você quer verificar se algum dos elementos em um array contém um valor específico, use o método Contains. Este código mostrará se um array contém um 2 ou um 12:

      $array7 = 1,2,5,8,3,4,5
$array7.Contains(2)
$array7.Contains(12)
      

Acessando itens usando o índice do array

Assim como na maioria das linguagens de programação, cada item individual em um array do PowerShell pode ser acessado por um índice. O índice de um array começa em zero, então em um array de três itens, o primeiro item está no índice 0, o segundo está no índice 1 e o terceiro está no índice 2.

Para acessar itens usando o índice do array, você precisa fornecer o índice entre colchetes após a variável do array. Abaixo está um exemplo mostrando como criar um array e exibir o segundo elemento:

      $colors = "Red", "Green", "Blue", "Yellow"

$secondColor = $colors[1]

Write-Output $secondColor
      

Você pode acessar itens do final de um array usando um índice negativo. -1 refere-se ao último item, -2 refere-se ao penúltimo item, etc.

Usando o operador Join e o operador Split

No PowerShell, o operador join é usado para anexar um array de strings em uma única string, opcionalmente usando um delimitador especificado. Aqui está um exemplo sem delimitador.

      $array = "Power", "Shell"

$joined = $array -join ""

# Output: "PowerShell"
      

Aqui está como seria com um delimitador:

O operador split basicamente faz o oposto do operador join, conforme mostrado no exemplo abaixo:

      $string = "apple,banana,grape"
$fruits = $string -split ","
      

Usando o Operador Replace

O operador replace é usado para substituir uma string por outra. Aqui está a estrutura do cmdlet:

      <originalString> -replace <patternToFind>, <replacementString>

      

Aqui está um exemplo que substituirá “Hello World” por “PowerShell”:

      $string = "Hello World"

$newString = $string -replace "World", "PowerShell"

      

Fatiando um Array

Você pode criar um subarray especificando um intervalo, conforme mostrado aqui:

      $array = 1,2,3,4,5,6,7,8,9

$subset = $array[3..6]

      

Invertendo um Array

Aqui está um exemplo de como inverter a ordem dos elementos em um array:

      $numbers = 1..5

[Array]::Reverse($numbers)
      

Conclusão

Os arrays são uma estrutura de dados fundamental na maioria das linguagens de script e programação porque permitem armazenar, recuperar e manipular uma coleção de itens de vários tipos de dados. Compreender arrays vai aumentar sua capacidade de automatizar tarefas usando PowerShell.

Agora a Netwrix pode ajudar

Precisa proteger seu Active Directory e o ambiente Entra ID (Azure AD) de forma mais eficiente e eficaz? Considere Netwrix Directory Manager. Suas capacidades automatizadas de gerenciamento de grupos e usuários reduzem o risco de data breaches enquanto eliminam tarefas administrativas manuais que consomem tempo.

Netwrix Directory Manager oferece a você a capacidade de:

• Automatize o provisionamento e desprovisionamento de usuários do seu sistema de informações de recursos humanos (HRIS) para o Active Directory, Entra ID e aplicações habilitadas para SCIM, permitindo assim que novos funcionários sejam produtivos rapidamente e reduzindo o risco de adversários assumirem identidades obsoletas.
• Atualize automaticamente os grupos de diretórios com base em alterações como a promoção de um funcionário ou a mudança para outro cargo, conforme registrado no seu HRIS. Essa automação mantém os direitos de acesso atualizados em tempo quase real, conforme necessário para segurança e conformidade, ao mesmo tempo que economiza tempo da sua equipe de TI.
• Delegue a gestão de grupos e usuários para as pessoas que sabem quem deve ter acesso a quê. Fluxos de trabalho simples permitem que os proprietários das linhas de negócio revisem seus grupos e aprovem ou neguem solicitações de acesso de usuários, reduzindo o risco de ter grupos e usuários com privilégios excessivos no seu Directory Management.
• Mantenha o diretório limpo e mais fácil de gerenciar com a criação, expiração e exclusão automáticas de usuários.
• Mantenha e comprove a conformidade com regulamentos e padrões com insights profundos, automação eficaz e relatórios claros sobre grupos e membros.