Os arrays são um recurso importante do PowerShell. Eles permitem adquirir, manipular e produzir estruturas de dados reais (e não apenas strings brutas). Esse recurso torna o PowerShell diferente e mais útil do que outras linguagens de script.
Neste artigo, explicaremos o que são arrays e como usá-los no PowerShell. Primeiro, vamos mostrar como criar arrays no PowerShell e depois como usar funções básicas para manipulá-los. Em seguida, vamos ver vários tipos diferentes de arrays e explorar alguns dos recursos menos evidentes.
Nosso objetivo é fornecer uma boa base para trabalhar com arrays no PowerShell. Depois de dominar esses conceitos básicos, você pode dar uma olhada no nosso curso sobre PowerShell para saber mais.
Arrays são uma característica comum de quase todas as linguagens de programação. São uma estrutura de dados que serve como uma coleção de vários dados. Ao trabalhar com um array, você pode usar o mesmo comando para executar a mesma função em cada item de um array ou acessar e manipular elementos individuais usando um índice.
Os arrays no PowerShell podem conter um ou mais itens. Um item pode ser uma string, um número inteiro, um objeto ou até mesmo outro array, e um array pode conter qualquer combinação desses itens. Cada um desses itens tem um índice, que sempre começa (às vezes de forma confusa) em 0. Portanto, o primeiro item em um array recebe o índice 0, o segundo é indexado como 1 e assim por diante.
Os arrays são uma parte essencial que aparecem em todos os tutoriais do PowerShell, e um bom conhecimento de como trabalhar com arrays é fundamental para muitos aspectos do uso do PowerShell, desde a configuração do Office 365 até o uso do PowerShell para Pentesting.
A maneira mais fácil de ilustrar o que é um array é dar um exemplo. Vamos criar um array representado por um cesto de frutas.
Existem várias maneiras de criar arrays no PowerShell, mas a mais simples é executar este comando:
@()
Isso criará um array vazio. Como um array vazio não é tem utilidade, vamos adicionar algumas frutas ao nosso novo array. Elas serão representadas como strings de texto. Para fazer isso, execute este comando:
$fruta = @('Maçãs','Laranjas','Bananas')
Isso nomeará um array como “fruta” e adicionará três itens. Para ver se funcionou, você pode ler o array usando este comando:
PS /Users/yourname> $fruta
Que agora retorna:
Maçãs Laranjas Bananas
Como você pode ver, esse array é um grupo de dados individuais. O PowerShell os indexará automaticamente como explicamos anteriormente: “Maçãs” será indexada como 0, “Laranjas” como 1 e “Bananas” como 2.
Esse exemplo pode fazer com que os arrays pareçam bem simples, o que de certa forma são. A simplicidade, no entanto, é também o que faz deles objetos flexíveis e poderosos. No restante deste guia, vamos apresentar brevemente o que é possível fazer com arrays.
Nesta seção, vamos ver as maneiras mais simples de criar e trabalhar com arrays no PowerShell.
Primeiro, vamos criar um array. Embora existam outras formas, a maneira padrão de fazer isso é usar @().
Por enquanto, vamos criar um array chamado “dados”. Para fazer isso, execute:
$dados = @()
Esse array está vazio no momento porque não especificamos nenhum dado para ele. Para verificar quantos itens estão em um array, podemos usar a função count:
$dados.count
Neste momento, a função retornará 0, pois não há itens no nosso array. Para criar um array com alguns dados, colocamos esses dados entre parênteses após o @:
$dados = @('Zero','Um','Dois','Três')
Agora, execute a mesma função de contagem e você verá que existem quatro itens nesse array. Para ver esses itens novamente, é só chamar o array:
$dados
O comando lista os itens que colocamos no array.
Agora que temos um array, queremos acessar os itens contidos nele. Existem várias maneiras de fazer isso. A primeira é usar o índice dos itens no array. Como explicamos anteriormente, os índices começam em 0, portanto, para recuperar o primeiro item no nosso array, teremos que dizer ao PowerShell para examinar o item cujo índice é zero. Para fazer isso, executamos:
$dados[0]
Isso retornará “Zero” porque foi a primeira string que colocamos no nosso array.
Também podemos estender essa sintaxe para retornar vários itens do mesmo array simplesmente inserindo mais índices no mesmo comando. Por exemplo, execute:
$dados[0,2,3]
Isso retornará “Zero Dois Três”. Os itens são retornados seguindo ordem em que os índices foram inseridos. Você também pode usar uma sintaxe adicional para retornar conjuntos de itens de um array. Por exemplo:
$dados[1..3]
O comando retornará todos os itens com índice entre 1 e 3 (inclusive). E:
$dados[-1]
Retornará o último item do array: o número negativo informa ao PowerShell quantos itens contar do final do array para o começo, portanto, nesse caso, esse comando retornará “Três”, o último item no nosso array de teste.
O mesmo método pode ser usado para atualizar itens em um array. Por exemplo, para atualizar o item cujo índice é 2 (lembre-se de que este é o terceiro item no array), podemos executar:
$dados[2] = 'segundo'
Isso nos dá acesso direto aos itens dentro de um array.
Um dos recursos mais poderosos do PowerShell (e, na verdade, de qualquer interface de linha de comando) é a capacidade de executar a mesma ação em todos os itens de um array. Existem várias maneiras de fazer isso.
A mais simples é usar um pipeline, que é o caractere |. Ao passar um array para um pipeline, cada item do array é processado individualmente. Como apontamos no nosso artigo sobre objetos do PowerShell e pipeline de dados, geralmente essa é a maneira mais fácil de executar ações iteradas.
Por exemplo, para adicionar uma descrição a cada item do nosso array, podemos usar este comando:
$dados | ForEach-Object {"Item: [$PSItem]"}
Esse comando diz ao PowerShell para pegar os itens em $dados um de cada vez e, para cada um, adicionar “Item:“ no início, seguido pelo valor original.
Existem várias outras maneiras de executar ações iteradas no PowerShell, muitas das quais já são familiares se você tiver usado outras linguagens de programação: o PowerShell inclui loops ForEach, loops For e loops Switch. Para obter mais detalhes sobre essas ações, consulte a documentação da Microsoft.
Até agora, trabalhamos com um array que contém dados básicos: uma string. No entanto, os arrays também podem conter objetos, e muitos dos usos mais comuns do PowerShell, como configurar o Office 365, exigem conhecimento de como trabalhar com objetos. Vamos dar uma olhada em alguns comandos básicos para fazer isso.
Podemos criar um array de objetos da mesma forma que fizemos com strings, usando a função @(). Por exemplo, para criar uma lista de testes de funcionários, podemos usar:
$dados = @(
[pscustomobject]@{FirstName='Kevin';LastName='Marquette'}
[pscustomobject]@{FirstName='John'; LastName='Doe'}
)
A maioria dos cmdlets retornará esse array quando você atribuir a eles uma variável para trabalhar.
O processo que executamos acima para acessar dados individuais também pode ser usado com arrays que contêm objetos. Por exemplo, se você executar:
$dados[0]
Retornará:
FirstName LastName ----- ---- Kevin Marquette
Como alternativa, podemos acessar as propriedades de objetos individuais especificando qual propriedade queremos dentro do mesmo comando, assim:
$dados[0].FirstName
O comando retornará “Kevin”.
Continuando, a mesma sintaxe nos oferece a capacidade de atualizar propriedades individuais dentro de objetos armazenados em arrays. Por exemplo:
$dados[0].FirstName = 'Jay'
Atualizará a propriedade FirstName no primeiro item do nosso array para “Jay”.
Na maioria das linguagens de programação, devemos usar um processo iterativo (veja acima) para acessar todas as propriedades em um array de objetos. Podemos fazer isso no PowerShell também, é claro, executando:
$dados | ForEach-Object {$_.LastName}
Isso retornará uma lista de todas as propriedades de LastName no nosso array, mas é computacionalmente caro e difícil de digitar toda vez que você quiser visualizar esses dados. Então o PowerShell tem um atalho. Execute:
$dados.LastName
E você verá a mesma lista. Na verdade, o PowerShell está pegando cada objeto, assim como antes, mas esconde essa complexidade de nós.
Quase todos os operadores que usamos para itens de dados individuais no PowerShell também funcionam com arrays, mas alguns deles funcionam de forma um pouco diferente quando usados dessa maneira. Então, vamos dar uma olhada nos operadores mais comuns e como usá-los em arrays.
O operador -join é um dos comandos do PowerShell mais usados e é extremamente útil ao trabalhar com arrays. Ele pode ser usado iterativamente sobre itens em um array para mesclá-los no output de um array.
Vamos ver um exemplo. Primeiro, crie um array simples:
$dados = @(1,2,3,4)
Em seguida, use -join para inserir um traço entre cada item e gerar o resultado:
$dados -join '-'
Que retornará “1-2-3-4”. O operador -join também pode ser utilizado sem um delimitador, no qual os itens em um array geram uma série de valores não separados.
O operador -contains funciona em arrays de maneira muito semelhante ao seu uso com pontos de dados únicos. Você pode usá-lo para verificar se um array contém uma string específica e produzirá um valor booleano. Por exemplo:
PS> $dados = @('vermelho','verde','azul')
PS> $dados -contains 'verde'
True
Existem dois operadores para verificar a igualdade no PowerShell: -eq e -ne. No entanto, se você usar esses operadores em valores únicos, a maneira como eles funcionam em relação aos arrays pode parecer um pouco estranha. Por exemplo, se você usar -eq, o operador não produzirá um booleano “True”, mas retornará o objeto correspondente.
Por exemplo:
PS> $dados = @('vermelho','verde','azul')
PS> $dados -eq 'verde'
verde
O operador -ne funciona da mesma forma, exceto que ele fornecerá todos os valores que não forem iguais ao valor especificado. Assim:
PS> $dados = @('vermelho','verde','azul')
PS> $dados -ne 'verde'
vermelho
azul
No entanto, você pode usar uma instrução if() para comparar o output desses operadores com o output esperado e retornar um output “True” ou “False”.
Depois de todas as instruções acima, você provavelmente está se perguntando por que não falamos sobre adicionar itens de dados a um array. É porque não é possível fazer isso. Um array, uma vez criado, permanece do mesmo tamanho para sempre. Então, para aumentá-lo, você precisa copiá-lo para um novo array e excluir o original.
Parece complicado, mas o PowerShell lida com esse processo usando uma série de operadores bem simples. Existem duas maneiras principais de fazer isso.
O PowerShell pode adicionar dois arrays usando o operador “+”, que oculta a complexidade do que o sistema está realmente fazendo. Por exemplo, se você fizer dois arrays de teste como este:
$primeiro = @( 'Zero' 'Um' ) $segundo = @( 'Dois' 'Três' )
você pode então adicioná-los usando apenas:
PS> $primeiro + $segundo
Isso criará um novo array com todos os quatro valores e produzirá os resultados. Observação: ele não dará um novo nome a esse novo array. Para isso, usamos o operador +=.
Em vez de usar o operador “+” no exemplo anterior, poderíamos ter usado o operador “+=”, que nos dará um array totalmente novo:
$primeiro += 'Dois, Três'
O comando parece simples, mas esconde o que o PowerShell está realmente fazendo aqui. Ele está copiando todos os valores de $primeiro e criando um novo array que inclui os valores extras. Em seguida, ele exclui o array original.
Isso é um pouco problemático porque é bastante caro computacionalmente. Com arrays pequenos, você pode não perceber, mas com grandes quantidades de dados, esse método pode bloquear rapidamente o sistema. É por isso que oferecemos abaixo uma maneira de corrigir esse problema.
Até agora, lidamos com arrays predefinidos no PowerShell. Embora o PowerShell não tenha nos informado na época, todos os arrays que criamos até agora são de um tipo: [PSObject[]]. Esse tipo de array pode conter qualquer tipo de valor de dados.
No entanto, há momentos em que você deseja restringir os tipos de dados ou objetos que um array pode conter a apenas um. Podemos fazer isso usando um array fortemente tipado, que só pode conter o tipo de dado especificado.
Por exemplo, para criar um array que aceite números inteiros, podemos usar:
PS> [int[]] $números = 1,2,3
Se você tentar colocar o tipo errado de valor de dados em um array fortemente tipado, ele retornará um código de erro.
Como mencionamos anteriormente, adicionar itens a arrays pode ser complicado. No entanto, existe um tipo diferente de coleção, ArrayList, que lida com isso de forma mais elegante. Para usar esse tipo de coleção, no entanto, precisaremos invocar o .Net framework, que pode levar a alguns outputs infelizes ao longo do caminho.
Para criar um ArrayList e adicionar itens a ele, execute o seguinte:
$myarray = [System.Collections.ArrayList]::new()
[void]$myArray.Add('Value')
Aqui, podemos usar o construtor .Net padrão para criar um novo ArrayList e, em seguida, usar o operador -Add para adicionar itens a ele. O operador [void] está presente porque, às vezes, esses comandos geram outputs estranhos, o que pode interferir no código.
Esses são os tipos de array mais comuns no PowerShell, mas existem alguns outros. Se você estiver desenvolvendo no PowerShell, recomendamos começar a usar ArrayLists em vez de arrays simples, mas você também deve estar ciente de que esse tipo de array não é usado por usuários avançados.
Em vez disso, os codificadores mais experientes usarão um tipo de lista genérico chamado List[]. Esse tipo de lista é um pouco mais complexo de usar porque é derivado diretamente de C#, mas uma vez que você o tenha dominado, ele oferece muito mais flexibilidade do que os arrays que discutimos até agora.
Além das funcionalidades básicas que abordamos até agora, há também várias funções de array mais avançadas e alguns recursos extras que devem ser observados conforme você começa a usá-las com mais frequência.
A maneira padrão de criar matrizes acima criará um array com um tamanho determinado pelo número de itens nele. No entanto, você pode criar um array de um tamanho especificado usando o construtor new($size).
Você pode fazer isso assim:
$dados = [Object[]]::new(4)
Se você executar uma query .count nesse array, ele retornará “4”, porque mesmo que não tenha dados nele, ele preencherá o espaço com 0. Na verdade, isso é extremamente útil se você precisar inicializar um novo array que é preenchido com zeros porque um array pré-dimensionado será inicialmente preenchido com 0.
Multiplicar os objetos em um array, e especialmente strings, é algo que confunde a maioria das pessoas quando elas precisam fazer isso pela primeira vez. Vimos scripts if() extremamente complicados para alcançar esse resultado, mas existe uma maneira muito mais simples:
PS> $dados = @('vermelho','verde','azul')
PS> $dados * 3
Sim, é isso mesmo. Isso criará um novo array com cada valor repetido três vezes. Você também pode usar esse comando como uma maneira alternativa de preencher um array com zeros (ou qualquer outro valor padrão) criando um array com o valor escolhido e multiplicando-o quantas vezes quiser.
Como muitas outras linguagens de programação, o PowerShell é compatível com arrays aninhados. A maneira padrão de fazer isso no PowerShell é usar um array multidimensional. O exemplo mais simples disso é criar um array bidimensional:
$dados = @(@(1,2,3),@(4,5,6),@(7,8,9)) $dados2 = @( @(1,2,3), @(4,5,6), @(7,8,9) )
A estrutura de dados que você está criando com esse comando é uma matriz clássica e pode ser trabalhada como em outras linguagens de programação. Por exemplo, para acessar um valor específico desse array, você precisará especificar duas dimensões.
Por exemplo, para acessar o valor “3”, usaríamos:
PS> $outside = 0 PS> $inside = 2 PS> $dados[$outside][$inside] 3
Esse comando pode ser usado para acessar qualquer valor, mas você precisa adicionar colchetes aninhados para entrar em cada nível da matriz.
Todas as instruções acima podem ser demais para os usuários que estão acessando o PowerShell pela primeira vez, mas foram cuidadosamente escolhidas como uma forma de aprender a linguagem. Combinando as várias técnicas, você pode criar scripts poderosos para automatizar muitos dos trabalhos mais frequentes, e mais demorados, que você faz com o PowerShell.
Essas habilidades também ajudarão você a se aprofundar no PowerShell. Muitas das linguagens mais comuns usadas para gerenciar a cibersegurança, como NetCat e Nmap, usam muitos dos mesmos princípios do PowerShell. Portanto, usar o PowerShell para melhorar sua cibersegurança é uma ótima maneira de aprender a proteger seus sistemas de maneira mais geral.