Impostazione delle variabili di ambiente di Windows PowerShell

Ho scoperto che l'impostazione della variabile di ambiente PATH influisce solo sul vecchio prompt dei comandi. PowerShell sembra avere impostazioni di ambiente diverse. Come posso modificare le variabili di ambiente per PowerShell (v1)?

Nota:

Voglio rendere permanenti le mie modifiche, quindi non devo impostarle ogni volta che eseguo PowerShell. PowerShell ha un file di profilo? Qualcosa come il profilo Bash su Unix?

La modifica delle variabili di ambiente effettive può essere effettuata utilizzando le env: namespace / driveinformazioni. Ad esempio, questo codice aggiornerà la variabile di ambiente del percorso:

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

Esistono modi per rendere permanenti le impostazioni dell'ambiente, ma se le si utilizza solo da PowerShell, è probabilmente molto meglio utilizzare il proprio profilo per avviare le impostazioni. All'avvio, PowerShell eseguirà tutti i file .ps1 che trova nella WindowsPowerShelldirectory nella cartella Documenti. In genere hai già un file profile.ps1 . Il percorso sul mio computer è

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

Se, durante una sessione di PowerShell, è necessario aggiungere temporaneamente la variabile di ambiente PATH, è possibile farlo in questo modo:

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

È inoltre possibile modificare le variabili di ambiente utente / sistema in modo permanente (ovvero sarà persistente tra i riavvii della shell) con quanto segue:

Modifica una variabile di ambiente di sistema

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

Modifica una variabile di ambiente utente

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

Utilizzo dai commenti: aggiungere alla variabile di ambiente di sistema

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

La soluzione basata su stringhe è anche possibile se non si desidera scrivere tipi

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

Dal prompt di PowerShell:

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

Dovresti quindi vedere il testo:

SUCCESS: Specified value was saved.

Riavvia la sessione e la variabile sarà disponibile. setxpuò anche essere usato per impostare variabili arbitrarie. Digitare setx /?al prompt per la documentazione.

Prima di fare confusione con il tuo percorso in questo modo, assicurati di salvare una copia del tuo percorso esistente eseguendo $env:path >> a.outun prompt di PowerShell.

Come la risposta di JeanT , volevo un'astrazione per aggiungere al percorso. A differenza della risposta di JeanT, ne avevo bisogno per funzionare senza l'interazione dell'utente. Altro comportamento che stavo cercando:

• Si aggiorna in $env:Pathmodo che la modifica abbia effetto nella sessione corrente
• Persiste la modifica della variabile di ambiente per sessioni future
• Non aggiunge un percorso duplicato quando esiste già lo stesso percorso

Nel caso sia utile, eccolo qui:

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 ';'
    }
}

Dai un'occhiata alla mia idea per la Remove-EnvPathfunzione corrispondente .

Sebbene l'attuale risposta accettata funzioni nel senso che la variabile path viene costantemente aggiornata dal contesto di PowerShell, in realtà non aggiorna la variabile d'ambiente memorizzata nel registro di Windows.

Per farlo, puoi ovviamente usare anche 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

Ulteriori informazioni sono nel post del blog Utilizzare PowerShell per modificare il percorso ambientale

Se si utilizzano le estensioni della comunità PowerShell, il comando corretto per aggiungere un percorso al percorso della variabile di ambiente è:

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

Tutte le risposte che suggeriscono una modifica permanente presentano lo stesso problema: interrompono il valore di registro del percorso.

SetEnvironmentVariabletrasforma il REG_EXPAND_SZvalore %SystemRoot%\system32 in un REG_SZvalore di C:\Windows\system32.

Anche tutte le altre variabili nel percorso vengono perse. L'aggiunta di nuovi utilizzando %myNewPath%non funzionerà più.

Ecco uno script Set-PathVariable.ps1che utilizzo per risolvere questo 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
 }

Spiego il problema in modo più dettagliato in un post sul blog .

Questo imposta il percorso per la sessione corrente e richiede all'utente di aggiungerlo 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'
    }
}

Puoi aggiungere questa funzione al tuo profilo predefinito, ( Microsoft.PowerShell_profile.ps1), generalmente situato in %USERPROFILE%\Documents\WindowsPowerShell.

Sulla base della risposta di @Michael Kropat ho aggiunto un parametro per anteporre il nuovo percorso alla PATHvariabile esistente e un controllo per evitare l'aggiunta di un percorso inesistente:

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 ';'
            }
        }
    }
}

Come Jonathan Leaders ha menzionato qui , è importante eseguire il comando / script elevato per poter modificare le variabili di ambiente per "macchina" , ma l'esecuzione di alcuni comandi elevati non deve essere eseguita con le estensioni della comunità, quindi mi piacerebbe per modificare ed estendere la risposta di JeanT in un modo, anche il cambiamento delle variabili macchina può essere eseguito anche se lo script stesso non viene eseguito in modo elevato:

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 maggior parte delle risposte non riguarda il controllo dell'account utente . Questo riguarda i problemi di controllo dell'account utente.

Prima installa le estensioni della community di PowerShell: choco install pscxtramite http://chocolatey.org/ (potrebbe essere necessario riavviare l'ambiente della shell).

Quindi abilitare pscx

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

Quindi utilizzare Invoke-Elevated

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

Il mio suggerimento è questo:

Ho provato questo per aggiungere permanentemente C:\oracle\x64\binalla variabile d'ambiente Pathe questo funziona bene.

$ENV:PATH

Il primo modo è semplicemente fare:

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

Ma questo cambiamento non è permanente. $env:pathtornerà automaticamente a quello che era prima non appena chiudi il tuo terminale PowerShell e lo riapri di nuovo. Questo perché hai applicato la modifica a livello di sessione e non a livello di origine (che è il livello di registro). Per visualizzare il valore globale di $env:path, eseguire:

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

O più precisamente:

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

Ora per cambiare questo, prima catturiamo il percorso originale che deve essere modificato:

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

Ora definiamo come dovrebbe apparire il nuovo percorso. In questo caso stiamo aggiungendo una nuova cartella:

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

Nota: assicurati che l' $newpathaspetto sia come desideri. Altrimenti, potresti danneggiare il tuo sistema operativo.

Ora applica il nuovo valore:

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

Ora fai un controllo finale che assomigli a come ti aspetti che:

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

Ora puoi riavviare il tuo terminale PowerShell (o persino riavviare il computer) e vedere che non ripristina nuovamente il suo vecchio valore.

Nota che l'ordine dei percorsi può cambiare in modo che sia in ordine alfabetico, quindi assicurati di controllare l'intera linea. Per semplificare, puoi dividere l'output in righe usando i punti e virgola come delimitatore:

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

Apri PowerShell ed esegui:

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

All'interno di PowerShell, è possibile accedere alla directory delle variabili di ambiente digitando:

Set-Location Env:

Questo ti porterà alla directory Env:>. Da questa directory:

Per vedere tutte le variabili di ambiente, digitare:

Env:\> Get-ChildItem

Per visualizzare una variabile di ambiente specifica, digitare:

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

Per impostare una variabile di ambiente, digitare:

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

Per rimuovere una variabile di ambiente, digitare:

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

Ulteriori informazioni sono disponibili in Informazioni sulle variabili di ambiente .

Ho cercato di ottimizzare un po ' il codice SBF e Michael per renderlo più compatto.

Mi affido alla coercizione del tipo di PowerShell in cui converte automaticamente le stringhe in valori di enum, quindi non ho definito il dizionario di ricerca.

Ho anche estratto il blocco che aggiunge il nuovo percorso all'elenco in base a una condizione, in modo che il lavoro venga svolto una volta e memorizzato in una variabile per il riutilizzo.

Viene quindi applicato in modo permanente o solo alla sessione in base al $PathContainerparametro.

Possiamo inserire il blocco di codice in una funzione o in un file ps1 che chiamiamo direttamente dal prompt dei comandi. Sono andato 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;

Faccio qualcosa di simile per 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;

Finora sembrano funzionare.

Solo le risposte che inseriscono il valore nel registro influiscono su una modifica permanente (quindi la maggior parte delle risposte su questo thread, inclusa la risposta accettata, non influisce in modo permanente su Path).

La seguente funzione funziona sia per Path/ PSModulePathche per User/ Systemtipi. Aggiungerà inoltre il nuovo percorso alla sessione corrente per impostazione predefinita.

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"