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

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

Alors, quel est le meilleur moyen standard, de déterminer le répertoire du script courant? Actuellement, je suis en train de faire:

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

Je sais que dans les modules (.psm1), vous pouvez utiliser $PSScriptRoot pour obtenir cette information, mais cela ne veut pas mettre régulièrement à des scripts (c'est à dire .fichiers ps1).

Quelle est la manière canonique pour obtenir le courant de script PowerShell emplacement du fichier?

double possible de Comment puis-je obtenir de l'emplacement du système de fichiers d'un script powershell?

InformationsquelleAutor Aaron Jensen | 2011-03-28

powershell powershell-v2.0

749

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 a pas de meilleur moyen que d'interroger l'
MyInvocation.MyCommand.Definition propriété générale des scripts. J'ai eu l'
ligne suivante en haut de chaque script powershell j'ai eu:
```
$scriptPath = split-path -parent $MyInvocation.MyCommand.Definition
```
- Ce n' Split-Path utilisé pour ici?
- Split-Path est utilisé avec le -Parent paramètre pour revenir au répertoire courant sans le script en cours d'exécution du nom.
- Remarque: avec PowerShell sur Linux/macOS, votre script doit avoir un .ps1 extension pour PSScriptRoot/MyInvocation etc à être peuplée. Voir le rapport de bug ici: github.com/PowerShell/PowerShell/issues/4217
InformationsquelleAutor JaredPar
58

Si vous êtes à la création d'un V2 Module, vous pouvez utiliser une variable automatique appelé
$PSScriptRoot.

De PS > Aider automatic_variable
```
$PSScriptRoot 
Contient le répertoire à partir duquel le module de script est en cours d'exécution. 
Cette variable permet à des scripts à utiliser le chemin d'accès du module pour accéder à d'autres 
les ressources. 
```
- C'est ce que vous avez besoin dans PS 3.0: $PSCommandPath Contains the full path and file name of the script that is being run. This variable is valid in all scripts.
- Juste testé $PSScriptRoot et fonctionne comme prévu. Cependant, il vous donnera une chaîne vide si vous l'exécuter en ligne de commande. Il ne serait que de vous donner raison si elle est utilisée dans un script et le script est exécuté. C'est pourquoi il faut le faire .....
- Je suis confus. Cette réponse dit d'utiliser PSScriptRoot pour V2. Une autre réponse, dit PSScriptRoot pour le V3+, et d'utiliser quelque chose de différent pour v2.
- dans la v2 est seulement pour modules, si vous écrivez "normal" scripts qui ne sont pas dans un module que vous avez besoin de $MyInvocation.MyCommand.Définition, voir en haut de réponse.
- Aussi, $MyInvocation.InvocationName fonctionne pour scripts pour retourner à leur emplacement.
- Ce n'est pas vrai. Il fonctionne dans n'importe quel type de script PowerShell si l'interprète est à PowerShell 3.0. Il fonctionne dans tous mes .fichiers ps1. N'a pas à être défini comme un module.
- Je l'ai dit dans "v2" il a été défini que pour les modules. Vous dites que c'est défini en dehors de modules en v3. Je pense que nous sommes en train de dire la même chose. : )
- Pssh, qui utilise la v2. J'ai raté cette partie quand j'étais en train de lire. 🙂
InformationsquelleAutor Andy Schneider
30

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
}
```
- Mieux encore, utiliser $PSScriptRoot. C'est le courant du fichier/répertoire du module.
- Cette commande comprend le nom de fichier du script, qui m'a jeté jusqu'à ce que j'ai réalisé que. Lorsque vous êtes désireux chemin, vous ne voulez probablement pas le nom du script dans là aussi. Au moins, je ne peux pas penser à une raison pour laquelle vous voulez que. $PSScriptRoot ne pas inclure le nom de fichier (recueillies à partir d'autres réponses).
- Split-Path -Parent $PSCommandPath fait la job, merci
InformationsquelleAutor CodeMonkeyKing
14

Peut-être que je suis absent quelque chose ici... mais si vous voulez le présent répertoire de travail, vous pouvez utiliser seulement ceci: (Get-Location).Path pour une chaîne de caractères, ou Get-Location pour un objet.

Sauf si vous faites allusion à quelque chose comme cela, que je comprends, après la lecture de la question à nouveau.
```
function Get-Script-Directory
{
    $scriptInvocation = (Get-Variable MyInvocation -Scope 1).Value
    return Split-Path $scriptInvocation.MyCommand.Path
}
```
- Cette fonction retourne la position actuelle où l'utilisateur exécute le script. Pas l'emplacement du fichier de script lui-même.
- function Get-Script-Directory { $scriptInvocation = (Get-Variable MyInvocation -Scope 1).Value return Split-Path $scriptInvocation.MyCommand.Path } $hello = "hello" Write-Host (Get-Script-Directory) Write-Host $hello Enregistrer et exécuter à partir d'un autre répertoire. Vous allez montrer le chemin vers le script.
- C'est une bonne fonction, et fait ce dont j'ai besoin, mais comment puis-je le partager et l'utiliser dans tous mes scripts? C'est la poule et de l'œuf problème: je voudrais utiliser une fonction pour trouver ma position actuelle, mais j'ai besoin de mon emplacement pour charger la fonction.
- REMARQUE: Le invokation de cette fonction doit être au top niveau du script, si elle est imbriquée dans une autre fonction, alors vous devez changer la "Portée" de paramètre pour désigner la profondeur de la pile d'appel vous sont.
InformationsquelleAutor Sean C.
13

Pour Powershell 3+
```
function Get-ScriptDirectory {
    if ($psise) {Split-Path $psise.CurrentFile.FullPath}
    else {$global:PSScriptRoot}
}
```
J'ai placé cette fonction dans mon profil. Travaille dans ISE à l'aide de la touche F8/Exécuter Sélection de trop.
- Agréable de voir une solution qui fonctionne également en ISE
InformationsquelleAutor nickkzl
11

Très similaire à déjà posté des réponses, mais de la tuyauterie semble plus PS-comme.
```
$PSCommandPath | Split-Path -Parent
```
InformationsquelleAutor CPAR
10

- Je utiliser le variable automatique $ExecutionContext, il travaille à partir de PowerShell 2 et plus tard.
```
$ExecutionContext.SessionState.Path.GetUnresolvedProviderPathFromPSPath('.\')
```
$ExecutionContext
Contient un EngineIntrinsics objet qui représente l'
contexte d'exécution de l'hôte de Windows PowerShell. Vous pouvez
utilisez cette variable pour trouver de l'exécution des objets qui sont
disponible pour les applets de commande.
- C'est le seul qu'il a travaillé pour moi, en essayant de nourrir powershell à partir de STDIN.
- Cette solution fonctionne aussi correctement lorsque vous êtes dans un chemin d'accès UNC contexte.
- C'est apparemment ramasser le répertoire de travail, plutôt que là où se trouve le script ?
- Oui, c'est essentiellement le répertoire de travail actuel et ne fonctionnera pas lors de l'appel d'un script à partir d'un autre emplacement.
InformationsquelleAutor Viggos
7

J'ai besoin de savoir le nom du script et où il est en cours d'exécution à partir d'.

Ajoutant le préfixe "$global:" à la MyInvocation structure renvoie le chemin d'accès complet et le nom du script lorsqu'il est appelé à partir à la fois le script principal, et la ligne principale d'un importés .PSM1 fichier de bibliothèque. Il travaille aussi à partir de l'intérieur d'une fonction dans un importés de la bibliothèque.

Après beaucoup de bidouiller, je me suis installé sur l'utilisation de $global:MyInvocation.InvocationName.
Il fonctionne de manière fiable avec CMD lancer, Courir Avec Powershell, et de l'ISE.
À la fois locale et UNC lance retourner le chemin d'accès correct.
- Split-Path-Chemin $($global:MyInvocation.MyCommand.Chemin d'accès) travaillé parfaite grâce. Les autres solutions retourné le chemin d'accès de l'application appelante.
- Trivial remarque: dans ISE à l'appel de cette fonction à l'aide de la touche F8/Exécuter la Sélection sera le déclencheur d'une ParameterArgumentValidationErrorNullNotAllowed exception.
InformationsquelleAutor Bruce Gavin
7

M'a fallu un certain temps pour développer quelque chose qui a pris la accepté de répondre et l'a transformé en un solide fonction.

Ne savez pas sur les autres, mais je travaille dans un environnement avec des machines sur les deux PowerShell version 2 et 3 j'ai donc besoin de gérer à la fois. La fonction suivante offre un gracieux de secours:
```
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 renvoie le Script de la portée que la mère de la portée de l'énoncé par Michael Sorens dans son blog
- Merci! Le "$script:" est ce que j'ai besoin d'obtenir ce pour fonctionner dans Windows PowerShell ISE.
InformationsquelleAutor Bruno

J'utilise toujours ce petit extrait de code qui fonctionne pour Powershell ISE de la même façon:

# 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

InformationsquelleAutor Peter

2

Vous pouvez également envisager split-path -parent $psISE.CurrentFile.Fullpath si les autres méthodes échouent. En particulier, si vous exécutez un fichier à charger un tas de fonctions et ensuite de l'exécution de ces fonctions dans la société internationale d'ethnobiologie shell (ou si vous l'exécutez-sélectionné), il semble que le Get-Script-Directory fonction comme ci-dessus ne fonctionne pas.
- $PSCommandPath va travailler dans la société internationale d'ethnobiologie aussi longtemps que vous enregistrez le script et exécutez le fichier en entier. Sinon, vous n'êtes pas en train d'exécuter un script; vous êtes juste à "coller" les commandes dans le shell.
- Je pense que c'était mon objectif à la fois. Même si mon objectif n'est pas aligné avec celui d'origine, ce ne serait pas trop utile, sauf à l'occasion Googlers...
InformationsquelleAutor user2023266

Constaté que les anciennes solutions postées ici ne fonctionne pas pour moi sur PowerShell V5. Je suis venu avec cette:

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"

HTH

InformationsquelleAutor Quantium

-3

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

InformationsquelleAutor Ravi

Vous devez vous connecter pour publier un commentaire.