Esiste un equivalente di "quale" nella riga di comando di Windows?
-
08-07-2019 - |
Domanda
Poiché a volte ho problemi di percorso, in cui uno dei miei script cmd è nascosto (ombreggiato) da un altro programma (in precedenza sul percorso), vorrei essere in grado di trovare il percorso completo di un programma sul comando di Windows linea, dato solo il suo nome.
Esiste un equivalente al comando UNIX 'quale'?
Su UNIX, quale comando
stampa l'intero percorso del comando dato per trovare e riparare facilmente questi problemi di ombreggiamento.
Soluzione
Windows Server 2003 e versioni successive (ovvero qualsiasi cosa dopo Windows XP a 32 bit) forniscono il programma where.exe
che fa parte di ciò che quale
, sebbene corrisponda a tutti i tipi di file, non solo comandi eseguibili. (Non corrisponde ai comandi di shell integrati come cd
.) Accetterà anche caratteri jolly, quindi dove nt *
trova tutti i file nel tuo % PATH%
e la directory corrente i cui nomi iniziano con nt
.
Prova dove /?
per aiuto.
Nota che Windows PowerShell definisce dove
come alias per il cmdlet Where-Object
, quindi se si desidera where.exe
, è necessario digitare il nome completo invece di omettere il .exe
estensione.
Altri suggerimenti
Mentre le versioni successive di Windows hanno un comando where
, puoi farlo anche con Windows XP usando i modificatori della variabile d'ambiente, come segue:
c:\> for %i in (cmd.exe) do @echo. %~$PATH:i
C:\WINDOWS\system32\cmd.exe
c:\> for %i in (python.exe) do @echo. %~$PATH:i
C:\Python25\python.exe
Non hai bisogno di strumenti extra e non è limitato a PERCORSO
poiché puoi sostituire qualsiasi variabile d'ambiente (nel formato del percorso, ovviamente) che desideri usare.
E, se vuoi uno in grado di gestire tutte le estensioni in PATHEXT (come fa Windows stesso), questo fa il trucco:
@echo off
setlocal enableextensions enabledelayedexpansion
:: Needs an argument.
if "x%1"=="x" (
echo Usage: which ^<progName^>
goto :end
)
:: First try the unadorned filenmame.
set fullspec=
call :find_it %1
:: Then try all adorned filenames in order.
set mypathext=!pathext!
:loop1
:: Stop if found or out of extensions.
if "x!mypathext!"=="x" goto :loop1end
:: Get the next extension and try it.
for /f "delims=;" %%j in ("!mypathext!") do set myext=%%j
call :find_it %1!myext!
:: Remove the extension (not overly efficient but it works).
:loop2
if not "x!myext!"=="x" (
set myext=!myext:~1!
set mypathext=!mypathext:~1!
goto :loop2
)
if not "x!mypathext!"=="x" set mypathext=!mypathext:~1!
goto :loop1
:loop1end
:end
endlocal
goto :eof
:: Function to find and print a file in the path.
:find_it
for %%i in (%1) do set fullspec=%%~$PATH:i
if not "x!fullspec!"=="x" @echo. !fullspec!
goto :eof
In realtà restituisce tutte le possibilità, ma puoi modificarlo abbastanza facilmente per regole di ricerca specifiche.
In PowerShell, Get-Command
troverà eseguibili ovunque in $ Env: PATH
.
Get-Command eventvwr
CommandType Name Definition
----------- ---- ----------
Application eventvwr.exe c:\windows\system32\eventvwr.exe
Application eventvwr.msc c:\windows\system32\eventvwr.msc
Trova anche cmdlet, funzioni, alias, file di PowerShell con estensioni eseguibili personalizzate tramite $ Env: PATHEXT
, ecc. definiti per la shell corrente (abbastanza simile al tipo di Bash -a foo
) - rendendolo un passaggio migliore rispetto ad altri strumenti come where.exe
, which.exe
, ecc. che non sono a conoscenza di questi comandi di PowerShell.
Ricerca di file eseguibili utilizzando solo una parte del nome
gcm *disk*
CommandType Name Version Source
----------- ---- ------- ------
Alias Disable-PhysicalDiskIndication 2.0.0.0 Storage
Alias Enable-PhysicalDiskIndication 2.0.0.0 Storage
Function Add-PhysicalDisk 2.0.0.0 Storage
Function Add-VirtualDiskToMaskingSet 2.0.0.0 Storage
Function Clear-Disk 2.0.0.0 Storage
Cmdlet Get-PmemDisk 1.0.0.0 PersistentMemory
Cmdlet New-PmemDisk 1.0.0.0 PersistentMemory
Cmdlet Remove-PmemDisk 1.0.0.0 PersistentMemory
Application diskmgmt.msc 0.0.0.0 C:\WINDOWS\system32\diskmgmt.msc
Application diskpart.exe 10.0.17... C:\WINDOWS\system32\diskpart.exe
Application diskperf.exe 10.0.17... C:\WINDOWS\system32\diskperf.exe
Application diskraid.exe 10.0.17... C:\WINDOWS\system32\diskraid.exe
...
Ricerca di eseguibili personalizzati
Per trovare altri eseguibili non-windows (python, ruby, perl, ecc.), le estensioni di file per tali eseguibili devono essere aggiunte alla variabile ambientale PATHEXT
(il valore predefinito è .COM; .EXE; .BAT; .CMD; .VBS; .VBE; .JS; .JSE; .WSF; .WSH; .MSC; .CPL
) per identificare i file con queste estensioni nel PATH
come eseguibile. Poiché Get-Command
onora anche questa variabile, può essere estesa per elencare eseguibili personalizzati. per es.
$Env:PATHEXT="$Env:PATHEXT;.dll;.ps1;.psm1;.py" # temporary assignment, only for this shell's process
gcm user32,kernel32,*WASM*,*http*py
CommandType Name Version Source
----------- ---- ------- ------
ExternalScript Invoke-WASMProfiler.ps1 C:\WINDOWS\System32\WindowsPowerShell\v1.0\Invoke-WASMProfiler.ps1
Application http-server.py 0.0.0.0 C:\Users\ME\AppData\Local\Microsoft\WindowsApps\http-server.py
Application kernel32.dll 10.0.17... C:\WINDOWS\system32\kernel32.dll
Application user32.dll 10.0.17... C:\WINDOWS\system32\user32.dll
Puoi impostare rapidamente un alias con sal quale gcm
(forma abbreviata di set-alias che ottiene il comando
).
Ulteriori informazioni ed esempi sono disponibili nella guida in linea per Get-Command
.
In Windows PowerShell:
set-alias which where.exe
Se hai installato PowerShell (che ti consiglio), puoi usare il seguente comando come equivalente approssimativo (sostituisci nome programma con il nome del tuo eseguibile):
($Env:Path).Split(";") | Get-ChildItem -filter programName*
Altro è qui: My Manwich! PowerShell che
Gli strumenti GnuWin32 hanno quale
, insieme a un'intera serie di altri Unix strumenti.
In Windows CMD che
chiama dove
:
$ where php
C:\Program Files\PHP\php.exe
Cygwin è una soluzione. Se non ti dispiace usare una soluzione di terze parti, Cygwin è la strada da percorrere.
Cygwin ti offre il comfort di * nix in ambiente Windows (e puoi usarlo nella tua shell dei comandi di Windows, oppure usare una shell * nix a tua scelta). Ti dà tutta una serie di comandi * nix (come che
) per Windows e puoi semplicemente includere quella directory nel tuo PATH
.
In PowerShell, è gcm
, che fornisce informazioni formattate su altri comandi. Se si desidera recuperare solo il percorso dell'eseguibile, utilizzare .Source
.
Ad esempio: gcm git
o (gcm git). Fonte
Tidbits:
- Disponibile per Windows XP.
- Disponibile da PowerShell 1.0.
-
gcm
è un alias diGet-Command cmdlet
. - Senza alcun parametro, elenca tutti i comandi disponibili offerti dalla shell host.
- Puoi creare un alias personalizzato con
Set-Alias ??che gcm
e usarlo come:(quale git). Fonte
. - Documenti ufficiali: https://technet.microsoft.com/en-us /library/ee176842.aspx
Vai a ottenere unxutils da qui: http://sourceforge.net/projects/unxutils/
oro su piattaforme Windows, mette tutte le belle utility unix su un DOS standard di Windows. Lo uso da anni.
Ha un 'quale' incluso. Nota che distingue tra maiuscole e minuscole.
NB: per installarlo esplodere la zip da qualche parte e aggiungere ... \ UnxUtils \ usr \ local \ wbin \ alla variabile env del percorso di sistema.
Ho una funzione nel mio profilo PowerShell chiamata 'quale'
function which {
get-command $args[0]| format-list
}
Ecco come appare l'output:
PS C:\Users\fez> which python
Name : python.exe
CommandType : Application
Definition : C:\Python27\python.exe
Extension : .exe
Path : C:\Python27\python.exe
FileVersionInfo : File: C:\Python27\python.exe
InternalName:
OriginalFilename:
FileVersion:
FileDescription:
Product:
ProductVersion:
Debug: False
Patched: False
PreRelease: False
PrivateBuild: False
SpecialBuild: False
Language:
Se riesci a trovare un compilatore Pascal gratuito, puoi compilarlo. Almeno funziona e mostra l'algoritmo necessario.
program Whence (input, output);
Uses Dos, my_funk;
Const program_version = '1.00';
program_date = '17 March 1994';
VAR path_str : string;
command_name : NameStr;
command_extension : ExtStr;
command_directory : DirStr;
search_dir : DirStr;
result : DirStr;
procedure Check_for (file_name : string);
{ Check existence of the passed parameter. If exists, then state so }
{ and exit. }
begin
if Fsearch(file_name, '') <> '' then
begin
WriteLn('DOS command = ', Fexpand(file_name));
Halt(0); { structured ? whaddayamean structured ? }
end;
end;
function Get_next_dir : DirStr;
{ Returns the next directory from the path variable, truncating the }
{ variable every time. Implicit input (but not passed as parameter) }
{ is, therefore, path_str }
var semic_pos : Byte;
begin
semic_pos := Pos(';', path_str);
if (semic_pos = 0) then
begin
Get_next_dir := '';
Exit;
end;
result := Copy(Path_str, 1, (semic_pos - 1)); { return result }
{ Hmm! although *I* never reference a Root drive (my directory tree) }
{ is 1/2 way structured), some network logon software which I run }
{ does (it adds Z:\ to the path). This means that I have to allow }
{ path entries with & without a terminating backslash. I'll delete }
{ anysuch here since I always add one in the main program below. }
if (Copy(result, (Length(result)), 1) = '\') then
Delete(result, Length(result), 1);
path_str := Copy(path_str,(semic_pos + 1),
(length(path_str) - semic_pos));
Get_next_dir := result;
end; { Of function get_next_dir }
begin
{ The following is a kludge which makes the function Get_next_dir easier }
{ to implement. By appending a semi-colon to the end of the path }
{ Get_next_dir doesn't need to handle the special case of the last entry }
{ which normally doesn't have a semic afterwards. It may be a kludge, }
{ but it's a documented kludge (you might even call it a refinement). }
path_str := GetEnv('Path') + ';';
if (paramCount = 0) then
begin
WriteLn('Whence: V', program_version, ' from ', program_date);
Writeln;
WriteLn('Usage: WHENCE command[.extension]');
WriteLn;
WriteLn('Whence is a ''find file''type utility witha difference');
Writeln('There are are already more than enough of those :-)');
Write ('Use Whence when you''re not sure where a command which you ');
WriteLn('want to invoke');
WriteLn('actually resides.');
Write ('If you intend to invoke the command with an extension e.g ');
Writeln('"my_cmd.exe param"');
Write ('then invoke Whence with the same extension e.g ');
WriteLn('"Whence my_cmd.exe"');
Write ('otherwise a simple "Whence my_cmd" will suffice; Whence will ');
Write ('then search the current directory and each directory in the ');
Write ('for My_cmd.com, then My_cmd.exe and lastly for my_cmd.bat, ');
Write ('just as DOS does');
Halt(0);
end;
Fsplit(paramStr(1), command_directory, command_name, command_extension);
if (command_directory <> '') then
begin
WriteLn('directory detected *', command_directory, '*');
Halt(0);
end;
if (command_extension <> '') then
begin
path_str := Fsearch(paramstr(1), ''); { Current directory }
if (path_str <> '') then WriteLn('Dos command = "', Fexpand(path_str), '"')
else
begin
path_str := Fsearch(paramstr(1), GetEnv('path'));
if (path_str <> '') then WriteLn('Dos command = "', Fexpand(path_str), '"')
else Writeln('command not found in path.');
end;
end
else
begin
{ O.K, the way it works, DOS looks for a command firstly in the current }
{ directory, then in each directory in the Path. If no extension is }
{ given and several commands of the same name exist, then .COM has }
{ priority over .EXE, has priority over .BAT }
Check_for(paramstr(1) + '.com'); { won't return if file is found }
Check_for(paramstr(1) + '.exe');
Check_for(paramstr(1) + '.bat');
{ Not in current directory, search through path ... }
search_dir := Get_next_dir;
while (search_dir <> '') do
begin
Check_for(search_dir + '\' + paramstr(1) + '.com');
Check_for(search_dir + '\' + paramstr(1) + '.exe');
Check_for(search_dir + '\' + paramstr(1) + '.bat');
search_dir := Get_next_dir;
end;
WriteLn('DOS command not found: ', paramstr(1));
end;
end.
Windows non disponibile ma fornito da Servizi per Unix e ci sono diversi semplici script batch che fluttuano attorno a questo scopo questo .
La migliore versione di questo che ho trovato su Windows è "Whereis" di Joseph Newcomer utility, che è disponibile (con fonte) dal il suo sito .
L'articolo sullo sviluppo di "whereis" vale la pena leggere.
Nessuna delle porte Win32 di Unix che ho potuto trovare su Internet è saziante, perché tutte hanno una o più di queste carenze:
- Nessun supporto per la variabile PATHEXT di Windows. (Che definisce l'elenco di estensioni implicitamente aggiunto a ciascun comando prima di scansionare il percorso, e in quale ordine.) (Uso molti script tcl e nessuno strumento pubblicamente disponibile quale strumento potrebbe trovarli.)
- Nessun supporto per le pagine di codice cmd.exe, che consente loro di visualizzare in modo errato i percorsi con caratteri non ASCII. (Sono molto sensibile a questo, con & # 231; nel mio nome :-))
- Nessun supporto per le distinte regole di ricerca in cmd.exe e nella riga di comando di PowerShell. (Nessuno strumento disponibile pubblicamente troverà script .ps1 in una finestra di PowerShell, ma non in una finestra cmd!)
Quindi alla fine ho scritto il mio, che supporta correttamente tutto quanto sopra.
Disponibile qui: http://jf.larvoire.free.fr/progs/which.exe
Questo file batch utilizza la gestione delle variabili CMD per trovare il comando che verrebbe eseguito nel percorso. Nota: che la directory corrente viene sempre eseguita prima del percorso) e in base alla chiamata API utilizzata, vengono cercate altre posizioni prima / dopo il percorso.
@echo off
echo.
echo PathFind - Finds the first file in in a path
echo ======== = ===== === ===== ==== == == = ====
echo.
echo Searching for %1 in %path%
echo.
set a=%~$PATH:1
If "%a%"=="" (Echo %1 not found) else (echo %1 found at %a%)
Vedi set /?
per aiuto.
Puoi prima installare Git da Scarica Git e quindi apri Git Bash e digita:
which app-name
Sto usando GOW (GNU su Windows) che è una versione leggera di Cygwin. Puoi prenderlo da GitHub qui .
GOW (GNU su Windows) è l'alternativa leggera a Cygwin. Utilizza un comodo programma di installazione di Windows che installa circa 130 estremamente utili applicazioni UNIX open source compilate come win32 nativo binari. È progettato per essere il più piccolo possibile, circa 10 MB, come al contrario di Cygwin che può funzionare ben oltre 100 MB a seconda opzioni. - Informazioni sulla descrizione (Brent R. Matzelle)
Uno screenshot di un elenco di comandi inclusi in GOW:
Ho creato uno strumento simile a Ned Batchelder:
Ricerca di file .dll ed .exe in PERCORSO
Mentre il mio strumento è principalmente per la ricerca di varie versioni di dll mostra più informazioni (data, dimensione, versione) ma non usa PATHEXT (spero di aggiornare presto il mio strumento).
Per voi utenti di Windows & nbsp; XP (che non hanno il comando dove
incorporato), ho scritto un " dove come " comando come un rubygem chiamato whichr
.
Per installarlo, installa Ruby.
Poi
gem install whichr
Eseguilo come:
C: > whichr cmd_here
TCC e TCC / LE di JPSoft sono sostituti di CMD.EXE che aggiungono funzionalità significative. Relativo alla domanda del PO, quale
è un comando incorporato per i processori di comandi della famiglia TCC.
Ho usato il quale
modulo da npm per un po 'di tempo, e funziona molto bene: https://www.npmjs.com/package/which
È un'ottima alternativa multi-piattaforma.
Ora sono passato al quale
fornito con Git. Aggiungi al tuo percorso il percorso / usr / bin
da Git, che di solito si trova in C: \ Programmi \ Git \ usr \ bin \ which.exe
. Il che
sarà in C: \ Programmi \ Git \ usr \ bin \ which.exe
. È più veloce e funziona anche come previsto.
prova questo
set a=%~$dir:1
If "%for%"=="" (Echo %1 not found) else (echo %1 found at %a%)