Definindo variáveis ​​de ambiente do Windows PowerShell

608

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?

Vasil
fonte
1
Eu gostaria de ter um perfil central localizado em um compartilhamento de arquivo. Sincronização é uma dor. Criando um perfil de stub com. \\ computador \ compartilhamento \ caminho \ Profile.ps1 parece um erro (tente o Notepad $ Profile). Seria bom se houvesse uma maneira de alterar permanentemente a variável automática $ Profile.
Nathan Hartley
5
Não, o ambiente PATH também afeta o prompt de comando do powershell. O que difere, porém, é que o PowerShell não aceita caminhos entre aspas. Solução: remover todas as citações que encerram ( ") na variável de ambiente do caminho
Nilzor
3
SE VOCÊ ESTÁ AQUI PARA PS> v1 ... Seguindo o comentário de Nilzor acima: Use isso para remover todos os "caminhos de variáveis ​​de ambiente PATH da sua sessão:$($Env:PATH).Split(';') | %{ $str += "$($_.Trim('"'));" }; $Env:PATH=$str
d3r3kk

Respostas:

479

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
JaredPar
fonte
38
$ profile é uma variável automática que aponta para o seu perfil de usuário para todos os hosts do PowerShell.
JasonMArcher
16
Observe que (caminho dividido $ profile) (para obter a pasta que contém) pode conter vários arquivos de perfil: profile.ps1 deve ser carregado por todos os hosts, <host-name> _profile.ps1 apenas pelo host especificado. Para o PowerShell.exe (host do console), este é Microsoft.PowerShell_profile.ps1.
Richard Richard
10
E se eu não tiver uma pasta WindowsPowerShell nos meus documentos? Devo criar a pasta e o arquivo? O que devo colocar no arquivo se quiser adicionar C:\path\to\file.extàs variáveis ​​de ambiente? EDIT: já encontrou. A resposta é sim, crie-a. O arquivo deve consistir de 1 linha: $env:path += ;C:\path\to\file.ext".
Lewistrick
7
@Lewistrick Você não tem um perfil por padrão. Eu segui as instruções para criar um: howtogeek.com/50236/customizing-your-powershell-profile
MikeB
16
Tenha cuidado ao fazer isso - ele irá atrapalhar seu caminho existente. $env:Path = "SomeRandomPath"; Em vez disso, consulte @mloskot, abaixo.
John Mark
626

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"
mloskot
fonte
4
+1 :: Este one-liner é bastante eficaz para invocações com base em sessões, como ... IE $ env: PATH + = "; c: \ MinGW \ msys \ 1.0 \ bin" ^ {alguns bin mingw ... }
Eddie B
2
e como faço para remover um caminho?
Becko
11
Se você precisa de seu caminho para ser chamado antes que um padrão, inseri-lo no início $env:Path = "C:\MyPath;$env:Path"
Michael Freidgeim
4
**** Não esqueça o ponto-e-vírgula no início da string anexada, como visto no comentário de @Kevin. Isso é bastante óbvio, mas pode ser esquecido se você simplesmente copiar / colar o código na resposta e não tiver um ponto-e-vírgula no final do caminho existente. Vou tentar enviar uma edição.
Matt Goodrich
1
@MattGoodrich Já fiz o rollback para a revisão anterior
Cœur
278

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")
hoge
fonte
6
Isso é muito útil para sistemas de acesso restrito.
H0tw1r3
14
@AndresRiofrio, Sim, isso é permanente. Uso: [Environment]::SetEnvironmentVariable("Path", $env:Path + ";C:\bin", [EnvironmentVariableTartget::Machine) Você não verá o resultado dessa alteração até iniciar uma nova sessão do PowerShell. Ou seja, se você inspecionar $ env: Path imediatamente após executar este comando, verá o que $ env: Path estava antes do comando. Para atualizar, feche e abra o shell ou inicie uma nova sessão.
FLGMwt
7
@FLGMwt você tem um erro de digitação, correta é: [Ambiente] :: SetEnvironmentVariable ( "Path", $ env: Caminho + "; C: \ bin", [EnvironmentVariableTarget] :: Machine)
enthus1ast
10
Você pode escrever a seqüência de caracteres "Máquina" ou "Usuário" em vez de toda a enumeração do .NET. De Technet .
bouvierr
3
Eu acho que essa resposta também deve demonstrar o uso para definir variáveis ​​de usuário, assim[Environment]::SetEnvironmentVariable("Path", [Environment]::GetEnvironmentVariable("Path", "User") + ";C:\bin", "User")
Saito
63

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.

tjb
fonte
5
Parece funcionar apenas quando 'executando como administrador' e, em seguida, entra em vigor apenas para 'executando como administrador' nos consoles do PowerShell, e não nos que executam regularmente.
matanster
12
Ai - acabei de ser atingido pelo limite de 1024 caracteres do setx; felizmente, segui o conselho para registrar o valor existente de $ end: Path. Apenas algo a ter em atenção: superuser.com/questions/387619/…
Jonno
3
Por que não definir $env:PATHprimeiro e depois setx /m PATH "$env:PATH"aplicar local e globalmente sem a reinicialização do shell?
tresf 9/02/19
1
Agradável! Embora setx não seja um cmdlet nativo, ainda é uma alternativa muito melhor e facilmente esquecida para as chamadas desagradáveis ​​e cansativas do .NET Framework! É desconcertante que mesmo o Powershell 7 ainda não tenha um cmdlet oficial para persistir os envvars. O que. Parece um recurso que deve ter paridade com 'ls'.
Jonas
27

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 .

Michael Kropat
fonte
16

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
gijswijs
fonte
12

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 .

Peter Hahndorf
fonte
Deve ser: $ newPath = $ newPath -replace ";;", ";" ?
Joe Johnston
8

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.

JeanT
fonte
6

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 ';'
            }
        }
    }
}
SBF
fonte
5

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
    }

}
Mehrdad Mirreza
fonte
5

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
Jonathan
fonte
4

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(“;”)
ali Darabi
fonte
3

Abra o PowerShell e execute:

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

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 .

Paul Maurer
fonte
0

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.

Eniola
fonte
0

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"
YorSubs
fonte