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

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.

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.

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.

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.

No Windows PowerShell:

set-alias which where.exe

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

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

Nas whichchamadas do Windows CMD where:

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

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.

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

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:

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.

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 .

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.

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".

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

which app-name

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

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.

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:

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).

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.

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

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.

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.

tente isso

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