about_Scopes

Descrição curta

Explica o conceito de escopo no PowerShell e mostra como definir e alterar o escopo dos elementos.

Descrição longa

O PowerShell protege o acesso a variáveis, aliases, funções e unidades do PowerShell (PSDrives) limitando onde elas podem ser lidas e alteradas. O PowerShell usa regras de escopo para garantir que você não faça alterações não intencionais em itens em outros escopos.

Regras de escopo

Quando você inicia o PowerShell, o host (pwsh.exe) cria um runspace do PowerShell. Os processos de host podem ter vários runspaces. Cada runspace tem seus próprios contêineres de escopo e estado de sessão. O estado e os escopos da sessão não podem ser acessados entre instâncias de runspace.

Veja a seguir as regras básicas de escopo:

Os escopos podem ser aninhados. Um escopo externo é conhecido como escopo primário. Os escopos aninhados são escopos secundários desse primário.
Um item fica visível no escopo em que foi criado e em qualquer escopo secundário, a menos que você o torne claramente privado.
Usando modificadores de escopo, você pode declarar variáveis, aliases, funções e unidades do PowerShell para um escopo fora do escopo atual.
Um item criado dentro de um escopo só pode ser alterado no escopo no qual ele foi criado, a menos que você especifique explicitamente um escopo diferente.
Quando o código em execução em um runspace faz referência a um item, o PowerShell pesquisa a hierarquia de escopo, começando com o escopo atual e continuando por cada escopo pai.
- Se o item não for encontrado, um novo item será criado no escopo atual.
- Se encontrar uma correspondência, o valor do item será obtido do escopo em que foi encontrado.
- Se você alterar o valor, o item será copiado para o escopo atual para que a alteração afete apenas o escopo atual.
Se você criar explicitamente um item que compartilha seu nome com um item em um escopo diferente, o item original poderá estar oculto pelo novo item, mas ele não será substituído ou alterado.

Escopos pai e filho

É possível criar um novo escopo secundário chamando um script ou uma função. O escopo de chamada é o escopo primário. O script ou a função chamada é o escopo secundário. As funções ou os scripts que você chama podem chamar outras funções, criando uma hierarquia de escopos secundários cujo escopo raiz é o escopo global.

Nota

As funções de um módulo não são executadas em um escopo secundário do escopo de chamada. Os módulos têm seu próprio estado de sessão vinculado ao escopo no qual o módulo foi importado. Todo o código do módulo é executado em uma hierarquia de escopos específica do módulo que tem seu próprio escopo raiz. Para obter mais informações, consulte a seção Módulos deste artigo.

Quando um escopo secundário é criado, ele inclui todos os aliases e variáveis que têm a opção AllScope, além de algumas variáveis automáticas. Essa opção é discutida posteriormente neste artigo.

A menos que abertamente você torne os itens privados, os itens no escopo primário ficam disponíveis para o escopo secundário. Os itens criados ou alterados em um escopo filho não afetam o escopo pai, a menos que você especifique explicitamente o escopo ao criar os itens.

Para localizar os itens em um escopo específico, use o parâmetro Scope de Get-Variable ou Get-Alias.

Por exemplo, para obter todas as variáveis no escopo local, digite:

Get-Variable -Scope Local

Para obter todas as variáveis no escopo global, digite:

Get-Variable -Scope Global

Quando uma referência é feita a uma variável, alias ou função, o PowerShell pesquisa o escopo atual. Se o item não for encontrado, o escopo primário será pesquisado. Essa pesquisa é repetida até o escopo global. Se uma variável é privada em um escopo primário, a pesquisa continua por toda a cadeia de escopos. exemplo 4 mostra o efeito de uma variável privada em uma pesquisa de escopo.

Nomes de escopo do PowerShell

O PowerShell define nomes para alguns escopos para permitir acesso mais fácil a esse escopo. O PowerShell define os seguintes escopos nomeados:

Global: o escopo que está em vigor quando o PowerShell é iniciado ou quando você cria uma sessão ou um runspace. Variáveis e funções presentes quando o PowerShell é iniciado, como variáveis automáticas e variáveis de preferência, são criadas no escopo global. As variáveis, os aliases e as funções em seus perfis do PowerShell também são criados no escopo global. Em um runspace, o escopo global é o escopo primário raiz.
Local: o escopo atual. O escopo local pode ser o escopo global ou qualquer outro escopo.
Script: o escopo criado enquanto um arquivo de script é executado. Os comandos no script são executados no escopo do script. Para os comandos em um script, o escopo do script é o escopo local.

No caso de cmdlets que aceitam escopos, os escopos podem ser referenciados por um número que descreve a posição de um escopo em relação a outro. O escopo 0 indica o escopo atual (local), o escopo 1 é o pai do escopo atual, o escopo 2 é o avô do escopo atual. Esse padrão continua até você chegar ao escopo raiz.

Modificadores de escopo

Uma variável, um alias ou um nome de função pode incluir qualquer um dos seguintes modificadores de escopo opcionais:

Global: – Especifica que o nome existe no escopo Global.
Local: – Especifica que o nome existe no escopo Local. O escopo atual é sempre o escopo Local. Quando você usa o modificador de escopo, o Local: PowerShell não pesquisa escopos pai. Se o item existir no escopo atual, ele será usado. Se o item não existir no escopo atual, o PowerShell criará um novo item no escopo atual.
Private: – Especifica que o nome é Privado e fica visível apenas para o escopo atual.

Nota

Private: não é um escopo. É uma opção que altera a acessibilidade de um item fora do escopo no qual ele é definido.
Script: – Especifica que o nome existe no escopo do Script. O escopoScript é o escopo do arquivo de script ancestral mais próximo ou Global se não houver um arquivo de script ancestral mais próximo.
Using: – usado para acessar variáveis definidas em outro escopo durante a execução em sessões remotas, trabalhos em segundo plano ou trabalhos de thread.
Workflow: - Especifica que o nome existe em um fluxo de trabalho. Observação: não há suporte para fluxos de trabalho no PowerShell v6 e superior.

<variable-namespace> – Um modificador criado por um provedor PSDrive do PowerShell. Por exemplo:

Namespace	Descrição
`Alias:`	Aliases definidos no escopo atual
`Env:`	Variáveis de ambiente definidas no escopo atual
`Function:`	Funções definidas no escopo atual
`Variable:`	Variáveis definidas no escopo atual

O escopo padrão para scripts é o escopo do script. O escopo padrão para funções e aliases é o escopo local, mesmo que sejam definidos em um script.

Usando modificadores de escopo

Para especificar o escopo de uma nova variável, alias ou função, use um modificador de escopo.

A sintaxe de um modificador de escopo em uma variável é:

$[<scope-modifier>:]<name> = <value>

A sintaxe de um modificador de escopo em uma função é:

function [<scope-modifier>:]<name> {<function-body>}

O comando a seguir, que não usa um modificador de escopo, cria uma variável no escopo atual ou local :

$a = "one"

Para criar a mesma variável no escopo global , use o modificador de escopo Global::

$Global:a = "one"
Get-Variable a | Format-List *

Observe os valores das propriedades Visibility e Options.

Name        : a
Description :
Value       : one
Visibility  : Public
Module      :
ModuleName  :
Options     : None
Attributes  : {}

Compare isso com uma variável privada:

$Private:pVar = 'Private variable'
Get-Variable pVar | Format-List *

Usar o modificador de escopo Private: define a propriedade Options como Private.

Name        : pVar
Description :
Value       : Private variable
Visibility  : Public
Module      :
ModuleName  :
Options     : Private
Attributes  : {}

Para criar a mesma variável no escopo de script, use o modificador de escopo Script::

$Script:a = "one"

Você também pode usar um modificador de escopo com funções. A seguinte definição de função cria uma função no escopo global:

function Global:Hello {
  Write-Host "Hello, World"
}

Você também pode usar modificadores de escopo para se referir a uma variável em um escopo diferente. O comando a seguir refere-se à variável $test, primeiro no escopo local e depois no escopo global:

$test
$Global:test

O modificador de escopo `Using:`

Using é um modificador de escopo especial que identifica uma variável local de um comando remoto. Sem um modificador, o PowerShell espera que variáveis em comandos remotos sejam definidas na sessão remota.

O modificador de escopo Using: foi introduzido no PowerShell 3.0.

Para qualquer script ou comando executado fora da sessão, você precisa do modificador de escopo Using: para inserir valores variáveis do escopo da sessão de chamada, para que o código fora da sessão possa acessá-los. O modificador de escopo Using: tem suporte nos seguintes contextos:

Comandos executados remotamente, iniciados com Invoke-Command usando os parâmetros ComputerName, HostName, SSHConnection ou Session (sessão remota)
Trabalhos em segundo plano, iniciados com Start-Job (sessão fora do processo)
Trabalhos de thread, iniciados através de Start-ThreadJob ou ForEach-Object -Parallel (sessão de thread separada)

Dependendo do contexto, os valores de variável incorporados são cópias independentes dos dados no escopo do chamador ou referências a ele. Em sessões remotas e fora de processo, elas são sempre independentes.

Para obter mais informações, consulte about_Remote_Variables.

Uma referência $Using: só se expande para o valor de uma variável. Se você quiser alterar o valor de uma variável no escopo do chamador, deverá ter uma referência à variável em si. Você pode criar uma referência a uma variável obtendo a instância de PSVariable da variável. O exemplo a seguir mostra como criar uma referência e fazer alterações em um trabalho de thread.

$Count = 1
$refOfCount = Get-Variable Count

Start-ThreadJob {
    ($Using:refOfCount).Value = 2
} | Receive-Job -Wait -AutoRemoveJob

$Count

Nota

Esta não é uma operação thread-safe. Você pode causar corrupção de dados se tentar alterar o valor de vários threads ao mesmo tempo. Você deve usar tipos de dados seguros para threads ou primitivos de sincronização para proteger dados compartilhados. Para mais informações, consulte as coleções Thread-Safe.

Serialização de valores variáveis

Comandos executados remotamente e trabalhos em segundo plano são executados fora do processo. Sessões fora de processo usam serialização e desserialização baseadas em XML para disponibilizar os valores das variáveis entre os limites do processo. O processo de serialização converte objetos em um PSObject que contém as propriedades de objetos originais, mas não seus métodos.

Para um conjunto limitado de tipos, a desserialização reidrata objetos para o tipo original. O objeto reidratado é uma cópia da instância de objeto original. Possui propriedades e métodos de tipo. Para tipos simples, como System.Version, a cópia é exata. Para tipos complexos, a cópia é imperfeita. Por exemplo, objetos de certificado reidratados não incluem a chave privada.

As instâncias de todos os outros tipos são instâncias de PSObject. A propriedade pstypenames contém o nome de tipo original prefixado com Desserializados, por exemplo, Deserialized.System.Data.DataTable

A opção AllScope

Variáveis e aliases têm uma propriedade Option que pode usar um valor de AllScope. Os itens que têm a propriedade AllScope tornam-se parte de quaisquer escopos secundários criados, embora não sejam herdados retroativamente por escopos primários.

Um item que tem a propriedade AllScope fica visível no escopo secundário e faz parte dele. As alterações no item em qualquer escopo afetam todos os escopos nos quais a variável é definida.

Gerenciando escopos

Vários cmdlets têm um parâmetro Scope que permite obter ou definir itens (criar e alterar) em um escopo específico. Use o seguinte comando para localizar todos os cmdlets em sua sessão que têm um parâmetro Scope:

Get-Help * -Parameter Scope

Para localizar as variáveis visíveis em um escopo específico, use o parâmetro Scope de Get-Variable. As variáveis visíveis incluem variáveis globais, variáveis no escopo primário e variáveis no escopo atual.

Por exemplo, o comando a seguir obtém as variáveis visíveis no escopo local:

Get-Variable -Scope Local

Para criar uma variável em um escopo específico, use um modificador de escopo ou o parâmetro Scope de Set-Variable. O comando a seguir cria uma variável no escopo global:

New-Variable -Scope Global -Name a -Value "One"

Você também pode usar o parâmetro Scope dos cmdlets New-Alias, Set-Aliasou Get-Alias para especificar o escopo. O comando a seguir cria um alias no escopo global:

New-Alias -Scope Global -Name np -Value Notepad.exe

Para obter as funções em um escopo específico, use o cmdlet Get-Item quando estiver dentro desse escopo. O cmdlet Get-Item não tem um parâmetro Scope.

Nota

Para os cmdlets que usam o parâmetro Escopo, você também pode referenciar escopos por número. O número descreve a posição relativa entre um escopo e outro. O escopo 0 representa o escopo atual ou local. O escopo 1 indica o escopo primário imediato. O escopo 2 indica o pai do escopo primário e assim por diante. Escopos numerados serão úteis se você tiver criado muitos escopos recursivos.

Usando a notação dot-source com escopos

Scripts e funções seguem as regras de escopo. Você os cria em um escopo específico e eles afetam somente esse escopo, a menos que você use um parâmetro cmdlet ou um modificador de escopo para alterar esse escopo.

Porém, você pode adicionar o conteúdo de um script ou de uma função ao escopo atual usando a notação dot-source. Quando você executa um script ou função usando a notação ponto-fonte, ele será executado no escopo atual. Quaisquer funções, aliases e variáveis no script ou função são adicionados ao escopo atual.

Por exemplo, para executar o script Sample.ps1 do diretório C:\Scripts no escopo do script (o padrão para scripts), basta inserir o caminho completo para o arquivo de script na linha de comando.

C:\scripts\sample.ps1

Um arquivo de script deve ter uma extensão de arquivo .ps1 para ser executável. Os arquivos que têm espaços em seu caminho devem ser colocados entre aspas. Se você tentar executar o caminho entre aspas, o PowerShell exibirá o conteúdo da cadeia de caracteres entre aspas em vez de executar o script. O operador de chamada (&) permite que você execute o conteúdo da cadeia de caracteres que contém o nome do arquivo.

Usar o operador de chamada para executar uma função ou script faz com que ele seja executado no escopo do script. Usar o operador de chamada não é diferente de executar o script pelo nome.

& C:\scripts\sample.ps1

Você pode ler mais sobre o operador de chamada em about_Operators.

Para executar o script Sample.ps1 no escopo local, digite um ponto e um espaço (. ) antes do caminho para o script:

. C:\scripts\sample.ps1

Agora, quaisquer funções, aliases ou variáveis definidas no script são adicionadas ao escopo atual.

Restringir sem escopo

O PowerShell tem algumas opções e recursos que são semelhantes a escopos e podem interagir com eles. Essa característica pode ser confundida com o escopo ou o comportamento do escopo.

Sessões, módulos e prompts aninhados são ambientes autônomos e não escopos secundários do escopo global na sessão.

Sessões

Uma sessão é um ambiente no qual o PowerShell é executado. Quando você cria uma sessão em um computador remoto, o PowerShell estabelece uma conexão persistente com o computador remoto. A conexão persistente permite que você use a sessão para vários comandos relacionados.

Como uma sessão é um ambiente independente, ela tem seu próprio escopo, mas uma sessão não é um escopo secundário da sessão em que foi criada. A sessão começa com um escopo global próprio. Esse escopo é independente do escopo global da sessão. Você pode criar escopos secundários na sessão. Por exemplo, você pode executar um script para criar um escopo secundário em uma sessão.

Módulos

Você pode usar um módulo do PowerShell para compartilhar e fornecer ferramentas do PowerShell. Um módulo é uma unidade que pode conter cmdlets, scripts, funções, variáveis, aliases e outros itens úteis. A menos que sejam exportados explicitamente (usando Export-ModuleMember ou o manifesto do módulo), os itens em um módulo não poderão ser acessados fora do módulo. Portanto, você pode adicionar o módulo à sessão e usar os itens públicos sem se preocupar que os outros itens possam substituir os cmdlets, scripts, funções e outros itens em sua sessão.

Por padrão, os módulos são carregados no escopo de nível raiz (global) do runspace. Importar um módulo não altera o escopo. Na sessão, os módulos têm seu próprio escopo. Considere o seguinte módulo C:\temp\mod1.psm1:

$a = "Hello"

function foo {
    "`$a = $a"
    "`$Global:a = $Global:a"
}

Agora, criamos uma variável global $a, damos a ela um valor e chamamos a função foo.

$a = "Goodbye"
foo

O módulo declara a variável $a no escopo do módulo e, em seguida, a função foo gera o valor da variável em ambos os escopos.

$a = Hello
$Global:a = Goodbye

Os módulos criam contêineres de escopo em paralelo vinculados ao escopo em que foram importados. Os itens exportados pelo módulo estão disponíveis a partir do nível do escopo no qual são importados. Os itens não exportados do módulo só estão disponíveis no contêiner de escopo do módulo. As funções no módulo podem acessar itens no escopo em que foram importados, bem como itens no contêiner de escopo do módulo.

Se você carregar Module2 de emModule1, Module2 será carregado no contêiner de escopo de Module1. Todas as exportações de Module2 são colocadas no escopo do módulo atual de Module1. Se você usar Import-Module -Scope Local, as exportações serão colocadas no objeto de escopo atual e não no nível superior. Se você estiver em um módulo e carregar outro módulo usando Import-Module -Scope Global (ou Import-Module -Global), esse módulo e suas exportações serão carregados no escopo global e não no escopo local do módulo. A funcionalidade WindowsCompatibility faz isso para importar módulos proxy no estado de sessão global.

Prompts aninhados

Os prompts aninhados não têm um escopo próprio. Quando você insere um prompt aninhado, ele é um subconjunto do ambiente. No entanto, você permanece no escopo local.

Os scripts têm seu próprio escopo. Se estiver depurando um script e chegar a um ponto de interrupção nele, insira o escopo do script.

Opção privada

Aliases e variáveis têm uma propriedade Option que pode usar um valor de Private. Os itens que têm a opção Private podem ser exibidos e alterados no escopo no qual são criados, mas não podem ser exibidos ou alterados fora desse escopo.

Por exemplo, se você criar uma variável que tenha uma opção privada no escopo global e, em seguida, executar um script, Get-Variable comandos no script não exibirão a variável privada. Usar o modificador de escopo Global: nesta instância não exibe a variável privada.

Você pode usar o parâmetro Option dos cmdlets New-Variable, Set-VariableNew-Alias e Set-Alias para definir o valor da propriedade Option como Privado.

Visibilidade

A propriedade Visibility de uma variável ou alias determina se você pode ver o item fora do contêiner, no qual ele foi criado. Um contêiner pode ser um módulo, um script ou um snap-in. A visibilidade é projetada para contêineres da mesma forma que o valor Private da propriedade Option é projetado para escopos.

A propriedade Visibility usa os valores Public e Private. Os itens que têm visibilidade privada podem ser exibidos e alterados somente no contêiner no qual foram criados. Se o contêiner for adicionado ou importado, os itens que têm visibilidade privada não poderão ser exibidos ou alterados.

Como a visibilidade foi projetada para contêineres, ela funciona de forma diferente em um escopo.

Se você criar um item que tenha visibilidade privada no escopo global, não poderá exibir ou alterar o item em qualquer escopo.
Se você tentar exibir ou alterar o valor de uma variável que tenha visibilidade privada, o PowerShell retornará uma mensagem de erro.

Você pode usar os cmdlets New-Variable e Set-Variable para criar uma variável que tenha visibilidade privada.

Exemplos

Exemplo 1: alterar um valor de variável somente em um script

O comando a seguir altera o valor da variável $ConfirmPreference em um script. A alteração não afeta o escopo global.

Primeiro, para exibir o valor da variável $ConfirmPreference no escopo local, use o seguinte comando:

PS>  $ConfirmPreference
High

Crie um script Scope.ps1 que contenha os seguintes comandos:

$ConfirmPreference = "Low"
"The value of `$ConfirmPreference is $ConfirmPreference."

Execute o script. O script altera o valor da variável $ConfirmPreference e, em seguida, relata seu valor no escopo do script. A saída deve ser semelhante à seguinte saída:

The value of $ConfirmPreference is Low.

Em seguida, teste o valor atual da variável $ConfirmPreference no escopo atual.

PS>  $ConfirmPreference
High

Este exemplo mostra que as alterações no valor de uma variável no escopo do script não afetam o valor da variável no escopo pai.

Exemplo 2: exibir um valor variável em escopos diferentes

Você pode usar modificadores de escopo para exibir o valor de uma variável no escopo local e em um escopo pai.

Primeiro, defina uma variável $test no escopo global.

$test = "Global"

Em seguida, crie um script Sample.ps1 que defina a variável $test. No script, use um modificador de escopo para se referir às versões globais ou locais da variável $test.

Em Sample.ps1:

$test = "Local"
"The local value of `$test is $test."
"The global value of `$test is $Global:test."

Quando você executa Sample.ps1, a saída deve ser semelhante à seguinte saída:

The local value of $test is Local.
The global value of $test is Global.

Quando o script é concluído, somente o valor global de $test é definido na sessão.

PS> $test
Global

Exemplo 3: alterar o valor de uma variável em um escopo primário

A menos que você proteja um item usando a opção 'Privado' ou outro método, você pode exibir e alterar o valor de uma variável em um escopo original.

Primeiro, defina uma variável $test no escopo global.

$test = "Global"

Em seguida, crie um script Sample.ps1 que defina a variável $test. No script, use um modificador de escopo para se referir às versões globais ou locais da variável $test.

Em Sample.ps1:

$Global:test = "Local"
"The global value of `$test is $Global:test."

Quando o script é concluído, o valor global de $test é alterado.

PS> $test
Local

Exemplo 4: Criando uma variável privada

Uma variável pode ser tornada privada usando o modificador de escopo Private: ou criando a variável com a propriedade option definida como Private. Variáveis privadas só podem ser visualizadas ou alteradas no escopo em que foram criadas.

Neste exemplo, o script ScopeExample.ps1 cria cinco funções. A primeira função chama a próxima função, que cria um escopo secundário. Uma das funções tem uma variável privada que só pode ser vista no escopo em que foi criada.

PS> Get-Content ScopeExample.ps1
# Start of ScopeExample.ps1
function funcA {
    "Setting `$funcAVar1 to 'Value set in funcA'"
    $funcAVar1 = "Value set in funcA"
    funcB
}

function funcB {
    "In funcB before set -> '$funcAVar1'"
    $Private:funcAVar1 = "Locally overwrite the value - child scopes can't see me!"
    "In funcB after set  -> '$funcAVar1'"
    funcC
}

function funcC {
    "In funcC before set -> '$funcAVar1' - should be the value set in funcA"
    $funcAVar1 = "Value set in funcC - Child scopes can see this change."
    "In funcC after set  -> '$funcAVar1'"
    funcD
}

function funcD {
    "In funcD before set -> '$funcAVar1' - should be the value from funcC."
    $funcAVar1 = "Value set in funcD"
    "In funcD after set  -> '$funcAVar1'"
    '-------------------'
    ShowScopes
}

function ShowScopes {
    $funcAVar1 = "Value set in ShowScopes"
    "Scope [0] (local)  `$funcAVar1 = '$(Get-Variable funcAVar1 -Scope 0 -ValueOnly)'"
    "Scope [1] (parent) `$funcAVar1 = '$(Get-Variable funcAVar1 -Scope 1 -ValueOnly)'"
    "Scope [2] (parent) `$funcAVar1 = '$(Get-Variable funcAVar1 -Scope 2 -ValueOnly)'"
    "Scope [3] (parent) `$funcAVar1 = '$(Get-Variable funcAVar1 -Scope 3 -ValueOnly)'"
    "Scope [4] (parent) `$funcAVar1 = '$(Get-Variable funcAVar1 -Scope 4 -ValueOnly)'"
}
funcA
# End of ScopeExample.ps1
PS> .\ScopeExample.ps1

A saída mostra o valor da variável em cada escopo. Você pode ver que a variável privada só está visível em funcB, o escopo no qual ela foi criada.

Setting $funcAVar1 to 'Value set in funcA'
In funcB before set -> 'Value set in funcA'
In funcB after set  -> 'Locally overwrite the value - child scopes can't see me!'
In funcC before set -> 'Value set in funcA' - should be the value set in funcA
In funcC after set  -> 'Value set in funcC - Child scopes can see this change.'
In funcD before set -> 'Value set in funcC - Child scopes can see this change.' - should be the value from funcC.
In funcD after set  -> 'Value set in funcD'
-------------------
Scope [0] (local)  $funcAVar1 = 'Value set in ShowScopes'
Scope [1] (parent) $funcAVar1 = 'Value set in funcD'
Scope [2] (parent) $funcAVar1 = 'Value set in funcC - Child scopes can see this change.'
Scope [3] (parent) $funcAVar1 = 'Locally overwrite the value - child scopes can't see me!'
Scope [4] (parent) $funcAVar1 = 'Value set in funcA'

Conforme mostrado pela saída de ShowScopes, você pode acessar variáveis de outros escopos usando Get-Variable e especificando um número de escopo.

Exemplo 5: Usando uma variável local em um comando remoto

Para variáveis em um comando remoto criado na sessão local, use o modificador de escopo Using:. O PowerShell pressupõe que as variáveis em comandos remotos foram criadas na sessão remota.

A sintaxe é:

$Using:<VariableName>

Por exemplo, os comandos a seguir criam uma variável $Cred na sessão local e usam a variável $Cred em um comando remoto:

$Cred = Get-Credential
Invoke-Command $s {Remove-Item .\Test*.ps1 -Credential $Using:Cred}

O modificador de escopo Using: foi introduzido no PowerShell 3.0.

Consulte também

Comentários

Esta página foi útil?

Last updated on 2026-01-16

Compartilhar via

about_Scopes

Descrição curta

Descrição longa

Regras de escopo

Escopos pai e filho

Nomes de escopo do PowerShell

Modificadores de escopo

Usando modificadores de escopo

O modificador de escopo Using:

Serialização de valores variáveis

A opção AllScope

Gerenciando escopos

Usando a notação dot-source com escopos

Restringir sem escopo

Sessões

Módulos

Prompts aninhados

Opção privada

Visibilidade

Exemplos

Exemplo 1: alterar um valor de variável somente em um script

Exemplo 2: exibir um valor variável em escopos diferentes

Exemplo 3: alterar o valor de uma variável em um escopo primário

Exemplo 4: Criando uma variável privada

Exemplo 5: Usando uma variável local em um comando remoto

Consulte também

Comentários

Recursos adicionais

O modificador de escopo `Using:`