Establecer variables de entorno de Windows PowerShell

Descubrí que establecer la variable de entorno PATH afecta solo al antiguo símbolo del sistema. PowerShell parece tener diferentes configuraciones de entorno. ¿Cómo cambio las variables de entorno para PowerShell (v1)?

Nota:

Quiero hacer que mis cambios sean permanentes, por lo que no tengo que configurarlo cada vez que ejecuto PowerShell. ¿PowerShell tiene un archivo de perfil? ¿Algo así como el perfil de Bash en Unix?

El cambio de las variables de entorno reales se puede hacer utilizando la env: namespace / driveinformación. Por ejemplo, este código actualizará la variable de entorno de ruta:

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

Hay formas de hacer que la configuración del entorno sea permanente, pero si solo las usa desde PowerShell, probablemente sea mucho mejor usar su perfil para iniciar la configuración. Al inicio, PowerShell ejecutará cualquier archivo .ps1 que encuentre en el WindowsPowerShelldirectorio bajo la carpeta Mis documentos. Por lo general, ya tiene un archivo profile.ps1 allí. El camino en mi computadora es

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

Si, en algún momento durante una sesión de PowerShell, necesita agregar temporalmente a la variable de entorno PATH, puede hacerlo de esta manera:

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

También puede modificar las variables de entorno del usuario / sistema de forma permanente (es decir, será persistente en los reinicios del shell) con lo siguiente:

Modificar una variable de entorno del sistema

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

Modificar una variable de entorno del usuario

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

Uso de comentarios: agregar a la variable de entorno del sistema

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

La solución basada en cadenas también es posible si no desea escribir tipos

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

Desde el indicador de PowerShell:

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

Entonces deberías ver el texto:

SUCCESS: Specified value was saved.

Reinicie su sesión, y la variable estará disponible. setxTambién se puede utilizar para establecer variables arbitrarias. Escriba setx /?en la solicitud de documentación.

Antes de jugar con su ruta de esta manera, asegúrese de guardar una copia de su ruta actual haciendo $env:path >> a.outen un indicador de PowerShell.

Al igual que la respuesta de JeanT , quería una abstracción en torno a agregar al camino. A diferencia de la respuesta de JeanT, la necesitaba para funcionar sin la interacción del usuario. Otro comportamiento que estaba buscando:

• Actualizaciones $env:Pathpara que el cambio surta efecto en la sesión actual
• Persiste el cambio de la variable de entorno para futuras sesiones.
• No agrega una ruta duplicada cuando ya existe la misma ruta

En caso de que sea útil, aquí 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 ';'
    }
}

Echa un vistazo a mi esencia para la Remove-EnvPathfunción correspondiente .

Aunque la respuesta aceptada actual funciona en el sentido de que la variable de ruta se actualiza permanentemente desde el contexto de PowerShell, en realidad no actualiza la variable de entorno almacenada en el registro de Windows.

Para lograr eso, obviamente también puede usar 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

Más información está en la publicación del blog Use PowerShell para modificar su ruta ambiental

Si usa extensiones de comunidad de PowerShell, el comando adecuado para agregar una ruta a la ruta de la variable de entorno es:

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

Todas las respuestas que sugieren un cambio permanente tienen el mismo problema: rompen el valor del registro de ruta.

SetEnvironmentVariableconvierte el REG_EXPAND_SZvalor %SystemRoot%\system32 en un REG_SZvalor deC:\Windows\system32 .

Cualquier otra variable en la ruta también se pierde. Agregar nuevos usando %myNewPath%ya no funcionará.

Aquí hay un script Set-PathVariable.ps1que utilizo para solucionar este 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
 }

Explico el problema con más detalle en una publicación de blog .

Esto establece la ruta para la sesión actual y solicita al usuario que la agregue 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'
    }
}

Puede agregar esta función a su perfil predeterminado, ( Microsoft.PowerShell_profile.ps1), generalmente ubicado en %USERPROFILE%\Documents\WindowsPowerShell.

Sobre la base de la respuesta de @Michael Kropat, agregué un parámetro para anteponer la nueva ruta a la PATHvariable existente y una comprobación para evitar la adición de una ruta no existente:

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 mencionó aquí , es importante ejecutar el comando / script elevado para poder cambiar las variables de entorno para 'máquina' , pero ejecutar algunos comandos elevados no tiene que hacerse con las Extensiones de comunidad, por lo que me gustaría para modificar y ampliar la respuesta de JeanT de una manera, que las variables de máquina de cambio también se pueden realizar incluso si el script en sí no se ejecuta 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
    }

}

La mayoría de las respuestas no se refieren a UAC . Esto cubre problemas de UAC.

Primero instale PowerShell Community Extensions: a choco install pscxtravés de http://chocolatey.org/ (puede que tenga que reiniciar su entorno de shell).

Luego habilite pscx

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

Luego usa Invoke-Elevated

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

Mi sugerencia es esta:

He probado esto para agregar C:\oracle\x64\bina la variable de entorno de forma Pathpermanente y esto funciona bien.

$ENV:PATH

La primera forma es simplemente hacer:

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

Pero este cambio no es permanente. $env:pathvolverá de forma predeterminada a lo que era antes tan pronto como cierre su terminal PowerShell y lo vuelva a abrir. Esto se debe a que ha aplicado el cambio a nivel de sesión y no a nivel de origen (que es el nivel de registro). Para ver el valor global de $env:path, haga:

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

O más específicamente:

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

Ahora para cambiar esto, primero capturamos la ruta original que necesita ser modificada:

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

Ahora definimos cómo debería ser la nueva ruta. En este caso estamos agregando una nueva carpeta:

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

Nota: asegúrese de que $newpath ve como quiere que se vea. De lo contrario, podría dañar su sistema operativo.

Ahora aplique el nuevo valor:

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

Ahora haga una comprobación final de que se ve como espera:

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

Ahora puede reiniciar su terminal PowerShell (o incluso reiniciar la máquina) y ver que no vuelva a su valor anterior.

Tenga en cuenta que el orden de las rutas puede cambiar para que esté en orden alfabético, así que asegúrese de verificar toda la línea. Para hacerlo más fácil, puede dividir la salida en filas utilizando el punto y coma como delimitador:

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

Abra PowerShell y ejecute:

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

Dentro de PowerShell, uno puede navegar al directorio de variables de entorno escribiendo:

Set-Location Env:

Esto lo llevará al directorio Env:>. Desde este directorio:

Para ver todas las variables de entorno, escriba:

Env:\> Get-ChildItem

Para ver una variable de entorno específica, escriba:

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

Para establecer una variable de entorno, escriba:

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

Para eliminar una variable de entorno, escriba:

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

Hay más información en Acerca de las variables de entorno .

Traté de optimizar un poco el código de SBF y Michael para hacerlo más compacto.

Confío en la coerción de tipo de PowerShell, donde convierte automáticamente las cadenas en valores de enumeración, por lo que no definí el diccionario de búsqueda.

También saqué el bloque que agrega la nueva ruta a la lista en función de una condición, de modo que el trabajo se realiza una vez y se almacena en una variable para su reutilización.

Luego se aplica de forma permanente o solo a la sesión dependiendo de la $PathContainer parámetro.

Podemos poner el bloque de código en una función o un archivo ps1 que llamamos directamente desde el símbolo del sistema. Fui con 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;

Hago algo similar para un 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;

Hasta ahora, parecen funcionar.

Solo las respuestas que introducen el valor en el registro afectan un cambio permanente (por lo que la mayoría de las respuestas en este hilo, incluida la respuesta aceptada, no afectan permanentemente Path).

La siguiente función funciona tanto para Path/ PSModulePathcomo para User/ Systemtipos. También agregará la nueva ruta a la sesión actual de forma predeterminada.

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"