Tengo una cadena en Bash:

string="My string"

¿Cómo puedo probar si contiene otra cadena?

if [ $string ?? 'foo' ]; then
  echo "It's there!"
fi

¿Dónde ??está mi operador desconocido? ¿Utilizo echo y grep?

if echo "$string" | grep 'foo'; then
  echo "It's there!"
fi

Eso se ve un poco torpe.

También puede usar la respuesta de Marcus (* comodines) fuera de una declaración de caso, si usa corchetes dobles:

string='My long string'
if [[ $string == *"My long"* ]]; then
  echo "It's there!"
fi

Tenga en cuenta que los espacios en la cadena de la aguja deben colocarse entre comillas dobles, y los *comodines deben estar afuera. También tenga en cuenta que se utiliza un operador de comparación simple (es decir ==), no el operador de expresiones regulares =~.

Si prefiere el enfoque regex:

string='My string';

if [[ $string =~ "My" ]]
then
   echo "It's there!"
fi

No estoy seguro de usar una declaración if, pero puede obtener un efecto similar con una declaración de caso:

case "$string" in 
  *foo*)
    # Do stuff
    ;;
esac

stringContain variantes (compatibles o independientes de mayúsculas y minúsculas)

Como estas respuestas de desbordamiento de pila se refieren principalmente a Bash , he publicado una función Bash independiente del caso en la parte inferior de esta publicación ...

De todos modos, ahí está mi

Respuesta compatible

Como ya hay muchas respuestas usando las características específicas de Bash, hay una manera de trabajar bajo shells con características más pobres, como BusyBox :

[ -z "${string##*$reqsubstr*}" ]

En la práctica, esto podría dar:

string='echo "My string"'
for reqsubstr in 'o "M' 'alt' 'str';do
  if [ -z "${string##*$reqsubstr*}" ] ;then
      echo "String '$string' contain substring: '$reqsubstr'."
    else
      echo "String '$string' don't contain substring: '$reqsubstr'."
    fi
  done

Esto se probó en Bash, Dash , KornShell ( ksh) y ash (BusyBox), y el resultado es siempre:

String 'echo "My string"' contain substring: 'o "M'.
String 'echo "My string"' don't contain substring: 'alt'.
String 'echo "My string"' contain substring: 'str'.

En una función

Según lo solicitado por @EeroAaltonen, aquí hay una versión de la misma demostración, probada bajo los mismos shells:

myfunc() {
    reqsubstr="$1"
    shift
    string="$@"
    if [ -z "${string##*$reqsubstr*}" ] ;then
        echo "String '$string' contain substring: '$reqsubstr'.";
      else
        echo "String '$string' don't contain substring: '$reqsubstr'."
    fi
}

Entonces:

$ myfunc 'o "M' 'echo "My String"'
String 'echo "My String"' contain substring 'o "M'.

$ myfunc 'alt' 'echo "My String"'
String 'echo "My String"' don't contain substring 'alt'.

Aviso: tiene que escapar o doble comillas y / o comillas dobles:

$ myfunc 'o "M' echo "My String"
String 'echo My String' don't contain substring: 'o "M'.

$ myfunc 'o "M' echo \"My String\"
String 'echo "My String"' contain substring: 'o "M'.

Función simple

Esto se probó en BusyBox, Dash y, por supuesto, Bash:

stringContain() { [ -z "${2##*$1*}" ]; }

Entonces ahora:

$ if stringContain 'o "M3' 'echo "My String"';then echo yes;else echo no;fi
no
$ if stringContain 'o "M' 'echo "My String"';then echo yes;else echo no;fi
yes

... O si la cadena enviada pudiera estar vacía, como lo señaló @Sjlver, la función sería:

stringContain() { [ -z "${2##*$1*}" ] && [ -z "$1" -o -n "$2" ]; }

o como lo sugiere el comentario de Adrian Günter , evitando -ointerruptores:

stringContain() { [ -z "${2##*$1*}" ] && { [ -z "$1" ] || [ -n "$2" ];};}

Función final (simple):

E invirtiendo las pruebas para que sean potencialmente más rápidas:

stringContain() { [ -z "$1" ] || { [ -z "${2##*$1*}" ] && [ -n "$2" ];};}

Con cadenas vacías:

$ if stringContain '' ''; then echo yes; else echo no; fi
yes
$ if stringContain 'o "M' ''; then echo yes; else echo no; fi
no

Caso independiente (¡solo Bash!)

Para probar cadenas sin cuidado de mayúsculas y minúsculas, simplemente convierta cada cadena a minúsculas:

stringContain() {
    local _lc=${2,,}
    [ -z "$1" ] || { [ -z "${_lc##*${1,,}*}" ] && [ -n "$2" ] ;} ;}

Cheque:

stringContain 'o "M3' 'echo "my string"' && echo yes || echo no
no
stringContain 'o "My' 'echo "my string"' && echo yes || echo no
yes
if stringContain '' ''; then echo yes; else echo no; fi
yes
if stringContain 'o "M' ''; then echo yes; else echo no; fi
no

Debe recordar que las secuencias de comandos de shell son menos un lenguaje y más una colección de comandos. Instintivamente piensas que este "lenguaje" requiere que sigas a ifcon a [o a [[. Ambos son solo comandos que devuelven un estado de salida que indica éxito o fracaso (como cualquier otro comando). Por esa razón usaría grep, y no el [comando.

Solo haz:

if grep -q foo <<<"$string"; then
    echo "It's there"
fi

Ahora que está pensando ifen probar el estado de salida del comando que lo sigue (completo con punto y coma), ¿por qué no reconsiderar la fuente de la cadena que está probando?

## Instead of this
filetype="$(file -b "$1")"
if grep -q "tar archive" <<<"$filetype"; then
#...

## Simply do this
if file -b "$1" | grep -q "tar archive"; then
#...

La -qopción hace que grep no muestre nada, ya que solo queremos el código de retorno. <<<hace que el shell expanda la siguiente palabra y la use como entrada para el comando, una versión de una línea del <<documento aquí (no estoy seguro de si esto es estándar o un Bashism).

La respuesta aceptada es la mejor, pero como hay más de una forma de hacerlo, aquí hay otra solución:

if [ "$string" != "${string/foo/}" ]; then
    echo "It's there!"
fi

${var/search/replace}es $varcon la primera instancia de searchreemplazado por replace, si se encuentra (no cambia $var). Si intenta reemplazar foopor nada, y la cadena ha cambiado, entonces obviamente foose encontró.

Entonces, hay muchas soluciones útiles para la pregunta, pero ¿cuál es la más rápida / usa la menor cantidad de recursos?

Pruebas repetidas usando este marco:

/usr/bin/time bash -c 'a=two;b=onetwothree; x=100000; while [ $x -gt 0 ]; do TEST ; x=$(($x-1)); done'

Reemplazar TEST cada vez:

[[ $b =~ $a ]]           2.92 user 0.06 system 0:02.99 elapsed 99% CPU

[ "${b/$a//}" = "$b" ]   3.16 user 0.07 system 0:03.25 elapsed 99% CPU

[[ $b == *$a* ]]         1.85 user 0.04 system 0:01.90 elapsed 99% CPU

case $b in *$a):;;esac   1.80 user 0.02 system 0:01.83 elapsed 99% CPU

doContain $a $b          4.27 user 0.11 system 0:04.41 elapsed 99%CPU

(doContain estaba en la respuesta de F. Houri)

Y para las risas:

echo $b|grep -q $a       12.68 user 30.86 system 3:42.40 elapsed 19% CPU !ouch!

Por lo tanto, la opción de sustitución simple previsiblemente gana ya sea en una prueba extendida o en un caso. El estuche es portátil.

¡Contar con 100000 greps es previsiblemente doloroso! La antigua regla sobre el uso de utilidades externas sin necesidad es cierta.

Esto también funciona:

if printf -- '%s' "$haystack" | egrep -q -- "$needle"
then
  printf "Found needle in haystack"
fi

Y la prueba negativa es:

if ! printf -- '%s' "$haystack" | egrep -q -- "$needle"
then
  echo "Did not find needle in haystack"
fi

Supongo que este estilo es un poco más clásico, menos dependiente de las características del shell Bash.

El --argumento es pura paranoia POSIX, utilizada para proteger contra cadenas de entrada similares a las opciones, como --abco-a .

Nota: En un bucle cerrado, este código será mucho más lento que el uso de las funciones internas del shell Bash, ya que uno (o dos) procesos separados se crearán y conectarán a través de tuberías.

Bash 4+ ejemplos. Nota: no usar comillas causará problemas cuando las palabras contengan espacios, etc. Comillas siempre en Bash, IMO.

Aquí hay algunos ejemplos de Bash 4+:

Ejemplo 1, verifique 'sí' en la cadena (sin distinción entre mayúsculas y minúsculas):

    if [[ "${str,,}" == *"yes"* ]] ;then

Ejemplo 2, verifique 'sí' en la cadena (sin distinción entre mayúsculas y minúsculas):

    if [[ "$(echo "$str" | tr '[:upper:]' '[:lower:]')" == *"yes"* ]] ;then

Ejemplo 3, verifique 'sí' en la cadena (distingue entre mayúsculas y minúsculas):

     if [[ "${str}" == *"yes"* ]] ;then

Ejemplo 4, verifique 'sí' en la cadena (distingue entre mayúsculas y minúsculas):

     if [[ "${str}" =~ "yes" ]] ;then

Ejemplo 5, coincidencia exacta (mayúsculas y minúsculas):

     if [[ "${str}" == "yes" ]] ;then

Ejemplo 6, coincidencia exacta (sin distinción entre mayúsculas y minúsculas):

     if [[ "${str,,}" == "yes" ]] ;then

Ejemplo 7, coincidencia exacta:

     if [ "$a" = "$b" ] ;then

Ejemplo 8, coincidencia con comodines .ext (sin distinción entre mayúsculas y minúsculas):

     if echo "$a" | egrep -iq "\.(mp[3-4]|txt|css|jpg|png)" ; then

Disfrutar.

Qué tal esto:

text="   <tag>bmnmn</tag>  "
if [[ "$text" =~ "<tag>" ]]; then
   echo "matched"
else
   echo "not matched"
fi

Como Paul mencionó en su comparación de rendimiento:

if echo "abcdefg" | grep -q "bcdef"; then
    echo "String contains is true."
else
    echo "String contains is not true."
fi

Esto es compatible con POSIX como el 'case "$ string" en' la respuesta proporcionada por Marcus , pero es un poco más fácil de leer que la respuesta de la declaración de caso. También tenga en cuenta que esto será mucho más lento que usar una declaración de caso. Como señaló Paul, no lo use en un bucle.

Esta respuesta de desbordamiento de pila fue la única que atrapó el espacio y los caracteres del guión:

# For null cmd arguments checking   
to_check=' -t'
space_n_dash_chars=' -'
[[ $to_check == *"$space_n_dash_chars"* ]] && echo found

[[ $string == *foo* ]] && echo "It's there" || echo "Couldn't find"

Uno es:

[ $(expr $mystring : ".*${search}.*") -ne 0 ] && echo 'yes' ||  echo 'no'

Me gusta sed

substr="foo"
nonsub="$(echo "$string" | sed "s/$substr//")"
hassub=0 ; [ "$string" != "$nonsub" ] && hassub=1

Editar, Lógica:

• Use sed para eliminar la instancia de la subcadena de la cadena

• Si la nueva cadena difiere de la antigua, existe una subcadena

grep -q Es útil para este propósito.

Lo mismo usando awk:

string="unix-bash 2389"
character="@"
printf '%s' "$string" | awk -vc="$character" '{ if (gsub(c, "")) { print "Found" } else { print "Not Found" } }'

Salida:

Extraviado

string="unix-bash 2389"
character="-"
printf '%s' "$string" | awk -vc="$character" '{ if (gsub(c, "")) { print "Found" } else { print "Not Found" } }'

Salida:

Encontró

Fuente original: http://unstableme.blogspot.com/2008/06/bash-search-letter-in-string-awk.html

Descubrí que necesitaba esta funcionalidad con bastante frecuencia, por lo que estoy usando una función de shell casera en mi .bashrcestilo que me permite reutilizarla tantas veces como sea necesario, con un nombre fácil de recordar:

function stringinstring()
{
    case "$2" in
       *"$1"*)
          return 0
       ;;
    esac
    return 1
}

Para probar si $string1(digamos, abc ) está contenido en $string2(digamos, 123abcABC ) solo necesito ejecutar stringinstring "$string1" "$string2"y verificar el valor de retorno, por ejemplo

stringinstring "$str1" "$str2"  &&  echo YES  ||  echo NO

My .bash_profile archivo y cómo usé grep:

Si la variable de entorno PATH incluye mis dos bindirectorios, no los agregue,

# .bash_profile
# Get the aliases and functions
if [ -f ~/.bashrc ]; then
    . ~/.bashrc
fi

U=~/.local.bin:~/bin

if ! echo "$PATH" | grep -q "home"; then
    export PATH=$PATH:${U}
fi

Extensión de la pregunta respondida aquí ¿Cómo saber si una cadena contiene otra cadena en POSIX sh? :

Esta solución funciona con caracteres especiales:

# contains(string, substring)
#
# Returns 0 if the specified string contains the specified substring,
# otherwise returns 1.
contains() {
    string="$1"
    substring="$2"

    if echo "$string" | $(type -p ggrep grep | head -1) -F -- "$substring" >/dev/null; then
        return 0    # $substring is in $string
    else
        return 1    # $substring is not in $string
    fi
}

contains "abcd" "e" || echo "abcd does not contain e"
contains "abcd" "ab" && echo "abcd contains ab"
contains "abcd" "bc" && echo "abcd contains bc"
contains "abcd" "cd" && echo "abcd contains cd"
contains "abcd" "abcd" && echo "abcd contains abcd"
contains "" "" && echo "empty string contains empty string"
contains "a" "" && echo "a contains empty string"
contains "" "a" || echo "empty string does not contain a"
contains "abcd efgh" "cd ef" && echo "abcd efgh contains cd ef"
contains "abcd efgh" " " && echo "abcd efgh contains a space"

contains "abcd [efg] hij" "[efg]" && echo "abcd [efg] hij contains [efg]"
contains "abcd [efg] hij" "[effg]" || echo "abcd [efg] hij does not contain [effg]"

contains "abcd *efg* hij" "*efg*" && echo "abcd *efg* hij contains *efg*"
contains "abcd *efg* hij" "d *efg* h" && echo "abcd *efg* hij contains d *efg* h"
contains "abcd *efg* hij" "*effg*" || echo "abcd *efg* hij does not contain *effg*"

Desde el POSIX pregunta / BusyBox está cerrada sin proporcionar la respuesta correcta (en mi humilde opinión), publicaré una respuesta aquí.

La respuesta más corta posible es:

[ ${_string_##*$_substring_*} ] || echo Substring found!

o

[ "${_string_##*$_substring_*}" ] || echo 'Substring found!'

Tenga en cuenta que el doble hash es obligatorio con algunos shells ( ash). Lo anterior evaluará [ stringvalue ]cuando no se encuentre la subcadena. No devuelve ningún error. Cuando se encuentra la subcadena, el resultado está vacío y se evalúa [ ]. Esto arrojará el código de error 1 ya que la cadena está completamente sustituida (debido a* ).

La sintaxis más corta más común:

[ -z "${_string_##*$_substring_*}" ] && echo 'Substring found!'

o

[ -n "${_string_##*$_substring_*}" ] || echo 'Substring found!'

Otro:

[ "${_string_##$_substring_}" != "$_string_" ] && echo 'Substring found!'

o

[ "${_string_##$_substring_}" = "$_string_" ] || echo 'Substring found!'

Tenga en cuenta el signo igual único !

Concordancia exacta de palabras:

string='My long string'
exactSearch='long'

if grep -E -q "\b${exactSearch}\b" <<<${string} >/dev/null 2>&1
  then
    echo "It's there"
  fi

Prueba oobash.

Es una biblioteca de cadenas de estilo OO para Bash 4. Tiene soporte para diéresis alemanas. Está escrito en Bash.

Muchas de las funciones están disponibles: -base64Decode, -base64Encode, -capitalize, -center, -charAt, -concat, -contains, -count, -endsWith, -equals, -equalsIgnoreCase, -reverse, -hashCode, -indexOf, -isAlnum, -isAlpha, -isAscii, -isDigit, -isEmpty, -isHexDigit, -isLowerCase, -isSpace, -isPrintable, -isUpperCase, -isVisible, -lastIndexOf, -length, -matches, -replaceAll, -replaceFirst, -startsWith, -substring, -swapCase, -toLowerCase, -toString, -toUpperCase, -trim, y -zfill.

Mira el ejemplo contiene :

[Desktop]$ String a testXccc
[Desktop]$ a.contains tX
true
[Desktop]$ a.contains XtX
false

oobash está disponible en Sourceforge.net .

Yo uso esta función (una dependencia no incluida pero obvia). Pasa las pruebas que se muestran a continuación. Si la función devuelve un valor> 0, se encontró la cadena. Podría simplemente devolver 1 o 0 en su lugar.

function str_instr {
   # Return position of ```str``` within ```string```.
   # >>> str_instr "str" "string"
   # str: String to search for.
   # string: String to search.
   typeset str string x
   # Behavior here is not the same in bash vs ksh unless we escape special characters.
   str="$(str_escape_special_characters "${1}")"
   string="${2}"
   x="${string%%$str*}"
   if [[ "${x}" != "${string}" ]]; then
      echo "${#x} + 1" | bc -l
   else
      echo 0
   fi
}

function test_str_instr {
   str_instr "(" "'foo@host (dev,web)'" | assert_eq 11
   str_instr ")" "'foo@host (dev,web)'" | assert_eq 19
   str_instr "[" "'foo@host [dev,web]'" | assert_eq 11
   str_instr "]" "'foo@host [dev,web]'" | assert_eq 19
   str_instr "a" "abc" | assert_eq 1
   str_instr "z" "abc" | assert_eq 0
   str_instr "Eggs" "Green Eggs And Ham" | assert_eq 7
   str_instr "a" "" | assert_eq 0
   str_instr "" "" | assert_eq 0
   str_instr " " "Green Eggs" | assert_eq 6
   str_instr " " " Green "  | assert_eq 1
}

case $string in (*foo*)
  # Do stuff
esac

Esta es la misma respuesta que https://stackoverflow.com/a/229585/11267590 . Pero estilo simple y también compatible con POSIX.

msg="message"

function check {
    echo $msg | egrep [abc] 1> /dev/null

    if [ $? -ne 1 ];
    then 
        echo "found" 
    else 
        echo "not found" 
    fi
}

check

Esto encontrará cualquier ocurrencia de a o b o c

El ejemplo genérico de pajar de agujas está siguiendo con variables

#!/bin/bash

needle="a_needle"
haystack="a_needle another_needle a_third_needle"
if [[ $haystack == *"$needle"* ]]; then
    echo "needle found"
else
    echo "needle NOT found"
fi