Qual è il modo migliore per determinare la posizione dell'attuale script PowerShell?

Ogni volta che ho bisogno di fare riferimento a un modulo o uno script comune, mi piace usare i percorsi relativi al file di script corrente. In questo modo, il mio script può sempre trovare altri script nella libreria.

Quindi, qual è il modo migliore e standard per determinare la directory dello script corrente? Attualmente sto facendo:

$MyDir = [System.IO.Path]::GetDirectoryName($myInvocation.MyCommand.Definition)

So che nei moduli (.psm1) è possibile utilizzare $PSScriptRootper ottenere queste informazioni, ma ciò non viene impostato negli script regolari (ad es. File .ps1).

Qual è il modo canonico per ottenere la posizione corrente del file di script di PowerShell?

PowerShell 3+

# This is an automatic variable set to the current file's/module's directory
$PSScriptRoot

PowerShell 2

Prima di PowerShell 3, non c'era modo migliore di interrogare la MyInvocation.MyCommand.Definitionproprietà per gli script generali. Ho avuto la seguente riga in cima a ogni script PowerShell che avevo:

$scriptPath = split-path -parent $MyInvocation.MyCommand.Definition

Se stai creando un modulo V2, puoi utilizzare una variabile automatica chiamata $PSScriptRoot.

Da PS> Aiuto automatic_variable

$ PSScriptRoot
       Contiene la directory da cui viene eseguito il modulo di script.
       Questa variabile consente agli script di utilizzare il percorso del modulo per accedere ad altri
       risorse.

Per PowerShell 3.0

$PSCommandPath
    Contains the full path and file name of the script that is being run. 
    This variable is valid in all scripts.

La funzione è quindi:

function Get-ScriptDirectory {
    Split-Path -Parent $PSCommandPath
}

Per PowerShell 3+

function Get-ScriptDirectory {
    if ($psise) {
        Split-Path $psise.CurrentFile.FullPath
    }
    else {
        $global:PSScriptRoot
    }
}

Ho inserito questa funzione nel mio profilo. Funziona in ISE anche usando F8/ Esegui selezione.

Forse mi manca qualcosa qui ... ma se vuoi l'attuale directory di lavoro puoi semplicemente usare questo: (Get-Location).Pathper una stringa o Get-Locationper un oggetto.

A meno che non ti riferisca a qualcosa del genere, che capisco dopo aver letto di nuovo la domanda.

function Get-Script-Directory
{
    $scriptInvocation = (Get-Variable MyInvocation -Scope 1).Value
    return Split-Path $scriptInvocation.MyCommand.Path
}

Molto simile alle risposte già pubblicate, ma il piping sembra più simile a PowerShell:

$PSCommandPath | Split-Path -Parent

Uso la variabile automatica $ExecutionContext . Funzionerà da PowerShell 2 e versioni successive.

 $ExecutionContext.SessionState.Path.GetUnresolvedProviderPathFromPSPath('.\')

$ ExecutionContext Contiene un oggetto EngineIntrinsics che rappresenta il contesto di esecuzione dell'host Windows PowerShell. È possibile utilizzare questa variabile per trovare gli oggetti di esecuzione disponibili per i cmdlet.

Mi ci è voluto un po 'di tempo per sviluppare qualcosa che prendesse la risposta accettata e la trasformasse in una solida funzione.

Non sono sicuro degli altri, ma lavoro in un ambiente con macchine sia su PowerShell versione 2 che 3, quindi dovevo gestirle entrambe. La seguente funzione offre un grazioso fallback:

Function Get-PSScriptRoot
{
    $ScriptRoot = ""

    Try
    {
        $ScriptRoot = Get-Variable -Name PSScriptRoot -ValueOnly -ErrorAction Stop
    }
    Catch
    {
        $ScriptRoot = Split-Path $script:MyInvocation.MyCommand.Path
    }

    Write-Output $ScriptRoot
}

Significa anche che la funzione si riferisce all'ambito dello script piuttosto che all'ambito del genitore, come sottolineato da Michael Sorens in uno dei suoi post sul blog .

Avevo bisogno di sapere il nome dello script e da dove viene eseguito.

Il prefisso "$ global:" alla struttura MyInvocation restituisce il percorso completo e il nome dello script quando viene chiamato sia dallo script principale sia dalla riga principale di un file di libreria .PSM1 importato. Funziona anche all'interno di una funzione in una libreria importata.

Dopo aver giocato molto, ho deciso di usare $ global: MyInvocation.InvocationName. Funziona in modo affidabile con il lancio di CMD, Run With Powershell e ISE. Sia i lanci locali che UNC restituiscono il percorso corretto.

Uso sempre questo piccolo frammento che funziona per PowerShell e ISE allo stesso modo:

# Set active path to script-location:
$path = $MyInvocation.MyCommand.Path
if (!$path) {
    $path = $psISE.CurrentFile.Fullpath
}
if ($path) {
    $path = Split-Path $path -Parent
}
Set-Location $path

Ho scoperto che le soluzioni precedenti pubblicate qui non funzionavano per me su PowerShell V5. Ho pensato a questo:

try {
    $scriptPath = $PSScriptRoot
    if (!$scriptPath)
    {
        if ($psISE)
        {
            $scriptPath = Split-Path -Parent -Path $psISE.CurrentFile.FullPath
        }
        else {
            Write-Host -ForegroundColor Red "Cannot resolve script file's path"
            exit 1
        }
    }
}
catch {
    Write-Host -ForegroundColor Red "Caught Exception: $($Error[0].Exception.Message)"
    exit 2
}

Write-Host "Path: $scriptPath"

Potresti anche considerare split-path -parent $psISE.CurrentFile.Fullpathse uno degli altri metodi fallisce. In particolare, se si esegue un file per caricare un mucchio di funzioni e quindi si eseguono tali funzioni all'interno della shell ISE (o se si è selezionate in modo corretto), la Get-Script-Directoryfunzione come sopra non funziona.

Usando pezzi di tutte queste risposte e commenti, ho messo questo insieme per chiunque veda questa domanda in futuro. Copre tutte le situazioni elencate nelle altre risposte

    # If using ISE
    if ($psISE) {
        $ScriptPath = Split-Path -Parent $psISE.CurrentFile.FullPath
    # If Using PowerShell 3 or greater
    } elseif($PSVersionTable.PSVersion.Major -gt 3) {
        $ScriptPath = $PSScriptRoot
    # If using PowerShell 2 or lower
    } else {
        $ScriptPath = split-path -parent $MyInvocation.MyCommand.Path
    }

function func1() 
{
   $inv = (Get-Variable MyInvocation -Scope 1).Value
   #$inv.MyCommand | Format-List *   
   $Path1 = Split-Path $inv.scriptname
   Write-Host $Path1
}

function Main()
{
    func1
}

Main