Arrays no PowerShell

Arrays são estruturas fundamentais em qualquer linguagem de programação, e no PowerShell não é diferente. Eles permitem armazenar múltiplos valores em uma única variável, facilitando o processamento de coleções de dados, como listas de nomes, números ou objetos. Nesta aula, você aprenderá a criar arrays, acessar e manipular seus elementos, e entender as diferenças entre o tipo de dados Array nativo e a classe ArrayList do .NET, que oferece maior flexibilidade em alguns cenários.

Dominar arrays é essencial para escrever scripts eficientes, especialmente quando você precisa processar grandes volumes de dados, como resultados de comandos ou leituras de arquivos. Ao final desta aula, você estará apto a usar arrays com confiança, sabendo escolher a melhor abordagem para cada situação.

Criação

No PowerShell, um array é uma coleção de itens que pode ser criada de várias formas. A maneira mais simples é atribuir múltiplos valores a uma variável separados por vírgula. Por exemplo:

$frutas = 'Maçã', 'Banana', 'Laranja'

Quando você atribui uma lista de valores separados por vírgula, o PowerShell automaticamente cria um array do tipo Object[]. Você também pode criar um array vazio usando o operador @() (também chamado de operador de subexpressão de array), ou um array com um único elemento, como veremos a seguir.

Outra forma comum é usar o operador @() para garantir que o resultado seja sempre um array, mesmo que o comando retorne apenas um item ou nenhum. Isso é especialmente útil ao capturar a saída de comandos que podem variar em quantidade de resultados. Por exemplo:

$numeros = @(1, 2, 3, 4, 5)  # array explícito com 5 elementos
$vazio = @()                 # array vazio
$umElemento = @('único')     # array com um elemento

Você também pode criar arrays com faixas de números usando o operador de intervalo ..:

$intervalo = 1..10  # array de 1 a 10

Para verificar o tipo e o tamanho de um array, use a propriedade Count ou o método Length:

$frutas.Count  # retorna 3
$frutas.Length # também retorna 3

É importante notar que, por padrão, os arrays no PowerShell são de tipo fixo em relação ao tamanho, mas não em relação ao tipo dos elementos — ou seja, você pode misturar tipos diferentes em um mesmo array, como números e strings.

Acesso e fatiamento

Para acessar elementos de um array, utilizamos índices numéricos que começam em 0. Por exemplo, para obter o primeiro elemento de $frutas, usamos $frutas[0]; o segundo, $frutas[1], e assim por diante.

$frutas = 'Maçã', 'Banana', 'Laranja'
$frutas[0]  # retorna 'Maçã'
$frutas[2]  # retorna 'Laranja'

O PowerShell também suporta índices negativos, que contam a partir do final do array. O índice -1 refere-se ao último elemento, -2 ao penúltimo, e assim por diante.

$frutas[-1]  # retorna 'Laranja'
$frutas[-3]  # retorna 'Maçã'

Para acessar múltiplos elementos de uma só vez, você pode usar uma lista de índices ou um intervalo. Por exemplo, para obter o primeiro e o terceiro elementos:

$frutas[0,2]  # retorna 'Maçã' e 'Laranja'

Ou para obter um intervalo contíguo, use o operador de intervalo dentro dos colchetes:

$numeros = 1..10
$numeros[2..5]  # retorna 3,4,5,6

Fatiamento (slicing) é o termo usado para extrair uma parte do array. No PowerShell, você pode combinar índices e intervalos para obter subconjuntos. Por exemplo:

$array = 0..9
$subArray = $array[1..3] + $array[7]  # combina elementos
$subArray  # retorna 1,2,3,7

Outra técnica útil é usar o método Where() ou o cmdlet Where-Object para filtrar elementos com base em uma condição. Por exemplo, para obter apenas números pares:

$pares = $numeros | Where-Object { $_ % 2 -eq 0 }

Essa abordagem é muito comum em scripts do PowerShell e permite processar arrays de forma declarativa.

Adicionando elementos

Arrays nativos no PowerShell têm tamanho fixo. Isso significa que você não pode simplesmente adicionar um elemento a um array existente sem criar um novo array. No entanto, o PowerShell oferece uma sintaxe conveniente para "adicionar" elementos usando o operador +=, que na prática cria um novo array combinando o array original com o novo elemento.

$frutas = 'Maçã', 'Banana'
$frutas += 'Laranja'  # cria um novo array com 3 elementos

Embora o operador += seja simples, ele pode ser ineficiente se usado em loops grandes, porque a cada iteração um novo array é criado e os elementos são copiados. Para cenários onde você precisa adicionar muitos elementos dinamicamente, é melhor usar uma ArrayList ou a classe List do .NET, que veremos na próxima seção.

Outra forma de adicionar elementos é usar o método Insert para inserir em uma posição específica, mas lembre-se de que isso também exige recriar o array. Por exemplo:

$array = 1, 2, 4
$array = $array[0..1] + 3 + $array[2]  # insere o 3 entre 2 e 4
$array  # retorna 1,2,3,4

Essa manipulação manual é propensa a erros, então prefira usar estruturas de dados mutáveis quando precisar de alterações frequentes.

Arrays vs ArrayList

Como mencionado, arrays nativos (Object[]) têm tamanho fixo. Para superar essa limitação, o PowerShell permite usar a classe System.Collections.ArrayList do .NET, que é uma lista dinâmica que pode crescer conforme necessário.

Para criar uma ArrayList, você pode usar o operador New-Object ou o acelerador de tipo [System.Collections.ArrayList]:

$list = New-Object System.Collections.ArrayList
# ou
$list = [System.Collections.ArrayList]@()

Uma das principais vantagens da ArrayList é o método Add(), que adiciona um elemento ao final da lista de forma eficiente, sem precisar recriar a lista inteira. O método retorna o índice do elemento adicionado.

$list = [System.Collections.ArrayList]@()
$null = $list.Add('Maçã')  # o retorno é descartado com $null
$null = $list.Add('Banana')
$list  # exibe os itens

Também é possível remover elementos com Remove() ou RemoveAt(), inserir em uma posição específica com Insert(), e acessar elementos por índice da mesma forma que arrays.

$list.Insert(1, 'Laranja')  # insere no índice 1
$list.Remove('Banana')       # remove o elemento 'Banana'
$list.RemoveAt(0)            # remove o elemento no índice 0

Outra classe útil é List[type] (genérica), que oferece desempenho melhor para tipos específicos, mas a ArrayList é mais comum em scripts por sua simplicidade.

Quando usar cada uma? Arrays nativos são ideais para coleções estáticas ou quando você precisa de desempenho máximo na leitura. ArrayList é recomendada quando você precisa modificar a coleção com frequência, como em loops que adicionam itens dinamicamente. Para scripts simples, a diferença de desempenho pode ser desprezível, mas em operações com milhares de itens, a eficiência se torna relevante.

Uma observação importante: a ArrayList não é tipada, o que significa que ela armazena objetos do tipo Object. Isso pode causar conversões de tipo inesperadas se você não tiver cuidado. Para coleções fortemente tipadas, considere usar List[int], por exemplo.

Boas Práticas

• Use @() ao capturar saídas de comandos para garantir que o resultado seja um array, mesmo que haja apenas um item.
• Evite usar += em loops grandes com arrays nativos; prefira ArrayList ou uma lista genérica.
• Prefira métodos como Where-Object e ForEach-Object para manipulação de arrays, em vez de loops tradicionais, pois são mais legíveis e eficientes.
• Quando precisar de uma coleção de tamanho fixo, use arrays nativos; para coleções dinâmicas, use ArrayList.
• Lembre-se de que índices começam em 0; isso é uma fonte comum de erros.

Referências

• Documentação oficial: about_Arrays
• Classe ArrayList (Microsoft .NET)
• Criando e modificando arrays (PowerShell)
• about_Operators (inclui operador de intervalo e subexpressão)
• Classe Array (.NET)
• Where-Object (referência)

Exercícios

1. Crie um array chamado $cores contendo as cores: "Vermelho", "Verde", "Azul". Exiba o segundo elemento.

Ver resposta

$cores = 'Vermelho', 'Verde', 'Azul'
$cores[1]  # Retorna 'Verde'

2. Dado o array $numeros = 10, 20, 30, 40, 50, use fatiamento para obter os elementos nas posições 1 a 3 (índices 1,2,3) e armazene em $parte. Exiba o resultado.

Ver resposta

$numeros = 10, 20, 30, 40, 50
$parte = $numeros[1..3]
$parte  # Retorna 20, 30, 40

3. Adicione o elemento "Roxo" ao final do array $cores criado no exercício 1 (use +=). Depois, exiba o array completo.

Ver resposta

$cores = 'Vermelho', 'Verde', 'Azul'
$cores += 'Roxo'
$cores  # Retorna Vermelho, Verde, Azul, Roxo

4. Crie uma ArrayList chamada $lista e adicione os números 1, 2 e 3 usando o método Add(). Em seguida, insira o número 0 na posição 0. Exiba a lista final.

Ver resposta

$lista = [System.Collections.ArrayList]@()
$null = $lista.Add(1)
$null = $lista.Add(2)
$null = $lista.Add(3)
$lista.Insert(0, 0)
$lista  # Retorna 0, 1, 2, 3

5. Explique a diferença entre um array nativo e uma ArrayList e dê um exemplo de situação onde cada um é mais adequado.

Ver resposta