les - which command windows




Y a-t-il un équivalent de 'which' sur la ligne de commande de Windows? (14)

Comme j'ai parfois des problèmes de chemin, lorsqu'un de mes propres scripts cmd est caché (occulté) 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 de Windows, étant donné juste son nom.

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

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


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

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

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

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


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 variable 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 de chemin, bien sûr) que vous souhaitez utiliser.

Et, si vous en voulez un qui peut gérer toutes les extensions dans PATHEXT (comme Windows lui-même le fait), 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 retourne toutes les possibilités, mais vous pouvez le modifier assez facilement pour des règles de recherche spécifiques.


Ce fichier de commandes utilise la gestion des variables CMD pour trouver la commande qui sera exécutée dans le chemin. Note: le répertoire courant est toujours fait avant le chemin) et en fonction de l'appel API utilisé, d'autres localisations sont recherchées 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 aider.


Dans PowerShell, c'est 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 git ou (gcm git).Source

Tidbits:

  • Disponible pour Windows XP
  • Disponible depuis PowerShell 1.0.
  • gcm est un alias de la cmdlet Get-Command .
  • 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 gcm et l'utiliser comme: (which git).Source .
  • Documents officiels: https://technet.microsoft.com/en-us/library/ee176842.aspx

Dans Windows PowerShell:

set-alias which where.exe

Dunno si cela aide. Publié comme réponse parce que je ne sais pas comment mettre en forme le code dans les commentaires (aide?)

Si vous pouvez trouver un compilateur pascal gratuit, vous pouvez le compiler, ou m'envoyer un email et je peux essayer d'en extraire un, ou poster l'exe ou le poster quelque part. Je poste le code, aussi mauvais soit-il, car 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 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.

J'ai une fonction dans mon profil PowerShell nommé '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:

J'utilise GOW (Gnu sur Windows) qui est une version allégée de cygwin. Vous pouvez le grap de github here.

Gow (Gnu sur Windows) est l'alternative légère à Cygwin. Il utilise un installateur 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, par opposition à Cygwin qui peut fonctionner bien au-delà de 100 Mo en fonction des options. - À propos de Description (Brent R. Matzelle)

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


Les outils GnuWin32 ont, avec un tas d'autres outils Unix.


Pas en stock Windows mais il est fourni par Services for Unix et il y a plusieurs scripts batch simples qui circulent et qui accomplissent la même chose que celle -ci .



Sous PowerShell, get-command trouvera 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, des fonctions, des alias, des fichiers avec des extensions exécutables personnalisées via $Env:PATHEXT , etc, défini pour le shell actuel (un peu comme le type -a foo de bash type -a foo ), ce qui en fait un meilleur outil. where.exe , which.exe , etc qui ne sont pas au courant de ces commandes PowerShell.

Vous pouvez rapidement mettre en place un alias avec sal which gcm (forme courte de set-alias which get-command ).


TCC et TCC / LE de JPSoft sont des remplacements CMD.EXE qui ajoutent des fonctionnalités significatives. Correspondant à la question du PO, which est un commandement intégré pour les responsables du traitement des commandes familiales de la CCT.






path-variables