How to check path in windows

First I will point out a number of issues that make this problem difficult to solve perfectly. Then I will present the most bullet-proof solution I have been able to come up with.

For this discussion I will use lower case path to represent a single folder path in the file system, and upper case PATH to represent the PATH environment variable.

From a practical standpoint, most people want to know if PATH contains the logical equivalent of a given path, not whether PATH contains an exact string match of a given path. This can be problematic because:

The trailing \ is optional in a path
Most paths work equally well both with and without the trailing \. The path logically points to the same location either way. The PATH frequently has a mixture of paths both with and without the trailing \. This is probably the most common practical issue when searching a PATH for a match.
- There is one exception: The relative path C: (meaning the current working directory of drive C) is very different than C:\ (meaning the root directory of drive C)
Some paths have alternate short names
Any path that does not meet the old 8.3 standard has an alternate short form that does meet the standard. This is another PATH issue that I have seen with some frequency, particularly in business settings.
Windows accepts both / and \ as folder separators within a path.
This is not seen very often, but a path can be specified using / instead of \ and it will function just fine within PATH (as well as in many other Windows contexts)
Windows treats consecutive folder separators as one logical separator.
C:\FOLDER\\ and C:\FOLDER\ are equivalent. This actually helps in many contexts when dealing with a path because a developer can generally append \ to a path without bothering to check if the trailing \ already exists. But this obviously can cause problems if trying to perform an exact string match.
- Exceptions: Not only is C:, different than C:\, but C:\ (a valid path), is different than C:\\ (an invalid path).
Windows trims trailing dots and spaces from file and directory names.
"C:\test. " is equivalent to "C:\test".
The current .\ and parent ..\ folder specifiers may appear within a path
Unlikely to be seen in real life, but something like C:\.\parent\child\..\.\child\ is equivalent to C:\parent\child
A path can optionally be enclosed within double quotes.
A path is often enclosed in quotes to protect against special characters like <space> , ; ^ & =. Actually any number of quotes can appear before, within, and/or after the path. They are ignored by Windows except for the purpose of protecting against special characters. The quotes are never required within PATH unless a path contains a ;, but the quotes may be present never-the-less.
A path may be fully qualified or relative.
A fully qualified path points to exactly one specific location within the file system. A relative path location changes depending on the value of current working volumes and directories. There are three primary flavors of relative paths:
- D: is relative to the current working directory of volume D:
- \myPath is relative to the current working volume (could be C:, D: etc.)
- myPath is relative to the current working volume and directory
It is perfectly legal to include a relative path within PATH. This is very common in the Unix world because Unix does not search the current directory by default, so a Unix PATH will often contain .\. But Windows does search the current directory by default, so relative paths are rare in a Windows PATH.

So in order to reliably check if PATH already contains a path, we need a way to convert any given path into a canonical (standard) form. The ~s modifier used by FOR variable and argument expansion is a simple method that addresses issues 1 — 6, and partially addresses issue 7. The ~s modifier removes enclosing quotes, but preserves internal quotes. Issue 7 can be fully resolved by explicitly removing quotes from all paths prior to comparison. Note that if a path does not physically exist then the ~s modifier will not append the \ to the path, nor will it convert the path into a valid 8.3 format.

The problem with ~s is it converts relative paths into fully qualified paths. This is problematic for Issue 8 because a relative path should never match a fully qualified path. We can use FINDSTR regular expressions to classify a path as either fully qualified or relative. A normal fully qualified path must start with <letter>:<separator> but not <letter>:<separator><separator>, where <separator> is either \ or /. UNC paths are always fully qualified and must start with \\. When comparing fully qualified paths we use the ~s modifier. When comparing relative paths we use the raw strings. Finally, we never compare a fully qualified path to a relative path. This strategy provides a good practical solution for Issue 8. The only limitation is two logically equivalent relative paths could be treated as not matching, but this is a minor concern because relative paths are rare in a Windows PATH.

There are some additional issues that complicate this problem:

9) Normal expansion is not reliable when dealing with a PATH that contains special characters.
Special characters do not need to be quoted within PATH, but they could be. So a PATH like
C:\THIS & THAT;"C:\& THE OTHER THING" is perfectly valid, but it cannot be expanded safely using simple expansion because both "%PATH%" and %PATH% will fail.

10) The path delimiter is also valid within a path name
A ; is used to delimit paths within PATH, but ; can also be a valid character within a path, in which case the path must be quoted. This causes a parsing issue.

jeb solved both issues 9 and 10 at ‘Pretty print’ windows %PATH% variable — how to split on ‘;’ in CMD shell

So we can combine the ~s modifier and path classification techniques along with my variation of jeb’s PATH parser to get this nearly bullet proof solution for checking if a given path already exists within PATH. The function can be included and called from within a batch file, or it can stand alone and be called as its own inPath.bat batch file. It looks like a lot of code, but over half of it is comments.

@echo off
:inPath pathVar
::
::  Tests if the path stored within variable pathVar exists within PATH.
::
::  The result is returned as the ERRORLEVEL:
::    0 if the pathVar path is found in PATH.
::    1 if the pathVar path is not found in PATH.
::    2 if pathVar is missing or undefined or if PATH is undefined.
::
::  If the pathVar path is fully qualified, then it is logically compared
::  to each fully qualified path within PATH. The path strings don't have
::  to match exactly, they just need to be logically equivalent.
::
::  If the pathVar path is relative, then it is strictly compared to each
::  relative path within PATH. Case differences and double quotes are
::  ignored, but otherwise the path strings must match exactly.
::
::------------------------------------------------------------------------
::
:: Error checking
if "%~1"=="" exit /b 2
if not defined %~1 exit /b 2
if not defined path exit /b 2
::
:: Prepare to safely parse PATH into individual paths
setlocal DisableDelayedExpansion
set "var=%path:"=""%"
set "var=%var:^=^^%"
set "var=%var:&=^&%"
set "var=%var:|=^|%"
set "var=%var:<=^<%"
set "var=%var:>=^>%"
set "var=%var:;=^;^;%"
set var=%var:""="%
set "var=%var:"=""Q%"
set "var=%var:;;="S"S%"
set "var=%var:^;^;=;%"
set "var=%var:""="%"
setlocal EnableDelayedExpansion
set "var=!var:"Q=!"
set "var=!var:"S"S=";"!"
::
:: Remove quotes from pathVar and abort if it becomes empty
set "new=!%~1:"=!"
if not defined new exit /b 2
::
:: Determine if pathVar is fully qualified
echo("!new!"|findstr /i /r /c:^"^^\"[a-zA-Z]:[\\/][^\\/]" ^
                           /c:^"^^\"[\\][\\]" >nul ^
  && set "abs=1" || set "abs=0"
::
:: For each path in PATH, check if path is fully qualified and then do
:: proper comparison with pathVar.
:: Exit with ERRORLEVEL 0 if a match is found.
:: Delayed expansion must be disabled when expanding FOR variables
:: just in case the value contains !
for %%A in ("!new!\") do for %%B in ("!var!") do (
  if "!!"=="" endlocal
  for %%C in ("%%~B\") do (
    echo(%%B|findstr /i /r /c:^"^^\"[a-zA-Z]:[\\/][^\\/]" ^
                           /c:^"^^\"[\\][\\]" >nul ^
      && (if %abs%==1 if /i "%%~sA"=="%%~sC" exit /b 0) ^
      || (if %abs%==0 if /i "%%~A"=="%%~C" exit /b 0)
  )
)
:: No match was found so exit with ERRORLEVEL 1
exit /b 1

The function can be used like so (assuming the batch file is named inPath.bat):

set test=c:\mypath
call inPath test && (echo found) || (echo not found)

Typically the reason for checking if a path exists within PATH is because you want to append the path if it isn’t there. This is normally done simply by using something like path %path%;%newPath%. But Issue 9 demonstrates how this is not reliable.

Another issue is how to return the final PATH value across the ENDLOCAL barrier at the end of the function, especially if the function could be called with delayed expansion enabled or disabled. Any unescaped ! will corrupt the value if delayed expansion is enabled.

These problems are resolved using an amazing safe return technique that jeb invented here: http://www.dostips.com/forum/viewtopic.php?p=6930#p6930

@echo off
:addPath pathVar /B
::
::  Safely appends the path contained within variable pathVar to the end
::  of PATH if and only if the path does not already exist within PATH.
::
::  If the case insensitive /B option is specified, then the path is
::  inserted into the front (Beginning) of PATH instead.
::
::  If the pathVar path is fully qualified, then it is logically compared
::  to each fully qualified path within PATH. The path strings are
::  considered a match if they are logically equivalent.
::
::  If the pathVar path is relative, then it is strictly compared to each
::  relative path within PATH. Case differences and double quotes are
::  ignored, but otherwise the path strings must match exactly.
::
::  Before appending the pathVar path, all double quotes are stripped, and
::  then the path is enclosed in double quotes if and only if the path
::  contains at least one semicolon.
::
::  addPath aborts with ERRORLEVEL 2 if pathVar is missing or undefined
::  or if PATH is undefined.
::
::------------------------------------------------------------------------
::
:: Error checking
if "%~1"=="" exit /b 2
if not defined %~1 exit /b 2
if not defined path exit /b 2
::
:: Determine if function was called while delayed expansion was enabled
setlocal
set "NotDelayed=!"
::
:: Prepare to safely parse PATH into individual paths
setlocal DisableDelayedExpansion
set "var=%path:"=""%"
set "var=%var:^=^^%"
set "var=%var:&=^&%"
set "var=%var:|=^|%"
set "var=%var:<=^<%"
set "var=%var:>=^>%"
set "var=%var:;=^;^;%"
set var=%var:""="%
set "var=%var:"=""Q%"
set "var=%var:;;="S"S%"
set "var=%var:^;^;=;%"
set "var=%var:""="%"
setlocal EnableDelayedExpansion
set "var=!var:"Q=!"
set "var=!var:"S"S=";"!"
::
:: Remove quotes from pathVar and abort if it becomes empty
set "new=!%~1:"^=!"
if not defined new exit /b 2
::
:: Determine if pathVar is fully qualified
echo("!new!"|findstr /i /r /c:^"^^\"[a-zA-Z]:[\\/][^\\/]" ^
                           /c:^"^^\"[\\][\\]" >nul ^
  && set "abs=1" || set "abs=0"
::
:: For each path in PATH, check if path is fully qualified and then
:: do proper comparison with pathVar. Exit if a match is found.
:: Delayed expansion must be disabled when expanding FOR variables
:: just in case the value contains !
for %%A in ("!new!\") do for %%B in ("!var!") do (
  if "!!"=="" setlocal disableDelayedExpansion
  for %%C in ("%%~B\") do (
    echo(%%B|findstr /i /r /c:^"^^\"[a-zA-Z]:[\\/][^\\/]" ^
                           /c:^"^^\"[\\][\\]" >nul ^
      && (if %abs%==1 if /i "%%~sA"=="%%~sC" exit /b 0) ^
      || (if %abs%==0 if /i %%A==%%C exit /b 0)
  )
)
::
:: Build the modified PATH, enclosing the added path in quotes
:: only if it contains ;
setlocal enableDelayedExpansion
if "!new:;=!" neq "!new!" set new="!new!"
if /i "%~2"=="/B" (set "rtn=!new!;!path!") else set "rtn=!path!;!new!"
::
:: rtn now contains the modified PATH. We need to safely pass the
:: value accross the ENDLOCAL barrier
::
:: Make rtn safe for assignment using normal expansion by replacing
:: % and " with not yet defined FOR variables
set "rtn=!rtn:%%=%%A!"
set "rtn=!rtn:"=%%B!"
::
:: Escape ^ and ! if function was called while delayed expansion was enabled.
:: The trailing ! in the second assignment is critical and must not be removed.
if not defined NotDelayed set "rtn=!rtn:^=^^^^!"
if not defined NotDelayed set "rtn=%rtn:!=^^^!%" !
::
:: Pass the rtn value accross the ENDLOCAL barrier using FOR variables to
:: restore the % and " characters. Again the trailing ! is critical.
for /f "usebackq tokens=1,2" %%A in ('%%^ ^"') do (
  endlocal & endlocal & endlocal & endlocal & endlocal
  set "path=%rtn%" !
)
exit /b 0

Источник

First I will point out a number of issues that make this problem difficult to solve perfectly. Then I will present the most bullet-proof solution I have been able to come up with.

For this discussion I will use lower case path to represent a single folder path in the file system, and upper case PATH to represent the PATH environment variable.

The trailing \ is optional in a path
Most paths work equally well both with and without the trailing \. The path logically points to the same location either way. The PATH frequently has a mixture of paths both with and without the trailing \. This is probably the most common practical issue when searching a PATH for a match.
- There is one exception: The relative path C: (meaning the current working directory of drive C) is very different than C:\ (meaning the root directory of drive C)
Some paths have alternate short names
Any path that does not meet the old 8.3 standard has an alternate short form that does meet the standard. This is another PATH issue that I have seen with some frequency, particularly in business settings.
Windows accepts both / and \ as folder separators within a path.
This is not seen very often, but a path can be specified using / instead of \ and it will function just fine within PATH (as well as in many other Windows contexts)
Windows treats consecutive folder separators as one logical separator.
C:\FOLDER\\ and C:\FOLDER\ are equivalent. This actually helps in many contexts when dealing with a path because a developer can generally append \ to a path without bothering to check if the trailing \ already exists. But this obviously can cause problems if trying to perform an exact string match.
- Exceptions: Not only is C:, different than C:\, but C:\ (a valid path), is different than C:\\ (an invalid path).
Windows trims trailing dots and spaces from file and directory names.
"C:\test. " is equivalent to "C:\test".
The current .\ and parent ..\ folder specifiers may appear within a path
Unlikely to be seen in real life, but something like C:\.\parent\child\..\.\child\ is equivalent to C:\parent\child
A path can optionally be enclosed within double quotes.
A path is often enclosed in quotes to protect against special characters like <space> , ; ^ & =. Actually any number of quotes can appear before, within, and/or after the path. They are ignored by Windows except for the purpose of protecting against special characters. The quotes are never required within PATH unless a path contains a ;, but the quotes may be present never-the-less.
A path may be fully qualified or relative.
A fully qualified path points to exactly one specific location within the file system. A relative path location changes depending on the value of current working volumes and directories. There are three primary flavors of relative paths:
- D: is relative to the current working directory of volume D:
- \myPath is relative to the current working volume (could be C:, D: etc.)
- myPath is relative to the current working volume and directory
It is perfectly legal to include a relative path within PATH. This is very common in the Unix world because Unix does not search the current directory by default, so a Unix PATH will often contain .\. But Windows does search the current directory by default, so relative paths are rare in a Windows PATH.

There are some additional issues that complicate this problem:

jeb solved both issues 9 and 10 at ‘Pretty print’ windows %PATH% variable — how to split on ‘;’ in CMD shell

@echo off
:inPath pathVar
::
::  Tests if the path stored within variable pathVar exists within PATH.
::
::  The result is returned as the ERRORLEVEL:
::    0 if the pathVar path is found in PATH.
::    1 if the pathVar path is not found in PATH.
::    2 if pathVar is missing or undefined or if PATH is undefined.
::
::  If the pathVar path is fully qualified, then it is logically compared
::  to each fully qualified path within PATH. The path strings don't have
::  to match exactly, they just need to be logically equivalent.
::
::  If the pathVar path is relative, then it is strictly compared to each
::  relative path within PATH. Case differences and double quotes are
::  ignored, but otherwise the path strings must match exactly.
::
::------------------------------------------------------------------------
::
:: Error checking
if "%~1"=="" exit /b 2
if not defined %~1 exit /b 2
if not defined path exit /b 2
::
:: Prepare to safely parse PATH into individual paths
setlocal DisableDelayedExpansion
set "var=%path:"=""%"
set "var=%var:^=^^%"
set "var=%var:&=^&%"
set "var=%var:|=^|%"
set "var=%var:<=^<%"
set "var=%var:>=^>%"
set "var=%var:;=^;^;%"
set var=%var:""="%
set "var=%var:"=""Q%"
set "var=%var:;;="S"S%"
set "var=%var:^;^;=;%"
set "var=%var:""="%"
setlocal EnableDelayedExpansion
set "var=!var:"Q=!"
set "var=!var:"S"S=";"!"
::
:: Remove quotes from pathVar and abort if it becomes empty
set "new=!%~1:"=!"
if not defined new exit /b 2
::
:: Determine if pathVar is fully qualified
echo("!new!"|findstr /i /r /c:^"^^\"[a-zA-Z]:[\\/][^\\/]" ^
                           /c:^"^^\"[\\][\\]" >nul ^
  && set "abs=1" || set "abs=0"
::
:: For each path in PATH, check if path is fully qualified and then do
:: proper comparison with pathVar.
:: Exit with ERRORLEVEL 0 if a match is found.
:: Delayed expansion must be disabled when expanding FOR variables
:: just in case the value contains !
for %%A in ("!new!\") do for %%B in ("!var!") do (
  if "!!"=="" endlocal
  for %%C in ("%%~B\") do (
    echo(%%B|findstr /i /r /c:^"^^\"[a-zA-Z]:[\\/][^\\/]" ^
                           /c:^"^^\"[\\][\\]" >nul ^
      && (if %abs%==1 if /i "%%~sA"=="%%~sC" exit /b 0) ^
      || (if %abs%==0 if /i "%%~A"=="%%~C" exit /b 0)
  )
)
:: No match was found so exit with ERRORLEVEL 1
exit /b 1

The function can be used like so (assuming the batch file is named inPath.bat):

set test=c:\mypath
call inPath test && (echo found) || (echo not found)

These problems are resolved using an amazing safe return technique that jeb invented here: http://www.dostips.com/forum/viewtopic.php?p=6930#p6930

@echo off
:addPath pathVar /B
::
::  Safely appends the path contained within variable pathVar to the end
::  of PATH if and only if the path does not already exist within PATH.
::
::  If the case insensitive /B option is specified, then the path is
::  inserted into the front (Beginning) of PATH instead.
::
::  If the pathVar path is fully qualified, then it is logically compared
::  to each fully qualified path within PATH. The path strings are
::  considered a match if they are logically equivalent.
::
::  If the pathVar path is relative, then it is strictly compared to each
::  relative path within PATH. Case differences and double quotes are
::  ignored, but otherwise the path strings must match exactly.
::
::  Before appending the pathVar path, all double quotes are stripped, and
::  then the path is enclosed in double quotes if and only if the path
::  contains at least one semicolon.
::
::  addPath aborts with ERRORLEVEL 2 if pathVar is missing or undefined
::  or if PATH is undefined.
::
::------------------------------------------------------------------------
::
:: Error checking
if "%~1"=="" exit /b 2
if not defined %~1 exit /b 2
if not defined path exit /b 2
::
:: Determine if function was called while delayed expansion was enabled
setlocal
set "NotDelayed=!"
::
:: Prepare to safely parse PATH into individual paths
setlocal DisableDelayedExpansion
set "var=%path:"=""%"
set "var=%var:^=^^%"
set "var=%var:&=^&%"
set "var=%var:|=^|%"
set "var=%var:<=^<%"
set "var=%var:>=^>%"
set "var=%var:;=^;^;%"
set var=%var:""="%
set "var=%var:"=""Q%"
set "var=%var:;;="S"S%"
set "var=%var:^;^;=;%"
set "var=%var:""="%"
setlocal EnableDelayedExpansion
set "var=!var:"Q=!"
set "var=!var:"S"S=";"!"
::
:: Remove quotes from pathVar and abort if it becomes empty
set "new=!%~1:"^=!"
if not defined new exit /b 2
::
:: Determine if pathVar is fully qualified
echo("!new!"|findstr /i /r /c:^"^^\"[a-zA-Z]:[\\/][^\\/]" ^
                           /c:^"^^\"[\\][\\]" >nul ^
  && set "abs=1" || set "abs=0"
::
:: For each path in PATH, check if path is fully qualified and then
:: do proper comparison with pathVar. Exit if a match is found.
:: Delayed expansion must be disabled when expanding FOR variables
:: just in case the value contains !
for %%A in ("!new!\") do for %%B in ("!var!") do (
  if "!!"=="" setlocal disableDelayedExpansion
  for %%C in ("%%~B\") do (
    echo(%%B|findstr /i /r /c:^"^^\"[a-zA-Z]:[\\/][^\\/]" ^
                           /c:^"^^\"[\\][\\]" >nul ^
      && (if %abs%==1 if /i "%%~sA"=="%%~sC" exit /b 0) ^
      || (if %abs%==0 if /i %%A==%%C exit /b 0)
  )
)
::
:: Build the modified PATH, enclosing the added path in quotes
:: only if it contains ;
setlocal enableDelayedExpansion
if "!new:;=!" neq "!new!" set new="!new!"
if /i "%~2"=="/B" (set "rtn=!new!;!path!") else set "rtn=!path!;!new!"
::
:: rtn now contains the modified PATH. We need to safely pass the
:: value accross the ENDLOCAL barrier
::
:: Make rtn safe for assignment using normal expansion by replacing
:: % and " with not yet defined FOR variables
set "rtn=!rtn:%%=%%A!"
set "rtn=!rtn:"=%%B!"
::
:: Escape ^ and ! if function was called while delayed expansion was enabled.
:: The trailing ! in the second assignment is critical and must not be removed.
if not defined NotDelayed set "rtn=!rtn:^=^^^^!"
if not defined NotDelayed set "rtn=%rtn:!=^^^!%" !
::
:: Pass the rtn value accross the ENDLOCAL barrier using FOR variables to
:: restore the % and " characters. Again the trailing ! is critical.
for /f "usebackq tokens=1,2" %%A in ('%%^ ^"') do (
  endlocal & endlocal & endlocal & endlocal & endlocal
  set "path=%rtn%" !
)
exit /b 0

Источник

check

Set path for Environment variable using cmd.

Video time control bar
0:00

▶️
⏸️
🔊
Audio volume control bar
0:00 / 0:00

↔️
↕️

Timecodes:

No transcript (subtitles) available for this video…

Related queries:

how to set path environment variable in windows command prompt

how to set path environment variable in windows 10 command line

how can i see environment variables in cmd

how to check the path environment variable in windows

how to check the path variable in windows cmd

Источник

When working with Windows operating system, sometimes you need to check if a specific directory exists in the %PATH% environment variable. This can be useful, for example, if you want to make sure that a required executable is accessible in the system PATH before running your script. There are several methods to check if a directory exists in the %PATH% environment variable in Windows, each with its own pros and cons. Here are some common ways to achieve this:

Method 1: Using the ‘where’ command

To check if a directory exists in the Windows %PATH% variable, we can use the built-in where command. This command searches for the specified file or directory in the directories listed in the %PATH% environment variable.

Here’s an example code snippet:

@echo off
setlocal EnableExtensions EnableDelayedExpansion

set "dirToFind=C:\Program Files\Java\jdk1.8.0_271\bin"

where /q %dirToFind%
if %errorlevel% equ 0 (
    echo Directory found in PATH
) else (
    echo Directory not found in PATH
)

In this example, we set the dirToFind variable to the directory we want to search for. We then use the where command with the /q option to perform a quiet search (i.e., no output is displayed). If the directory is found, the where command returns a zero error code, which we check using the %errorlevel% variable. If the error code is zero, we output a message indicating that the directory was found in the %PATH% variable. Otherwise, we output a message indicating that the directory was not found.

Note that the where command searches for both files and directories, so if you want to search for a specific directory, you should include the trailing backslash in the path.

You can also use the where command to display the full path to the directory if it is found:

@echo off
setlocal EnableExtensions EnableDelayedExpansion

set "dirToFind=C:\Program Files\Java\jdk1.8.0_271\bin"

where /r %path% %dirToFind% >nul 2>&1
if %errorlevel% equ 0 (
    set "dirPath=!errorlevel!"
    echo Directory found in PATH: !dirPath!
) else (
    echo Directory not found in PATH
)

In this example, we use the /r option to perform a recursive search of all directories listed in the %PATH% variable. We redirect the output of the where command to nul to suppress any output, and then check the error code as before. If the directory is found, we set the dirPath variable to the full path returned by the where command (which is stored in the %errorlevel% variable), and output a message indicating that the directory was found along with its full path.

Finally, note that the where command is only available in Windows Vista and later versions of Windows. If you need to support older versions of Windows, you may need to use a different method to check if a directory exists in the %PATH% variable.

Method 2: Using the ‘for’ loop in batch file

To check if a directory exists in the %PATH% on Windows using the for loop in a batch file, follow these steps:

Create a new batch file and open it in a text editor.
Use the for loop to iterate over each directory in the %PATH% environment variable.
For each directory, use the if statement to check if the directory exists.
If the directory exists, output a message indicating that it was found.

Here is an example code:

@echo off
setlocal EnableDelayedExpansion

set "dir_to_find=C:\Program Files\Java\jdk1.8.0_231"

for %%I in (%PATH%) do (
    if exist "%%~I\%dir_to_find%\" (
        echo Directory found: %%~I\%dir_to_find%\"
    )
)

In this example, the dir_to_find variable is set to the directory we want to search for in the %PATH%. The for loop iterates over each directory in the %PATH%, and the if statement checks if the directory we are looking for exists in that directory. If it does, a message is output indicating that the directory was found.

Note that the EnableDelayedExpansion option is used to allow the use of variables within the for loop.

This method can be modified to search for files or other directories as well by changing the value of the dir_to_find variable and the path in the if statement accordingly.

I hope this helps!

Method 3: Using the GetEnvironmentVariable function from Windows API

To check if a directory exists in the %PATH% environment variable on Windows, you can use the GetEnvironmentVariable function from the Windows API. Here is an example code that demonstrates how to do it:

#include <Windows.h>
#include <stdio.h>

int main() {
    const char* path = getenv("PATH"); // get the value of the PATH environment variable
    char* p = strtok((char*)path, ";"); // split the value by semicolon
    while (p) {
        if (strcmp(p, "C:\\Windows") == 0) { // check if the directory exists
            printf("The directory C:\\Windows is in the PATH.\n");
            break;
        }
        p = strtok(NULL, ";"); // get the next token
    }
    return 0;
}

In this code, we first get the value of the PATH environment variable using the getenv function. Then we split the value by semicolon using the strtok function. We iterate through each token and check if it is equal to the directory we are looking for (in this case, «C:\Windows»). If we find the directory, we print a message and break out of the loop.

Note that this code assumes that the PATH environment variable is a semicolon-separated list of directories. If your system uses a different separator, you will need to modify the code accordingly.

Another way to do this is to use the GetEnvironmentVariable function from the Windows API. Here is an example code that demonstrates how to do it:

#include <Windows.h>
#include <stdio.h>

int main() {
    char path[MAX_PATH];
    DWORD len = GetEnvironmentVariable("PATH", path, MAX_PATH); // get the value of the PATH environment variable
    if (len == 0 || len > MAX_PATH) {
        printf("Error: Could not get the PATH environment variable.\n");
        return 1;
    }
    char* p = strtok(path, ";"); // split the value by semicolon
    while (p) {
        if (strcmp(p, "C:\\Windows") == 0) { // check if the directory exists
            printf("The directory C:\\Windows is in the PATH.\n");
            break;
        }
        p = strtok(NULL, ";"); // get the next token
    }
    return 0;
}

In this code, we first create a buffer to hold the value of the PATH environment variable. We then call the GetEnvironmentVariable function to get the value of the PATH environment variable and store it in the buffer. We check the return value of the function to make sure that we got the value successfully. We then split the value by semicolon using the strtok function and iterate through each token to check if it is equal to the directory we are looking for.

Again, note that this code assumes that the PATH environment variable is a semicolon-separated list of directories. If your system uses a different separator, you will need to modify the code accordingly.

Method 4: Using PowerShell

To check if a directory exists in the %PATH% using PowerShell, you can use the Get-Item cmdlet. Here are the steps to do it:

First, you need to split the %PATH% environment variable into an array of paths using the Split method. This will allow you to iterate over each path in the %PATH% variable.

$paths = $env:Path.Split(';')

Next, you can use a foreach loop to iterate over each path in the $paths array. Inside the loop, you can use the Get-Item cmdlet to check if the directory exists.

foreach ($path in $paths) {
    $directory = Join-Path $path "directory_name"
    if (Test-Path $directory -PathType Container) {
        Write-Host "$directory exists"
    }
}

In the above code, the Join-Path cmdlet is used to combine the current path with the directory name you want to check. The Test-Path cmdlet is then used to check if the directory exists. If it does, a message is output to the console.
You can also use the Where-Object cmdlet to filter the paths in the %PATH% variable to only include those that contain the directory you are looking for.

$directory = "directory_name"
$paths | Where-Object { Test-Path (Join-Path $_ $directory) -PathType Container }

In the above code, the $directory variable is set to the name of the directory you want to check. The Where-Object cmdlet is then used to filter the paths in the $paths array to only include those that contain the directory. The Join-Path and Test-Path cmdlets are used in the filter expression to check if the directory exists.

These are some examples of how to check if a directory exists in the %PATH% using PowerShell. You can use these examples as a starting point and modify them to fit your specific needs.

Источник

Introduction

In this article, we will see how we can create and set up path environment variables in Windows 11.

Windows Environment Variables

The Environment Variable is a variable that the computer creates and maintains automatically. It assists the system in determining where to install files, locate programs, and check for user and system preferences. It may also be accessed from anywhere on the computer by graphical and command-line tools. It is required to set up the environment variables so that system knows the executable file that it needs to run on a given command.

Windows Path Variable

The PATH variable is nothing more than a directory of your computer’s applications and instructions. The PATH variable must include the address of any new program on your computer that you want to start through the command-line interface. As part of the process, Windows looks for the address for a certain command. When you send a command from the command line, Windows initially searches for it in the current directory. If it cannot be found in the current directory, the operating system checks for the address in the PATH variable.

Check Environment Variables

Use the following command to check the environment variables set on your PC.

echo %Environment Variable name%

To check the Path environment variable I will use «echo %Path%»

Setup Path Environment Variable

We require permission from the system administrator and privileges to utilize and set the environment variables. As a result, you must notify the system administrator and request their assistance if you are not one.

Step 1

Open the Setting using any of the following ways

Press Windows+R, type «sysdm.cpl» and press «Ok».
Press Window+I
Press Windows+X, select «System».
Press Windows+S, search for «System».

Note

You can skip steps 1 to 3 and directly open «System Properties» by pressing Windows+S to open the search menu and typing «environment», and pressing open.

Step 2

Under System, click on «About».

Step 3

Click on «Advanced system settings».

Step 4

Click «Environment Variables…».

Step 5

The environment variables panel shows up on the screen. You can observe two types of variables

User Variables: Use them when you wish to change the environment variables for the current or specific user.
System Variables: Use them when you want the system-wide changes.

I want to change the path variable system-wide, hence I will double click on the highlighted row.

Step 6

Click the New button to add new paths or edit to modify the existing path. Delete will delete a path.

Press «OK» to save the changes.

If you already know the path, just write it in or copy and paste it. You may simply select Browse and then go to the route you wish to add in the System path variables.

To Create a New Environment Variable

Sometimes you may need to create a new environment variable, so for that, follow steps 1 to 4.

After that click on «New» to open the «New System Variable» popup.

Add «Variable Name», you may choose whatever name you want.

Using «Browse Directory», you can select a directory. Press OK to select the desired folder.

Using «Browse Directory», you can select a particular file. Press OK to select the desired file.

Conclusion

In this article, we discussed how we can manage path environment variables on Windows 11.

Visit C# Corner to find answers to more such questions.

Источник