Esiste un equivalente di "quale" nella riga di comando di Windows?

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 dalla riga di comando di Windows, dato solo il suo nome.

Esiste un equivalente al comando UNIX 'quale'?

Su UNIX, which commandstampa l'intero percorso del comando dato per trovare e riparare facilmente questi problemi di ombreggiamento.

Windows Server 2003 e versioni successive (ovvero qualsiasi cosa dopo Windows XP a 32 bit) forniscono il where.exeprogramma che fa parte di ciò che whichfa, sebbene corrisponda a tutti i tipi di file, non solo ai comandi eseguibili. (Non corrisponde a comandi shell incorporati come cd.) Accetterà anche caratteri jolly, quindi where nt*trova tutti i file nella tua %PATH%directory e corrente i cui nomi iniziano con nt.

Cerca where /?aiuto.

Si noti che Windows PowerShell definisce whereun alias per il Where-Objectcmdlet , quindi, se lo si desidera where.exe, è necessario digitare il nome completo invece di omettere l' .exeestensione.

Mentre le versioni successive di Windows dispongono di un wherecomando, è possibile eseguire questa operazione anche con Windows XP utilizzando i modificatori della variabile di ambiente, come indicato di seguito:

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 PATHdal momento che puoi sostituire qualsiasi variabile d'ambiente (nel formato del percorso, ovviamente) che desideri utilizzare.

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 è possibile modificarlo abbastanza facilmente per regole di ricerca specifiche.

Sotto PowerShell, Get-Commandtroverai 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

Si trova anche cmdlet di PowerShell, le funzioni, gli alias, i file con eseguibili personalizzati estensioni via $Env:PATHEXT, ecc definiti per la shell corrente (del tutto simile a Bash di type -a foo) - che lo rende una migliore go-to rispetto ad altri strumenti come where.exe, which.exe, ecc, che non sono a conoscenza di questi Comandi PowerShell.

Trovare eseguibili usando 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
...

Trovare eseguibili personalizzati

Per trovare altri eseguibili non Windows (python, ruby, perl, ecc.), È necessario aggiungere estensioni di file per tali eseguibili alla PATHEXTvariabile ambientale (impostazione predefinita a .COM;.EXE;.BAT;.CMD;.VBS;.VBE;.JS;.JSE;.WSF;.WSH;.MSC;.CPL) per identificare i file con queste estensioni PATHcome eseguibili. Come Get-Commandonora anche questa variabile, può essere estesa per elencare eseguibili personalizzati. per esempio

$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

È possibile impostare rapidamente un alias con sal which gcm(forma breve di set-alias which get-command).

Ulteriori informazioni ed esempi sono disponibili nella guida in linea di 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 Quale

Gli strumenti GnuWin32 hanno which, insieme a tutta una serie di altri strumenti Unix.

Nelle whichchiamate CMD di Windows where:

$ 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 which) per Windows e puoi semplicemente includere quella directory nella tua PATH.

In PowerShell, lo è gcm, che fornisce informazioni formattate su altri comandi. Se si desidera recuperare solo il percorso dell'eseguibile, utilizzare .Source.

Ad esempio: gcm gito(gcm git).Source

tidbits:

• Disponibile per Windows XP.
• Disponibile da PowerShell 1.0.
• gcmè un alias di Get-Commandcmdlet .
• Senza parametri, elenca tutti i comandi disponibili offerti dalla shell host.
• È possibile creare un alias personalizzato con Set-Alias which gcme usarlo come: (which git).Source.
• Documenti ufficiali: https://technet.microsoft.com/en-us/library/ee176842.aspx

Ho una funzione nel mio profilo PowerShell denominata '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:

Vai a ottenere unxutils da qui: http://sourceforge.net/projects/unxutils/

oro su piattaforme Windows, mette tutte le belle utilità unix su un DOS standard di Windows. Lo uso da anni.

Ha un 'quale' incluso. Si noti che è sensibile al maiuscolo / minuscolo.

NB: per installarlo esplodere la zip da qualche parte e aggiungere ... \ UnxUtils \ usr \ local \ wbin \ alla variabile env del percorso di sistema.

Non disponibile Windows, ma esso è fornito dalla Services for Unix e ci sono diverse semplici script batch di galleggianti intorno che svolgono la stessa cosa come questo questo .

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.

La migliore versione di questo che ho trovato su Windows è l'utilità "whereis" di Joseph Newcomer, che è disponibile (con sorgente) dal suo sito .

Vale la pena leggere l'articolo sullo sviluppo di "whereis".

Puoi prima installare Git dal download di Git , quindi aprire Git Bash e digitare:

which app-name

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 che li possa trovare.)
• Nessun supporto per le tabelle di codici cmd.exe, che consente loro di visualizzare erroneamente i percorsi con caratteri non ASCII. (Sono molto sensibile a questo, con la ç nel mio nome :-))
• Nessun supporto per le regole di ricerca distinte 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 sostiene correttamente tutto quanto sopra.

Disponibile lì: 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%)

Chiedi set /?aiuto.

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 applicazioni UNIX open source estremamente utili compilate come binari nativi win32. È progettato per essere il più piccolo possibile, circa 10 MB, a differenza di Cygwin che può funzionare ben oltre 100 MB a seconda delle 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 nel 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).

Devi solo pubblicare questo file batch di una sola riga di Windows:

C:>type wh.cmd
@for %%f in (%*) do for %%e in (%PATHEXT% .dll .lnk) do for %%b in (%%f%%e) do for %%d in (%PATH%) do if exist %%d\%%b echo %%d\%%b

Un test:

C:>wh ssh
C:\cygwin64\bin\ssh.EXE
C:\Windows\System32\OpenSSH\\ssh.EXE

Non del tutto una riga se si inserisce il codice setlocal enableextensionse endlocal.

Per voi utenti di Windows XP (che non hanno alcun wherecomando incorporato), ho scritto un comando "dove mi piace" come ha chiamato un rubygem 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. Rilevante per la domanda del PO, whichè un comando incorporato per i processori di comandi della famiglia TCC.

Ho usato il whichmodulo da npm per un po 'e funziona molto bene: https://www.npmjs.com/package/which È un'ottima alternativa multi-piattaforma.

Ora sono passato a whichquello fornito con Git. Basta aggiungere al tuo percorso il /usr/binpercorso da Git, che di solito è a C:\Program Files\Git\usr\bin\which.exe. Il whichbinario sarà a C:\Program Files\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%)