Qual é a melhor maneira de determinar o local do script atual do PowerShell?

Sempre que preciso fazer referência a um módulo ou script comum, gosto de usar caminhos relativos ao arquivo de script atual. Dessa forma, meu script sempre pode encontrar outros scripts na biblioteca.

Então, qual é a melhor maneira padrão de determinar o diretório do script atual? Atualmente, estou fazendo:

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

Eu sei nos módulos (.psm1) que você pode usar $PSScriptRootpara obter essas informações, mas isso não é definido em scripts regulares (arquivos .ps1).

Qual é a maneira canônica de obter a localização atual do arquivo de script do PowerShell?

PowerShell 3+

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

PowerShell 2

Antes do PowerShell 3, não havia uma maneira melhor do que consultar a MyInvocation.MyCommand.Definitionpropriedade para obter scripts gerais. Eu tinha a seguinte linha no topo de todos os scripts do PowerShell que eu tinha:

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

Se você estiver criando um módulo V2, poderá usar uma variável automática chamada $PSScriptRoot.

No PS> Ajuda automatic_variable

$ PSScriptRoot
       Contém o diretório a partir do qual o módulo de script está sendo executado.
       Essa variável permite que os scripts usem o caminho do módulo para acessar outros
       Recursos.

Para o 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.

A função é então:

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

Para o PowerShell 3+

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

Eu coloquei essa função no meu perfil. Também funciona no ISE usando F8/ Run Selection.

Talvez esteja faltando alguma coisa aqui ... mas se você quiser o diretório de trabalho atual, você pode simplesmente usar isso: (Get-Location).Pathpara uma string ouGet-Location para um objeto.

A menos que você esteja se referindo a algo assim, o que eu entendo depois de ler a pergunta novamente.

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

Muito semelhante às respostas já postadas, mas a tubulação parece mais com o PowerShell:

$PSCommandPath | Split-Path -Parent

Eu uso a variável automática $ExecutionContext . Ele funcionará no PowerShell 2 e posterior.

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

$ ExecutionContext Contém um objeto EngineIntrinsics que representa o contexto de execução do host do Windows PowerShell. Você pode usar essa variável para encontrar os objetos de execução disponíveis para os cmdlets.

Demorei um pouco para desenvolver algo que pegou a resposta aceita e a transformou em uma função robusta.

Não tenho certeza sobre os outros, mas trabalho em um ambiente com máquinas no PowerShell versão 2 e 3, portanto, precisava lidar com ambos. A função a seguir oferece um fallback 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
}

Isso também significa que a função se refere ao escopo do Script em vez do escopo dos pais, conforme descrito por Michael Sorens em uma de suas postagens no blog .

Eu precisava saber o nome do script e de onde ele está sendo executado.

Prefixar "$ global:" à estrutura MyInvocation retorna o caminho completo e o nome do script quando chamado do script principal e da linha principal de um arquivo de biblioteca .PSM1 importado. Também funciona de dentro de uma função em uma biblioteca importada.

Depois de muita discussão, decidi usar o $ global: MyInvocation.InvocationName. Funciona de forma confiável com o lançamento do CMD, Run With Powershell e o ISE. Lançamentos locais e UNC retornam o caminho correto.

Eu sempre uso esse pequeno trecho que funciona para o PowerShell e o ISE da mesma maneira:

# 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

Descobri que as soluções mais antigas postadas aqui não funcionavam para mim no PowerShell V5. Eu vim com isso:

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"

Você também pode considerar split-path -parent $psISE.CurrentFile.Fullpathse algum dos outros métodos falhar. Em particular, se você executar um arquivo para carregar um monte de funções e depois executá-las dentro do shell do ISE (ou se você executar selecionado), parece que a Get-Script-Directoryfunção como acima não funciona.

Usando trechos de todas essas respostas e comentários, montei isso para todos que virem essa pergunta no futuro. Abrange todas as situações listadas nas outras respostas

    # 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