වින්ඩෝස් විධාන රේඛාවේ 'කුමන' ට සමානද?

මට සමහර විට මාර්ග ගැටලු ඇති බැවින්, මගේම cmd ස්ක්‍රිප්ට් එකක් වෙනත් වැඩසටහනකින් සඟවා (සෙවනැලි කර ඇති) වෙනත් වැඩසටහනකින් (කලින් මාර්ගයේ), වින්ඩෝස් විධාන රේඛාවේ ඇති වැඩසටහනකට සම්පූර්ණ මාර්ගය සොයා ගැනීමට මම කැමතියි. එහි නම පමණි.

'කුමන' යුනික්ස් විධානයට සමානද?

යුනික්ස් හි, which commandමෙම සෙවනැලි ගැටළු පහසුවෙන් සොයා ගැනීමට සහ අලුත්වැඩියා කිරීමට දී ඇති විධානයේ සම්පූර්ණ මාර්ගය මුද්‍රණය කරයි.

වින්ඩෝස් සර්වර් 2003 සහ ඊට පසු (එනම් වින්ඩෝස් එක්ස්පී 32 බිට් පසු ඕනෑම දෙයක්) මඟින් where.exeවැඩසටහන මඟින් whichසපයනුයේ එය ක්‍රියාත්මක කළ හැකි විධානයන්ට පමණක් නොව සියලු වර්ගවල ලිපිගොනු වලට ගැලපෙන නමුත් එය කරන දේය . (එය බිල්ට් ෂෙල් විධාන වැනි නොගැලපේcd .) එය ආදේශක කාඩ්පත් පවා පිළිගනු ඇත, එබැවින් where nt*ඔබගේ %PATH%සහ වර්තමාන නාමාවලියෙහි ඇති සියලුම ලිපිගොනු සොයා ගනී nt.

where /?උදව් සඳහා උත්සාහ කරන්න.

වින්ඩෝස් පවර්ෂෙල් cmdletwhere සඳහා අන්වර්ථයක් ලෙස අර්ථ දක්වන බව Where-Objectසලකන්න , එබැවින් ඔබට අවශ්‍ය නම් where.exe, .exeදිගුව මඟ හැරීම වෙනුවට සම්පූර්ණ නම ටයිප් කළ යුතුය .

වින්ඩෝස් හි පසු සංස්කරණ වලට whereවිධානයක් ඇති අතර , ඔබට පහත සඳහන් පරිදි පරිසර විචල්‍ය විකරණකාරක භාවිතා කරමින් වින්ඩෝස් එක්ස්පී සමඟ මෙය කළ හැකිය:

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

ඔබට අමතර මෙවලම් අවශ්‍ය නොවන අතර එය භාවිතා කිරීමට PATHඔබ කැමති ඕනෑම පරිසර විචල්‍යයක් (මාර්ග ආකෘතියේ, ඇත්ත වශයෙන්ම) ආදේශ කළ හැකි බැවින් එය සීමා නොවේ .

තවද, ඔබට PATHEXT හි ඇති සියලුම දිගු හැසිරවිය හැකි එකක් අවශ්‍ය නම් (වින්ඩෝස් මෙන්), මෙය උපක්‍රමය කරයි:

@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

එය සැබවින්ම සියලු හැකියාවන් ආපසු ලබා දෙන නමුත් නිශ්චිත සෙවුම් නීති සඳහා ඔබට එය පහසුවෙන් වෙනස් කළ හැකිය.

පවර්ෂෙල් යටතේ, Get-Commandඕනෑම තැනක ක්‍රියාත්මක කළ හැකි දේ සොයාගත හැකිය $Env:PATH.

Get-Command eventvwr

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

එය ද PowerShell cmdlets, කාර්යයන්, යළි-යොමුවීම්, අභිරුචි ක්රියාත්මක කළ දිගු ගොනු හරහා සම්බ $Env:PATHEXT, ආදිය වත්මන් shell (තරමක් බෑෂ් ගේ සමාන අර්ථ type -a fooවැනි අනෙකුත් මෙවලම් වඩා එය වඩාත් හොඳ යැමට අවශ්ය බවට -) where.exe, which.exeමේ කිසිවක් නොදැන සිටින ආදිය, පවර්ෂෙල් විධාන.

නමේ කොටසක් පමණක් භාවිතා කරමින් ක්‍රියාත්මක කළ හැකි දේ සොයා ගැනීම

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

අභිරුචි ක්‍රියාත්මක කළ හැකි දේ සොයා ගැනීම

වෙනත් වින්ඩෝස් නොවන ක්‍රියාත්මක කළ හැකි දේ සොයා ගැනීමට (පයිතන්, රූබි, පර්ල්, ආදිය), ක්‍රියාත්මක කළ හැකි ලෙස මෙම දිගු සමඟ ලිපිගොනු හඳුනා ගැනීම සඳහා එම ක්‍රියාත්මක කළ හැකි අය සඳහා ගොනු දිගු කිරීම PATHEXTපාරිසරික විචල්‍යයට (පෙරනිමියෙන් .COM;.EXE;.BAT;.CMD;.VBS;.VBE;.JS;.JSE;.WSF;.WSH;.MSC;.CPL) එකතු කළ යුතුය PATH. Get-Commandමෙම විචල්‍යයට ගරු කරන ආකාරයටම , අභිරුචි ක්‍රියාත්මක කළ හැකි ලැයිස්තුගත කිරීම සඳහා එය දීර් can කළ හැකිය. උදා

$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

sal which gcm(කෙටි ස්වරූපයෙන් set-alias which get-command) සමඟ අන්වර්ථයක් ඔබට ඉක්මනින් සැකසිය හැකිය .

සඳහා මාර්ගගත උදව් යටතේ වැඩි විස්තර සහ උදාහරණ සොයාගත හැකිය Get-Command.

වින්ඩෝස් පවර්ෂෙල් හි:

set-alias which where.exe

ඔබ පවර්ෂෙල් ස්ථාපනය කර ඇත්නම් (මම නිර්දේශ කරන), ඔබට පහත විධානය දළ වශයෙන් සමාන ලෙස භාවිතා කළ හැකිය (ඔබේ ක්‍රියාත්මක කළ හැකි නම සඳහා ආදේශක ක්‍රමලේඛ නාමය):

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

තවත් මෙහි ඇත: මගේ මැන්විච්! පවර්ෂෙල් කුමන

මෙම GnuWin32 මෙවලම් ද තිබිය whichවෙනත් යුනික්ස් මෙවලම් මුළු මරා සමග.

වින්ඩෝස් සීඑම්ඩී whichඇමතුම් වල where:

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

සිග්වින් විසඳුමකි. තෙවන පාර්ශවීය විසඳුමක් භාවිතා කිරීම ඔබට ප්‍රශ්නයක් නොවේ නම්, සිග්වින් යනු යා යුතු මාර්ගයයි.

සිග්වින් ඔබට වින්ඩෝස් පරිසරය තුළ * නික්ස් හි සුවපහසුව ලබා දෙයි (ඔබට එය ඔබේ වින්ඩෝස් විධාන කවචයේ භාවිතා කළ හැකිය, නැතහොත් ඔබේ අභිමතය පරිදි * නික්ස් කවචයක් භාවිතා කරන්න). එය ඔබට whichවින්ඩෝස් සඳහා * නික්ස් විධාන (වැනි ) සම්පුර්ණ ධාරකයක් ලබා දෙන අතර, ඔබට එම නාමාවලිය ඔබගේ තුළට ඇතුළත් කළ හැකිය PATH.

පවර්ෂෙල් හි, එය gcm, වෙනත් විධානයන් පිළිබඳ ආකෘතිගත තොරතුරු ලබා දෙයි. ක්‍රියාත්මක කළ හැකි මාර්ගය පමණක් ලබා ගැනීමට ඔබට අවශ්‍ය නම්, භාවිතා කරන්න.Source .

උදාහරණයක් ලෙස: gcm gitහෝ(gcm git).Source

තොරතුරු:

• වින්ඩෝස් එක්ස්පී සඳහා ලබා ගත හැකිය.
• පවර්ෂෙල් 1.0 සිට ලබා ගත හැකිය.
• gcmcmdlet හි අන්වර්ථයකිGet-Command .
• කිසිදු පරාමිතියක් නොමැතිව, එය ධාරක කවචය මඟින් ලබා ගත හැකි සියලුම විධාන ලැයිස්තුගත කරයි.
• ඔබට අභිරුචි අන්වර්ථයක් නිර්මාණය කර Set-Alias which gcmඑය භාවිතා කළ හැකිය:(which git).Source .
• නිල ලියකියවිලි: https://technet.microsoft.com/en-us/library/ee176842.aspx

මගේ පවර්ෂෙල් පැතිකඩෙහි 'කුමන' නමින් ශ්‍රිතයක් ඇත

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

නිමැවුමේ පෙනුම මෙන්න:

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:

මෙතැනින් unxutils ලබා ගන්න: http://sourceforge.net/projects/unxutils/

වින්ඩෝස් වේදිකාවල රන්, සියලු හොඳ යුනික්ස් උපයෝගිතා සම්මත වින්ඩෝස් ඩොස් මත තබයි. වසර ගණනාවක් තිස්සේ එය භාවිතා කර ඇත.

එයට 'එය' ඇතුළත් වේ. එය සිද්ධි සංවේදී බව සලකන්න.

සැ.යු: එය ස්ථාපනය කිරීම සඳහා කොතැනක හෝ සිප් එක පුපුරා ගොස් ... x UnxUtils \ usr \ local \ wbin your ඔබේ පද්ධති මාවත env විචල්‍යයට එක් කරන්න.

ඔබට නොමිලේ පැස්කල් සම්පාදකයෙකු සොයා ගත හැකි නම්, ඔබට මෙය සම්පාදනය කළ හැකිය. අවම වශයෙන් එය ක්‍රියාත්මක වන අතර අවශ්‍ය ඇල්ගොරිතම පෙන්වයි.

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.

කොටස් Windows හි නමුත් එය ලබා නැති යුනික්ස් සඳහා සේවා සහ එවැනි මෙම එකම දේ ඉටු ක් පමණ පාවෙමින් සරල කණ්ඩායම පිටපත් කිහිපයක් ඇති මේ එක .

වින්ඩෝස් හි මා සොයාගත් මෙහි හොඳම අනුවාදය වන්නේ ජෝසෆ් නිව්කොමර්ගේ “කොහේද” උපයෝගීතාවයි, එය ඔහුගේ වෙබ් අඩවියෙන් ලබා ගත හැකිය (ප්‍රභවය සමඟ) .

"කොහේද" සංවර්ධනය පිළිබඳ ලිපිය කියවීම වටී.

ඔබට පළමුව Git බාගත කිරීමෙන් Git ස්ථාපනය කළ හැකිය , පසුව Git Bash විවෘත කර ටයිප් කරන්න:

which app-name

මට යුනික්ස් හි වින් 32 වරායන් කිසිවක් අන්තර්ජාලයේ සොයාගත නොහැකි විය, මන්ද ඒවා සියල්ලටම මෙම අඩුපාඩු එකක් හෝ කිහිපයක් තිබේ:

• වින්ඩෝස් PATHEXT විචල්‍යයට සහය නොදක්වයි. (එමඟින් මාර්ගය පරිලෝකනය කිරීමට පෙර එක් එක් විධානයට ව්‍යංගයෙන් එකතු කරන ලද දිගු ලැයිස්තුව නිර්වචනය කරයි, සහ කුමන අනුපිළිවෙලටද?) (මම බොහෝ tcl ස්ක්‍රිප්ට් භාවිතා කරමි, ඒවා සොයාගත හැකි මෙවලම ප්‍රසිද්ධියේ නොමැත.)
• Cmd.exe කේත පිටු සඳහා සහය නොදක්වන අතර, එමඟින් ඇස්කි නොවන අක්ෂර සහිත මාර්ග වැරදි ලෙස පෙන්වයි. (මගේ මුල් නමේ with සමඟ: මම ඒ ගැන ඉතා සංවේදී වෙමි)
• Cmd.exe සහ PowerShell විධාන රේඛාවේ පැහැදිලි සෙවුම් නීති සඳහා සහය නොදක්වයි. (ප්‍රසිද්ධියේ ලබා ගත හැකි කිසිදු මෙවලමක් පවර්ෂෙල් කවුළුවක .ps1 ස්ක්‍රිප්ට් සොයාගන්නේ නැත, නමුත් cmd කවුළුවක නොවේ!)

ඒ නිසා මම අවසානයේදී මගේම දෑ ලිව්වා.

එහි ඇත: http://jf.larvoire.free.fr/progs/which.exe

මෙම කාණ්ඩ ගොනුව CMD විචල්‍ය හැසිරවීම භාවිතා කරමින් මාර්ගයෙහි ක්‍රියාත්මක වන විධානය සොයා ගනී. සටහන: වත්මන් ඩිරෙක්ටරිය සෑම විටම මාර්ගයට පෙර සිදු කරන බව) සහ ඒපීඅයි ඇමතුම භාවිතා කරන්නේ කුමන ස්ථානයද යන්න මත පදනම්ව වෙනත් ස්ථාන මාර්ගයට පෙර / පසු සොයනු ලැබේ.

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

set /?උදව් සඳහා බලන්න .

මම භාවිතා කරන්නේ සිග්වින්ගේ සැහැල්ලු අනුවාදයක් වන GOW (වින්ඩෝස් හි GNU) ය. ඔබ GitHub සිට එය ඩැහැ ගන්න පුළුවන් මෙතන .

GOW (වින්ඩෝස් හි GNU) යනු සිග්වින්ට වඩා සැහැල්ලු විකල්පයකි. එය ස්වදේශීය වින් 32 ද්විමය ලෙස සම්පාදනය කරන ලද අතිශයින්ම ප්‍රයෝජනවත් විවෘත කේත යුනික්ස් යෙදුම් 130 ක් පමණ ස්ථාපනය කරන පහසු වින්ඩෝස් ස්ථාපකයක් භාවිතා කරයි. සිග්වින්ට සාපේක්ෂව එය හැකි තරම් කුඩා, 10 MB පමණ වන පරිදි නිර්මාණය කර ඇති අතර විකල්ප මත පදනම්ව 100 MB ට වඩා හොඳින් ධාවනය කළ හැකිය. - විස්තරය ගැන (බ්‍රෙන්ට් ආර්. මැට්සෙල්)

GOW හි ඇතුළත් කර ඇති විධාන ලැයිස්තුවක තිර රුවක්:

මම නෙඩ් බැට්චෙල්ඩර්ට සමාන මෙවලමක් නිර්මාණය කර ඇත:

PATH හි .dll සහ .exe ගොනු සොයමින්

මගේ මෙවලම මූලික වශයෙන් විවිධ ඩීඑල්එල් අනුවාදයන් සෙවීම සඳහා වැඩි තොරතුරු (දිනය, ප්‍රමාණය, අනුවාදය) පෙන්වන නමුත් එය පැතෙක්ස්ට් භාවිතා නොකරයි (මගේ මෙවලම ඉක්මනින් යාවත්කාලීන කිරීමට බලාපොරොත්තු වෙමි).

මෙම වින්ඩෝස් හි එක් ලයිනර් කාණ්ඩ ගොනුවක් පළ කළ යුතුය:

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

පරීක්ෂණයක්:

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

නොවුණාට එක නෞකාවකි ඔබ තුළ ඇති කේතය ආවරණය කරනවා නම් setlocal enableextensionsසහ endlocal.

වින්ඩෝස් එක්ස්පී භාවිතා කරන්නන් සඳහා (කිසිදු whereවිධානයක් ගොඩනගා නැති ), මම "කොහේද කැමති" විධානයක් රුබිජම් ලෙස ලියා whichrඇත.

එය ස්ථාපනය කිරීම සඳහා, රූබි ස්ථාපනය කරන්න.

ඉන්පසු

gem install whichr

එය මෙලෙස ධාවනය කරන්න:

C:> whichr cmd_here

JPSoft වෙතින් TCC සහ TCC / LE යනු CMD.EXE ආදේශන වන අතර එය සැලකිය යුතු ක්‍රියාකාරිත්වයක් එක් කරයි. OP හි ප්‍රශ්නයට අදාළ වන්නේ whichTCC පවුලේ විධාන සකසනයන් සඳහා වන විධානයකි.

මම whichමොඩියුලය npm සිට සෑහෙන කාලයක් තිස්සේ භාවිතා කර ඇති අතර එය ඉතා හොඳින් ක්‍රියාත්මක වේ: https://www.npmjs.com/package/which එය විශිෂ්ට බහු වේදිකා විකල්පයකි.

දැන් මම whichGit සමඟ එන දෙයට මාරු වුණෙමි . සාමාන්‍යයෙන් පවතින /usr/binGit වෙතින් මාර්ගය ඔබේ මාර්ගයට එක් කරන්න C:\Program Files\Git\usr\bin\which.exe. මෙම whichද්විමය වනු ඇත C:\Program Files\Git\usr\bin\which.exe. එය වේගවත් වන අතර අපේක්ෂිත පරිදි ක්‍රියා කරයි.

මේක උත්සාහ කරන්න

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