Existe-t-il un équivalent de "which" sur la ligne de commande Windows?

alors que les versions ultérieures de Windows ont une commande where , vous pouvez également le faire avec Windows XP en utilisant les modificateurs de variables d'environnement, comme suit:

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

vous n'avez pas besoin d'outils supplémentaires et ce n'est pas limité à PATH car vous pouvez remplacer n'importe quelle variable d'environnement (dans le format path, bien sûr) que vous souhaitez utiliser.

et, si vous voulez un qui peut gérer toutes les extensions dans PATHEXT (comme Windows lui-même), celui-ci fait l'affaire:

@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

il renvoie en fait toutes les possibilités mais vous pouvez le modifier assez facilement pour des règles de recherche spécifiques.

sous PowerShell get-command trouvera des exécutables n'importe où dans $Env:PATH .

get-command eventvwr

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

il trouve aussi des cmdlets powershell, des fonctions, des alias, des fichiers avec des extensions exécutables personnalisées via $Env:PATHEXT , etc défini pour le shell actuel (assez proche de celui de bash type -a foo )-ce qui en fait un meilleur go-to Que d'autres outils comme where.exe , which.exe , etc qui ne sont pas au courant de ces commandes PowerShell.

vous pouvez rapidement configurer un alias avec sal which gcm (forme abrégée de set-alias which get-command ).

dans windows powershell:

set-alias which where.exe

si vous avez PowerShell installé (ce que je recommande), vous pouvez utiliser la commande suivante comme équivalent approximatif (substitue programName pour le nom de votre exécutable):

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

plus ici: http://www.codeassassin.com/blog/PermaLink,guid, fd1967d1-f844-4e29-82e2-f2d6424b4ef9.aspx

le GnuWin32 outils ont which , avec un ensemble complet d'autres outils Unix.

Dans Windows CMD which appels where :

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

surpris que personne n'ait encore mentionné cygwin comme solution. Si cela ne vous dérange pas d'utiliser une solution tierce partie, alors cygwin est la voie à suivre.

Cygwin vous donne le confort de *nix dans L'environnement Windows (et vous pouvez l'utiliser dans votre shell Windows command, ou utiliser un shell *nix de votre choix). Il vous donne un hôte entier de commandes * nix (comme which ) Pour Windows, et vous pouvez juste inclure que répertoire dans votre PATH .

dans PowerShell , c'est gcm , qui donne des informations formatées sur d'autres commandes. Si vous voulez récupérer seulement le chemin vers l'exécutable, utilisez .Source .

par exemple: gcm git ou (gcm git).Source

Tidbits:

• Disponible pour Windows XP.
• Disponible depuis PowerShell 1.0.
• gcm est un alias de Get-Command applet de commande .
• sans aucun paramètre, il Liste toutes les commandes disponibles offertes par le shell hôte.
• vous pouvez créer un alias personnalisé avec Set-Alias which gcm et l'utiliser comme: (which git).Source .
• documents officiels: https://technet.microsoft.com/en-us/library/ee176842.aspx

allez chercher des unxutils d'ici: http://sourceforge.net/projects/unxutils/

or sur les plates-formes windows, met tous les utilitaires unix nice sur un DOS windows standard. Été utilisé pendant des années.

Il a un " qui " inclus. Notez que c'est sensible à la casse.

NB: pour l'installer exploser la fermeture éclair quelque part et ajouter ...\UnxUtils\usr\local\wbin\ à votre chemin d'accès au système env variable.

j'ai une fonction dans mon profil PowerShell appelée 'which'

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

voici à quoi ressemble la sortie:

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:

Je ne sais pas si ça peut aider. Posté comme réponse parce que je ne sais pas comment formater le code dans les commentaires (aide?)

si vous pouvez trouver un compilateur pascal libre, Vous pouvez compiler ceci, ou m'envoyer un email et je peux essayer d'en extraire un, ou renvoyer l'exe ou le poster quelque part. Je poste le code, mauvais comme il est, parce qu'au moins il fonctionne et indique l'algorithme nécessaire.

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.

pas dans les fenêtres de stock, mais il est fourni par Services pour Unix et il y a plusieurs scripts de lot simple flottant autour qui accomplissent la même chose telle que cette celle-ci .

la meilleure version de ce que j'ai trouvé sur Windows est l'utilitaire" Whois "de Joseph Newcomer, qui est disponible (avec source) à partir de son site .

l'article sur le développement de" Whois " vaut la peine d'être lu.

j'ai créé outil similaire à Ned Batchelder:

recherche .dll et .fichiers exe dans le chemin

alors que mon outil est primordial pour la recherche des différentes versions de dll, il affiche plus d'informations (date, Taille, version) mais il n'utilise pas PATHEXT (j'espère mettre à jour mon outil bientôt).

aucun des ports Win32 D'Unix que j'ai pu trouver sur L'Internet ne sont satistactoires, parce qu'ils ont tous un ou plusieurs de ces défauts:

• No support for Windows PATHEXT variable. (Qui définit la liste des extensions implicitement ajoutés à chaque commande avant de numériser le chemin, et dans quel ordre.) (J'ai utiliser beaucoup de scripts tcl, et pas publiquement disponibles, ce qui pourrait les trouver.)
• aucun soutien pour cmd.code exe les pages, ce qui les rend Afficher des chemins avec des caractères non-ascii incorrectement. (Je suis très sensible à ça, avec le ç dans mon prénom :-))
• pas de support pour les règles de recherche distinctes dans cmd.exe et la ligne de commande PowerShell. (Aucun outil accessible au public ne sera trouvé .les scripts ps1 dans une fenêtre PowerShell, mais pas dans une fenêtre cmd!)

donc j'ai finalement écrit mon propre qui, qui soutient tout ce qui précède correctement.

Disponible: http://jf.larvoire.free.fr/progs/which.exe

ce fichier batch utilise la gestion des variables CMD pour trouver la commande qui serait exécutée dans le chemin. Note: le répertoire courant est toujours fait avant le chemin) et en fonction de quel appel API est utilisé d'autres emplacements sont recherchés avant/après le chemin.

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

Voir set /? pour obtenir de l'aide.

vous pouvez d'abord installer git à partir de https://git-scm.com/download/win puis ouvrez git bash et tapez

which app-name

TCC et TCC / LE de JPSoft sont CMD.Les remplacements de EXE qui ajoutent une fonctionnalité importante. En ce qui concerne la question de L'OP, which est une commande intégrée pour les processeurs de commande de la famille TCC.

pour vous utilisateurs de XP (qui n'ont pas de commande where intégrée), j'ai écrit un" où comme "commande comme un rubygem appelé whichr

pour l'installer, installez ruby

puis

gem install whichr

exécuter comme

c:\>whichr cmd_here

j'utilise Gow(Gnu sur Windows) qui est une version légère de cygwin. Vous pouvez l'attraper à partir de github ici.

Gow (Gnu On Windows) est l'alternative légère à Cygwin. Il utilise un installateur de Windows pratique qui installe environ 130 extrêmement applications UNIX open source utiles compilées en tant que win32 natif binaire. Il est conçu pour être aussi petit que possible, environ 10 MB, comme contrairement à Cygwin qui peut bien fonctionner plus de 100 MB selon option. - À Propos De La Description(Brent R. Matzelle)

Capture d'écran d'une liste de commandes inclus dans GOW.

j'utilise depuis longtemps le module which de la npm, et il fonctionne très bien: https://www.npmjs.com/package/which C'est un grand multi-plateforme alternative.

maintenant je suis passé au which qui vient avec Git. Il suffit d'ajouter à votre chemin le chemin /usr/bin de Git, qui est habituellement à C:\Program Files\Git\usr\bin\which.exe . Le binaire which sera à C:\Program Files\Git\usr\bin\which.exe . Il est plus rapide et fonctionne également comme prévu.