command-line locate - Esiste un equivalente di "which" sulla riga di comando di Windows?




program where (19)

Poiché a volte ho problemi di percorso, in cui uno dei miei script cmd è nascosto (ombreggiato) da un altro programma (in precedenza sul percorso), mi piacerebbe essere in grado di trovare il percorso completo di un programma sulla riga di comando di Windows, dato solo il suo nome

Esiste un equivalente al comando UNIX 'which'?

Su UNIX, which command stampa il percorso completo del comando dato per trovare e riparare facilmente questi problemi di shadowing.


Answers

Sto usando GOW (Gnu su Windows) che è una versione leggera di cygwin. Puoi prenderlo da GitHub here.

Gow (Gnu On Windows) è l'alternativa leggera a Cygwin. Usa un comodo programma di installazione di Windows che installa circa 130 applicazioni UNIX open source estremamente utili compilate come binari nativi di win32. È progettato per essere il più piccolo possibile, circa 10 MB, a differenza di Cygwin che può funzionare ben oltre i 100 MB a seconda delle opzioni. - Informazioni sulla descrizione (Brent R. Matzelle)

Screenshot di un elenco di comandi inclusi in GOW.


In Windows PowerShell:

set-alias which where.exe

TCC e TCC / LE di JPSoft sono sostituzioni CMD.EXE che aggiungono funzionalità significative. Pertinente alla domanda dell'OP, which è un comando incorporato per i processori di comandi della famiglia TCC.


Nessuna delle porte Win32 di Unix che potrei trovare su Internet è soddisfacente, perché tutte hanno una o più di queste carenze:

  • Nessun supporto per la variabile PATHEXT di Windows. (Che definisce l'elenco di estensioni implicitamente aggiunte a ciascun comando prima di analizzare il percorso e in quale ordine.) (Uso molti script tcl e non è disponibile pubblicamente quale strumento potrebbe trovarli.)
  • Nessun supporto per le code page cmd.exe, che consente loro di visualizzare i percorsi con caratteri non ascii in modo errato. (Sono molto sensibile a questo, con il ç nel mio nome :-))
  • Nessun supporto per le distinte regole di ricerca in cmd.exe e nella riga di comando di PowerShell. (Nessuno strumento pubblicamente disponibile troverà script .ps1 in una finestra di PowerShell, ma non in una finestra di cmd!)

Così alla fine ho scritto il mio che, che sostiene correttamente tutto quanto sopra.

Disponibile qui: http://jf.larvoire.free.fr/progs/which.exe



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


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

oro su piattaforme Windows, mette tutte le utilities unix su un DOS Windows standard. Lo stavo usando da anni.

Ha un "che" incluso. Si noti che è maiuscole / minuscole.

NB: per installarlo, fai esplodere il file zip da qualche parte e aggiungi ... \ UnxUtils \ usr \ local \ wbin \ alla variabile env del tuo percorso di sistema.


Ho creato uno strumento simile a Ned Batchelder:

Ricerca di file .dll e .exe in PATH

Mentre il mio strumento è principalmente per la ricerca di varie versioni di dll mostra maggiori informazioni (data, dimensione, versione) ma non usa PATHEXT (spero di aggiornare presto il mio strumento).


Per voi utenti XP (che non hanno il comando integrato), ho scritto un comando "where like" come un rubygem chiamato whichr

Per installarlo, installa ruby

poi

gem install whichr

eseguilo come

c:\>whichr cmd_here



Sorpreso che nessuno abbia ancora menzionato cygwin come soluzione. Se non ti dispiace usare una soluzione di terze parti, allora cygwin è la strada da percorrere.

Cygwin ti dà il comfort di * nix nell'ambiente Windows (e puoi usarlo nella shell dei comandi di Windows o usare una shell * nix a tua scelta). Ti dà un'intera serie di comandi * nix (come i which ) per Windows, e puoi semplicemente includere quella directory nel tuo PATH .


In Windows CMD which chiama where :

$ where php
C:\Program Files\PHP\php.exe

Non so se questo aiuta. Inserito come risposta perché non so come formattare il codice nei commenti (help?)

Se riesci a trovare un compilatore pascal gratuito, puoi compilarlo o mandarmi una e-mail e posso provare a cercarne uno, o spedire per posta l'exe o postarlo da qualche parte. Inserisco il codice, per quanto sia cattivo, perché 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 existance 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 thru 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.

Non disponibile Windows, ma è fornito da Services for Unix e ci sono diversi script batch che girano attorno alla stessa cosa come questa.


Ho usato il modulo da npm per un bel po ', e funziona molto bene: https://www.npmjs.com/package/which È una grande alternativa multi piattaforma.

Ora sono passato a which che viene fornito con Git. Basta aggiungere al percorso il percorso /usr/bin da Git, che di solito è in C:\Program Files\Git\usr\bin\which.exe . Il which binario sarà in C:\Program Files\Git\usr\bin\which.exe . È più veloce e funziona come previsto.


Questo file batch utilizza la gestione delle variabili CMD per trovare il comando che verrebbe eseguito nel percorso. Nota: la directory corrente viene sempre eseguita prima del percorso) e, a seconda della chiamata API utilizzata, vengono cercati altri percorsi 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 un aiuto.


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

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


Windows Server 2003 e versioni successive (ovvero qualsiasi cosa dopo Windows XP a 32 bit) fornisce il programma where.exe che esegue alcuni di ciò which fa, sebbene corrisponda a tutti i tipi di file, non solo ai comandi eseguibili. (Non corrisponde ai comandi della shell incorporati come cd .) Accetta anche i caratteri jolly, quindi where nt* trova tutti i file nel %PATH% e nella directory corrente i cui nomi iniziano con nt .

Prova where /? per un aiuto.

Notare che Windows PowerShell definisce where un alias per il cmdlet Where-Object , quindi se si desidera where.exe , è necessario digitare il nome completo invece di omettere l'estensione .exe .


Per un problema simile (il mio problema era mostrare caratteri UTF-8 da MySQL al prompt dei comandi),

L'ho risolto così:

  1. Ho cambiato il carattere del prompt dei comandi in Lucida Console. (Questo passaggio deve essere irrilevante per la tua situazione. Deve farlo solo con ciò che vedi sullo schermo e non con quello che è realmente il personaggio).

  2. Ho cambiato la codepage in Windows-1253. Lo fai al prompt dei comandi di "chcp 1253". Ha funzionato per il mio caso in cui volevo vedere UTF-8.





windows command-line path-variables