3. Conceitos básicos

Nota editorial

Importante

O Windows PowerShell Language Specification 3.0 foi publicado em dezembro de 2012 e é baseado no Windows PowerShell 3.0. Esta especificação não reflete o estado atual do PowerShell. Não há nenhum plano para atualizar esta documentação para refletir o estado atual. Esta documentação é apresentada aqui para referência histórica.

O documento de especificação está disponível como um documento do Microsoft Word no Centro de Download da Microsoft em: https://www.microsoft.com/download/details.aspx?id=36389 Esse documento do Word foi convertido para apresentação aqui no Microsoft Learn. Durante a conversão, algumas alterações editoriais foram feitas para acomodar a formatação da plataforma do Documentos. Alguns erros de digitação e pequenos erros foram corrigidos.

3.1 Fornecedores e unidades

Um provedor de permite o acesso a dados e componentes que, de outra forma, não seriam facilmente acessíveis na linha de comando. Os dados são apresentados em um formato consistente que se assemelha a uma unidade de sistema de arquivos.

Os dados que um provedor expõe aparecem em uma unidade de e os dados são acessados por meio de um caminho como em uma unidade de disco. Cmdlets internos para cada provedor gerem os dados no drive do provedor.

O PowerShell inclui o seguinte conjunto de provedores internos para acessar os diferentes tipos de armazenamentos de dados:

Provedor	Nome da unidade	Descrição	Ref.
Apelido	Pseudônimo:	Aliases do PowerShell	§3.1.1
Meio Ambiente	Env:	Variáveis de ambiente	§3.1.2
Sistema de arquivos	A:, B:, C:, ...	Unidades de disco, diretórios e arquivos	§3.1.3
Função	Função:	Funções do PowerShell	§3.1.4
Variável	Variável:	Variáveis do PowerShell	§3.1.5

Windows PowerShell:

Provedor	Nome da unidade	Descrição
Certidão	Certidão:	Certificados x509 para assinaturas digitais
Registo	HKLM: (HKEY_LOCAL_MACHINE - Chave de Registro da Máquina Local), HKCU: (HKEY_CURRENT_USER - Chave de Registro do Usuário Atual)	Registro do Windows
WSMan	WSMan:	WS-Management informações de configuração

Os cmdlets a seguir lidam com provedores e unidades:

• Get-PSProvider: Obtém informações sobre um ou mais provedores
• Get-PSDrive: Obtém informações sobre uma ou mais unidades

O tipo de objeto que representa um provedor é descrito em §4.5.1. O tipo de objeto que representa uma unidade é descrito em §4.5.2.

3.1.1 Pseudónimos

Um alias é um nome alternativo para um comando. Um comando pode ter vários aliases, e o nome original e todos os seus aliases podem ser usados de forma intercambiável. Um pseudónimo pode ser reatribuído. Um alias é um item (§3.3).

Um alias pode ser atribuído a outro alias; no entanto, o novo alias não é um alias do comando original.

O Alias do provedor é um namespace simples que contém apenas objetos que representam os aliases. As variáveis não têm itens filhos.

O PowerShell vem com um conjunto de aliases internos.

Os cmdlets a seguir tratam de alias:

• New-Alias: Cria um apelido
• Set-Alias: cria ou altera um ou mais pseudónimos
• Get-Alias: Obtém informações sobre um ou mais aliases
• Export-Alias: Exporta um ou mais aliases para um arquivo

Quando um alias é criado para um comando usando New-Alias, os parâmetros desse comando não podem ser incluídos nesse alias. No entanto, a atribuição direta a uma variável no namespace Alias: permite que parâmetros sejam incluídos.

Observação

É uma questão simples, no entanto, criar uma função que nada mais faz do que conter a invocação desse comando com todos os parâmetros desejados, e atribuir um alias a essa função.

O tipo de objeto que representa um alias é descrito em §4.5.4.

Os objetos do Alias são armazenados no disco Alias: (§3.1).

3.1.2 Variáveis de ambiente

O provedor de Ambiente do PowerShell permite que as variáveis de ambiente do sistema operacional sejam recuperadas, adicionadas, alteradas, limpas e excluídas.

O provedor Environment é um namespace simples que contém apenas objetos que representam as variáveis de ambiente. As variáveis não têm itens filhos.

O nome de uma variável de ambiente não pode incluir o sinal de igual (=).

As alterações nas variáveis de ambiente afetam apenas a sessão atual.

Uma variável de ambiente é um item (§3.3).

O tipo de objeto que representa uma variável de ambiente é descrito em §4.5.6.

Os objetos variáveis de ambiente são armazenados na unidade Env: (§3.1).

3.1.3 Sistema de ficheiros

O provedor PowerShell FileSystem permite que diretórios e arquivos sejam criados, abertos, alterados e excluídos.

O provedor FileSystem é um namespace hierárquico que contém objetos que representam o sistema de arquivos subjacente.

Os arquivos são armazenados em unidades com nomes como A:, B:, C:, e assim por diante (§3.1). Diretórios e arquivos são acessados usando notação de caminho (§3.4).

Um diretório ou arquivo é um item (§3.3).

3.1.4 Funções

O provedor de função do PowerShell permite que funções (§8.10) e filtros (§8.10.1) sejam recuperados, adicionados, alterados, limpos e excluídos.

A função do provedor é um namespace simples que contém apenas os objetos de função e filtro. Nem funções nem filtros têm subitens.

As alterações nas funções afetam apenas a sessão atual.

Uma função é um item (§3.3).

O tipo de objeto que representa uma função é descrito no §4.5.10. O tipo de objeto que representa um filtro é descrito no §4.5.11.

Os objetos de função são armazenados na unidade Função: (§3.1).

3.1.5 Variáveis

As variáveis podem ser definidas e manipuladas diretamente na linguagem PowerShell.

A variável do provedor é um namespace simples que contém apenas objetos que representam as variáveis. As variáveis não têm itens filhos.

Os cmdlets a seguir também lidam com variáveis:

• New-Variable: Cria uma variável
• Set-Variable: Cria ou altera as características de uma ou mais variáveis
• Get-Variable: Obtém informações sobre uma ou mais variáveis
• Clear-Variable: Exclui o valor de uma ou mais variáveis
• Remove-Variable: Exclui uma ou mais variáveis

Como uma variável é um item (§3.3), ela pode ser manipulada pela maioria dos cmdlets relacionados ao item.

O tipo de objeto que representa uma variável é descrito em §4.5.3.

Os objetos variáveis são armazenados na unidade Variável: (§3.1).

3.2 Locais de trabalho

O local de trabalho atual é o local padrão para o qual os comandos apontam. Este é o local usado se um caminho explícito (§3.4) não for fornecido quando um comando é invocado. Esta localização inclui a drive atual .

Um host PowerShell pode ter várias unidades, nesse caso, cada unidade tem seu próprio local atual.

Quando um nome de unidade é especificado sem um diretório, o local atual dessa unidade é implícito.

O local de trabalho atual pode ser salvo em uma pilha e, em seguida, definido para um novo local. Mais tarde, esse local salvo pode ser restaurado a partir dessa pilha e estabelecido como o local de trabalho atual. Há dois tipos de pilhas de localização: a pilha de local de trabalho padrão e zero ou mais pilhas de local de trabalho nomeadas definidas pelo utilizador. Quando uma sessão começa, a pilha padrão de local de trabalho é a mesma que a pilha atual de local de trabalho . No entanto, qualquer pilha de local de trabalho nomeada pode ser transformada na pilha de local de trabalho atual.

Os cmdlets a seguir trabalham com locais:

• Set-Location: Estabelece o local de trabalho atual
• Get-Location: Determina o local de trabalho atual para a(s) unidade(s) especificada(s) ou os locais de trabalho para a(s) pilha(s) especificada(s)
• Push-Location: Salva o local de trabalho atual no topo de uma pilha especificada de locais
• Pop-Location: restaura a localização de trabalho atual do topo de uma pilha especificada de locais

Os tipos de objeto que representam um local de trabalho e uma pilha de locais de trabalho são descritos em §4.5.5.

3.3 Itens

Um item é um alias (§3.1.1), uma variável (§3.1.5), uma função (§3.1.4), uma variável de ambiente (§3.1.2), ou um arquivo ou diretório em um sistema de arquivos (§3.1.3).

Os cmdlets seguintes lidam com itens:

• Novo Item : Cria um novo item
• Set-Item: Altera o valor de um ou mais itens
• Get-Item: Obtém os itens no local especificado
• Get-ChildItem: Obtém os itens e itens filho no local especificado
• Copy-Item: Copia um ou mais itens de um local para outro
• Move-Item: Move um ou mais itens de um local para outro
• Renomear item: Renomeia um item
• Invoke-Item: Executa a ação padrão em um ou mais itens
• Clear-Item: Exclui o conteúdo de um ou mais itens, mas não exclui os itens (consulte
• Remove-Item: Exclui os itens especificados

Os cmdlets a seguir lidam com o conteúdo dos itens:

• Get-Content: Obtém o conteúdo do item
• Add-Content: adiciona conteúdo aos itens especificados
• Set-Content: Grava ou substitui o conteúdo de um item
• Clear-Content : Limpa o conteúdo de um item

O tipo de objeto que representa um diretório é descrito em §4.5.17. O tipo de objeto que representa um arquivo é descrito em §4.5.18.

3.4 Nomes de caminhos

Todos os itens em um armazenamento de dados acessível por meio de um provedor do PowerShell podem ser identificados exclusivamente por seus nomes de caminho. Um nome de caminho é uma combinação do nome do item, do contentor e dos subcontenedores nos quais o item está localizado e da unidade do PowerShell por meio da qual os contentores são acessados.

Os nomes dos caminhos são classificados em dois tipos: qualificados e relativos. Um nome de caminho totalmente qualificado consiste em todos os elementos que compõem um caminho. A sintaxe a seguir mostra os elementos em um nome de caminho totalmente qualificado:

Dica

A notação ~opt~ nas definições de sintaxe indica que a entidade lexical é opcional na sintaxe.

path:
    provider~opt~   drive~opt~   containers~opt~   item

provider:
    module~opt~   provider   ::

module:
    module-name   \

drive:
    drive-name   :

containers:
    container   \
    containers container   \

nome do módulo refere-se ao módulo pai.

provedor refere-se a provedor do PowerShell através do qual se acede ao armazenamento de dados.

A unidade refere-se à unidade do PowerShell que é suportada por um fornecedor PowerShell específico.

Um recipiente pode conter outros recipientes, que podem conter outros recipientes, e assim por diante, com o recipiente final contendo um item . Os contêineres devem ser especificados na ordem hierárquica em que existem no armazenamento de dados.

Aqui está um exemplo de um nome de caminho:

E:\Accounting\InvoiceSystem\Production\MasterAccount\MasterFile.dat

Se o elemento final em um caminho contiver outros elementos, ele será um elemento de contêiner ; caso contrário, é um elemento de folha .

Em alguns casos, um nome de caminho totalmente qualificado não é necessário; um nome de caminho relativo será suficiente. Um nome de caminho relativo é baseado no local de trabalho atual. O PowerShell permite que um item seja identificado com base em sua localização em relação ao local de trabalho atual. Um nome de caminho relativo envolve o uso de alguns caracteres especiais. A tabela a seguir descreve cada um desses caracteres e fornece exemplos de nomes de caminho relativos e nomes de caminho totalmente qualificados. Os exemplos na tabela são baseados no diretório de trabalho atual que está sendo definido como C:\Windows:

Símbolo	Descrição	Caminho relativo	Caminho totalmente especificado
.	Local de trabalho atual	.\System	C:\Windows\System
..	Pai do local de trabalho atual	..\Program Files	C:\Program Files
\	Raiz da unidade de disco do local de trabalho atual	\Program Files	C:\Program Files
nenhum	Sem caracteres especiais	System	C:\Windows\System

Para usar um nome de caminho em um comando, digite esse nome como um nome de caminho totalmente qualificado ou relativo.

Os cmdlets a seguir lidam com caminhos:

• Convert-Path: converte um caminho de um caminho do PowerShell para um caminho de provedor do PowerShell
• Join-Path: Combina um caminho e um subcaminho num único caminho
• Resolve-Path : Resolve os caracteres curinga num caminho
• Split-Path : Devolve a parte especificada de um caminho
• Test-Path: Determina se os elementos de um caminho existem ou se um caminho está bem formado

Alguns cmdlets (como Add-Content e Copy-Item usam filtros de arquivo. Um filtro de arquivo é um mecanismo para especificar os critérios de seleção de um conjunto de caminhos.

O tipo de objeto que representa um caminho resolvido é descrito em §4.5.5. Os caminhos são frequentemente manipulados como cadeias de caracteres.

3.5 Âmbitos

3.5.1 Introdução

Um nome pode indicar uma variável, uma função, um apelido, uma variável de ambiente ou uma unidade. O mesmo nome pode indicar itens diferentes em locais diferentes em um script. Para cada item diferente que um nome denota, esse nome é visível apenas na região de texto do script denominada seu escopo. Itens diferentes indicados pelo mesmo nome têm escopos diferentes ou estão em espaços de nome diferentes.

Escopos podem aninhar-se, sendo que, nesse caso, um escopo mais externo é referido como escopo pai , e quaisquer escopos aninhados são escopos filho desse pai. O escopo de um nome é o escopo no qual ele é definido e todos os seus subescopos, a menos que ele seja tornado privado. Dentro de um escopo filho, um nome definido nesse escopo oculta todos os itens definidos com o mesmo nome nos escopos pai.

A menos que a notação de origem por pontos (§3.5.5) seja usada, cada um dos itens listados cria um novo escopo.

• Um arquivo de script
• Um bloco de script
• Uma função ou filtro

Considere o seguinte exemplo:

# Start of script
$x = 2; $y = 3
Get-Power $x $y

# Function defined in script
function Get-Power([int]$x, [int]$y) {
    if ($y -gt 0) {
        return $x * (Get-Power $x (--$y))
    } else {
        return 1
    }
}
# End of script

O escopo das variáveis $x e $y criadas no script é o corpo desse script, incluindo a função definida dentro dele. A função Get-Power define dois parâmetros com esses mesmos nomes. Como cada função tem seu próprio escopo, essas variáveis são diferentes daquelas definidas no escopo pai e ocultam aquelas do escopo pai. O escopo da função é aninhado dentro do escopo do script.

Observe que a função se chama recursivamente. Cada vez que faz isso, ele cria mais um escopo aninhado, cada um com suas próprias variáveis $x e $y.

Aqui está um exemplo mais complexo, que também mostra escopos aninhados e reutilização de nomes:

# start of script scope
$x = 2              # top-level script-scope $x created
                    # $x is 2
F1                  # create nested scope with call to function F1
                    # $x is 2
F3                  # create nested scope with call to function F3
                    # $x is 2

function F1 {       # start of function scope
                    # $x is 2
    $x = $true      # function-scope $x created
                    # $x is $true

    & {             # create nested scope with script block
                    # $x is $true
        $x = 12.345 # scriptblock-scope $x created
                    # $x is 12.345
    }               # end of scriptblock scope, local $x goes away

                    # $x is $true
    F2              # create nested scope with call to function F2
                    # $x is $true
}                   # end of function scope, local $x goes away

function F2 {       # start of function scope
                    # $x is $true
    $x = "red"      # function-scope $x created
                    # $x is "red"
}                   # end of function scope, local $x goes away

function F3 {       # start of function scope
                    # $x is 2
    if ($x -gt 0) {
                    # $x is 2
        $x = "green"
                    # $x is "green"
    }               # end of block, but not end of any scope
                    # $x is still "green"
}                   # end of function scope, local $x goes away
# end of script scope

3.5.2 Nomes e números do escopo

O PowerShell oferece suporte aos seguintes escopos:

• Global: Este é o escopo de nível mais alto. Todas as variáveis automáticas e de preferência são definidas neste âmbito. O escopo global é o escopo pai de todos os outros escopos, e todos os outros escopos são escopos filhos do escopo global.

• Local: Este é o escopo atual em qualquer ponto de execução dentro de um script, bloco de script ou função. Qualquer escopo pode ser o âmbito local.

• Script: esse escopo existe para cada arquivo de script executado. O escopo do script é o escopo pai de todos os escopos criados a partir dele. Um bloco de script não tem seu próprio escopo de script; em vez disso, seu escopo de script é o de seu arquivo de script ancestral mais próximo. Embora não exista tal coisa como escopo de módulo, o escopo de script fornece o equivalente.

Os nomes podem ser declarados privados, caso em que não são visíveis fora do âmbito pai, nem mesmo para âmbitos filho. O conceito de privado não é um âmbito distinto; é um alias para escopo local com a adição de ocultar o nome se usado como um local gravável.

Os escopos podem ser referidos por um número, que descreve a posição relativa de um escopo para outro. O escopo 0 denota o escopo local, o escopo 1 denota um escopo ancestral de 1 geração, o escopo 2 denota um escopo ancestral de 2 gerações e assim por diante. (Os números de escopo são utilizados por comandos cmdlet que manipulam variáveis.)

3.5.3 Âmbito do nome da variável

Como mostrado pela produção a seguir, um nome de variável pode ser especificado com qualquer um dos seis escopos diferentes:

variable-scope:
    Global:
    Local:
    Private:
    Script:
    Using:
    Workflow:
    variable-namespace

O âmbito é opcional. A tabela a seguir mostra o significado de cada um em todos os contextos possíveis. Ele também mostra o escopo quando nenhum escopo é especificado explicitamente:

Modificador de escopo	dentro de um arquivo de script	dentro de um bloco de script	dentro de uma função
A nível mundial	Âmbito global	Âmbito global	Âmbito global
Script	Escopo do arquivo de script ancestral mais próximo ou Global se não houver um arquivo de script ancestral mais próximo	Escopo do arquivo de script ancestral mais próximo ou Global se não houver um arquivo de script ancestral mais próximo	Escopo do arquivo de script ancestral mais próximo ou Global se não houver um arquivo de script ancestral mais próximo
Privado	Âmbito global/script/local	Âmbito local	Âmbito local
Locais	Âmbito global/script/local	Âmbito local	Âmbito local
Utilizar	Execução definida	Execução definida	Execução definida
Fluxo de trabalho	Execução definida	Execução definida	Execução definida
Nenhum	Escopo global/script/local	Âmbito local	Âmbito local

Informações de escopo variável também podem ser especificadas ao usar a família de cmdlets listados em (§3.1.5). Em particular, consulte o parâmetro Scope, e os parâmetros Option Private e Option AllScope para obter mais informações.

O Using: modificador de escopo é usado para acessar variáveis definidas em outro escopo durante a execução de scripts por meio de cmdlets como Start-Job, Invoke-Command, ou dentro de uma instrução inlinescript. Por exemplo:

$a = 42
Invoke-Command --ComputerName RemoteServer { $Using:a } # returns 42
workflow foo
{
    $b = "Hello"
    inlinescript { $Using:b }
}
foo # returns "Hello"

O fluxo de trabalho de escopo é utilizado com uma instrução-paralela ou uma instrução-de-sequência para aceder a uma variável definida no fluxo de trabalho.

3.5.4 Âmbito do nome da função

Um nome de função também pode ter um dos quatro escopos diferentes, e a visibilidade desse nome é a mesma que para variáveis (§3.5.3).

3.5.5 Notação de fonte por ponto

Quando um arquivo de script, bloco de script ou função é executado de dentro de outro arquivo de script, bloco de script ou função, o arquivo de script executado cria um novo escopo aninhado. Por exemplo

Script1.ps1
& "Script1.ps1"
& { ... }
FunctionA

No entanto, quando se usa a notação de origem de ponto , não se cria um novo escopo antes de o comando ser executado, pelo que as adições/alterações que teria feito no seu próprio escopo local são feitas no escopo atual. Por exemplo

. Script2.ps1
. "Script2.ps1"
. { ... }
. FunctionA

3.5.6 Módulos

Assim como um arquivo de script de nível superior está na raiz de uma árvore de escopo aninhada hierárquica, o mesmo acontece com cada módulo (§3.14). No entanto, por padrão, apenas os nomes exportados por um módulo estão disponíveis por nome no contexto de importação. O parâmetro Global do cmdlet Import-Module permite que os nomes exportados tenham maior visibilidade.

3.6 Propriedades ReadOnly e Constant

Variáveis e aliases são descritos por objetos que contêm várias propriedades. Essas propriedades são definidas e manipuladas por duas famílias de cmdlets (§3.1.5, §3.1.1). Uma dessas propriedades é Options, que pode ser definida como ReadOnly ou Constant (usando o parâmetro Option). Uma variável ou alias marcado como ReadOnly pode ser removido e suas propriedades podem ser alteradas desde que o parâmetro Force seja especificado. No entanto, uma variável ou alias marcado como constante não pode ser removido nem que suas propriedades sejam alteradas.

3.7 Sobrecargas de métodos e resolução de chamadas

3.7.1 Introdução

Conforme declarado no §1, um procedimento externo disponibilizado pelo ambiente de execução (e escrito em alguma linguagem diferente do PowerShell) é chamado de método .

O nome de um método, juntamente com o número e os tipos de seus parâmetros, são chamados coletivamente de assinatura desse método. (Observe que a assinatura não inclui o tipo de retorno do método.) O ambiente de execução pode permitir que um tipo tenha vários métodos com o mesmo nome, desde que cada um tenha uma assinatura diferente. Quando várias versões de algum método são definidas, esse método é dito estar sobrecarregado. Por exemplo, o tipo Math (§4.3.8) contém um conjunto de métodos chamado Abs, que calcula o valor absoluto de um número especificado, onde o número especificado pode ter um de vários tipos. Os métodos nesse conjunto têm as seguintes assinaturas:

Abs(decimal)
Abs(float)
Abs(double)
Abs(int)
Abs(long)
Abs(SByte)
Abs(Int16)

Neste caso, todos os métodos têm o mesmo número de argumentos; suas assinaturas diferem apenas pelo tipo de argumento.

Outro exemplo envolve o tipo Array (§4.3.2), que contém um conjunto de métodos chamado Copy que copia um intervalo de elementos de uma matriz para outra, começando no início de cada matriz (por padrão) ou em algum elemento designado. Os métodos nesse conjunto têm as seguintes assinaturas:

Copy(Array, Array, int)
Copy(Array, Array, long)
Copy(Array, int, Array, int, int)
Copy(Array, long, Array, long, long)

Neste caso, as assinaturas diferem por tipo de argumento e, em alguns casos, também por número de argumento.

Na maioria das chamadas para métodos sobrecarregados, o número e o tipo de argumentos passados correspondem exatamente a uma das sobrecargas, e o método selecionado é óbvio. No entanto, se esse não for o caso, precisa haver uma maneira de resolver qual versão sobrecarregada deve ser chamada, se houver. Por exemplo

[Math]::Abs([byte]10) # no overload takes type byte
[array]::Copy($source, 3, $dest, 5L, 4) # both int and long indexes

Outros exemplos incluem o tipo string (ou seja, System.String), que tem vários métodos sobrecarregados.

Embora o PowerShell tenha regras para resolver chamadas de método que não correspondem exatamente a uma assinatura sobrecarregada, o PowerShell por si só não fornece uma maneira de definir métodos sobrecarregados.

Observação

Nota do editor: O PowerShell 5.0 adicionou a capacidade de definir classes baseadas em script. Essas classes podem conter métodos sobrecarregados.

3.7.2 Resolução de sobrecarga do método

Dada uma chamada de método (§7.1.3) com uma lista de expressões de argumento, e um conjunto de métodos candidatos(ou seja, aqueles métodos que podem ser chamados), o mecanismo para selecionar o melhor método é chamado resolução de sobrecarga.

Dado o conjunto de métodos candidatos aplicáveis (§3.7.3), seleciona-se o melhor método desse conjunto. Se o conjunto contém apenas um método, então esse método é o melhor método. Caso contrário, o melhor método é aquele que é melhor do que todos os outros métodos em relação à lista de argumentos dada usando as regras mostradas em §3.7.4. Se não houver exatamente um método que seja melhor do que todos os outros métodos, então a invocação do método é ambígua e um erro é relatado.

O melhor método deve ser acessível no contexto em que é chamado. Por exemplo, um script do PowerShell não pode chamar um método que é privado ou protegido.

O melhor método para uma chamada para um método estático deve ser um método estático, e o melhor método para uma chamada para um método de instância deve ser um método de instância.

3.7.3 Método aplicável

Diz-se que um método é aplicável em relação a uma lista de argumentos A quando uma das seguintes opções for verdadeira:

• O número de argumentos em A é idêntico ao número de parâmetros que o método aceita.
• O método tem parâmetros necessários M e parâmetros opcionais N, e o número de argumentos em A é maior ou igual a M, mas menor que N.
• O método aceita um número variável de argumentos e o número de argumentos em A é maior do que o número de parâmetros que o método aceita.

Além de ter um número apropriado de argumentos, cada argumento em A deve corresponder ao modo de passagem de parâmetros do argumento, e o tipo de argumento deve corresponder ao tipo de parâmetro, ou deve haver uma conversão do tipo de argumento para o tipo de parâmetro.

Se o tipo de argumento for ref (§4.3.6), o parâmetro correspondente também deve ser ref, e o tipo de argumento para fins de conversão é o tipo da propriedade Value do argumento ref.

Se o tipo de argumento for ref, o parâmetro correspondente poderá ser out em vez de ref.

Se o método aceitar um número variável de argumentos, o método pode ser aplicável na forma normal ou forma expandida. Se o número de argumentos em A é idêntico ao número de parâmetros que o método aceita e o último parâmetro é uma matriz, então o formulário depende da classificação de uma das duas conversões possíveis:

• A hierarquia da conversão do tipo do último argumento em A para o tipo de matriz do último parâmetro.
• A classificação da conversão do tipo do último argumento em A para o tipo de elemento do tipo de matriz para o último parâmetro.

Se a primeira conversão (para o tipo de matriz) for melhor do que a segunda conversão (para o tipo de elemento da matriz), então o método é aplicável na forma normal, caso contrário, é aplicável na forma expandida.

Se houver mais argumentos do que parâmetros, o método pode ser aplicável apenas na forma expandida. Para ser aplicável na forma expandida, o último parâmetro deve ter o tipo de matriz. O método é substituído por um método equivalente que tem o último parâmetro substituído por parâmetros suficientes para levar em conta cada argumento não correspondido em A. Cada tipo de parâmetro adicional é o tipo de elemento do tipo de matriz para o último parâmetro no método original. As regras acima para um método aplicável são aplicadas a este novo método e lista de argumentos A.

3.7.4 Melhor método

Dada uma lista de argumentos A com um conjunto de expressões de argumento { E~1~, E~2~, ..., E~N~ } e dois métodos de aplicação M~P~ e M~Q~ com tipos de parâmetros { P~1~, P~2~, ..., P~N~ } e { Q~1~, Q~2~, ..., Q~N~ }, M~P~ é definido como um método melhor do que M~Q~ se a classificação cumulativa de conversões para M~P~ for melhor do que a de M~Q~.

A classificação acumulada das conversões é calculada da seguinte forma. Cada conversão vale um valor diferente dependendo do número de parâmetros, com a conversão de E~1~ vale N, E~2~ vale N-1, até E~N~ vale 1. Se a conversão de E~X~ para P~X~ for melhor do que a de E~X~ para Q~X~, o M~P~ acumula N-X+1; caso contrário, M~Q~ acumula N-X+1. Se M~P~ e M~Q~ tiverem o mesmo valor, as seguintes regras de desempate serão usadas, aplicadas em ordem:

• A classificação cumulativa de conversões entre tipos de parâmetros (ignorando tipos de argumentos) é calculada de forma semelhante à classificação anterior, de modo que P~1~ é comparada com Q~1~, P~2~ contra Q~2~, ..., e P~N~ contra Q~N~. A comparação é ignorada se o argumento foi $nullou se os tipos de parâmetro não são tipos numéricos. A comparação também é ignorada se a conversão do argumento E~X~ perde informações quando convertido em P~X~ mas não perde informações quando convertido em Q~X~, ou vice versa. Se os tipos de conversão de parâmetros forem comparados, se a conversão de P~X~ para Q~X~ for melhor do que a de Q~X~ para P~X~, o M~P~ acumula N-X+1; caso contrário, M~Q~ acumula N-X+1. Esta regra de desempate destina-se a preferir o método mais específico (ou seja, o método com parâmetros com os menores tipos de dados) se nenhuma informação for perdida em conversões, ou preferir o método mais geral (ou seja, o método com os parâmetros com os maiores tipos de dados) se as conversões resultarem em perda de informações.
• Se ambos os métodos usam sua forma expandida, o método com mais parâmetros é o melhor método.
• Se um método usa a forma expandida e o outro usa a forma normal, o método usando a forma normal é o melhor método.

3.7.5 Melhor conversão

O texto abaixo marcado assim é específico do Windows PowerShell.

As conversões são classificadas da seguinte maneira, da mais baixa para a mais alta:

• T~1~[] para T~2~[] onde não existe conversão atribuível entre T~1~ e T~2~
• T para string onde T é qualquer tipo
• T~1~ para T~2~ onde T~1~ ou T~2~ definem uma conversão personalizada de uma forma definida pela implementação
• T~1~ para T~2~ onde T~1~ implementa IConvertible
• T~1~ para T~2~ onde T~1~ ou T~2~ implementa o método T~2~ op_Implicit(T1)
• T~1~ para T~2~ onde T~1~ ou T~2~ implementa o método T~2~ op_Explicit(T1)
• T~1~ para T~2~ em que T~2~ implementa um construtor que recebe um único argumento do tipo T~1~
• Uma das seguintes conversões:
  • string to T onde T implementa um método estático T Parse(string) ou T Parse(string, IFormatProvider)
  • T~1~ para T~2~ onde T~2~ é qualquer enum e T~1~ é string ou uma coleção de objetos que podem ser convertidos em string
• T para PSObject onde T é de qualquer tipo
• Qualquer uma das seguintes conversões: Language
  • T para bool onde T é qualquer tipo numérico
  • string para T onde T é regex, wmisearcher, wmi, wmiclass, adsi, adsisearcherou type
  • de T a bool
  • T~1~ para Nullable[T~2~] onde há uma conversão de T~1~ para T~2~
  • T para anular
  • T~1~[] a T~2~[] onde existe uma conversão atribuível entre T~1~ e T~2~
  • T~1~ a T~2~[] onde T~1~ é uma coleção
  • de IDictionary a Hashtable
  • de T a ref
  • de T a xml
  • de scriptblock a delegate
  • T~1~ para T~2~ onde T~1~ é um tipo inteiro e T~2~ é um enum
• $null para T onde T é qualquer tipo de valor
• $null para T onde T é qualquer tipo de referência
• Qualquer uma das seguintes conversões:

  • byte para T onde T é SByte

  • UInt16 para T onde T é SByte, byteou Int16

  • Int16 para T onde T é SByte ou byte

  • UInt32 para T onde T é SByte, byte, Int16, UInt16ou int

  • int para T onde T é SByte, byte, Int16ou UInt16

  • UInt64 para T onde T é SByte, byte, Int16, UInt16, int, UInt32ou long

  • long para T onde T é SByte, byte, Int16, UInt16, intou UInt32

  • float para T onde T é qualquer tipo de inteiro ou decimal

  • double para T onde T é qualquer tipo de inteiro ou decimal

  • decimal para T onde T pode ser qualquer tipo inteiro

• Qualquer uma das seguintes conversões:
  • SByte para T onde T é byte, uint6, UInt32ou UInt64
  • Int16 para T onde T é UInt16, UInt32ou UInt64
  • int para T onde T é UInt32 ou UInt64
  • de long a UInt64
  • decimal para T onde T é float ou double
• Qualquer uma das seguintes conversões:
  • T para string onde T é qualquer tipo numérico
  • T para char onde T é qualquer tipo numérico
  • string para T onde T é qualquer tipo numérico
• Qualquer uma das seguintes conversões, essas conversões são consideradas conversões atribuíveis:
  • byte para T onde T é Int16, UInt16, int, UInt32, long, UInt64, single, doubleou decimal
  • SByte para T onde T é Int16, UInt16, int, UInt32, long, UInt64, single, doubleou decimal
  • UInt16 para T onde T é int, UInt32, long, ou UInt64, single, doubleou decimal
  • Int16 para T onde T é int, UInt32, long, ou UInt64, single, doubleou decimal
  • UInt32 para T onde T é long, ou UInt64, single, doubleou decimal
  • int para T onde T é long, UInt64, single, doubleou decimal
  • de single a double
• T~1~ para T~2~ onde T~2~ é uma classe base ou interface de T~1~. Esta conversão é considerada uma conversão atribuível.
• de string a char[]
• T para T -- Esta conversão é considerada uma conversão atribuível.

Para cada conversão do formulário T~1~ para T~2~[] onde T~1~ não é uma matriz e nenhuma outra conversão se aplica, se houver uma conversão de T~1~ para T~2~, a classificação da conversão é pior do que a conversão de T~1~ para T~2~, mas melhor do que qualquer conversão classificada menos do que a conversão de T~1~ para T~2~

3.8 Pesquisa de nomes

É possível ter comandos de diferentes tipos, todos com o mesmo nome. A ordem na qual a pesquisa de nome é executada nesse caso é alias, função, cmdlet e comando externo.

3.9 Consulta de nome de tipo

§7.1.10 contém a declaração: "Um literal de tipo é representado em uma implementação por algum tiposubjacente não especificado. Como resultado, um nome de tipo é um sinônimo de seu tipo subjacente." Exemplos de tipos são int, double, long[]e Hashtable.

Os nomes de tipo são correspondidos da seguinte forma: Compare um determinado nome de tipo com a lista de aceleradores internos de tipo , como int, long, double. Se for encontrada uma correspondência, esse é o tipo. Caso contrário, presuma que o nome do tipo é totalmente qualificado e veja se tal tipo existe no sistema anfitrião. Se for encontrada uma correspondência, esse é o tipo. Caso contrário, adicione o prefixo do namespace System.. Se for encontrada uma correspondência, isso será o tipo. Caso contrário, o nome do tipo está errado. Este algoritmo é aplicado para cada argumento de tipo para tipos genéricos. No entanto, não há necessidade de especificar a aridade (o número de argumentos ou operandos tomados por uma função ou operador).

3.10 Gestão automática de memória

Vários operadores e cmdlets resultam na alocação de memória para objetos de referência, como cadeias de caracteres e matrizes. A alocação e liberação dessa memória é gerenciada pelo sistema de tempo de execução do PowerShell. Ou seja, o PowerShell fornece coleta de lixo automática.

3.11 Ordem de execução

Um efeito colateral é uma alteração no estado do ambiente de execução de um comando. Uma alteração no valor de uma variável (através dos operadores de atribuição ou dos operadores de pré e pós-incremento e decréscimo) é um efeito colateral, assim como uma alteração no conteúdo de um arquivo.

Salvo indicação em contrário, as declarações são executadas em ordem lexical.

Exceto quando especificado para alguns operadores, a ordem de avaliação dos termos numa expressão e a ordem em que os efeitos secundários ocorrem não são especificadas.

Uma expressão que invoca um comando envolve a expressão que designa o comando e zero ou mais expressões que designam os argumentos cujos valores devem ser passados para esse comando. A ordem em que essas expressões são avaliadas umas em relação às outras não é especificada.

3.12 Tratamento de erros

Quando um comando falha, isso é considerado um erro , e as informações sobre esse erro são registradas em um registro de erro , cujo tipo não é especificado (§4.5.15); no entanto, esse tipo oferece suporte a subscripting.

Um erro enquadra-se numa de duas categorias. Ou encerra a operação (um erro de encerramento ) ou não (um erro não terminativo). Com um erro de encerramento, o erro é registrado e a operação é interrompida. Com um erro não terminal, o erro é registado e a operação continua.

Os erros não finais são gravados no fluxo de erros. Embora essas informações possam ser redirecionadas para um arquivo, os objetos de erro são primeiro convertidos em cadeias de caracteres e informações importantes nesses objetos não seriam capturadas, tornando o diagnóstico difícil, se não impossível. Em vez disso, o texto de erro pode ser redirecionado (§7.12) e o objeto de erro salvo em uma variável, como em $Error1 = command 2>&1.

A variável automática $Error contém uma coleção de registros de erro que representam erros recentes, e o erro mais recente está em $Error[0]. Essa coleção é mantida em um buffer de modo que os registros antigos são descartados à medida que novos são adicionados. A variável automática $MaximumErrorCount controla o número de registros que podem ser armazenados.

$Error contém todos os erros de todos os comandos misturados em uma coleção. Para coletar os erros de um comando específico, use o parâmetro comum ErrorVariable, que permite que uma variável definida pelo usuário seja especificada para armazenar a coleção.

3.13 Tubulações

Um pipeline é uma série de um ou mais comandos, cada um separado pelo operador pipe | (U+007C). Cada comando recebe entrada de seu antecessor e grava a saída para seu sucessor. A menos que a saída no final do pipeline seja descartada ou redirecionada para um arquivo, ela é enviada para o ambiente host, que pode optar por gravá-la na saída padrão. Os comandos em um pipeline também podem receber entrada de argumentos. Por exemplo, considere o seguinte uso de comandos Get-ChildItem, Sort-Objecte Process-File, que criam uma lista de nomes de arquivo em um determinado diretório do sistema de arquivos, classificam um conjunto de registros de texto e executam algum processamento em um registro de texto, respectivamente:

Get-ChildItem
Get-ChildItem E:*.txt | Sort-Object -CaseSensitive | Process-File >results.txt

No primeiro caso, Get-ChildItem cria uma coleção de nomes dos arquivos no diretório atual/padrão. Essa coleção é enviada para o ambiente do host, que, por padrão, grava o valor de cada elemento na saída padrão.

No segundo caso, Get-ChildItem cria uma coleção de nomes dos arquivos no diretório especificado, usando o argumento E:*.txt. Esse conjunto de dados é escrito com o comando Sort-Object, que, por padrão, os organiza em ordem crescente, sendo sensível a maiúsculas/minúsculas (em função do argumento CaseSensitive). A coleção resultante é então gravada no comando Process-File, que executa algum processamento (desconhecido). A saída desse comando é então redirecionada para o arquivo results.txt.

Se um comando grava um único objeto, seu sucessor recebe esse objeto e, em seguida, termina depois de escrever o(s) seu(s) próprio(s) objeto(s) para seu sucessor. Se, no entanto, um comando grava vários objetos, eles são entregues um de cada vez ao comando sucessor, que é executado uma vez por objeto. Este comportamento é denominado streaming. No processamento de fluxo, os objetos são gravados no pipeline assim que ficam disponíveis, não quando toda a coleção foi produzida.

Ao processar uma coleção, um comando pode ser escrito de forma que possa fazer processamento especial antes do elemento inicial e depois do elemento final.

3.14 Módulos

Um módulo é uma unidade reutilizável independente que permite que o código do PowerShell seja particionado, organizado e abstraído. Um módulo pode conter comandos (como cmdlets e funções) e itens (como variáveis e aliases) que podem ser usados como uma única unidade.

Uma vez que um módulo tenha sido criado, ele deve ser importado para uma sessão antes que os comandos e itens dentro dele possam ser usados. Uma vez importados, os comandos e itens se comportam como se fossem definidos localmente. Um módulo é importado explicitamente com o comando Import-Module. Um módulo também pode ser importado automaticamente, conforme determinado de uma maneira definida pela implementação.

O tipo de objeto que representa um módulo é descrito no §4.5.12.

Os módulos são discutidos em detalhe no §11.

3.15 Expressões curinga

Uma expressão de carácter especial pode conter zero ou mais dos seguintes elementos:

Elemento	Descrição
Caractere diferente de *, ?, ou [	Corresponde a esse caractere
*	Corresponde a zero ou mais caracteres. Para corresponder a um caractere *, use [*].
?	Corresponde a qualquer personagem. Para corresponder a um ? caractere, use [?].
[conjunto]	Corresponde a qualquer caractere do conjunto, que não pode estar vazio. Se conjunto começar com ], esse colchete direito é considerado parte de conjunto e o próximo colchete direito termina o conjunto; caso contrário, o primeiro colchete direito encerra o conjunto. Se conjunto começa ou termina com -, esse hífen-menos é considerado parte de conjunto; caso contrário, indica um intervalo de pontos de código Unicode consecutivos com os caracteres de ambos os lados do hífen-menos sendo os delimitadores de intervalo inclusivos. Por exemplo, A-Z indica as 26 letras maiúsculas em inglês e 0-9 indica os 10 dígitos decimais.

Observação

Mais informações podem ser encontradas em «As Especificações Base do Open Group: Correspondência de Padrões», IEEE Std 1003.1, Edição de 2004.. No entanto, no PowerShell, o caractere de escape é *backtick* (`), não *backslash* (\).

3.16 Expressões regulares

Uma expressão regular pode conter zero ou mais dos seguintes elementos:

Elemento	Descrição
Caractere diferente de ., [, ^, *, $, ou \	Corresponde a esse caractere
.	Corresponde a qualquer personagem. Para corresponder a um . caractere, use \..
[definir] [^conjunto]	A forma [set] corresponde a qualquer caractere de conjunto. O formulário [^conjunto] não corresponde a nenhum caractere de conjunto. conjunto não pode estar vazio. Se conjunto começar com ] ou ^], esse colchete direito é considerado parte de conjunto e o próximo colchete direito termina o conjunto; caso contrário, o primeiro colchete direito encerra o conjunto. Se o conjunto começa com - ou ^-, ou termina com -, esse hífen-menos é considerado parte do conjunto ; caso contrário, indica um intervalo de pontos de código Unicode consecutivos, com os caracteres de cada lado do hífen-menos sendo os delimitadores de intervalo inclusivos. Por exemplo, A-Z indica as 26 letras maiúsculas em inglês e 0-9 indica os 10 dígitos decimais.
*	Corresponde a zero ou mais ocorrências do elemento anterior.
+	Corresponde a uma das mais ocorrências do elemento anterior.
?	Corresponde a zero de uma ocorrência do elemento anterior.
^	Corresponde no início da cadeia de caracteres. Para corresponder a um caractere ^, use \^.
$	Corresponde no final da sequência. Para corresponder a um caractere $, use $.
\ c	Escapa do caractere c, por isso não é reconhecido como um elemento de expressão regular.

Observação

Mais informações podem ser encontradas em, The Open Group Base Specifications: Regular Expressions, IEEE Std 1003.1, 2004 Edition..

Windows PowerShell: As classes de caracteres disponíveis em expressões regulares do Microsoft .NET Framework são suportadas, da seguinte maneira:

Elemento	Descrição
\p{name}	Corresponde a qualquer caractere na classe de caractere nomeada especificada por nome. Os nomes suportados são grupos Unicode e intervalos de blocos, como Ll, Nd, Z, IsGreek e IsBoxDrawing.
\P{name}	Corresponde ao texto não incluído nos grupos e intervalos de blocos especificados em nome.
\w	Corresponde a qualquer caractere de palavra. Equivalente às categorias de caracteres Unicode [\p{Ll}\p{Lu}\p{Lt}\p{Lo}\p{Nd}\p{Pc}]. Se o comportamento compatível com ECMAScript for especificado com a opção ECMAScript, \w será equivalente a [a-zA-Z_0-9].
\W	Corresponde a qualquer caractere não alfabético. Equivalente às categorias Unicode [\^\p{Ll}\p{Lu}\p{Lt}\p{Lo}\p{Nd}\p{Pc}].
\s	Corresponde a qualquer caractere de espaço em branco. Equivalente às categorias de caracteres Unicode [\f\n\r\t\v\x85\p{Z}].
\S	Corresponde a qualquer caractere que não seja de espaço em branco. Equivalente às categorias de caracteres Unicode [\^\f\n\r\t\v\x85\p{Z}].
\d	Corresponde a qualquer dígito decimal. Equivalente a \p{Nd} para Unicode e [0-9] para comportamento não-Unicode.
\D	Corresponde a qualquer carater que não seja um dígito. Equivalente a \P{Nd} para Unicode e [\^0-9] para comportamento não-Unicode.

Os quantificadores disponíveis em expressões regulares do Microsoft .NET Framework são suportados, da seguinte forma:

Elemento	Descrição
*	Especifica zero ou mais coincidências; por exemplo, \w* ou (abc)*. Equivalente a {0,}.
+	Corresponde a ocorrências repetidas dos caracteres anteriores.
?	Especifica zero ou uma correspondência; por exemplo, \w? ou (abc)?. Equivalente a {0,1}.
{n}	Especifica exatamente n correspondências; por exemplo, (pizza){2}.
{n,}	Especifica pelo menos n correspondências; por exemplo, (abc){2,}.
{n,m}	Especifica pelo menos n, mas não mais de m, corresponde.