Observação
O acesso a essa página exige autorização. Você pode tentar entrar ou alterar diretórios.
O acesso a essa página exige autorização. Você pode tentar alterar os diretórios.
Descrição curta
Descreve como criar, usar e classificar hashtables no PowerShell.
Descrição longa
Um hashtable, também conhecido como dicionário ou matriz associativa, é uma estrutura de dados compacta que armazena um ou mais pares chave-valor. Por exemplo, um hashtable pode conter uma série de endereços IP e nomes de computador, em que os endereços IP são as chaves e os nomes de computador são os valores ou vice-versa.
No PowerShell, cada hashtable é um objeto [System.Collections.Hashtable]. Você pode usar as propriedades e os métodos de objetos Hashtable no PowerShell.
A partir do PowerShell 3.0, você pode usar o acelerador de tipo [ordered] para criar um objeto [System.Collections.Specialized.OrderedDictionary] no PowerShell.
Os dicionários ordenados diferem dos hashtables em que as chaves sempre aparecem na ordem em que você as lista. A ordem das chaves em um hashtable não é determinística.
As chaves e o valor em hashtables também são objetos .NET. Eles geralmente são cadeias de caracteres ou inteiros, mas podem ter qualquer tipo de objeto. Você também pode criar tabelas de hash aninhados, nos quais o valor de uma chave é outra tabela de hash.
Os hashtables são usados com frequência porque são eficientes para localizar e recuperar dados. Você pode usar hashtables para armazenar listas e criar propriedades calculadas no PowerShell. E o cmdlet ConvertFrom-StringData converte dados de cadeia de caracteres estruturados em um hashtable.
Sintaxe
A sintaxe de um hashtable é a seguinte:
@{ <name> = <value>; [<name> = <value> ] ...}
A sintaxe de um dicionário ordenado é a seguinte:
[ordered]@{ <name> = <value>; [<name> = <value> ] ...}
O acelerador de tipo [ordered] foi introduzido no PowerShell 3.0.
Para criar uma tabela hash, siga estas diretrizes:
- Inicie a tabela de hash com um sinal (
@). - Coloque a tabela de hash entre chaves (
{}). - Insira um ou mais pares chave/valor para o conteúdo da tabela hash.
- Use um sinal de igual (
=) para separar cada chave de seu valor. - Use um ponto-e-vírgula (
;) ou uma quebra de linha para separar os pares chave-valor. - As chaves que contêm espaços devem ser colocadas entre aspas. Os valores devem ser expressões válidas do PowerShell. As cadeias de caracteres devem aparecer entre aspas, mesmo que não incluam espaços.
- Para gerenciar o hashtable, salve-o em uma variável.
- Ao atribuir um hashtable ordenado a uma variável, coloque o tipo
[ordered]antes do símbolo@. Se você colocá-lo antes do nome da variável, o comando falhará.
Você pode usar dicionários ordenados da mesma maneira que usa hashtables. Qualquer tipo pode ser usado como o valor de parâmetros que utilizam objetos do tipo tabela hash ou dicionário (iDictionary).
Criando hashtables e dicionários ordenados
Considere os seguintes exemplos de tabela de hash e dicionário ordenado:
$hash = @{
1 = 'one'
2 = 'two'
'three' = 3
}
$hash
Name Value
---- -----
three 3
2 two
1 one
Como você pode ver, os pares chave-valor em uma tabela hash não aparecem na ordem em que foram definidos.
A maneira mais fácil de criar um dicionário ordenado é usar o atributo [ordered]. Coloque o atributo imediatamente antes do símbolo @.
$dictionary = [ordered]@{
1 = 'one'
2 = 'two'
'three' = 3
}
$dictionary
Name Value
---- -----
1 one
2 two
three 3
Ao contrário dos hashtables, os dicionários ordenados mantêm a ordem do valor-chave.
Convertendo tabelas de hash e dicionários ordenados
Você não pode usar o acelerador de tipo [ordered] para converter ou lançar uma tabela de hash.
Se você colocar o atributo ordenado antes do nome da variável, o comando falhará com a seguinte mensagem de erro.
[ordered]$orderedHash = @{}
ParserError:
Line |
1 | [ordered]$orderedHash = @{}
| ~~~~~~~~~~~~~~
| The ordered attribute can be specified only on a hash literal node.
Para corrigir a expressão, mova o atributo [ordenado].
$orderedHash = [ordered]@{}
Você pode converter um dicionário ordenado em uma tabela de hash, mas não pode garantir a ordem dos membros.
[hashtable]$newHash = [ordered]@{
Number = 1
Shape = "Square"
Color = "Blue"
}
$newHash
Name Value
---- -----
Color Blue
Shape Square
Number 1
Hashtable e propriedades de dicionário
Hashtables e dicionários ordenados compartilham várias propriedades. Considere as variáveis $hash e $dictionary definidas nos exemplos anteriores.
$hash | Get-Member -MemberType Properties, ParameterizedProperty
TypeName: System.Collections.Hashtable
Name MemberType Definition
---- ---------- ----------
Item ParameterizedProperty System.Object Item(System.Object key) {get;set;}
Count Property int Count {get;}
IsFixedSize Property bool IsFixedSize {get;}
IsReadOnly Property bool IsReadOnly {get;}
IsSynchronized Property bool IsSynchronized {get;}
Keys Property System.Collections.ICollection Keys {get;}
SyncRoot Property System.Object SyncRoot {get;}
Values Property System.Collections.ICollection Values {get;}
$dictionary | Get-Member -MemberType Properties, ParameterizedProperty
TypeName: System.Collections.Specialized.OrderedDictionary
Name MemberType Definition
---- ---------- ----------
Item ParameterizedProperty System.Object Item(int index) {get;set;},
System.Object Item(System.Object key) {get;set;}
Count Property int Count {get;}
IsFixedSize Property bool IsFixedSize {get;}
IsReadOnly Property bool IsReadOnly {get;}
IsSynchronized Property bool IsSynchronized {get;}
Keys Property System.Collections.ICollection Keys {get;}
SyncRoot Property System.Object SyncRoot {get;}
Values Property System.Collections.ICollection Values {get;}
As propriedades mais usadas são Count, Keys, Valuese Item.
A propriedade Count que indica o número de pares chave-valor no objeto.
A propriedade Keys é uma coleção de nomes de chave na tabela de hash ou dicionário.
PS> $hash.Keys three 2 1 PS> $dictionary.Keys 1 2 threeA propriedade Values é uma coleção dos valores na tabela de hash ou no dicionário.
PS> $hash.Values 3 two one PS> $dictionary.Values one two 3A propriedade Item é uma propriedade parametrizada que retorna o valor do item especificado. Os hashtables usam a chave como o parâmetro para a propriedade parametrizada, enquanto os dicionários usam o índice por padrão. Essa diferença afeta a forma como você acessa os valores de cada tipo.
Acessando valores
Há duas formas comuns de acessar os valores em uma tabela de hash ou dicionário: notação de ponto ou notação de índice.
Notação de membro – os valores podem ser acessados usando o nome da chave como uma propriedade membro do objeto. Por exemplo:
PS> $hash.1 one PS> $dictionary.2 twonotação de índice de matriz – os valores podem ser acessados usando a notação de índice. O PowerShell converte essa notação em uma chamada para a propriedade parametrizada Item do objeto.
Quando você usa a notação de índice com hashtables, o valor dentro dos colchetes é o nome da chave. Se a chave for um valor de cadeia de caracteres, coloque o nome da chave entre aspas. Por exemplo:
PS> $hash['three'] 3 PS> $hash[2] twoNeste exemplo, o valor da chave
2não é um índice na coleção de valores. É o valor da chave no par chave-valor. Você pode provar isso indexando na coleção de valores.PS> ([array]$hash.Values)[2] oneQuando você usa a notação de índice com dicionários, o valor dentro dos colchetes é interpretado com base em seu tipo. Se o valor for um inteiro, ele será tratado como um índice na coleção de valores. Se o valor não for um inteiro, ele será tratado como o nome da chave. Por exemplo:
PS> $dictionary[1] two PS> ([array]$dictionary.Values)[1] two PS> $dictionary[[Object]1] one PS> $dictionary['three'] 3Neste exemplo, o valor da matriz
[1]é um índice na coleção de valores usando a sobrecarga de propriedade parametrizadaItem(int index). O valor da matriz[[Object]1]não é um índice, mas um valor de chave usando a sobrecarga deItem(System.Object key).Nota
Esse comportamento pode ser confuso quando o valor da chave é um inteiro. Quando possível, você deve evitar o uso de valores de chave inteiros em dicionários.
Manipulando colisões de nomes de propriedades
Se o nome da chave colidir com um dos nomes de propriedade do tipo HashTable, você poderá usar o psbasemembro intrínseco para acessar essas propriedades. Por exemplo, se o nome da chave for keys e você quiser retornar a coleção de chaves da HashTable , use esta sintaxe:
$hashtable.psbase.Keys
Esse requisito se aplica a outros tipos que implementam a interface System.Collections.IDictionary, como OrderedDictionary.
Iterando sobre chaves e valores
Você pode iterar nas chaves em uma tabela de hash para processar os valores de várias formas. Cada um dos exemplos nesta seção tem uma saída idêntica. Eles iteram sobre a variável $hash definida aqui:
$hash = [ordered]@{Number = 1; Shape = "Square"; Color = "Blue"}
Nota
Nesses exemplos, $hash é definido como um dicionário ordenado para garantir que a saída esteja sempre na mesma ordem. Esses exemplos funcionam da mesma forma para hashables padrão, mas a ordem da saída não é previsível.
Cada exemplo retorna uma mensagem para cada chave e seu valor:
The value of 'Number' is: 1
The value of 'Shape' is: Square
The value of 'Color' is: Blue
Este exemplo usa um bloco foreach para iterar sobre as chaves.
foreach ($Key in $hash.Keys) {
"The value of '$Key' is: $($hash[$Key])"
}
Este exemplo utiliza ForEach-Object para percorrer as chaves.
$hash.Keys | ForEach-Object {
"The value of '$_' is: $($hash[$_])"
}
Este exemplo usa o método GetEnumerator() para enviar cada par chave-valor por meio do pipeline para ForEach-Object.
$hash.GetEnumerator() | ForEach-Object {
"The value of '$($_.Key)' is: $($_.Value)"
}
Este exemplo usa os métodos GetEnumerator() e ForEach() para percorrer cada par chave-valor.
$hash.GetEnumerator().ForEach({"The value of '$($_.Key)' is: $($_.Value)"})
Adicionando e removendo chaves e valores
Normalmente, ao criar um hashtable, você inclui os pares chave-valor na definição. No entanto, você pode adicionar e remover pares chave-valor de uma tabela hash a qualquer momento. O exemplo a seguir cria uma tabela hash vazia.
$hash = @{}
Você pode adicionar pares chave-valor usando notação de matriz. Por exemplo, o exemplo a seguir adiciona uma chave Time com um valor de Now ao hashtable.
$hash["Time"] = "Now"
Você também pode adicionar chaves e valores a um hashtable usando o método Add() do objeto System.Collections.Hashtable. O método Add() tem a seguinte sintaxe:
Add(Key, Value)
Por exemplo, para adicionar uma chave Time com um valor de Now ao hashtable, use o seguinte formato de instrução.
$hash.Add("Time", "Now")
Além disso, você pode adicionar chaves e valores a um hashtable usando o operador de adição (+) para adicionar um hashtable a um hashtable existente. Por exemplo, a instrução a seguir adiciona uma chave Time com um valor de Now ao hashtable na variável $hash.
$hash = $hash + @{Time="Now"}
Você também pode adicionar valores armazenados em variáveis.
$t = "Today"
$now = (Get-Date)
$hash.Add($t, $now)
Você não pode usar um operador de subtração para remover um par chave-valor de um hashtable, mas pode usar o método Remove() do objeto hashtable. O método Remove tem a seguinte sintaxe:
$object.Remove(<key>)
O exemplo a seguir remove o par chave-valor Time de $hash.
$hash.Remove("Time")
Tipos de objeto em hashtables
As chaves e os valores em um hashtable podem ter qualquer tipo de objeto .NET, e um único hashtable pode ter chaves e valores de vários tipos.
A instrução a seguir cria um hashtable de cadeias de caracteres de nome de processo e valores de objeto de processo e salva-o na variável $p.
$p = @{
"PowerShell" = (Get-Process powershell)
"Notepad" = (Get-Process notepad)
}
Você pode exibir o hashtable em $p e usar as propriedades de nome-chave para exibir os valores.
PS> $p
Name Value
---- -----
PowerShell System.Diagnostics.Process (PowerShell)
Notepad System.Diagnostics.Process (notepad)
PS> $p.PowerShell
Handles NPM(K) PM(K) WS(K) VM(M) CPU(s) Id ProcessName
------- ------ ----- ----- ----- ------ -- -----------
441 24 54196 54012 571 5.10 1788 PowerShell
PS> $p.Keys | ForEach-Object {$p.$_.Handles}
441
251
As chaves em um hashtable podem ser qualquer tipo .NET. A instrução a seguir adiciona um par chave-valor ao hashtable na variável $p. A chave é um objeto Service que representa o serviço WinRM e o valor é o status atual do serviço.
$p = $p + @{
(Get-Service WinRM) = ((Get-Service WinRM).Status)
}
Você pode exibir e acessar o novo par chave-valor usando os mesmos métodos usados para outros pares no hashtable.
PS> $p
Name Value
---- -----
PowerShell System.Diagnostics.Process (PowerShell)
Notepad System.Diagnostics.Process (notepad)
System.ServiceProcess.Servi... Running
PS> $p.Keys
PowerShell
Notepad
Status Name DisplayName
------ ---- -----------
Running winrm Windows Remote Management (WS-Manag...
PS> $p.Keys | ForEach-Object {$_.Name}
WinRM
As chaves e os valores em uma tabela hash também podem ser objetos Hashtable. A instrução a seguir adiciona o par chave-valor ao hashable na variável $p na qual a chave é uma cadeia de caracteres, Hash2 e o valor é um hashtable com três pares chave-valor.
$p = $p + @{
"Hash2"= @{a=1; b=2; c=3}
}
Você pode exibir e acessar os novos valores usando os mesmos métodos.
PS> $p
Name Value
---- -----
PowerShell System.Diagnostics.Process (pwsh)
Hash2 {[a, 1], [b, 2], [c, 3]}
Notepad System.Diagnostics.Process (Notepad)
WinRM Running
PS> $p.Hash2
Name Value
---- -----
a 1
b 2
c 3
PS> $p.Hash2.b
2
Classificando chaves e valores
Os itens em um hashtable não são ordenados intrinsecamente. Os pares chave-valor podem aparecer em uma ordem diferente toda vez que forem exibidos.
Embora não seja possível classificar um hashtable, você pode usar o método GetEnumerator() de hashtables para enumerar as chaves e os valores e, em seguida, usar o cmdlet Sort-Object para classificar os valores enumerados para exibição.
Por exemplo, os comandos a seguir enumeram as chaves e os valores no hashtable na variável $p e, em seguida, classificam as chaves em ordem alfabética.
PS> $p.GetEnumerator() | Sort-Object -Property Key
Name Value
---- -----
Hash2 {[a, 1], [b, 2], [c, 3]}
Notepad System.Diagnostics.Process (Notepad)
PowerShell System.Diagnostics.Process (pwsh)
WinRM Running
O comando a seguir usa o mesmo procedimento para classificar os valores de hash em ordem decrescente.
PS> $p.GetEnumerator() | Sort-Object -Property Value -Descending
Name Value
---- -----
PowerShell System.Diagnostics.Process (pwsh)
Notepad System.Diagnostics.Process (Notepad)
Hash2 {[a, 1], [b, 2], [c, 3]}
WinRM Running
Criando objetos de hashtables
A partir do PowerShell 3.0, você pode criar um objeto com base em uma tabela hash de propriedades e valores de propriedade.
A sintaxe é a seguinte:
[<class-name>]@{
<property-name>=<property-value>
<property-name>=<property-value>
}
Esse método funciona apenas para classes que têm um construtor que não tem parâmetros. As propriedades do objeto devem ser públicas e definíveis.
Para obter mais informações, consulte about_Object_Creation.
ConvertFrom-StringData
O cmdlet ConvertFrom-StringData converte uma cadeia de caracteres ou uma cadeia de caracteres aqui de pares chave-valor em uma tabela de hash. Você pode usar o cmdlet ConvertFrom-StringData com segurança na seção Dados de um script e usá-lo com o cmdlet Import-LocalizedData para exibir mensagens do usuário na cultura da interface do usuário do usuário atual.
As cadeias de caracteres aqui são especialmente úteis quando os valores na tabela de hash incluem aspas. Para obter mais informações sobre cadeias de caracteres here, consulte about_Quoting_Rules.
O exemplo a seguir mostra como criar uma cadeia de caracteres aqui das mensagens do usuário no exemplo anterior e como usar ConvertFrom-StringData para convertê-las de uma cadeia de caracteres em um hashtable.
O comando a seguir cria uma string aqui com os pares chave-valor e, em seguida, salva-a na variável $string.
$string = @"
Msg1 = Type "Windows".
Msg2 = She said, "Hello, World."
Msg3 = Enter an alias (or "nickname").
"@
Esse comando usa o cmdlet ConvertFrom-StringData para converter a cadeia de caracteres aqui em um hashtable.
ConvertFrom-StringData $string
Name Value
---- -----
Msg3 Enter an alias (or "nickname").
Msg2 She said, "Hello, World."
Msg1 Type "Windows".
Para obter mais informações sobre cadeias de caracteres here, consulte about_Quoting_Rules.
Consulte também
Colaborar conosco no GitHub
A fonte deste conteúdo pode ser encontrada no GitHub, onde você também pode criar e revisar problemas e solicitações de pull. Para obter mais informações, confira o nosso guia para colaboradores.
