Como verificar se o diretório existe em% PATH%?

Como se verifica se um diretório já está presente na variável de ambiente PATH? Aqui está um começo. Tudo o que consegui fazer com o código abaixo, no entanto, é ecoar o primeiro diretório em% PATH%. Como esse é um loop FOR, você pensaria que enumeraria todos os diretórios em% PATH%, mas somente o primeiro.

Existe um jeito melhor de fazer isso? Algo como find ou findstr operando na variável% PATH%? Gostaria apenas de verificar se existe um diretório na lista de diretórios em% PATH%, para evitar adicionar algo que já esteja lá.

FOR /F "delims=;" %%P IN ("%PATH%") DO ( @ECHO %%~P ) 

Primeiro, vou apontar uma série de questões que dificultam a resolução deste problema. Em seguida, apresentarei a solução mais inovadora que consegui criar.

Para essa discussão, usarei o caminho de letras minúsculas para representar um único caminho de pasta no sistema de arquivos e o PATH maiúsculo para representar a variável de ambiente PATH.

Do ponto de vista prático, a maioria das pessoas quer saber se o PATH contém o equivalente lógico de um determinado caminho, e não se o PATH contém uma correspondência exata de cadeia de um determinado caminho. Isso pode ser problemático porque:

  1. O trailing \ é opcional em um caminho
    A maioria dos caminhos funcionam igualmente bem com e sem o trailing \ . O caminho aponta logicamente para o mesmo local de qualquer maneira. O PATH freqüentemente tem uma mistura de caminhos com e sem o trailing \ . Esse é provavelmente o problema prático mais comum ao pesquisar um PATH para uma correspondência.

    • Há uma exceção: O caminho relativo C: (significando o diretório de trabalho atual da unidade C) é muito diferente de C:\ (significando o diretório raiz da unidade C)
  2. Alguns caminhos têm nomes curtos alternativos
    Qualquer caminho que não atenda ao antigo padrão 8.3 possui um formato curto alternativo que atende ao padrão. Este é outro problema do PATH que tenho visto com certa frequência, particularmente em configurações de negócios.

  3. O Windows aceita ambos / e \ como separadores de pastas em um caminho.
    Isso não é visto com muita frequência, mas um caminho pode ser especificado usando / vez de \ e ele funcionará bem no PATH (assim como em muitos outros contextos do Windows)

  4. O Windows trata os separadores de pastas consecutivas como um separador lógico.
    C: \ FOLDER \\ e C: \ FOLDER \ são equivalentes. Isso realmente ajuda em muitos contextos ao lidar com um caminho, porque um desenvolvedor pode geralmente append \ a um caminho sem se preocupar em verificar se o trailing \ já existe. Mas isso obviamente pode causar problemas ao tentar executar uma correspondência exata de string.

    • Exceções: Não só é C: diferente de C:\ , mas C:\ (um caminho válido), é diferente de C:\\ (um caminho inválido).
  5. O Windows corta pontos e espaços à direita dos nomes de arquivos e diretórios.
    "C:\test. " É equivalente a "C:\test" .

  6. Os especificadores de pasta .\ E pai ..\ podem aparecer em um caminho
    É improvável que seja visto na vida real, mas algo como C:\.\parent\child\..\.\child\ é equivalente a C:\parent\child

  7. Um caminho pode, opcionalmente, ser colocado entre aspas duplas.
    Um caminho é frequentemente colocado entre aspas para proteger contra caracteres especiais como ; ^ & = . Na verdade, qualquer número de aspas pode aparecer antes, dentro e / ou depois do caminho. Eles são ignorados pelo Windows, exceto com o propósito de proteger contra caracteres especiais. As aspas nunca são necessárias no PATH, a menos que um caminho contenha um ; , mas as citações podem estar presentes nunca a menos.

  8. Um caminho pode ser totalmente qualificado ou relativo.
    Um caminho totalmente qualificado aponta para exatamente um local específico dentro do sistema de arquivos. Um local de caminho relativo é alterado dependendo do valor dos volumes e diretórios de trabalho atuais. Existem três tipos principais de caminhos relativos:

    • D: é relativo ao diretório de trabalho atual do volume D:
    • \myPath é relativo ao volume de trabalho atual (pode ser C :, D: etc.)
    • myPath é relativo ao volume de trabalho atual e ao diretório

    É perfeitamente legal include um caminho relativo dentro do PATH. Isso é muito comum no mundo Unix porque o Unix não pesquisa o diretório atual por padrão, então um PATH Unix frequentemente conterá .\ . Mas o Windows procura o diretório atual por padrão, portanto, os caminhos relativos são raros em um PATH do Windows.

Portanto, para verificar com segurança se o PATH já contém um caminho, precisamos de uma maneira de converter qualquer caminho determinado em um formulário canônico (padrão). O modificador ~s utilizado pela variável FOR e pela expansão de argumentos é um método simples que resolve os problemas de 1 a 6, e resolve parcialmente o problema 7. O modificador ~s remove as aspas, mas preserva as aspas internas. O problema 7 pode ser totalmente resolvido removendo explicitamente as cotações de todos os caminhos antes da comparação. Observe que, se um caminho não existir fisicamente, o modificador ~s não appendá o \ ao caminho, nem converterá o caminho em um formato 8.3 válido.

O problema com o ~s é converter caminhos relativos em caminhos completos. Isso é problemático para o problema 8 porque um caminho relativo nunca deve corresponder a um caminho totalmente qualificado. Podemos usar expressões regulares FINDSTR para classificar um caminho como totalmente qualificado ou relativo. Um caminho totalmente qualificado deve começar com : mas não : , em que é \ ou / . Os caminhos UNC são sempre totalmente qualificados e devem começar com \\ . Ao comparar caminhos completos, usamos o modificador ~s . Ao comparar caminhos relativos, usamos as strings brutas. Finalmente, nunca comparamos um caminho totalmente qualificado a um caminho relativo. Essa estratégia fornece uma boa solução prática para o Problema 8. A única limitação é que dois caminhos relativos equivalentes logicamente podem ser tratados como não correspondentes, mas essa é uma preocupação menor porque os caminhos relativos são raros em um PATH do Windows.

Existem alguns problemas adicionais que complicam esse problema:

9) A expansão normal não é confiável ao lidar com um PATH que contenha caracteres especiais.
Caracteres especiais não precisam ser citados no PATH, mas poderiam ser. Portanto, um PATH como C:\THIS & THAT;"C:\& THE OTHER THING" é perfeitamente válido, mas não pode ser expandido com segurança usando expansão simples porque ambos "%PATH%" e %PATH% falharão.

10) O delimitador de caminho também é válido dentro de um nome de caminho
A ; é usado para delimitar caminhos dentro do PATH, mas ; também pode ser um caractere válido em um caminho, caso em que o caminho deve ser citado. Isso causa um problema de análise.

jeb resolveu ambos os problemas 9 e 10 em ‘Pretty print’ windows% PATH% variable – como dividir em ‘;’ no shell CMD

Assim, podemos combinar as técnicas de modificador e de sorting de caminho junto com minha variação do analisador PATH do jeb para obter essa solução quase à prova de balas para verificar se um determinado caminho já existe no PATH. A function pode ser incluída e chamada de dentro de um arquivo de lote ou pode ser independente e ser chamada como seu próprio arquivo de lote inPath.bat. Parece muito código, mas mais da metade é de comentários.

 @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 

A function pode ser usada assim (assumindo que o arquivo de lote é nomeado inPath.bat):

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


Normalmente, o motivo para verificar se um caminho existe no PATH é porque você deseja append o caminho se ele não estiver lá. Isso normalmente é feito simplesmente usando algo como path %path%;%newPath% . Mas a edição 9 demonstra como isso não é confiável.

Outra questão é como retornar o valor final do PATH através da barreira ENDLOCAL no final da function, especialmente se a function puder ser chamada com a expansão atrasada ativada ou desativada. Qualquer unescaped ! irá corromper o valor se a expansão atrasada estiver ativada.

Estes problemas são resolvidos usando uma incrível técnica de retorno seguro que Jeb inventou aqui: 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 

Eu não fiz nenhuma programação de arquivos em lote há algum tempo, mas:

 echo ;%PATH%; | find /C /I ";;" 

deve dar 0 se a string não for encontrada e 1 ou mais se for.

EDIT: Adicionado sinalizador insensível a maiúsculas e minúsculas, graças ao Panos.

Outra maneira de verificar se algo está no caminho é executar algum executável inocente que não irá falhar se estiver lá e verificar o resultado. Por exemplo, o próximo snippet de código verifica se o maven está no caminho:

 mvn --help > NUL 2> NUL if errorlevel 1 goto mvnNotInPath 

Então eu tento executar o mvn –help , ignorar a saída (não quero realmente ver a ajuda se o maven estiver lá) (> NUL), e também não exibir a mensagem de erro se o maven não foi encontrado (2> NUL).

Depois de ler as respostas aqui eu acho que posso fornecer um novo ponto de vista: se o propósito desta pergunta é saber se o caminho para um determinado arquivo executável existe em %PATH% e se não, insira-o (e este é o único razão para fazer isso, eu acho), então ele pode ser resolvido de uma maneira um pouco diferente: “Como verificar se o diretório de um determinado programa executável existe em% PATH%”? Esta questão pode ser facilmente resolvida desta maneira:

 for %%p in (programname.exe) do set "progpath=%%~$PATH:p" if not defined progpath ( rem The path to programname.exe don't exist in PATH variable, insert it: set "PATH=%PATH%;C:\path\to\progranname" ) 

Se você não conhece a extensão do arquivo executável, apenas revise todos eles:

 set "progpath=" for %%e in (%PATHEXT%) do ( if not defined progpath ( for %%p in (programname.%%e) do set "progpath=%%~$PATH:p" ) ) 

Usando for e delims , você não pode capturar um número arbitrário de campos (como Adam apontou também), então você tem que usar uma técnica de looping. O seguinte script de comando listará cada caminho na variável de ambiente PATH em uma linha separada:

 @echo off setlocal if "%~1"=="" ( set PATHQ=%PATH% ) else ( set PATHQ=%~1 ) :WHILE if "%PATHQ%"=="" goto WEND for /F "delims=;" %%i in ("%PATHQ%") do echo %%i for /F "delims=; tokens=1,*" %%i in ("%PATHQ%") do set PATHQ=%%j goto WHILE :WEND 

Ele simula um constructo clássico enquantowend encontrado em muitas linguagens de programação. Com isso, você pode usar algo como findstr para filtrar e procurar um determinado caminho. Por exemplo, se você salvou o script acima em um arquivo chamado tidypath.cmd , aqui está como você pode canalizar para findstr , procurando caminhos no diretório de programas padrão (usando uma correspondência sem distinção entre maiúsculas e minúsculas):

 > tidypath | findstr /i "%ProgramFiles%" 

Isso irá procurar por uma partida exata, mas sem distinção entre maiúsculas e minúsculas, portanto, lembre-se de todas as barras invertidas posteriores, etc.

 for %P in ("%path:;=";"%") do @if /i %P=="PATH_TO_CHECK" echo %P exists in PATH 

ou, em um arquivo de lote (por exemplo, checkpath.bat), que leva um argumento:

 @for %%P in ("%path:;=";"%") do @if /i %%P=="%~1" echo %%P exists in PATH 

Na última forma, pode-se chamar eg checkpath "%ProgramFiles%" para ver se o caminho especificado já existe no PATH.

Por favor, note que esta implementação não assume ponto-e-vírgula ou aspas estão presentes dentro de um único item de caminho.

Eu peguei sua implementação usando o loop for e a estendi em algo que percorre todos os elementos do caminho. Cada iteração do loop for remove o primeiro elemento do caminho (% p) do caminho inteiro (mantido em% q e% r).

 @echo off SET MYPATHCOPY=%PATH% :search for /f "delims=; tokens=1,2*" %%p in ("%MYPATHCOPY%") do ( @echo %%~p SET MYPATHCOPY=%%~q;%%~r ) if "%MYPATHCOPY%"==";" goto done; goto search; :done 

Exemplo de saída:

 Z:\>path.bat C:\Program Files\Microsoft DirectX SDK (November 2007)\Utilities\Bin\x86 c:\program files\imagemagick-6.3.4-q16 C:\WINDOWS\system32 C:\WINDOWS C:\SFU\common\ c:\Program Files\Debugging Tools for Windows C:\Program Files\Nmap 

Adicionar Diretório ao PATH, se ainda não existir:

 set myPath=c:\mypath For /F "Delims=" %%I In ('echo %PATH% ^| find /C /I "%myPath%"') Do set pathExists=%%I 2>Nul If %pathExists%==0 (set PATH=%myPath%;%PATH%) 

Você também pode usar a substituição de substring para testar a presença de uma substring. Aqui eu removo aspas para criar PATH_NQ, então eu removo “c: \ mydir” do PATH_NQ e comparo com o original para ver se alguma coisa mudou:

 set PATH_NQ=%PATH:"=% if not "%PATH_NQ%"=="%PATH_NQ:c:\mydir=%" goto already_in_path set PATH=%PATH%;c:\mydir :already_in_path 

Combinei algumas das respostas acima para sugerir isso para garantir que uma dada input de caminho exista exatamente como dada com a maior brevidade possível e sem ecos indesejados na linha de comando.

 set myPath= echo ;%PATH%; | find /C /I ";%myPath%;" >nul if %ERRORLEVEL% NEQ 0 set PATH=%PATH%;%myPath% 

Se a sua pergunta foi “por que esse fragment de script cmd não funciona?” então a resposta é que for /f itera as linhas. Os delims dividem as linhas em campos, mas você só captura o primeiro campo em %%P Não há como capturar um número arbitrário de campos com um loop for /f .

Com base na resposta do rcar, você precisa garantir que uma substring do alvo não seja encontrada.

 if a%X%==a%PATH% echo %X% is in PATH echo %PATH% | find /c /i ";%X%" if errorlevel 1 echo %X% is in PATH echo %PATH% | find /c /i "%X%;" if errorlevel 1 echo %X% is in PATH 

Você menciona que deseja evitar adicionar o diretório ao caminho de pesquisa, se ele já existir lá. Sua intenção é armazenar o diretório permanentemente no caminho, ou apenas temporariamente para o bem do arquivo de lote?

Se você deseja adicionar (ou remover) diretórios permanentemente ao PATH, dê uma olhada no utilitário Path Manager (pathman.exe) no Windows Resource Kit Tools para tarefas administrativas, http://support.microsoft.com/kb/927229 . Com isso, você pode adicionar ou remover componentes dos caminhos do sistema e do usuário, além de lidar com anomalias, como inputs duplicadas.

Se você precisar modificar o caminho apenas temporariamente para um arquivo em lote, eu adicionaria apenas o caminho extra na frente do caminho, com o risco de um pequeno impacto no desempenho devido à input duplicada no caminho.

Esta versão funciona razoavelmente bem. Ele simplesmente verifica se o vim71 está no caminho e o preenche, se não estiver.

 @echo off echo %PATH% | find /c /i "vim71" > nul if not errorlevel 1 goto jump PATH = C:\Program Files\Vim\vim71\;%PATH% :jump 

Esta demonstração é para ilustrar a lógica do nível de erro:

 @echo on echo %PATH% | find /c /i "Windows" if "%errorlevel%"=="0" echo Found Windows echo %PATH% | find /c /i "Nonesuch" if "%errorlevel%"=="0" echo Found Nonesuch 

A lógica é invertida no código vim71, já que errorlevel 1 é equivalente a errorlevel> = 1. Segue-se que errorlevel 0 sempre avaliaria true, então ” not errorlevel 1 ” é usado.

A verificação de Postscript pode não ser necessária se você usar setlocal e endlocal para localizar suas configurações de ambiente, por exemplo

 @echo off setlocal PATH = C:\Program Files\Vim\vim71\;%PATH% rem your code here endlocal 

Depois do endlocal, você está de volta ao seu caminho original.

Um comentário ao script “addPath”; Ao fornecer um caminho com espaços, ele vomita.

Exemplo: chame addPath “c: \ Arquivos de programas (x86) \ Microsoft SDKs \ Windows \ v7.0A \ Bin”

rendimentos: ‘Arquivos’ não é reconhecido como um comando interno ou externo, programa operável ou arquivo em lotes.

Em geral, isso é colocar um exe / dll no caminho. Contanto que este arquivo não apareça em nenhum outro lugar:

 @echo off where /q  if %errorlevel% == 1 ( setx PATH "%PATH%;" ) else ( echo "already set path" ) 

Essa é uma variação da resposta de Kevin Edwards usando a substituição de string. O padrão básico é:

 IF "%PATH:new_path=%" == "%PATH%" PATH=%PATH%;new_path 

Por exemplo:

 IF "%PATH:C:\Scripts=%" == "%PATH%" PATH=%PATH%;C:\Scripts 

Em suma, fazemos um teste condicional onde tentamos remover / replace new_path de nossa variável de ambiente PATH . Se new_path não existir, a condição será bem-sucedida e o new_path será anexado ao PATH pela primeira vez. Se new_path já existir, a condição falhará e nós não adicionaremos new_path pela segunda vez.

Você pode fazer isso usando o PoweShell;

 Test-Path $ENV:SystemRoot\YourDirectory Test-Path C:\Windows\YourDirectory 

Isso retorna TRUE ou FALSE

Curto, simle e fácil!

Apenas como alternativa:

  1. Na pasta em que você vai procurar a variável PATH , crie um arquivo temporário com um nome tão incomum que jamais esperaria que qualquer outro arquivo em seu computador tivesse.

  2. Use a construção de script em lote padrão que permite executar a pesquisa de um arquivo consultando uma lista de diretórios definida por alguma variável de ambiente (geralmente PATH ).

  3. Verifique se o resultado da pesquisa corresponde ao caminho em questão e exiba o resultado.

  4. Exclua o arquivo temporário.

Isso pode parecer com isso:

 @ECHO OFF SET "mypath=D:\the\searched-for\path" SET unusualname=nowthisissupposedtobesomeveryunusualfilename ECHO.>"%mypath%\%unusualname%" FOR %%f IN (%unusualname%) DO SET "foundpath=%%~dp$PATH:f" ERASE "%mypath%\%unusualname%" IF "%mypath%" == "%foundpath%" ( ECHO The dir exists in PATH ) ELSE ( ECHO The dir DOES NOT exist in PATH ) 

Problemas conhecidos:

  1. O método só pode funcionar se o diretório existir (o que nem sempre é o caso).

  2. Criar / excluir arquivos em um diretório afeta seu atributo ‘data / hora modificada’ (que pode ser um efeito indesejável às vezes).

  3. A criação de um nome de arquivo exclusivo em todo o mundo não pode ser considerado muito confiável. Gerar esse nome não é uma tarefa trivial.

Esta rotina irá procurar por um caminho \ ou arquivo.ext na variável de caminho que retorna 0 se encontrado. Caminho \ ou arquivo pode conter espaços se citado. Se uma variável é passada como o último argumento, ela será configurada para d:\path\file .

 @echo off&goto :PathCheck :PathCheck.CMD echo.PathCheck.CMD: Checks for existence of a path or file in %%PATH%% variable echo.Usage: PathCheck.CMD [Checkpath] or [Checkfile] [PathVar] echo.Checkpath must have a trailing \ but checkfile must not echo.If Checkpath contains spaces use quotes ie. "C:\Check path\" echo.Checkfile must not include a path, just the filename.ext echo.If Checkfile contains spaces use quotes ie. "Check File.ext" echo.Returns 0 if found, 1 if not or -1 if checkpath does not exist at all echo.If PathVar is not in command line it will be echoed with surrounding quotes echo.If PathVar is passed it will be set to d:\path\checkfile with no trailing \ echo.Then %%PathVar%% will be set to the fully qualified path to Checkfile echo.Note: %%PathVar%% variable set will not be surrounded with quotes echo.To view the path listing line by line use: PathCheck.CMD /L exit/b 1 :PathCheck if "%~1"=="" goto :PathCheck.CMD setlocal EnableDelayedExpansion set "PathVar=%~2" set "pth=" set "pcheck=%~1" if "%pcheck:~-1%" equ "\" ( if not exist %pcheck% endlocal&exit/b -1 set/a pth=1 ) for %%G in ("%path:;=" "%") do ( set "Pathfd=%%~G\" set "Pathfd=!Pathfd:\\=\!" if /i "%pcheck%" equ "/L" echo.!Pathfd! if defined pth ( if /i "%pcheck%" equ "!Pathfd!" endlocal&exit/b 0 ) else ( if exist "!Pathfd!%pcheck%" goto :CheckfileFound ) ) endlocal&exit/b 1 :CheckfileFound endlocal&( if not "%PathVar%"=="" ( call set "%~2=%Pathfd%%pcheck%" ) else (echo."%Pathfd%%pcheck%") exit/b 0 ) 

Apenas para elaborar a resposta de Heyvoon (2015.06.08) usando o Powershell, este simples script Powershell deve fornecer detalhes sobre% path%

 $env:Path -split ";" | % {"$(test-path $_);$_"} 

gerando este tipo de saída que você pode verificar de forma independente

 True;C:\WINDOWS True;C:\WINDOWS\system32 True;C:\WINDOWS\System32\Wbem False;C:windows\System32\windowsPowerShell\v1.0\ False;C:\Program Files (x86)\Java\jre7\bin 

para remontar para atualizar o caminho:

 $x=$null;foreach ($t in ($env:Path -split ";") ) {if (test-path $t) {$x+=$t+";"}};$x