Entspricht dem Befehl * Nix 'which' in PowerShell?

Wie frage ich PowerShell, wo sich etwas befindet?

Beispiel: "welcher Notizblock" und es wird das Verzeichnis zurückgegeben, in dem die Datei notepad.exe gemäß den aktuellen Pfaden ausgeführt wird.

Der allererste Alias, den ich erstellt habe, als ich anfing, mein Profil in PowerShell anzupassen, war "welcher".

New-Alias which get-command

Geben Sie Folgendes ein, um dies Ihrem Profil hinzuzufügen:

"`nNew-Alias which get-command" | add-content $profile

Das `n am Anfang der letzten Zeile soll sicherstellen, dass es als neue Zeile beginnt.

Hier ist ein tatsächliches * nix-Äquivalent, dh es gibt eine Ausgabe im * nix-Stil.

Get-Command <your command> | Select-Object -ExpandProperty Definition

Ersetzen Sie einfach durch das, was Sie suchen.

PS C:\> Get-Command notepad.exe | Select-Object -ExpandProperty Definition
C:\Windows\system32\notepad.exe

Wenn Sie es Ihrem Profil hinzufügen, möchten Sie eine Funktion anstelle eines Alias ​​verwenden, da Sie keine Aliase mit Pipes verwenden können:

function which($name)
{
    Get-Command $name | Select-Object -ExpandProperty Definition
}

Wenn Sie jetzt Ihr Profil neu laden, können Sie Folgendes tun:

PS C:\> which notepad
C:\Windows\system32\notepad.exe

Normalerweise tippe ich einfach:

gcm notepad

oder

gcm note*

gcm ist der Standardalias für Get-Command.

Auf meinem System gibt gcm note * Folgendes aus:

[27] » gcm note*

CommandType     Name                                                     Definition
-----------     ----                                                     ----------
Application     notepad.exe                                              C:\WINDOWS\notepad.exe
Application     notepad.exe                                              C:\WINDOWS\system32\notepad.exe
Application     Notepad2.exe                                             C:\Utils\Notepad2.exe
Application     Notepad2.ini                                             C:\Utils\Notepad2.ini

Sie erhalten das Verzeichnis und den Befehl, die dem entsprechen, wonach Sie suchen.

Versuchen Sie dieses Beispiel:

(Get-Command notepad.exe).Path

Mein Vorschlag für die Welche Funktion:

function which($cmd) { get-command $cmd | % { $_.Path } }

PS C:\> which devcon

C:\local\code\bin\devcon.exe

Eine schnelle und schmutzige Übereinstimmung mit Unix whichist

New-Alias which where.exe

Es werden jedoch mehrere Zeilen zurückgegeben, wenn sie vorhanden sind

function which {where.exe command | select -first 1}

Dies scheint zu tun, was Sie wollen (ich fand es auf http://huddledmasses.org/powershell-find-path/ ):

Function Find-Path($Path, [switch]$All = $false, [Microsoft.PowerShell.Commands.TestPathType]$type = "Any")
## You could comment out the function stuff and use it as a script instead, with this line:
#param($Path, [switch]$All = $false, [Microsoft.PowerShell.Commands.TestPathType]$type = "Any")
   if($(Test-Path $Path -Type $type)) {
      return $path
   } else {
      [string[]]$paths = @($pwd);
      $paths += "$pwd;$env:path".split(";")

      $paths = Join-Path $paths $(Split-Path $Path -leaf) | ? { Test-Path $_ -Type $type }
      if($paths.Length -gt 0) {
         if($All) {
            return $paths;
         } else {
            return $paths[0]
         }
      }
   }
   throw "Couldn't find a matching path of type $type"
}
Set-Alias find Find-Path

Überprüfen Sie diese PowerShell Welche .

Der dort bereitgestellte Code schlägt Folgendes vor:

($Env:Path).Split(";") | Get-ChildItem -filter notepad.exe

Ich mag Get-Command | Format-Listoder kürzer, Aliase für die beiden zu verwenden und nur für powershell.exe:

gcm powershell | fl

Sie können Aliase wie diese finden:

alias -definition Format-List

Die Tab-Vervollständigung funktioniert mit gcm .

Probieren Sie die where Befehl unter Windows 2003 oder höher (oder Windows 2000 / XP, wenn Sie ein Resource Kit installiert haben).

Übrigens erhielt dies mehr Antworten in anderen Fragen:

Gibt es ein Äquivalent zu 'which' unter Windows?

PowerShell entspricht dem Unix- whichBefehl?

Ich habe diese whicherweiterte Funktion in meinem PowerShell-Profil:

function which {
<#
.SYNOPSIS
Identifies the source of a PowerShell command.
.DESCRIPTION
Identifies the source of a PowerShell command. External commands (Applications) are identified by the path to the executable
(which must be in the system PATH); cmdlets and functions are identified as such and the name of the module they are defined in
provided; aliases are expanded and the source of the alias definition is returned.
.INPUTS
No inputs; you cannot pipe data to this function.
.OUTPUTS
.PARAMETER Name
The name of the command to be identified.
.EXAMPLE
PS C:\Users\Smith\Documents> which Get-Command

Get-Command: Cmdlet in module Microsoft.PowerShell.Core

(Identifies type and source of command)
.EXAMPLE
PS C:\Users\Smith\Documents> which notepad

C:\WINDOWS\SYSTEM32\notepad.exe

(Indicates the full path of the executable)
#>
    param(
    [String]$name
    )

    $cmd = Get-Command $name
    $redirect = $null
    switch ($cmd.CommandType) {
        "Alias"          { "{0}: Alias for ({1})" -f $cmd.Name, (. { which cmd.Definition } ) }
        "Application"    { $cmd.Source }
        "Cmdlet"         { "{0}: {1} {2}" -f $cmd.Name, $cmd.CommandType, (. { if ($cmd.Source.Length) { "in module {0}" -f $cmd.Source} else { "from unspecified source" } } ) }
        "Function"       { "{0}: {1} {2}" -f $cmd.Name, $cmd.CommandType, (. { if ($cmd.Source.Length) { "in module {0}" -f $cmd.Source} else { "from unspecified source" } } ) }
        "Workflow"       { "{0}: {1} {2}" -f $cmd.Name, $cmd.CommandType, (. { if ($cmd.Source.Length) { "in module {0}" -f $cmd.Source} else { "from unspecified source" } } ) }
        "ExternalScript" { $cmd.Source }
        default          { $cmd }
    }
}

Verwenden:

function Which([string] $cmd) {
  $path = (($Env:Path).Split(";") | Select -uniq | Where { $_.Length } | Where { Test-Path $_ } | Get-ChildItem -filter $cmd).FullName
  if ($path) { $path.ToString() }
}

# Check if Chocolatey is installed
if (Which('cinst.bat')) {
  Write-Host "yes"
} else {
  Write-Host "no"
}

Oder diese Version, die den ursprünglichen where-Befehl aufruft.

Diese Version funktioniert auch besser, da sie nicht auf Fledermausdateien beschränkt ist:

function which([string] $cmd) {
  $where = iex $(Join-Path $env:SystemRoot "System32\where.exe $cmd 2>&1")
  $first = $($where -split '[\r\n]')
  if ($first.getType().BaseType.Name -eq 'Array') {
    $first = $first[0]
  }
  if (Test-Path $first) {
    $first
  }
}

# Check if Curl is installed
if (which('curl')) {
  echo 'yes'
} else {
  echo 'no'
}

Wenn Sie ein Kommando wünschen, das sowohl Eingaben aus der Pipeline als auch als Parameter akzeptiert, sollten Sie Folgendes versuchen:

function which($name) {
    if ($name) { $input = $name }
    Get-Command $input | Select-Object -ExpandProperty Path
}

Kopieren Sie den Befehl und fügen Sie ihn in Ihr Profil ein ( notepad $profile).

Beispiele:

❯ echo clang.exe | which
C:\Program Files\LLVM\bin\clang.exe

❯ which clang.exe
C:\Program Files\LLVM\bin\clang.exe