Existe-t-il un équivalent de «qui» sur la ligne de commande Windows?


2353

Comme j'ai parfois des problèmes de chemin, où l'un de mes propres scripts cmd est caché (masqué) par un autre programme (plus tôt sur le chemin), je voudrais pouvoir trouver le chemin complet d'un programme sur la ligne de commande Windows, étant donné juste son nom.

Existe-t-il un équivalent à la commande UNIX 'which'?

Sous UNIX, which commandimprime le chemin complet de la commande donnée pour trouver et réparer facilement ces problèmes d'observation.


3
Foredecker: "qui" recherche dans le PATH l'exécutable qui sera exécuté si vous tapez une commande à l'invite du shell.
Greg Hewgill

3
par exemple, si vous avez 5 versions de Java installées et que vous ne savez pas laquelle est utilisée, vous pouvez taper "quel java" et cela vous donne le CHEMIN vers le binaire
ninesided

9
@Foredecker, MR dit que c'est "où" dans Win2k3 mais Win2k3 ne faisait pas partie de la question. Si "où" n'est pas dans les autres versions de Windows, d'autres réponses sont également valides. IMNSHO, la réponse qui fonctionne sur toutes les versions de Windows est la meilleure. De plus, les autres réponses ne sont pas fausses, juste différentes façons de le faire.
paxdiablo

36
Je sais que cette question s'est posée avant SuperUser, mais elle y appartient probablement.
palswim

16
Il n'y a pas de whichcommande sous Unix standard. L'utilitaire POSIX est type. Le C Shell a une commande which, et certains systèmes l'ont comme un exécutable externe. Par exemple, sur Debian Linux, whichprovient d'un paquet appelé debutils. Cet externe whichne "voit" pas les fonctions intégrées, les alias ou les fonctions du shell. typeEst-ce que; Bash typea une option pour supprimer cela et faire juste une recherche de chemin.
Kaz

Réponses:


2552

Windows Server 2003 et versions ultérieures (c'est-à-dire n'importe quoi après Windows XP 32 bits) fournissent le where.exeprogramme qui fait certaines de ces whichfonctions, bien qu'il corresponde à tous les types de fichiers, pas seulement aux commandes exécutables. (Il ne correspond pas aux commandes shell intégrées comme cd.) Il acceptera même les caractères génériques, donc where nt*trouve tous les fichiers dans votre %PATH%répertoire actuel dont les noms commencent parnt .

Essayer where /? d'obtenir de l'aide.

Notez que Windows PowerShell se définit wherecomme un alias pour l' Where-Objectapplet de commande , donc si vous le souhaitez where.exe, vous devez taper le nom complet au lieu d'omettre l' .exeextension.


30
Non, car grep examine le contenu de son entrée, que vous devez donner explicitement. which et where.exe ne regardent que les noms des fichiers dans un ensemble de répertoires définis dans les variables d'environnement PATH.
Michael Ratanapintha

12
@ Ajedi32 - Correct, qui n'est pas sous XP. Comme je l'ai dit, "Windows Server 2003 et versions ultérieures".
Michael Ratanapintha

24
Fonctionne dans Windows 8
volez le

58
attention à ce que cela ne fonctionne pas dans powershell sauf si vous tapez where.exe
JonnyRaa

17
N'oubliez pas que ce where.exen'est pas un shell intégré, vous devez en avoir %windir%\system32sur vous %PATH%- ce qui peut ne pas être le cas, car l'utilisation wheresuggère que vous pouvez travailler sur des problèmes avec votre chemin!
Tomasz Gandor du

288

Bien que les versions ultérieures de Windows aient une wherecommande, 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é PATHcar vous pouvez remplacer n'importe quelle variable d'environnement (au format de chemin, bien sûr) que vous souhaitez utiliser.


Et, si vous en voulez une qui peut gérer toutes les extensions dans PATHEXT (comme le fait Windows lui-même), celle-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.


7
Hé, j'aurais aimé avoir appris ça! Dommage que cela ne fonctionne pas avec MS-DOS ou Win9x (c'est-à-dire avec command.com). (Raymond Chen a une version plus "élaborée" que vous pouvez transformer en fichier batch: blogs.msdn.com/oldnewthing/archive/2005/01/20/357225.aspx )
Michael Ratanapintha

110
@Michael, si vous utilisez toujours DOS ou Win95, trouver les exécutables sur le chemin est le moindre de vos problèmes :-)
paxdiablo

Windows reconnaît plus que .exe comme exécutable. La dernière fois que j'ai codé un whichretour dans les jours W95 / DOS, l'ordre de recherche était - le répertoire actuel, puis chaque répertoire de chemin, pour cmd.com, puis cmd.exe, puis cmd.bat Donc, même cmd.bat dans le répertoire actuel est exécuté befroe cmd.exe dans le chemin
Mawg dit de réintégrer Monica

3
@mawg, l'original était pour l'endroit où vous connaissez l'extension car elle reflète celle sous UNIX (où cette astuce d'ajout d'extension ne se produit pas). J'en ai maintenant ajouté une qui peut faire ce que vous voulez mais ce n'est plus une simple commande autant qu'un script. Il essaie d'abord la commande sans fioritures puis chacune des extensions. J'espère que cela pourra aider. Vous pouvez l'adapter à vos besoins comme bon vous semble (si vous voulez le même ordre de recherche qu'avec Windows par exemple - celui-ci montre toutes les possibilités).
paxdiablo

2
Pour transformer ceci en script batch, créez un fichier appelé "which.bat": @echo off for %%i in (%1) do @echo. %%~$PATH:%i pour l'ajouter à un script alias.bat que vous chargez à chaque fois que vous exécutez cmd.exe (placez le script ci-dessus dans un nouveau répertoire appelé C: \ usr \ aliases): DOSKEY which=C:\usr\aliases\which.bat $* Ensuite, vous pouvez créer un script pour lancer cmd.exe avec le fichier alias.bat: cmd.exe /K E:\usr\aliases\alias.bat
Brad T.

152

Sous PowerShell, vous Get-Commandtrouverez les 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 également des applets de commande PowerShell, des fonctions, des alias, des fichiers avec des extensions exécutables personnalisées via $Env:PATHEXT, etc. définis pour le shell actuel (assez similaire à Bash type -a foo) - ce qui en fait un meilleur choix que d'autres outils comme where.exe,which.exe , etc. , qui ne sont pas conscients de ces Commandes PowerShell.

Recherche d'exécutables en utilisant uniquement une partie du nom

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

Recherche d'exécutables personnalisés

Pour trouver d'autres exécutables non Windows (python, ruby, perl, etc.), des extensions de fichier pour ces exécutables doivent être ajoutées à la PATHEXTvariable d'environnement (par défaut .COM;.EXE;.BAT;.CMD;.VBS;.VBE;.JS;.JSE;.WSF;.WSH;.MSC;.CPL) pour identifier les fichiers avec ces extensions dans l' PATHexécutable as. Comme Get-Commandelle honore également cette variable, elle peut être étendue pour répertorier les exécutables personnalisés. par exemple

$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

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

Pour plus d'informations et d'exemples, consultez l'aide en ligne de Get-Command.


2
Il trouve bien plus que de simples exécutables. Il capture également les fichiers de commandes
Maximilian Burszley

2
@ TheIncorrigible1 - si vous voulez parler des fichiers de commande tels que les fichiers de traitement par lots ( .BAT, .CMD, etc.), ils sont considérés comme exécutable parce que leurs extensions sont nommées dans la PATHEXTvariable (qui par défaut est PATHEXT=.COM;.EXE;.BAT;.CMD;.VBS;.VBE;.JS;.JSE;.WSF;.WSH;.MSC;.CPL). D'autres types d'exécutables (par exemple .py, .rbetc.) peuvent être ajoutés en ajoutant l'extension de fichier dans et en créant une association exécutable avecassoc / ftype- par exemple docs.python.org/3.3/using/…
shalomb


40

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

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

Plus est ici: Mon Manwich! PowerShell qui


1
Je cherchais cette commande Pithy PowerShell exacte. J'utilisais where.exe, mais avoir à jouer avec le code d'erreur en plus d'analyser sa sortie est bien inférieur à une solution native PowerShell. Merci!
scobi

9
Mais ($Env:Path).Split(";") | Get-ChildItem -filter programName*est si facile à taper ... ;-)
Craig

Cela échoue également si vous avez une variable dans votre chemin qui est normalement résolue par le système (aka% JAVA_HOME%).
dragon788

Je ne peux pas faire fonctionner which.exe, j'ai essayé cela et cela a fonctionné.
Asfand Qazi


24

Dans les whichappels Windows CMD where:

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

17

Cygwin est une solution. Si cela ne vous dérange pas d'utiliser une solution tierce, alors Cygwin est la solution.

Cygwin vous offre le confort de * nix dans l'environnement Windows (et vous pouvez l'utiliser dans votre shell de commande Windows, ou utiliser un shell * nix de votre choix). Il vous donne une multitude de commandes * nix (comme which) pour Windows, et vous pouvez simplement inclure ce répertoire dans votre PATH.


10
GnuWin32 mentionné plus tôt par Ferruccio est beaucoup mieux dans ce cas que vous pouvez avoir natif exécutable seul.
Piotr Dobrogost

GnuWin32 est génial, et je l'utilise, mais si vous voulez cette fonctionnalité sans installer les outils GnuWin32 où.exe semble être le bon appel. Cependant, je place les outils GnuWin32 dans un partage \ bin $ sur notre réseau afin de pouvoir les utiliser à partir de postes de travail (et dans des fichiers batch) qui ne les ont pas installés localement.
Craig

1
Lorsque nous parlons de l'utilisation de Cygwin dans Windows, je préfère: cygpath -w "` qui <appname> `"
mpasko256

12

Dans PowerShell, c'est le cas gcm, qui donne des informations formatées sur d'autres commandes. Si vous souhaitez récupérer uniquement le chemin d'accès à l'exécutable, utilisez.Source .

Par exemple: gcm gitou(gcm git).Source

Petits morceaux:

  • Disponible pour Windows XP.
  • Disponible depuis PowerShell 1.0.
  • gcmest un alias de Get-Commandcmdlet .
  • Sans aucun paramètre, il répertorie toutes les commandes disponibles offertes par le shell hôte.
  • Vous pouvez créer un alias personnalisé avec Set-Alias which gcmet l'utiliser comme:(which git).Source .
  • Documents officiels: https://technet.microsoft.com/en-us/library/ee176842.aspx

11

J'ai une fonction dans mon profil PowerShell nommée 'qui'

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:

Aucune des autres solutions n'a fonctionné pour moi mais > get-command app.exe | format-lista parfaitement fonctionné!
Alexander McFarlane

10

Allez chercher unxutils à partir d'ici: http://sourceforge.net/projects/unxutils/

or sur les plates-formes Windows, met tous les bons utilitaires Unix sur un DOS Windows standard. Je l'utilise depuis des années.

Il a un «qui» inclus. Notez cependant qu'il est sensible à la casse.

NB: pour l'installer, faites exploser le zip quelque part et ajoutez ... \ UnxUtils \ usr \ local \ wbin \ à la variable env de votre chemin système.


2
il n'est pas sensible à la casse, je dois également dire quel java.exe au lieu de quel java - windows 7
Kalpesh Soni

Il y a quelques frustrations bien que liées aux nouvelles lignes; grep par exemple ne correspondra pas à EOL sans que vous ayez mis un .pour le \ r. C'est une solution à 99% bien sûr!
dash-tom-bang

Oui, il ne respecte pas la casse, mais par défaut, les noms de fichiers dans Windows ne sont pas sensibles à la casse non plus.
Wernfried Domscheit

8

Pas en stock Windows mais il est fourni par Services pour Unix et il existe plusieurs scripts batch simples qui accomplissent la même chose comme celui -ci .


1
Sauf que la commande que vous liez ne produit que la variable PATH et ne vérifie même pas si le fichier s'y trouve.
Angel O'Sphere

8

Si vous pouvez trouver un compilateur Pascal gratuit, vous pouvez le compiler. Au moins, cela fonctionne et montre 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 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.

21
Wow, il y a encore des gens qui utilisent Pascal? :-)
paxdiablo

6
J'imagine qu'il y en a. Mais pas moi. Avez-vous vu la ligne program_date = '17 mars 1994 ';
Mawg dit réintégrer Monica

1
L'unité my_funk;est inutile. Merci d'avoir posté un programme Pascal, ça me rappelle ma jeunesse! Dommage que Pascal n'ait pas évolué.
yannis

2
Oh, mais ça l'a fait. Il est désormais orienté objet, par exemple. Lazarus-ide.org propose une excellente plate-forme, implémentation et IDE gratuits et un descendant direct de Borland vit toujours à Delphi sur embarcadero.com/products/delphi, ce qui est très cher (imo) à 299 $ pour l'édition de démarrage. et 1 000 $ pour l'édition «utilisable». Cependant, il s'agit d'une plateforme multiplateforme - Windows, iOS, Mac, Android. Obtenez une édition d'essai ou utilisez Lazarus et sentez-vous 20 ans plus jeune, -)
Mawg dit réintégrer Monica

1
@yannis "dommage que Pascal n'ait pas évolué" ... à part 'Turbo Pascal' Anders qui continue à concevoir C # vous voulez dire?
piers7

7

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

L'article sur le développement de "whereis" mérite d'être lu.


1
Commentaire tardif: whereis a des problèmes pour trouver des exécutables 64 bits sous Win 7 64 bits.
Axel Kemper


6

Aucun des ports Win32 d'Unix que j'ai pu trouver sur Internet n'est satisfaisant, car ils ont tous un ou plusieurs de ces défauts:

  • Pas de prise en charge de la variable Windows PATHEXT. (Ce qui définit la liste des extensions implicitement ajoutées à chaque commande avant de scanner le chemin, et dans quel ordre.) (J'utilise beaucoup de scripts tcl, et aucun outil publiquement disponible ne pourrait les trouver.)
  • Pas de prise en charge des pages de codes cmd.exe, ce qui les rend incorrectement afficher les chemins d'accès avec des caractères non ASCII. (J'y suis très sensible, avec le ç dans mon prénom :-))
  • Aucune prise en charge des règles de recherche distinctes dans cmd.exe et la ligne de commande PowerShell. (Aucun outil accessible au public ne trouvera de scripts .ps1 dans une fenêtre PowerShell, mais pas dans une fenêtre cmd!)

J'ai donc finalement écrit le mien, ce qui soutient tout ce qui précède correctement.

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


Pour info j'ai open source mon outil which.exe mentionné ci-dessus, et bien d'autres, sur github.com/JFLarvoire/SysToolsLib . Vous pouvez y obtenir la dernière version, signaler des problèmes, etc.
Jean-François Larvoire

6

Ce fichier de commandes utilise la gestion des variables CMD pour trouver la commande qui serait exécutée dans le chemin. Remarque: que le répertoire courant se fait toujours avant le chemin) et en fonction de l'appel d'API 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 de l'aide.


6

J'utilise GOW (GNU sous Windows) qui est une version allégée de Cygwin. Vous pouvez le récupérer sur GitHub ici .

GOW (GNU sous Windows) est l'alternative légère à Cygwin. Il utilise un programme d'installation Windows pratique qui installe environ 130 applications UNIX open source extrêmement utiles compilées en tant que binaires Win32 natifs. Il est conçu pour être aussi petit que possible, environ 10 Mo, contrairement à Cygwin qui peut fonctionner bien au-delà de 100 Mo selon les options. - À propos de la description (Brent R. Matzelle)

Une capture d'écran d'une liste de commandes incluses dans GOW:

Entrez la description de l'image ici


5

J'ai créé un outil similaire à Ned Batchelder:

Recherche de fichiers .dll et .exe dans PATH

Bien que mon outil soit principalement destiné à la recherche de 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).


5

Il suffit de publier ce fichier batch à une ligne de 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 examen:

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

Pas tout à fait une ligne si vous enveloppez le code dans setlocal enableextensionset endlocal.


2
Je préférerais cela sur plusieurs lignes pour que je puisse le comprendre. ;-)
Gringo Suave

4

Pour vous les utilisateurs de Windows XP (qui n'ont pas de wherecommande intégrée), j'ai écrit une commande "where like" sous la forme d'un rubygem appeléwhichr .

Pour l'installer, installez Ruby.

alors

gem install whichr

Exécutez-le comme:

C:> quir cmd_here


3
Je soupçonne que vous êtes sous-estimé parce que vous proposez de faire quoi que ce soit sur Windows XP.
sebastian-c

1
N'a pas diminué, mais l'installation de Ruby pour implémenter une commande triviale est également difficile à vendre. Il y a une boucle for au-dessus qui pourrait être mise dans un script batch.
Gringo Suave

2
Imprime-t-il les premières lignes de la chanson thème de The Witcher si vous l'exécutez en mode verbeux? ;)
Agi Hammerthief

3

TCC et TCC / LE de JPSoft sont des remplacements CMD.EXE qui ajoutent des fonctionnalités importantes. Relatif à la question du PO, whichest une commande intégrée pour les processeurs de commande de la famille TCC.


2

J'ai utilisé le whichmodule de npm pendant un bon moment, et cela fonctionne très bien: https://www.npmjs.com/package/which C'est une excellente alternative multi-plateforme.

Maintenant, je suis passé à celui whichqui vient avec Git. Ajoutez simplement à votre chemin le /usr/binchemin de Git, qui est généralement à C:\Program Files\Git\usr\bin\which.exe. Le whichbinaire sera à C:\Program Files\Git\usr\bin\which.exe. Il est plus rapide et fonctionne également comme prévu.


1

essaye ça

set a=%~$dir:1
If "%for%"=="" (Echo %1 not found) else (echo %1 found at %a%)
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.