Quelle est la meilleure façon de déterminer l'emplacement du script PowerShell actuel?

Chaque fois que j'ai besoin de référencer un module ou un script commun, j'aime utiliser des chemins relatifs au fichier de script actuel. De cette façon, mon script peut toujours trouver d'autres scripts dans la bibliothèque.

Alors, quelle est la meilleure façon standard de déterminer le répertoire du script actuel? Actuellement, je fais:

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

Je sais que dans les modules (.psm1), vous pouvez utiliser $PSScriptRootpour obtenir ces informations, mais cela n'est pas défini dans les scripts réguliers (c'est-à-dire les fichiers .ps1).

Quelle est la manière canonique d'obtenir l'emplacement du fichier de script PowerShell actuel?

PowerShell 3+

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

PowerShell 2

Avant PowerShell 3, il n'y avait pas de meilleur moyen que d'interroger la MyInvocation.MyCommand.Definitionpropriété pour des scripts généraux. J'avais la ligne suivante en haut de pratiquement tous les scripts PowerShell que j'avais:

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

Si vous créez un module V2, vous pouvez utiliser une variable automatique appelée $PSScriptRoot .

Depuis PS> Aide automatic_variable

$ PSScriptRoot
       Contient le répertoire à partir duquel le module de script est exécuté.
       Cette variable permet aux scripts d'utiliser le chemin du module pour accéder à d'autres
       Ressources.

Pour 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 fonction est alors:

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

Pour PowerShell 3+

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

J'ai placé cette fonction dans mon profil. Il fonctionne également dans ISE en utilisant F8/ Run Selection.

Peut-être que je manque quelque chose ici ... mais si vous voulez le répertoire de travail actuel, vous pouvez simplement l'utiliser: (Get-Location).Pathpour une chaîne ou Get-Locationpour un objet.

À moins que vous ne parliez de quelque chose comme ça, ce que je comprends après avoir relu la question.

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

Très similaire aux réponses déjà publiées, mais la tuyauterie semble plus proche de PowerShell:

$PSCommandPath | Split-Path -Parent

J'utilise la variable automatique $ExecutionContext . Cela fonctionnera à partir de PowerShell 2 et versions ultérieures.

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

$ ExecutionContext Contient un objet EngineIntrinsics qui représente le contexte d'exécution de l'hôte Windows PowerShell. Vous pouvez utiliser cette variable pour rechercher les objets d'exécution disponibles pour les applets de commande.

Il m'a fallu un certain temps pour développer quelque chose qui prenait la réponse acceptée et en faisait une fonction robuste.

Je ne suis pas sûr des autres, mais je travaille dans un environnement avec des machines sur PowerShell version 2 et 3, donc j'avais besoin de gérer les deux. La fonction suivante offre une solution de rechange élégante:

Function Get-PSScriptRoot
{
    $ScriptRoot = ""

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

    Write-Output $ScriptRoot
}

Cela signifie également que la fonction fait référence à la portée du script plutôt qu'à la portée du parent comme indiqué par Michael Sorens dans l'un de ses articles de blog .

J'avais besoin de connaître le nom du script et d'où il s'exécute.

Le préfixe «$ global:» à la structure MyInvocation renvoie le chemin d'accès complet et le nom du script lorsqu'il est appelé à la fois à partir du script principal et de la ligne principale d'un fichier de bibliothèque .PSM1 importé. Il fonctionne également à partir d'une fonction dans une bibliothèque importée.

Après avoir beaucoup tripoté, j'ai décidé d'utiliser $ global: MyInvocation.InvocationName. Il fonctionne de manière fiable avec le lancement de CMD, Run With Powershell et ISE. Les lancements locaux et UNC renvoient le chemin correct.

J'utilise toujours ce petit extrait qui fonctionne pour PowerShell et ISE de la même manière:

# 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

J'ai trouvé que les anciennes solutions publiées ici ne fonctionnaient pas pour moi sur PowerShell V5. Je suis venu avec ceci:

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"

Vous pouvez également considérer split-path -parent $psISE.CurrentFile.Fullpathsi l'une des autres méthodes échoue. En particulier, si vous exécutez un fichier pour charger un tas de fonctions, puis exécutez ces fonctions dans le shell ISE (ou si vous exécutez-sélectionné), il semble que la Get-Script-Directoryfonction comme ci-dessus ne fonctionne pas.

En utilisant des morceaux de toutes ces réponses et des commentaires, j'ai mis cela ensemble pour quiconque verra cette question à l'avenir. Il couvre toutes les situations énumérées dans les autres réponses

    # 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