Cómo saber si una cadena Bash contiene una subcadena en Linux

A veces, en los scripts de Linux, desea saber si una cadena de texto contiene una cadena específica más pequeña. Hay muchas maneras de hacer esto. Te mostramos algunas técnicas sencillas y fiables.

¿Por qué es útil?

Buscar una cadena para una subcadena más pequeña es un requisito común. Un ejemplo sería leer texto de un archivo o de una entrada humana y buscar en la cadena una subcadena específica para que su secuencia de comandos pueda decidir qué hacer a continuación. Podría estar buscando una etiqueta o nombre de dispositivo en un archivo de configuración o una cadena de comando en una línea de entrada de un usuario.

Los usuarios de Linux están bendecidos con una gran cantidad de utilidades para manipular texto. Algunos están integrados en el shell de Bash, otros se proporcionan como utilidades o aplicaciones independientes. Hay una razón por la cual los sistemas operativos derivados de Unix cuentan con abundantes capacidades de manipulación de cadenas.

RELACIONADO Cómo manipular cadenas en Bash en Linux

Algunas cosas que parecen ser archivos no son archivos simples. Son archivos especiales que representan cosas como dispositivos de hardware y fuentes de información del sistema. La abstracción que realiza el sistema operativo les da la apariencia y características de archivos. Puede leer información de ellos, como texto, naturalmente, y en algunos casos escribir en ellos, pero no son archivos ordinarios.

El texto también se usa como entrada y salida para comandos en una ventana de terminal. Esto permite la redirección y canalización de entrada y salida. Esa funcionalidad respalda la capacidad de encadenar secuencias de comandos de Linux, pasando la salida de un comando como entrada al siguiente.

Independientemente de sus orígenes, buscar en el texto que recibimos una palabra, un comando, una etiqueta o algún otro indicador significativo es una parte estándar del manejo de datos basados ​​en texto. Aquí hay una colección de técnicas simples que puede incluir en sus propios scripts.

Encontrar subcadenas con Bash Builtins

La prueba de comparación de cadenas de corchetes dobles “ [[...]] ” se puede utilizar en declaraciones if para determinar si una cadena contiene otra cadena.

Copie este script en un editor y guárdelo en un archivo llamado "double.sh".

 #!/bin/bash

if [[ "mono" = *"llave"* ]]; después
  echo "la clave está en mono"
más
  echo "la clave no está en mono"
fi 

RELACIONADO Cómo usar pruebas condicionales de doble corchete en Linux

Deberá hacer que el script sea ejecutable con el comando chmod . Este es un paso que siempre se requiere para hacer que cualquier script sea ejecutable. Deberá hacer esto cada vez que cree un archivo de secuencia de comandos. Sustituya el nombre del script apropiado en cada caso.

 chmod +x doble.sh 

Ejecutemos el script.

 ./doble.sh 

Esto funciona porque el asterisco ” * ” representa cualquier secuencia de caracteres, incluso sin caracteres. Si la "clave" de la subcadena se encuentra dentro de la cadena de destino, con o sin caracteres delante o detrás, la prueba devolverá verdadero.

En nuestro ejemplo, hay caracteres delante de la subcadena. Estos se corresponden con el primer asterisco. No hay letras detrás de la subcadena pero, debido a que un asterisco tampoco coincide con ningún carácter, la prueba aún pasa.

Para mayor flexibilidad, podemos modificar nuestro script para manejar variables en lugar de cadenas literales. Este es el script "double2.sh".

 #!/bin/bash

cadena="Mono"
subcadena = "clave"

if [[ $cadena = *$subcadena* ]]; después
  echo "$subcadena fue encontrada en $cadena"
más
  echo "$subcadena no fue encontrada en $cadena"
fi

Veamos cómo funciona eso.

 ./doble2.sh 

Esto funciona de la misma manera, con la ventaja de que podemos usar nombres de variables en lugar de cadenas literales. Convertir nuestra pequeña solución en una función proporcionará la mayor flexibilidad.

Este es el script "double3.sh".

 #!/bin/bash

shopt -s nocasematch

cadena="Mono"
subcadena="Clave"
capital="Londres"

comprobar_subcadena ()
{
si [[ $1 = *$2* ]]; después
  echo "$2 fue encontrado en $1"
más
  echo "$2 no fue encontrado en $1"
fi
}

check_substring "Mono" "clave" 
check_subcadena $cadena $subcadena
check_substring $cadena "plátano"
check_substring "Gales" $capital

Llamamos a nuestra función check_substring usando una combinación de variables y cadenas literales. Usamos shopt con su opción -s (establecer) para establecer nocasematch , para que las coincidencias no distingan entre mayúsculas y minúsculas.

Así es como funciona.

 ./doble3.sh 

También podemos usar el truco de envolver la subcadena en asteriscos en declaraciones de case . Esto es "case.sh".

 #!/bin/bash

shopt -s nocasematch

string="Walabí"
subcadena = "Pared"

caso $cadena en

  *$subcadena*)
    echo "$subcadena fue encontrada en $cadena"
    ;;

  *)
    echo "Nada coincide: $cadena"
    ;;
esac

El uso de declaraciones de case en lugar de declaraciones if muy largas puede hacer que los scripts sean más fáciles de leer y depurar. Si necesita verificar si una cadena contiene una de muchas subcadenas posibles, la declaración de case sería la mejor opción.

 ./caso.sh 

Se encuentra la subcadena.

Encontrar subcadenas con grep

Más allá de las funciones integradas de Bash, la primera herramienta de búsqueda de texto que probablemente encontrará es grep . Podemos usar la capacidad innata de grep para buscar una cadena dentro de una cadena para buscar nuestras subcadenas.

Este script se llama "subgrep.sh".

 #!/bin/bash

string="olla de avena"
subcadena = "cresta"

if $(echo $cadena | grep -q $subcadena); después
  echo "$subcadena fue encontrada en $cadena"
más
  echo "$subcadena no fue encontrada en $cadena"
fi

El script usa echo para enviar la cadena a grep , que busca la subcadena. Estamos usando la opción -q (silencioso) para evitar que grep escriba algo en la salida estándar.

RELACIONADO Cómo usar el comando grep en Linux

Si el resultado de los comandos entre paréntesis “ (...) ” es igual a cero, significa que se encontró una coincidencia. Debido a que cero equivale a true en Bash, se cumple la declaración if y se ejecuta la cláusula then .

Veamos cuál es su salida.

 ./subgrep.sh 

Encontrar subcadenas con sed

También podemos usar sed para encontrar una subcadena.

De forma predeterminada, sed imprime todo el texto que se introduce en él. El uso sed -n evita esto. Las únicas líneas que se imprimen son las líneas coincidentes. Esta expresión imprimirá cualquier línea que coincida o contenga el valor de $subcadena.

 "/$subcadena/p"

Alimentamos el valor de $string en sed usando una redirección aquí, <<< . Esto se usa para redirigir valores a un comando en el shell actual. No invoca una subcapa como lo haría una canalización.

RELACIONADO Cómo usar el comando sed en Linux

El primero -n es la prueba. Devolverá true si la salida del comando sed no es cero. La única forma en que la salida de sed puede ser distinta de cero es si se encuentra una línea coincidente. Si ese es el caso, $substring debe haberse encontrado en $string .

Esto es "subsed.sh".

 #!/bin/bash

cadena="Suecia"
subcadena="eden"

if [ -n "$(sed -n "/$subcadena/p" <<< $cadena)" ]; después
  echo "$subcadena fue encontrada en $cadena"
más
  echo "$subcadena no fue encontrada en $cadena"
fi

Obtenemos la respuesta esperada cuando ejecutamos el script.

 ./suscrito.sh 

Podemos probar la lógica del script editando el valor de $substring para que la comparación falle.

./suscrito.sh

Deja de buscar, lo encontré

Otras herramientas pueden encontrar subcadenas, como awk y Perl , pero un caso de uso simple como encontrar una subcadena no garantiza su funcionalidad adicional ni la complejidad adicional. En particular, usar las funciones integradas de Bash para buscar subcadenas es rápido, simple y no requiere herramientas externas.

RELACIONADO: Cómo usar declaraciones de casos en scripts Bash