Observação: PowerShell 1.0
, gostaria de obter o nome do arquivo PowerShell em execução no momento. Ou seja, se eu começar minha sessão assim:

powershell.exe .\myfile.ps1

Eu gostaria de obter a string ". \ Myfile.ps1" (ou algo parecido). EDIT : "myfile.ps1" é preferível.
Alguma ideia?

Tentei resumir as várias respostas aqui, atualizadas para PowerShell 5:

• Se você estiver usando apenas PowerShell 3 ou superior, use $PSCommandPath

• Se quiser compatibilidade com versões mais antigas, insira o calço:

  if ($PSCommandPath -eq $null) { function GetPSCommandPath() { return $MyInvocation.PSCommandPath; } $PSCommandPath = GetPSCommandPath; }

  Isso adiciona $PSCommandPathse ainda não existir.

  O código do shim pode ser executado em qualquer lugar (nível superior ou dentro de uma função), embora a $PSCommandPathvariável esteja sujeita às regras normais de escopo (por exemplo, se você colocar o shim em uma função, a variável terá o escopo apenas dessa função).

Detalhes

Existem 4 métodos diferentes usados ​​em várias respostas, então escrevi este script para demonstrar cada um (mais $PSCommandPath):

function PSCommandPath() { return $PSCommandPath; }
function ScriptName() { return $MyInvocation.ScriptName; }
function MyCommandName() { return $MyInvocation.MyCommand.Name; }
function MyCommandDefinition() {
    # Begin of MyCommandDefinition()
    # Note: ouput of this script shows the contents of this function, not the execution result
    return $MyInvocation.MyCommand.Definition;
    # End of MyCommandDefinition()
}
function MyInvocationPSCommandPath() { return $MyInvocation.PSCommandPath; }

Write-Host "";
Write-Host "PSVersion: $($PSVersionTable.PSVersion)";
Write-Host "";
Write-Host "`$PSCommandPath:";
Write-Host " *   Direct: $PSCommandPath";
Write-Host " * Function: $(ScriptName)";
Write-Host "";
Write-Host "`$MyInvocation.ScriptName:";
Write-Host " *   Direct: $($MyInvocation.ScriptName)";
Write-Host " * Function: $(ScriptName)";
Write-Host "";
Write-Host "`$MyInvocation.MyCommand.Name:";
Write-Host " *   Direct: $($MyInvocation.MyCommand.Name)";
Write-Host " * Function: $(MyCommandName)";
Write-Host "";
Write-Host "`$MyInvocation.MyCommand.Definition:";
Write-Host " *   Direct: $($MyInvocation.MyCommand.Definition)";
Write-Host " * Function: $(MyCommandDefinition)";
Write-Host "";
Write-Host "`$MyInvocation.PSCommandPath:";
Write-Host " *   Direct: $($MyInvocation.PSCommandPath)";
Write-Host " * Function: $(MyInvocationPSCommandPath)";
Write-Host "";

Resultado:

PS C:\> .\Test\test.ps1

PSVersion: 5.1.19035.1

$PSCommandPath:
 *   Direct: C:\Test\test.ps1
 * Function: C:\Test\test.ps1

$MyInvocation.ScriptName:
 *   Direct:
 * Function: C:\Test\test.ps1

$MyInvocation.MyCommand.Name:
 *   Direct: test.ps1
 * Function: MyCommandName

$MyInvocation.MyCommand.Definition:
 *   Direct: C:\Test\test.ps1
 * Function:
    # Begin of MyCommandDefinition()
    # Note this is the contents of the MyCommandDefinition() function, not the execution results
    return $MyInvocation.MyCommand.Definition;
    # End of MyCommandDefinition()


$MyInvocation.PSCommandPath:
 *   Direct:
 * Function: C:\Test\test.ps1

Notas:

• Executado de C:\, mas o script real é C:\Test\test.ps1.
• Nenhum método informa o caminho de invocação passado ( .\Test\test.ps1)
• $PSCommandPath é a única maneira confiável, mas foi introduzida no PowerShell 3
• Para versões anteriores a 3, nenhum método funciona dentro e fora de uma função

Embora a Resposta atual esteja certa na maioria dos casos, há certas situações em que ela não fornecerá a resposta correta. Se você usar dentro de suas funções de script:

$MyInvocation.MyCommand.Name 

Retorna o nome da função em vez do nome do nome do script.

function test {
    $MyInvocation.MyCommand.Name
}

Fornecerá um " teste " independentemente do nome do seu script. O comando certo para obter o nome do script é sempre

$MyInvocation.ScriptName

isso retorna o caminho completo do script que você está executando. Se você precisa apenas do nome do arquivo do script, este código deve ajudá-lo:

split-path $MyInvocation.PSCommandPath -Leaf

Se você deseja apenas o nome do arquivo (não o caminho completo), use este:

$ScriptName = $MyInvocation.MyCommand.Name

Tente o seguinte

$path =  $MyInvocation.MyCommand.Definition 

Isso pode não fornecer o caminho real digitado, mas fornecerá um caminho válido para o arquivo.

Se você está procurando o diretório atual no qual o script está sendo executado, você pode tentar este:

$fullPathIncFileName = $MyInvocation.MyCommand.Definition
$currentScriptName = $MyInvocation.MyCommand.Name
$currentExecutingPath = $fullPathIncFileName.Replace($currentScriptName, "")

Write-Host $currentExecutingPath

cuidado: Ao contrário das variáveis ​​automáticas $PSScriptRoote $PSCommandPath, as propriedades PSScriptRoote PSCommandPathda $MyInvocationvariável automática contêm informações sobre o invocador ou o script de chamada, não o script atual.

por exemplo

PS C:\Users\S_ms\OneDrive\Documents> C:\Users\SP_ms\OneDrive\Documents\DPM ...
=!C:\Users\S_ms\OneDrive\Documents\DPM.ps1

... onde DPM.ps1contém

Write-Host ("="+($MyInvocation.PSCommandPath)+"!"+$PSCommandPath)

Eu diria que existe um método melhor, definindo o escopo da variável $ MyInvocation.MyCommand.Path:

ex> $ script : MyInvocation.MyCommand.Name

Este método funciona em todas as circunstâncias de invocação:

EX: Somescript.ps1

function printme () {
    "In function:"
    ( "MyInvocation.ScriptName: " + [string]($MyInvocation.ScriptName) )
    ( "script:MyInvocation.MyCommand.Name: " + [string]($script:MyInvocation.MyCommand.Name) )
    ( "MyInvocation.MyCommand.Name: " + [string]($MyInvocation.MyCommand.Name) )
}
"Main:"
( "MyInvocation.ScriptName: " + [string]($MyInvocation.ScriptName) )
( "script:MyInvocation.MyCommand.Name: " + [string]($script:MyInvocation.MyCommand.Name) )
( "MyInvocation.MyCommand.Name: " + [string]($MyInvocation.MyCommand.Name) )
" "
printme
exit

RESULTADO:

PS> powershell C:\temp\test.ps1
Main:
MyInvocation.ScriptName:
script:MyInvocation.MyCommand.Name: test.ps1
MyInvocation.MyCommand.Name: test.ps1

In function:
MyInvocation.ScriptName: C:\temp\test.ps1
script:MyInvocation.MyCommand.Name: test.ps1
MyInvocation.MyCommand.Name: printme

Observe como a resposta aceita acima NÃO retorna um valor quando chamada de Main. Além disso, observe que a resposta aceita acima retorna o caminho completo quando a pergunta solicitou apenas o nome do script. A variável com escopo funciona em todos os lugares.

Além disso, se você quiser o caminho completo, basta chamar:

$script:MyInvocation.MyCommand.Path

Conforme observado nas respostas anteriores, o uso de "$ MyInvocation" está sujeito a problemas de escopo e não necessariamente fornece dados consistentes (valor de retorno vs. valor de acesso direto). Descobri que o método "mais limpo" (mais consistente) para obter informações de script, como caminho de script, nome, parâmetros, linha de comando, etc., independentemente do escopo (em chamadas de função principal ou subsequentes / aninhadas) é usar "Get- Variável "em" MyInvocation "...

# Get the MyInvocation variable at script level
# Can be done anywhere within a script
$ScriptInvocation = (Get-Variable MyInvocation -Scope Script).Value

# Get the full path to the script
$ScriptPath = $ScriptInvocation.MyCommand.Path

# Get the directory of the script
$ScriptDirectory = Split-Path $ScriptPath

# Get the script name
# Yes, could get via Split-Path, but this is "simpler" since this is the default return value
$ScriptName = $ScriptInvocation.MyCommand.Name

# Get the invocation path (relative to $PWD)
# @GregMac, this addresses your second point
$InvocationPath = ScriptInvocation.InvocationName

Portanto, você pode obter as mesmas informações de $ PSCommandPath, mas muito mais no negócio. Não tenho certeza, mas parece que "Get-Variable" não estava disponível até o PS3, então não é uma grande ajuda para sistemas realmente antigos (não atualizados).

Existem também alguns aspectos interessantes ao usar "-Scope", pois você pode retroceder para obter os nomes, etc. da (s) função (ões) de chamada. 0 = atual, 1 = pai, etc.

Espero que isso seja de alguma forma útil.

Ref, https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.utility/get-variable

Fiz alguns testes com o seguinte script, tanto no PS 2 quanto no PS 4 e obteve o mesmo resultado. Espero que isso ajude as pessoas.

$PSVersionTable.PSVersion
function PSscript {
  $PSscript = Get-Item $MyInvocation.ScriptName
  Return $PSscript
}
""
$PSscript = PSscript
$PSscript.FullName
$PSscript.Name
$PSscript.BaseName
$PSscript.Extension
$PSscript.DirectoryName

""
$PSscript = Get-Item $MyInvocation.InvocationName
$PSscript.FullName
$PSscript.Name
$PSscript.BaseName
$PSscript.Extension
$PSscript.DirectoryName

Resultados -

Major  Minor  Build  Revision
-----  -----  -----  --------
4      0      -1     -1      

C:\PSscripts\Untitled1.ps1
Untitled1.ps1
Untitled1
.ps1
C:\PSscripts

C:\PSscripts\Untitled1.ps1
Untitled1.ps1
Untitled1
.ps1
C:\PSscripts

Isso pode funcionar na maioria das versões do PowerShell:

(& { $MyInvocation.ScriptName; })

Isso pode funcionar para trabalho agendado

Get-ScheduledJob |? Name -Match 'JOBNAMETAG' |% Command