Definindo variáveis ​​de ambiente do Windows PowerShell

Eu descobri que a configuração da variável de ambiente PATH afeta apenas o prompt de comando antigo. O PowerShell parece ter diferentes configurações de ambiente. Como altero as variáveis ​​de ambiente do PowerShell (v1)?

Nota:

Quero tornar minhas alterações permanentes, para não precisar defini-las sempre que executar o PowerShell. O PowerShell tem um arquivo de perfil? Algo como o perfil do Bash no Unix?

A alteração das variáveis ​​de ambiente reais pode ser feita usando as env: namespace / driveinformações. Por exemplo, este código atualizará a variável de ambiente do caminho:

$env:Path = "SomeRandomPath";             (replaces existing path) 
$env:Path += ";SomeRandomPath"            (appends to existing path)

Existem maneiras de tornar as configurações do ambiente permanentes, mas se você as estiver usando apenas no PowerShell, provavelmente será muito melhor usar seu perfil para iniciar as configurações. Na inicialização, o PowerShell executará os arquivos .ps1 encontrados no WindowsPowerShelldiretório, na pasta Meus Documentos. Normalmente você já possui um arquivo profile.ps1 . O caminho no meu computador é

C:\Users\JaredPar\Documents\WindowsPowerShell\profile.ps1

Se, em algum momento durante uma sessão do PowerShell, você precisar anexar temporariamente à variável de ambiente PATH, poderá fazer o seguinte:

$env:Path += ";C:\Program Files\GnuWin32\bin"

Você também pode modificar as variáveis ​​de ambiente do usuário / sistema permanentemente (ou seja, será persistente nas reinicializações do shell) com o seguinte:

Modifique uma variável de ambiente do sistema

[Environment]::SetEnvironmentVariable
     ("Path", $env:Path, [System.EnvironmentVariableTarget]::Machine)

Modifique uma variável de ambiente do usuário

[Environment]::SetEnvironmentVariable
     ("INCLUDE", $env:INCLUDE, [System.EnvironmentVariableTarget]::User)

Uso dos comentários - adicione à variável de ambiente do sistema

[Environment]::SetEnvironmentVariable(
    "Path",
    [Environment]::GetEnvironmentVariable("Path", [EnvironmentVariableTarget]::Machine) + ";C:\bin",
    [EnvironmentVariableTarget]::Machine)

A solução baseada em string também é possível se você não quiser escrever tipos

[Environment]::SetEnvironmentVariable("Path", $env:Path + ";C:\bin", "Machine")

No prompt do PowerShell:

setx PATH "$env:path;\the\directory\to\add" -m

Você deve ver o texto:

SUCCESS: Specified value was saved.

Reinicie sua sessão e a variável estará disponível. setxtambém pode ser usado para definir variáveis ​​arbitrárias. Digite setx /?no prompt da documentação.

Antes de mexer com o caminho dessa maneira, salve uma cópia do caminho existente, fazendo isso $env:path >> a.outem um prompt do PowerShell.

Como a resposta de JeanT , eu queria uma abstração em torno de adicionar ao caminho. Diferentemente da resposta do JeanT, eu precisava que ele fosse executado sem a interação do usuário. Outro comportamento que eu estava procurando:

• Atualiza $env:Pathpara que a alteração entre em vigor na sessão atual
• Persiste na alteração da variável de ambiente para sessões futuras
• Não adiciona um caminho duplicado quando o mesmo caminho já existe

Caso seja útil, aqui está:

function Add-EnvPath {
    param(
        [Parameter(Mandatory=$true)]
        [string] $Path,

        [ValidateSet('Machine', 'User', 'Session')]
        [string] $Container = 'Session'
    )

    if ($Container -ne 'Session') {
        $containerMapping = @{
            Machine = [EnvironmentVariableTarget]::Machine
            User = [EnvironmentVariableTarget]::User
        }
        $containerType = $containerMapping[$Container]

        $persistedPaths = [Environment]::GetEnvironmentVariable('Path', $containerType) -split ';'
        if ($persistedPaths -notcontains $Path) {
            $persistedPaths = $persistedPaths + $Path | where { $_ }
            [Environment]::SetEnvironmentVariable('Path', $persistedPaths -join ';', $containerType)
        }
    }

    $envPaths = $env:Path -split ';'
    if ($envPaths -notcontains $Path) {
        $envPaths = $envPaths + $Path | where { $_ }
        $env:Path = $envPaths -join ';'
    }
}

Confira minha essência para a Remove-EnvPathfunção correspondente .

Embora a resposta aceita atualmente funcione no sentido de que a variável path é permanentemente atualizada no contexto do PowerShell, na verdade, ela não atualiza a variável de ambiente armazenada no registro do Windows.

Para conseguir isso, obviamente você também pode usar o PowerShell:

$oldPath=(Get-ItemProperty -Path 'Registry::HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\Session Manager\Environment' -Name PATH).Path

$newPath=$oldPath+’;C:\NewFolderToAddToTheList\’

Set-ItemProperty -Path 'Registry::HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\Session Manager\Environment' -Name PATH –Value $newPath

Mais informações estão na postagem do blog Use o PowerShell para modificar seu caminho ambiental

Se você usar extensões da comunidade do PowerShell, o comando apropriado para adicionar um caminho ao caminho da variável de ambiente é:

Add-PathVariable "C:\NewFolderToAddToTheList" -Target Machine

Todas as respostas que sugerem uma alteração permanente têm o mesmo problema: Eles quebram o valor do registro do caminho.

SetEnvironmentVariabletransforma o REG_EXPAND_SZvalor %SystemRoot%\system32 em um REG_SZvalor de C:\Windows\system32.

Quaisquer outras variáveis ​​no caminho também são perdidas. Adicionar novos usando %myNewPath%não funcionará mais.

Aqui está um script Set-PathVariable.ps1que eu uso para solucionar esse problema:

 [CmdletBinding(SupportsShouldProcess=$true)]
 param(
     [parameter(Mandatory=$true)]
     [string]$NewLocation)

 Begin
 {

 #requires –runasadministrator

     $regPath = "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"
     $hklm = [Microsoft.Win32.Registry]::LocalMachine

     Function GetOldPath()
     {
         $regKey = $hklm.OpenSubKey($regPath, $FALSE)
         $envpath = $regKey.GetValue("Path", "", [Microsoft.Win32.RegistryValueOptions]::DoNotExpandEnvironmentNames)
         return $envPath
     }
 }

 Process
 {
     # Win32API error codes
     $ERROR_SUCCESS = 0
     $ERROR_DUP_NAME = 34
     $ERROR_INVALID_DATA = 13

     $NewLocation = $NewLocation.Trim();

     If ($NewLocation -eq "" -or $NewLocation -eq $null)
     {
         Exit $ERROR_INVALID_DATA
     }

     [string]$oldPath = GetOldPath
     Write-Verbose "Old Path: $oldPath"

     # Check whether the new location is already in the path
     $parts = $oldPath.split(";")
     If ($parts -contains $NewLocation)
     {
         Write-Warning "The new location is already in the path"
         Exit $ERROR_DUP_NAME
     }

     # Build the new path, make sure we don't have double semicolons
     $newPath = $oldPath + ";" + $NewLocation
     $newPath = $newPath -replace ";;",""

     if ($pscmdlet.ShouldProcess("%Path%", "Add $NewLocation")){

         # Add to the current session
         $env:path += ";$NewLocation"

         # Save into registry
         $regKey = $hklm.OpenSubKey($regPath, $True)
         $regKey.SetValue("Path", $newPath, [Microsoft.Win32.RegistryValueKind]::ExpandString)
         Write-Output "The operation completed successfully."
     }

     Exit $ERROR_SUCCESS
 }

Eu explico o problema com mais detalhes em uma postagem no blog .

Isso define o caminho da sessão atual e solicita que o usuário a adicione permanentemente:

function Set-Path {
    param([string]$x)
    $Env:Path+= ";" +  $x
    Write-Output $Env:Path
    $write = Read-Host 'Set PATH permanently ? (yes|no)'
    if ($write -eq "yes")
    {
        [Environment]::SetEnvironmentVariable("Path",$env:Path, [System.EnvironmentVariableTarget]::User)
        Write-Output 'PATH updated'
    }
}

Você pode adicionar esta função ao seu perfil padrão ( Microsoft.PowerShell_profile.ps1), geralmente localizado em %USERPROFILE%\Documents\WindowsPowerShell.

Com base na resposta de @Michael Kropat, adicionei um parâmetro para preceder o novo caminho na PATHvariável existente e uma verificação para evitar a adição de um caminho inexistente:

function Add-EnvPath {
    param(
        [Parameter(Mandatory=$true)]
        [string] $Path,

        [ValidateSet('Machine', 'User', 'Session')]
        [string] $Container = 'Session',

        [Parameter(Mandatory=$False)]
        [Switch] $Prepend
    )

    if (Test-Path -path "$Path") {
        if ($Container -ne 'Session') {
            $containerMapping = @{
                Machine = [EnvironmentVariableTarget]::Machine
                User = [EnvironmentVariableTarget]::User
            }
            $containerType = $containerMapping[$Container]

            $persistedPaths = [Environment]::GetEnvironmentVariable('Path', $containerType) -split ';'
            if ($persistedPaths -notcontains $Path) {
                if ($Prepend) {
                    $persistedPaths = ,$Path + $persistedPaths | where { $_ }
                    [Environment]::SetEnvironmentVariable('Path', $persistedPaths -join ';', $containerType)
                }
                else {
                    $persistedPaths = $persistedPaths + $Path | where { $_ }
                    [Environment]::SetEnvironmentVariable('Path', $persistedPaths -join ';', $containerType)
                }
            }
        }

        $envPaths = $env:Path -split ';'
        if ($envPaths -notcontains $Path) {
            if ($Prepend) {
                $envPaths = ,$Path + $envPaths | where { $_ }
                $env:Path = $envPaths -join ';'
            }
            else {
                $envPaths = $envPaths + $Path | where { $_ }
                $env:Path = $envPaths -join ';'
            }
        }
    }
}

Como Jonathan Leaders mencionou aqui , é importante executar o comando / script elevado para poder alterar variáveis ​​de ambiente para 'machine' , mas a execução de alguns comandos elevados não precisa ser feita com as extensões da comunidade, então eu gostaria para modificar e estender a resposta de JeanT de uma maneira, essas variáveis ​​de máquina em mudança também podem ser executadas mesmo se o próprio script não for executado elevado:

function Set-Path ([string]$newPath, [bool]$permanent=$false, [bool]$forMachine=$false )
{
    $Env:Path += ";$newPath"

    $scope = if ($forMachine) { 'Machine' } else { 'User' }

    if ($permanent)
    {
        $command = "[Environment]::SetEnvironmentVariable('PATH', $env:Path, $scope)"
        Start-Process -FilePath powershell.exe -ArgumentList "-noprofile -command $Command" -Verb runas
    }

}

A maioria das respostas não está abordando o UAC . Isso cobre problemas de UAC.

Primeiro instale as extensões de comunidade do PowerShell: choco install pscxvia http://chocolatey.org/ (pode ser necessário reiniciar o ambiente do shell).

Em seguida, ative o pscx

Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser #allows scripts to run from the interwebs, such as pcsx

Então use Invoke-Elevated

Invoke-Elevated {Add-PathVariable $args[0] -Target Machine} -ArgumentList $MY_NEW_DIR

Minha sugestão é esta:

Eu testei isso para adicionar C:\oracle\x64\binà variável de ambiente Pathpermanentemente e isso funciona bem.

$ENV:PATH

A primeira maneira é simplesmente fazer:

$ENV:PATH=”$ENV:PATH;c:\path\to\folder”

Mas essa mudança não é permanente. $env:pathvoltará ao padrão anterior, assim que você fechar o terminal do PowerShell e reabri-lo novamente. Isso ocorre porque você aplicou a alteração no nível da sessão e não no nível de origem (que é o nível do registro). Para visualizar o valor global de $env:path, faça:

Get-ItemProperty -Path ‘Registry::HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\Session Manager\Environment’ -Name PATH

Ou mais especificamente:

(Get-ItemProperty -Path ‘Registry::HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\Session Manager\Environment’ -Name PATH).path

Agora, para mudar isso, primeiro capturamos o caminho original que precisa ser modificado:

$oldpath = (Get-ItemProperty -Path ‘Registry::HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\Session Manager\Environment’ -Name PATH).path

Agora, definimos como deve ser o novo caminho. Nesse caso, anexamos uma nova pasta:

$newpath = “$oldpath;c:\path\to\folder”

Nota: Certifique-se de que tenha a $newpathaparência que deseja. Caso contrário, você pode danificar seu sistema operacional.

Agora aplique o novo valor:

Set-ItemProperty -Path ‘Registry::HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\Session Manager\Environment’ -Name PATH -Value $newPath

Agora, faça uma verificação final da aparência que você espera:

(Get-ItemProperty -Path ‘Registry::HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\Session Manager\Environment’ -Name PATH).Path

Agora você pode reiniciar o terminal do PowerShell (ou até mesmo reiniciar o computador) e verificar se ele não reverte novamente para o valor antigo.

Observe que a ordem dos caminhos pode mudar, de modo que esteja em ordem alfabética; portanto, verifique a linha inteira. Para facilitar, você pode dividir a saída em linhas usando o ponto e vírgula como um delimitador:

($env:path).split(“;”)

Abra o PowerShell e execute:

[Environment]::SetEnvironmentVariable("PATH", "$ENV:PATH;<path to exe>", "USER")

No PowerShell, é possível navegar para o diretório de variáveis ​​de ambiente digitando:

Set-Location Env:

Isso o levará ao diretório Env:>. De dentro deste diretório:

Para ver todas as variáveis ​​de ambiente, digite:

Env:\> Get-ChildItem

Para ver uma variável de ambiente específica, digite:

Env:\> $Env:<variable name>, e.g. $Env:Path

Para definir uma variável de ambiente, digite:

Env:\> $Env:<variable name> = "<new-value>", e.g. $Env:Path="C:\Users\"

Para remover uma variável de ambiente, digite:

Env:\> remove-item Env:<variable name>, e.g. remove-item Env:SECRET_KEY

Mais informações estão em Sobre variáveis ​​de ambiente .

Tentei otimizar um pouco o código da SBF e do Michael para torná-lo mais compacto.

Estou confiando na coerção de tipos do PowerShell, na qual ele converte automaticamente as seqüências de caracteres em valores de enumeração, então não defini o dicionário de pesquisa.

Também retirei o bloco que adiciona o novo caminho à lista com base em uma condição, para que o trabalho seja feito uma vez e armazenado em uma variável para reutilização.

Em seguida, é aplicado permanentemente ou apenas na sessão, dependendo do $PathContainerparâmetro.

Podemos colocar o bloco de código em uma função ou em um arquivo ps1 que chamamos diretamente no prompt de comando. Eu fui com DevEnvAddPath.ps1.

param(
    [Parameter(Position=0,Mandatory=$true)][String]$PathChange,

    [ValidateSet('Machine', 'User', 'Session')]
    [Parameter(Position=1,Mandatory=$false)][String]$PathContainer='Session',
    [Parameter(Position=2,Mandatory=$false)][Boolean]$PathPrepend=$false
)

[String]$ConstructedEnvPath = switch ($PathContainer) { "Session"{${env:Path};} default{[Environment]::GetEnvironmentVariable('Path', $containerType);} };
$PathPersisted = $ConstructedEnvPath -split ';';

if ($PathPersisted -notcontains $PathChange) {
    $PathPersisted = $(switch ($PathPrepend) { $true{,$PathChange + $PathPersisted;} default{$PathPersisted + $PathChange;} }) | Where-Object { $_ };

    $ConstructedEnvPath = $PathPersisted -join ";";
}

if ($PathContainer -ne 'Session') 
{
    # Save permanently to Machine, User
    [Environment]::SetEnvironmentVariable("Path", $ConstructedEnvPath, $PathContainer);
}

# Update the current session
${env:Path} = $ConstructedEnvPath;

Eu faço algo semelhante para um DevEnvRemovePath.ps1.

param(
    [Parameter(Position=0,Mandatory=$true)][String]$PathChange,

    [ValidateSet('Machine', 'User', 'Session')]
    [Parameter(Position=1,Mandatory=$false)][String]$PathContainer='Session'
)

[String]$ConstructedEnvPath = switch ($PathContainer) { "Session"{${env:Path};} default{[Environment]::GetEnvironmentVariable('Path', $containerType);} };
$PathPersisted = $ConstructedEnvPath -split ';';

if ($PathPersisted -contains $PathChange) {
    $PathPersisted = $PathPersisted | Where-Object { $_ -ne $PathChange };

    $ConstructedEnvPath = $PathPersisted -join ";";
}

if ($PathContainer -ne 'Session') 
{
    # Save permanently to Machine, User
    [Environment]::SetEnvironmentVariable("Path", $ConstructedEnvPath, $PathContainer);
}

# Update the current session
${env:Path} = $ConstructedEnvPath;

Até agora, eles parecem funcionar.

Somente as respostas que colocam o valor no registro afetam uma alteração permanente (portanto, a maioria das respostas nesse segmento, incluindo a resposta aceita, não afeta permanentemente o Path).

A função a seguir funciona para os tipos Path/ PSModulePathe User/ System. Ele também adicionará o novo caminho à sessão atual por padrão.

function AddTo-Path {
    param ( 
        [string]$PathToAdd,
        [Parameter(Mandatory=$true)][ValidateSet('System','User')][string]$UserType,
        [Parameter(Mandatory=$true)][ValidateSet('Path','PSModulePath')][string]$PathType
    )

    # AddTo-Path "C:\XXX" "PSModulePath" 'System' 
    if ($UserType -eq "System" ) { $RegPropertyLocation = 'HKLM:\System\CurrentControlSet\Control\Session Manager\Environment' }
    if ($UserType -eq "User"   ) { $RegPropertyLocation = 'HKCU:\Environment' } # also note: Registry::HKEY_LOCAL_MACHINE\ format
    $PathOld = (Get-ItemProperty -Path $RegPropertyLocation -Name $PathType).$PathType
    "`n$UserType $PathType Before:`n$PathOld`n"
    $PathArray = $PathOld -Split ";" -replace "\\+$", ""
    if ($PathArray -notcontains $PathToAdd) {
        "$UserType $PathType Now:"   # ; sleep -Milliseconds 100   # Might need pause to prevent text being after Path output(!)
        $PathNew = "$PathOld;$PathToAdd"
        Set-ItemProperty -Path $RegPropertyLocation -Name $PathType -Value $PathNew
        Get-ItemProperty -Path $RegPropertyLocation -Name $PathType | select -ExpandProperty $PathType
        if ($PathType -eq "Path") { $env:Path += ";$PathToAdd" }                  # Add to Path also for this current session
        if ($PathType -eq "PSModulePath") { $env:PSModulePath += ";$PathToAdd" }  # Add to PSModulePath also for this current session
        "`n$PathToAdd has been added to the $UserType $PathType"
    }
    else {
        "'$PathToAdd' is already in the $UserType $PathType. Nothing to do."
    }
}

# Add "C:\XXX" to User Path (but only if not already present)
AddTo-Path "C:\XXX" "User" "Path"

# Just show the current status by putting an empty path
AddTo-Path "" "User" "Path"