Arquivo em lote: encontre se a substring está na string (não em um arquivo)

Em um arquivo em lotes, eu tenho uma string abcdefg. Quero verificar se bcdestá na string.

Infelizmente, parece que todas as soluções que estou encontrando pesquisam um arquivo por uma substring, não uma string para uma substring.

Existe uma solução fácil para isso?

Sim, você pode usar substituições e comparar com a sequência original:

if not x%str1:bcd=%==x%str1% echo It contains bcd

O %str1:bcd=%bit substituirá um bcdin str1por uma string vazia, tornando-o diferente do original.

Se o original não contiver uma bcdstring, a versão modificada será idêntica.

Testar com o seguinte script o mostrará em ação:

@setlocal enableextensions enabledelayedexpansion
@echo off
set str1=%1
if not x%str1:bcd=%==x%str1% echo It contains bcd
endlocal

E os resultados de várias execuções:

c:\testarea> testprog hello

c:\testarea> testprog abcdef
It contains bcd

c:\testarea> testprog bcd
It contains bcd

Algumas notas:

• A ifafirmação é a base desta solução, tudo o resto é material de suporte.
• O xantes dos dois lados da igualdade é garantir que a string bcdfuncione bem. Também protege contra certos caracteres iniciais "impróprios".

Você pode canalizar a cadeia de origem findstre verificar o valor de ERRORLEVELpara ver se a cadeia de padrão foi encontrada. Um valor zero indica sucesso e o padrão foi encontrado. Aqui está um exemplo:

::
: Y.CMD - Test if pattern in string
: P1 - the pattern
: P2 - the string to check
::
@echo off

echo.%2 | findstr /C:"%1" 1>nul

if errorlevel 1 (
  echo. got one - pattern not found
) ELSE (
  echo. got zero - found pattern
)

Quando isso é executado no CMD.EXE, obtemos:

C:\DemoDev>y pqrs "abc def pqr 123"
 got one - pattern not found

C:\DemoDev>y pqr "abc def pqr 123" 
 got zero - found pattern

Eu costumo fazer algo assim:

Echo.%1 | findstr /C:"%2">nul && (
    REM TRUE
) || (
    REM FALSE
)

Exemplo:

Echo.Hello world | findstr /C:"world">nul && (
    Echo.TRUE
) || (
    Echo.FALSE
)

Echo.Hello world | findstr /C:"World">nul && (Echo.TRUE) || (Echo.FALSE)

Resultado:

TRUE
FALSE

Não sei se é o melhor caminho.

Para compatibilidade e facilidade de uso, geralmente é melhor usar o FIND para fazer isso.

Você também deve considerar se deseja corresponder maiúsculas de minúsculas ou maiúsculas de minúsculas.

O método com 78 pontos (acredito que estava me referindo à postagem de paxdiablo) corresponderá apenas a maiúsculas e minúsculas, portanto, você deve colocar uma verificação separada para todas as variações de maiúsculas e minúsculas para cada iteração possível que desejar.

(Que dor! Com apenas 3 letras, isso significa 9 testes diferentes para realizar a verificação!)

Além disso, muitas vezes é preferível combinar a saída do comando, uma variável em um loop ou o valor de uma variável de ponteiro no seu lote / CMD, o que não é tão simples.

Por esses motivos, essa é uma metodologia alternativa preferível:

Uso: Encontre [/ I] [/ V] "Caracteres a Combinar"

[/ I] (não faz distinção entre maiúsculas e minúsculas) [/ V] (NÃO deve conter os caracteres)

Como linha única:

ECHO.%Variable% | FIND /I "ABC">Nul && ( Echo.Found "ABC" ) || ( Echo.Did not find "ABC" )

Multi-linha:

ECHO.%Variable%| FIND /I "ABC">Nul && ( 
  Echo.Found "ABC"
) || (
  Echo.Did not find "ABC"
)

Como mencionado, isso é ótimo para coisas que não estão em variáveis ​​que também permitem a substituição de strings:

FOR %A IN (
  "Some long string with Spaces does not contain the expected string"
  oihu AljB
  lojkAbCk
  Something_Else
 "Going to evaluate this entire string for ABC as well!"
) DO (
  ECHO.%~A| FIND /I "ABC">Nul && (
    Echo.Found "ABC" in "%A"
  ) || ( Echo.Did not find "ABC" )
)

Output From a command:

    NLTest | FIND /I "ABC">Nul && ( Echo.Found "ABC" ) || ( Echo.Did not find "ABC" )

As you can see this is the superior way to handle the check for multiple reasons.

Se você está detectando presença, aqui está a solução mais fácil:

SET STRING=F00BAH
SET SUBSTRING=F00
ECHO %STRING% | FINDSTR /C:"%SUBSTRING%" >nul & IF ERRORLEVEL 1 (ECHO CASE TRUE) else (ECHO CASE FALSE)

Isso funciona muito bem para soltar a saída dos comandos do Windows em uma variável booleana. Apenas substitua o eco pelo comando que você deseja executar. Você também pode agrupar o Findstr para qualificar ainda mais uma declaração usando pipes. EG para Controle de Serviço (SC.exe)

SC QUERY WUAUSERV | findstr /C:"STATE" | FINDSTR /C:"RUNNING" & IF ERRORLEVEL 1 (ECHO case True) else (ECHO CASE FALSE)

A pessoa avalia a saída do SC Query para serviços de atualização do Windows que sai como um texto de múltiplas linhas, localiza a linha que contém "state" e, em seguida, localiza se a palavra "running" ocorre nessa linha e define o nível de erro de acordo.

Provavelmente estou chegando tarde demais com esta resposta, mas a resposta aceita funciona apenas para verificar se uma "sequência codificada" faz parte da sequência de pesquisa.

Para pesquisa dinâmica, você teria que fazer o seguinte:

SET searchString=abcd1234
SET key=cd123

CALL SET keyRemoved=%%searchString:%key%=%%

IF NOT "x%keyRemoved%"=="x%searchString%" (
    ECHO Contains.
)

Nota: Você pode usar as duas variáveis ​​como argumentos.

Melhor resposta foi aqui :

set "i=hello " world"
set i|find """" >nul && echo contains || echo not_contains

ECHO %String%| FINDSTR /C:"%Substring%" && (Instructions)

As soluções que pesquisam um arquivo por uma substring também podem pesquisar uma string , por exemplo. findou findstr.
No seu caso, a solução fácil mais seria inserir uma string no comando em vez de fornecer um nome de arquivo, por exemplo.

sequência que diferencia maiúsculas de minúsculas:
echo "abcdefg" | find "bcd"

ignorar maiúsculas de minúsculas:
echo "abcdefg" | find /I "bcd"

Se nenhuma correspondência for encontrada, você receberá uma resposta de linha em branco no CMD e% ERRORLEVEL% definido como 1