¿Cuál es la mejor manera de determinar la ubicación del script actual de PowerShell?

Siempre que necesito hacer referencia a un módulo o script común, me gusta usar rutas relativas al archivo de script actual. De esa manera, mi script siempre puede encontrar otros scripts en la biblioteca.

Entonces, ¿cuál es la mejor forma estándar de determinar el directorio del script actual? Actualmente estoy haciendo:

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

Sé que en los módulos (.psm1) puede usar $PSScriptRootpara obtener esta información, pero eso no se configura en scripts normales (es decir, archivos .ps1).

¿Cuál es la forma canónica de obtener la ubicación actual del archivo de script de PowerShell?

PowerShell 3+

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

PowerShell 2

Antes de PowerShell 3, no había una mejor manera que consultar la MyInvocation.MyCommand.Definitionpropiedad en busca de scripts generales. Tenía la siguiente línea en la parte superior de esencialmente cada script de PowerShell que tenía:

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

Si está creando un módulo V2, puede usar una variable automática llamada $PSScriptRoot.

Desde PS> Ayuda automatic_variable

$ PSScriptRoot
       Contiene el directorio desde el que se ejecuta el módulo de script.
       Esta variable permite que los scripts utilicen la ruta del módulo para acceder a otros
       recursos

Para 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 función es entonces:

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

Para PowerShell 3+

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

He puesto esta función en mi perfil. Funciona en ISE usando F8/ Ejecutar selección también.

Tal vez me falta algo aquí ... pero si quieres el directorio de trabajo actual, puedes usar esto: (Get-Location).Pathpara una cadena o Get-Locationpara un objeto.

A menos que se refiera a algo como esto, lo entiendo después de leer la pregunta nuevamente.

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

Muy similar a las respuestas ya publicadas, pero las tuberías parecen más como PowerShell:

$PSCommandPath | Split-Path -Parent

Yo uso la variable automática $ExecutionContext . Funcionará desde PowerShell 2 y versiones posteriores.

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

$ ExecutionContext Contiene un objeto EngineIntrinsics que representa el contexto de ejecución del host de Windows PowerShell. Puede usar esta variable para buscar los objetos de ejecución que están disponibles para los cmdlets.

Me llevó un tiempo desarrollar algo que tomara la respuesta aceptada y la convirtiera en una función robusta.

No estoy seguro acerca de los demás, pero trabajo en un entorno con máquinas en PowerShell versión 2 y 3, por lo que necesitaba manejar ambos. La siguiente función ofrece un retroceso elegante:

Function Get-PSScriptRoot
{
    $ScriptRoot = ""

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

    Write-Output $ScriptRoot
}

También significa que la función se refiere al alcance del Script en lugar del alcance de los padres como lo describe Michael Sorens en una de sus publicaciones de blog .

Necesitaba saber el nombre del script y desde dónde se está ejecutando.

El prefijo "$ global:" a la estructura MyInvocation devuelve la ruta completa y el nombre del script cuando se llama desde el script principal y la línea principal de un archivo de biblioteca .PSM1 importado. También funciona desde una función en una biblioteca importada.

Después de mucho jugar, decidí usar $ global: MyInvocation.InvocationName. Funciona de manera confiable con el lanzamiento de CMD, Run With Powershell e ISE. Tanto los lanzamientos locales como UNC devuelven la ruta correcta.

Siempre uso este pequeño fragmento que funciona para PowerShell e ISE de la misma manera:

# 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

Descubrí que las soluciones más antiguas publicadas aquí no me funcionaron en PowerShell V5. Se me ocurrió esto:

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"

También puede considerar split-path -parent $psISE.CurrentFile.Fullpathsi alguno de los otros métodos falla. En particular, si ejecuta un archivo para cargar un montón de funciones y luego ejecuta esas funciones dentro del shell ISE (o si seleccionó la ejecución), parece que la Get-Script-Directoryfunción como la anterior no funciona.

Utilizando las piezas de todas estas respuestas y los comentarios, preparé esto para cualquiera que vea esta pregunta en el futuro. Cubre todas las situaciones enumeradas en las otras respuestas.

    # 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