Existe um equivalente de 'what' na linha de comando do Windows?

2352

Como às vezes tenho problemas de caminho, onde um dos meus próprios scripts cmd está oculto (sombreado) por outro programa (anteriormente no caminho), eu gostaria de encontrar o caminho completo para um programa na linha de comando do Windows, considerando apenas o seu nome.

Existe um equivalente ao comando UNIX 'what'?

No UNIX, which commandimprime o caminho completo do comando fornecido para localizar e reparar facilmente esses problemas de sombreamento.

namin
fonte
3
Foredecker: "which" pesquisa no PATH o executável que será executado se você digitar um comando no prompt do shell.
Greg Hewgill
3
Por exemplo, se você tem 5 versões do Java instalado e você não sabe qual deles está sendo usado você pode digitar "que java" e dá-lhe o caminho para o binário
ninesided
9
@Foredecker, MR diz que é "onde" no Win2k3, mas o Win2k3 não fazia parte da questão. Se "where" não estiver nas outras versões do Windows, outras respostas também serão válidas. IMNSHO, a resposta que funciona em todas as versões do Windows é a melhor. Além disso, as outras respostas não estão erradas, apenas diferentes maneiras de fazê-lo.
22468
36
Eu sei que essa pergunta surgiu antes do SuperUser, mas provavelmente pertence a ela.
palswim
16
Não há whichcomando no Unix padrão. O utilitário POSIX é type. O C Shell possui um comando which, e alguns sistemas o possuem como um executável externo. Por exemplo, no Debian Linux, whichvem de um pacote chamado debutils. Este externo whichnão "vê" built-ins, aliases ou funções do shell. typefaz; O Bash's typetem uma opção para suprimir isso e apenas fazer uma pesquisa de caminho.
Kaz

Respostas:

2551

O Windows Server 2003 e posterior (ou seja, qualquer coisa após o Windows XP 32 bits) fornece o where.exeprograma que faz parte do que whichfaz, embora corresponda a todos os tipos de arquivos, não apenas aos comandos executáveis. (Ele não corresponde aos comandos internos do shell, como cd.) Ele aceita até curingas, portanto, where nt*encontra todos os arquivos no %PATH%diretório atual e cujos nomes começam com nt.

Tente where /?ajuda.

Observe que o Windows PowerShell define wherecomo um alias para o Where-Objectcmdlet ; portanto, se você quiser where.exe, digite o nome completo em vez de omitir a .exeextensão.

Michael Ratanapintha
fonte
30
Não, porque o grep examina o conteúdo de sua entrada, que você deve fornecer explicitamente. which e where.exe examinam apenas os nomes dos arquivos em um conjunto de diretórios definidos nas variáveis ​​de ambiente PATH.
Michael Ratanapintha
12
@ Ajedi32 - Correto, que não está no XP. Como eu disse, "Windows Server 2003 e posterior".
Michael Ratanapintha
24
Funciona no Windows 8
rob
57
atente que este não vai funcionar no PowerShell a menos que você digite where.exe
JonnyRaa
17
Lembre-se de que where.exenão é um shell embutido, você precisa ter %windir%\system32no seu %PATH%- o que pode não ser o caso, pois o uso wheresugere que você pode estar trabalhando em problemas no seu caminho!
Tomasz Gandor
288

Embora as versões posteriores do Windows tenham um wherecomando, você também pode fazer isso no Windows XP usando os modificadores de variáveis ​​de ambiente, da seguinte maneira:

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

Você não precisa de ferramentas extras e isso não se limita, PATHpois você pode substituir qualquer variável de ambiente (no formato do caminho, é claro) que deseja usar.


E, se você quiser um que possa lidar com todas as extensões no PATHEXT (como o próprio Windows), este fará o truque:

@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

Na verdade, ele retorna todas as possibilidades, mas você pode ajustá-lo facilmente para regras de pesquisa específicas.

paxdiablo
fonte
7
Ei, eu gostaria de ter aprendido isso! Pena que não funciona com o MS-DOS ou Win9x (ou seja, com o command.com). (Raymond Chen tem uma versão mais "elaborado", você pode se transformar em um arquivo de lote: blogs.msdn.com/oldnewthing/archive/2005/01/20/357225.aspx )
Michael Ratanapintha
110
@ Michael, se você ainda estiver usando o DOS ou o Win95, encontrar executáveis ​​no caminho é o menor dos seus problemas :-) #
384
O Windows reconhece mais de .exe como executável. A última vez que codifiquei um whichretorno nos dias do W95 / DOS, a ordem de pesquisa foi - dir atual, depois cada diretório de caminho, para cmd.com, cmd.exe e cmd.bat Então, cmd.bat no dir atual é executado befroe cmd.exe em outro lugar no caminho
Mawg diz que restabelece Monica
3
@mawg, o original era para onde você conhece a extensão, uma vez que espelha a do UNIX (onde esse truque para adicionar extensões não ocorre). Agora adicionei um que pode fazer o que você deseja, mas não é mais um comando simples, mas um script. Primeiro, tenta o comando sem adornos e depois cada um dos de extensão. Espero que ajude. Você pode ajustá-lo às suas necessidades como achar melhor (se desejar a mesma ordem de pesquisa do Windows, por exemplo - esta mostra todas as possibilidades).
precisa
2
Para transformar isso em um script em lotes, crie um arquivo chamado "what.bat": @echo off for %%i in (%1) do @echo. %%~$PATH:%i Para adicioná-lo a um script alias.bat carregado toda vez que você executa o cmd.exe (coloque o script acima em um novo diretório chamado C: \ usr \ aliases): DOSKEY which=C:\usr\aliases\which.bat $* Em seguida, você pode criar um script para iniciar o cmd.exe com o arquivo alias.bat: cmd.exe /K E:\usr\aliases\alias.bat
Brad T.
152

No PowerShell, Get-Commandencontrará executáveis ​​em qualquer lugar $Env:PATH.

Get-Command eventvwr

CommandType   Name          Definition
-----------   ----          ----------
Application   eventvwr.exe  c:\windows\system32\eventvwr.exe
Application   eventvwr.msc  c:\windows\system32\eventvwr.msc

Também encontra cmdlets PowerShell, funções, aliases, arquivos com executáveis personalizados extensões via $Env:PATHEXT, etc. definidos para o shell atual (bastante semelhante ao Bash de type -a foo) - tornando-se uma melhor go-to que outras ferramentas como where.exe, which.exe, etc, que não têm conhecimento destes Comandos do PowerShell.

Localizando executáveis ​​usando apenas parte do 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
...

Localizando Executáveis ​​Customizados

Para encontrar outros executáveis ​​que não sejam do Windows (python, ruby, perl, etc), as extensões de arquivo desses executáveis ​​precisam ser adicionadas à PATHEXTvariável de ambiente (o padrão é .COM;.EXE;.BAT;.CMD;.VBS;.VBE;.JS;.JSE;.WSF;.WSH;.MSC;.CPL) para identificar os arquivos com essas extensões no PATHexecutável. Como Get-Commandtambém honra essa variável, ela pode ser estendida para listar executáveis ​​personalizados. por exemplo

$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

Você pode configurar rapidamente um alias com sal which gcm(forma abreviada de set-alias which get-command).

Mais informações e exemplos podem ser encontrados na ajuda online de Get-Command.

shalomb
fonte
2
Encontra muito mais do que apenas executáveis. Ele também captura os arquivos de comando
Maximilian Burszley 30/11
2
@ TheIncorrigible1 - se você quer dizer arquivos de comando , como arquivos em lote ( .BAT, .CMDetc), eles são considerados executáveis ​​porque suas extensões são nomeadas na PATHEXTvariável (que por padrão é PATHEXT=.COM;.EXE;.BAT;.CMD;.VBS;.VBE;.JS;.JSE;.WSF;.WSH;.MSC;.CPL). Outros tipos de executáveis ​​(por exemplo .py, .rbetc) podem ser adicionados adicionando a extensão do arquivo e criando uma associação executável com assoc/ ftype- por exemplo, docs.python.org/3.3/using/…
shalomb
59

No Windows PowerShell:

set-alias which where.exe
cmcginty
fonte
40

Se você possui o PowerShell instalado (o que eu recomendo), você pode usar o seguinte comando como um equivalente aproximado (substituir programName pelo nome do seu executável):

($Env:Path).Split(";") | Get-ChildItem -filter programName*

Mais está aqui: My Manwich! PowerShell Quais

RexE
fonte
1
Eu estava procurando por este exato comando conciso do powershell. Eu estava usando where.exe, mas ter que mexer com o código de erro além de analisar sua saída é muito inferior a uma solução nativa do PowerShell. Obrigado!
Scobi
9
Mas ($Env:Path).Split(";") | Get-ChildItem -filter programName*é tão fácil de escrever ... ;-)
Craig
Isso também falhará se você tiver uma variável em seu caminho que normalmente é resolvida pelo sistema (também conhecida como% JAVA_HOME%).
precisa saber é o seguinte
Não consigo obter o arquivo.exe.exe, tentei isso e funcionou.
Asfand Qazi
37

As ferramentas GnuWin32 têm which, junto com uma série de outras ferramentas Unix.

Ferruccio
fonte
24

Nas whichchamadas do Windows CMD where:

$ where php
C:\Program Files\PHP\php.exe
automatix
fonte
17

Cygwin é uma solução. Se você não se importa em usar uma solução de terceiros, o Cygwin é o caminho a seguir.

O Cygwin oferece o conforto do * nix no ambiente Windows (e você pode usá-lo no shell de comando do Windows ou no shell * nix de sua escolha). Ele fornece a você uma série de comandos * nix (como which) para Windows, e você pode apenas incluir esse diretório no seu PATH.

palswim
fonte
10
O GnuWin32 mencionado anteriormente por Ferruccio é muito melhor nesse caso, pois você pode ter nativo onde executável sozinho.
Piotr Dobrogost
O GnuWin32 é ótimo, e eu o uso, mas se você quiser essa funcionalidade sem instalar as ferramentas do GnuWin32 where.exe parece a decisão certa. Embora eu coloque as ferramentas do GnuWin32 em um compartilhamento \ bin $ em nossa rede, para que eu possa usá-las em estações de trabalho (e em arquivos em lotes) que não as instalem localmente.
Craig
1
Quando falamos sobre o uso do Cygwin no Windows, prefiro: cygpath -w "` what <appname> `"
mpasko256 8/08/15
12

No PowerShell, ele gcmfornece informações formatadas sobre outros comandos. Se você deseja recuperar apenas o caminho do executável, use .Source.

Por exemplo: gcm gitou(gcm git).Source

Petiscos:

  • Disponível para Windows XP.
  • Disponível desde o PowerShell 1.0.
  • gcmé um alias do Get-Commandcmdlet .
  • Sem nenhum parâmetro, ele lista todos os comandos disponíveis oferecidos pelo shell do host.
  • Você pode criar um alias de costume com Set-Alias which gcme usá-lo como: (which git).Source.
  • Documentos oficiais: https://technet.microsoft.com/en-us/library/ee176842.aspx
corvo vulcano
fonte
11

Eu tenho uma função no meu perfil do PowerShell chamada 'what'

function which {
    get-command $args[0]| format-list
}

Aqui está a aparência da saída:

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:
Fez
fonte
Nenhuma das outras soluções funcionou para mim, mas > get-command app.exe | format-listfuncionou perfeitamente!
Alexander McFarlane
10

Acesse unxutils aqui: http://sourceforge.net/projects/unxutils/

ouro nas plataformas Windows, coloca todos os utilitários unix em um DOS padrão do Windows. Utilizado há anos.

Tem um 'que' incluído. Note que é sensível a maiúsculas.

Nota: para instalá-lo, exploda o zip em algum lugar e adicione ... \ UnxUtils \ usr \ local \ wbin \ à variável env do caminho do sistema.

Jon Court
fonte
2
não é sensível a maiúsculas, também eu tenho que dizer que Java.exe vez de que java - windows 7
Kalpesh Soni
Ele tem algumas frustrações, embora tenha a ver com novas linhas; grep, por exemplo, não corresponderá ao EOL sem você colocar um .para the \ r. É uma solução de 99%, com certeza!
Dash-tom-bang
Sim, não diferencia maiúsculas de minúsculas; no entanto, por padrão, os nomes de arquivo no Windows também não diferenciam maiúsculas de minúsculas.
Wernfried Domscheit
8

Não em estoque Windows, mas ele é fornecido pelo Services for Unix e há vários scripts simples em lote por aí que realizar a mesma coisa tão presente este .

Robert Gamble
fonte
1
Exceto que o comando que você vincula gera apenas a variável PATH e nem verifica se o arquivo foi encontrado lá.
Anjo O'Sphere
8

Se você pode encontrar um compilador Pascal gratuito, é possível compilá-lo. Pelo menos funciona e mostra o algoritmo necessário.

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.
Mawg diz que restabelece Monica
fonte
21
Uau, ainda há pessoas usando Pascal? :-)
paxdiablo 26/03
6
Eu imagino que existem. Mas eu não. Você viu a linha program_date = '17 março 1994 ';
Mawg diz que restabelece Monica em 26/03/10
1
A unidade não my_funk;é necessária. Obrigado por postar um programa em Pascal, me lembra minha juventude! É uma pena que Pascal não tenha evoluído.
yannis
2
Ah, mas fez. Agora é orientado a objetos, por exemplo. Existe uma ótima implementação gratuita e multiplataforma, e IDE no lazarus-ide.org. E um descendente direto da Borland ainda mora em Delphi em embarcadero.com/products/delphi, que é muito caro (imo) por US $ 299 para a edição inicial e US $ 1 mil para a edição "utilizável". No entanto, é multiplataforma - Windows, iOS, Mac, Android. Faça uma edição de avaliação ou use o Lazarus e sinta-se 20 anos mais novo, -)
Mawg diz que restabelece Monica em 27/08/2015
1
@yannis "uma pena que Pascal não tenha evoluído" ... além de 'Turbo Pascal' Anders projetando C #, você quer dizer?
piers7
7

A melhor versão disso que encontrei no Windows é o utilitário "whereis", de Joseph Newcomer, que está disponível (com a fonte) em seu site .

Vale a pena ler o artigo sobre o desenvolvimento de "whereis".

Tim Lesher
fonte
1
Comentário tardio: onde há problemas para encontrar executáveis ​​de 64 bits no Win 7 de 64 bits.
Axel Kemper
7

Você pode instalar o Git primeiro a partir do Download Git e, em seguida, abra o Git Bash e digite:

which app-name
hamidreza samsami
fonte
6

Nenhuma das portas Win32 do Unix que eu encontrei na Internet é satistatória, porque todas elas têm uma ou mais dessas deficiências:

  • Não há suporte para a variável PATHEXT do Windows. (Que define a lista de extensões adicionadas implicitamente a cada comando antes de verificar o caminho e em qual ordem.) (Eu uso muitos scripts tcl, e nenhuma ferramenta disponível publicamente que ferramenta possa encontrá-los.)
  • Não há suporte para páginas de código cmd.exe, o que faz com que eles exibam caminhos com caracteres não-ascii incorretamente. (Eu sou muito sensível a isso, com o ç no meu primeiro nome :-))
  • Não há suporte para as regras de pesquisa distintas no cmd.exe e na linha de comando do PowerShell. (Nenhuma ferramenta disponível publicamente encontrará scripts .ps1 em uma janela do PowerShell, mas não em uma janela do cmd!)

Então, eu finalmente escrevi o meu próprio que, que suporta tudo acima corretamente.

Disponível lá: http://jf.larvoire.free.fr/progs/which.exe

Jean-François Larvoire
fonte
Para sua informação, disponibilizei minha ferramenta which.exe mencionada acima e muitas outras em github.com/JFLarvoire/SysToolsLib . Você pode obter a versão mais recente lá, problemas de relatório, etc.
Jean-François Larvoire
6

Esse arquivo em lote usa a manipulação de variáveis ​​CMD para encontrar o comando que seria executado no caminho. Nota: que o diretório atual é sempre feito antes do caminho) e, dependendo de qual chamada da API é usada, outros locais são pesquisados ​​antes / depois do caminho.

@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%)

Veja set /?para ajuda.


fonte
6

Estou usando o GOW (GNU no Windows), que é uma versão light do Cygwin. Você pode obtê-lo no GitHub aqui .

GOW (GNU no Windows) é a alternativa mais leve ao Cygwin. Ele usa um instalador conveniente do Windows que instala cerca de 130 aplicativos UNIX de código aberto extremamente úteis, compilados como binários nativos do win32. Ele foi projetado para ter o menor tamanho possível, cerca de 10 MB, em oposição ao Cygwin, que pode executar mais de 100 MB, dependendo das opções. - Sobre a descrição (Brent R. Matzelle)

Uma captura de tela de uma lista de comandos incluídos no GOW:

Digite a descrição da imagem aqui

Prayson W. Daniel
fonte
5

Eu criei uma ferramenta semelhante ao Ned Batchelder:

Pesquisando arquivos .dll e .exe no PATH

Embora minha ferramenta seja principalmente para pesquisar várias versões de dll, ela mostra mais informações (data, tamanho, versão), mas não usa PATHEXT (espero atualizar minha ferramenta em breve).

Michał Niklas
fonte
5

Apenas é necessário postar o arquivo em lotes de liner deste 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

Um teste:

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

Não é uma linha única, se você incluir o código em setlocal enableextensionse endlocal.

bobbogo
fonte
2
Preferiria isso em várias linhas para que eu pudesse entender. ;-)
Gringo Suave
4

Para você, usuários do Windows XP (que não possuem wherecomando interno), escrevi um comando "where like" como um rubygem chamado whichr.

Para instalá-lo, instale o Ruby.

Então

gem install whichr

Execute-o como:

C:> qual cmd_aqui

rogerdpack
fonte
3
Suspeito que você esteja com o voto negativo porque está sugerindo fazer algo no Windows XP.
sebastian-c
1
Não diminuiu o voto, mas instalar o Ruby para implementar um comando trivial também é uma venda difícil. Existe um loop for acima que pode ser colocado em um script em lote.
Gringo Suave
2
Ele imprime as linhas de abertura da música tema de The Witcher se você a executar no modo detalhado? ;)
Agi Hammerthief 25/11/19
3

TCC e TCC / LE da JPSoft são substituições do CMD.EXE que adicionam funcionalidade significativa. Relevante à pergunta do OP, whichhá um comando interno para os processadores de comando da família TCC.

David G
fonte
2

Eu uso o whichmódulo da npm há um bom tempo e funciona muito bem: https://www.npmjs.com/package/which É uma ótima alternativa multiplataforma.

Agora mudei para o whichque vem com o Git. Basta adicionar ao seu caminho o /usr/bincaminho do Git, que geralmente está em C:\Program Files\Git\usr\bin\which.exe. O whichbinário estará em C:\Program Files\Git\usr\bin\which.exe. É mais rápido e também funciona como esperado.

Giovanni Bassi
fonte
1

tente isso

set a=%~$dir:1
If "%for%"=="" (Echo %1 not found) else (echo %1 found at %a%)

fonte