En Bash, ¿cómo puedo verificar si una cadena comienza con algún valor?

Me gustaría comprobar si una cadena comienza con "nodo", por ejemplo, "nodo001". Algo como

if [ $HOST == user* ]
  then
  echo yes
fi

¿Cómo puedo hacerlo correctamente?

Además, necesito combinar expresiones para verificar si HOST es "user1" o comienza con "node"

if [ [[ $HOST == user1 ]] -o [[ $HOST == node* ]] ];
then
echo yes
fi

> > > -bash: [: too many arguments

¿Cómo puedo hacerlo correctamente?

Este fragmento de la Guía avanzada de secuencias de comandos Bash dice:

# The == comparison operator behaves differently within a double-brackets
# test than within single brackets.

[[ $a == z* ]]   # True if $a starts with a "z" (wildcard matching).
[[ $a == "z*" ]] # True if $a is equal to z* (literal matching).

Entonces lo tenías casi correcto; necesitabas corchetes dobles , no corchetes individuales.

Con respecto a su segunda pregunta, puede escribirla de esta manera:

HOST=user1
if  [[ $HOST == user1 ]] || [[ $HOST == node* ]] ;
then
    echo yes1
fi

HOST=node001
if [[ $HOST == user1 ]] || [[ $HOST == node* ]] ;
then
    echo yes2
fi

Que hará eco

yes1
yes2

ifEs difícil acostumbrarse a la sintaxis de Bash (IMO).

Si está utilizando una versión reciente de Bash (v3 +), sugiero el operador de comparación de expresiones regulares de Bash =~, por ejemplo,

if [[ "$HOST" =~ ^user.* ]]; then
    echo "yes"
fi

Para coincidir this or thaten una expresión regular, use |, por ejemplo,

if [[ "$HOST" =~ ^user.*|^host1 ]]; then
    echo "yes"
fi

Nota: esta es la sintaxis de expresión regular 'adecuada'.

• user*significa usey cero o más ocurrencias de r, entonces usey userrrrcoincidirá.
• user.*significa usery cero o más ocurrencias de cualquier carácter, por lo tanto user1, userXcoincidirán.
• ^user.*significa hacer coincidir el patrón user.*al comienzo de $ HOST.

Si no está familiarizado con la sintaxis de expresiones regulares, intente consultar este recurso .

Siempre trato de mantener POSIX en shlugar de usar extensiones Bash, ya que uno de los puntos principales de la secuencia de comandos es la portabilidad (además de conectar programas, no reemplazarlos).

En sh, hay una manera fácil de verificar si hay una condición "es-prefijo".

case $HOST in node*)
    # Your code here
esac

Dada la antigüedad, sh arcano y crujiente (y Bash no es la cura: es más complicado, menos consistente y menos portátil), me gustaría señalar un aspecto funcional muy agradable: mientras que algunos elementos de sintaxis como caseestán incorporados , las construcciones resultantes no son diferentes a cualquier otro trabajo. Se pueden componer de la misma manera:

if case $HOST in node*) true;; *) false;; esac; then
    # Your code here
fi

O incluso más corto

if case $HOST in node*) ;; *) false;; esac; then
    # Your code here
fi

O incluso más corto (solo para presentarlo !como un elemento del lenguaje, pero este es un mal estilo ahora)

if ! case $HOST in node*) false;; esac; then
    # Your code here
fi

Si te gusta ser explícito, crea tu propio elemento de lenguaje:

beginswith() { case $2 in "$1"*) true;; *) false;; esac; }

¿No es esto realmente bastante agradable?

if beginswith node "$HOST"; then
    # Your code here
fi

Y dado shque básicamente son solo trabajos y listas de cadenas (y procesos internos, de los cuales se componen los trabajos), ahora podemos incluso hacer una programación funcional ligera:

beginswith() { case $2 in "$1"*) true;; *) false;; esac; }
checkresult() { if [ $? = 0 ]; then echo TRUE; else echo FALSE; fi; }

all() {
    test=$1; shift
    for i in "$@"; do
        $test "$i" || return
    done
}

all "beginswith x" x xy xyz ; checkresult  # Prints TRUE
all "beginswith x" x xy abc ; checkresult  # Prints FALSE

Esto es elegante No es que yo recomendaría usar shalgo serio: se rompe demasiado rápido según los requisitos del mundo real (no hay lambdas, por lo que debemos usar cadenas. Pero anidar llamadas de función con cadenas no es posible, las tuberías no son posibles, etc.)

Puede seleccionar solo la parte de la cadena que desea verificar:

if [ "${HOST:0:4}" = user ]

Para su pregunta de seguimiento, puede usar un OR :

if [[ "$HOST" == user1 || "$HOST" == node* ]]

Prefiero los otros métodos ya publicados, pero a algunas personas les gusta usar:

case "$HOST" in 
    user1|node*) 
            echo "yes";;
        *)
            echo "no";;
esac

Editar:

He agregado sus alternativas a la declaración de caso anterior

En su versión editada tiene demasiados corchetes. Debe tener un aspecto como este:

if [[ $HOST == user1 || $HOST == node* ]];

Si bien la mayoría de las respuestas aquí son bastante correctas, muchas de ellas contienen Bashismos innecesarios. La expansión de parámetros POSIX le brinda todo lo que necesita:

[ "${host#user}" != "${host}" ]

y

[ "${host#node}" != "${host}" ]

${var#expr}tiras el más pequeño emparejamiento de prefijo exprde ${var}y rendimientos. Por tanto, si ${host}no no comenzar con user( node), ${host#user}( ${host#node}) es el mismo que ${host}.

exprpermite fnmatch()comodines, por lo tanto ${host#node??}y amigos también funcionan.

Ya que # tiene un significado en Bash, llegué a la siguiente solución.

Además, me gusta más empacar cadenas con "" para superar espacios, etc.

A="#sdfs"
if [[ "$A" == "#"* ]];then
    echo "Skip comment line"
fi

Agregando un poco más de detalle de sintaxis a la respuesta de rango más alto de Mark Rushakoff.

La expresion

$HOST == node*

También se puede escribir como

$HOST == "node"*

El efecto es el mismo. Solo asegúrese de que el comodín esté fuera del texto citado. Si el comodín está dentro de las comillas, se interpretará literalmente (es decir, no como un comodín).

@OP, para ambas preguntas puede usar case / esac:

string="node001"
case "$string" in
  node*) echo "found";;
  * ) echo "no node";;
esac

Segunda pregunta

case "$HOST" in
 node*) echo "ok";;
 user) echo "ok";;
esac

case "$HOST" in
 node*|user) echo "ok";;
esac

O Bash 4.0

case "$HOST" in
 user) ;&
 node*) echo "ok";;
esac

if [ [[ $HOST == user1 ]] -o [[ $HOST == node* ]] ];
then
echo yes
fi

no funciona, porque todos [, [[y testreconocer la misma gramática recursiva. Consulte la sección EXPRESIONES CONDICIONALES en su página de manual de Bash.

Como un aparte, el SUSv3 dice

El comando condicional derivado de KornShell (paréntesis doble [[]] ) se eliminó de la descripción del lenguaje de comando de shell en una propuesta inicial. Se plantearon objeciones de que el problema real es el mal uso del comando de prueba ( [ ), y ponerlo en el shell es la forma incorrecta de solucionar el problema. En cambio, la documentación adecuada y una nueva palabra reservada de shell ( ! ) Son suficientes.

Las pruebas que requieren múltiples de ensayo operaciones se pueden hacer en el nivel de la cáscara utilizando invocaciones individuales de las pruebas Logicals de mando y de la cáscara, en vez de utilizar la propenso a errores -o bandera de prueba .

Tendría que escribirlo de esta manera, pero la prueba no lo admite:

if [ $HOST == user1 -o $HOST == node* ];
then
echo yes
fi

prueba utiliza = para la igualdad de cadena, y lo más importante, no admite la coincidencia de patrones.

case/ esactiene buen soporte para la coincidencia de patrones:

case $HOST in
user1|node*) echo yes ;;
esac

Tiene el beneficio adicional de que no depende de Bash, y la sintaxis es portátil. De la especificación Single Unix , el lenguaje de comandos de Shell :

case word in
    [(]pattern1) compound-list;;
    [[(]pattern[ | pattern] ... ) compound-list;;] ...
    [[(]pattern[ | pattern] ... ) compound-list]
esac

grep

Olvidando el rendimiento, esto es POSIX y se ve mejor que las casesoluciones:

mystr="abcd"
if printf '%s' "$mystr" | grep -Eq '^ab'; then
  echo matches
fi

Explicación:

• printf '%s'para evitar la printfexpansión de las barras invertidas: Bash printf literal literal text
• grep -qevita el eco de coincidencias con stdout: Cómo verificar si un archivo contiene una cadena específica usando Bash
• grep -E habilita expresiones regulares extendidas, que necesitamos para ^

Ajusté la respuesta de @ markrushakoff para que sea una función invocable:

function yesNo {
  # Prompts user with $1, returns true if response starts with y or Y or is empty string
  read -e -p "
$1 [Y/n] " YN

  [[ "$YN" == y* || "$YN" == Y* || "$YN" == "" ]]
}

Úselo así:

$ if yesNo "asfd"; then echo "true"; else echo "false"; fi

asfd [Y/n] y
true

$ if yesNo "asfd"; then echo "true"; else echo "false"; fi

asfd [Y/n] Y
true

$ if yesNo "asfd"; then echo "true"; else echo "false"; fi

asfd [Y/n] yes
true

$ if yesNo "asfd"; then echo "true"; else echo "false"; fi

asfd [Y/n]
true

$ if yesNo "asfd"; then echo "true"; else echo "false"; fi

asfd [Y/n] n
false

$ if yesNo "asfd"; then echo "true"; else echo "false"; fi

asfd [Y/n] ddddd
false

Aquí hay una versión más compleja que proporciona un valor predeterminado especificado:

function toLowerCase {
  echo "$1" | tr '[:upper:]' '[:lower:]'
}

function yesNo {
  # $1: user prompt
  # $2: default value (assumed to be Y if not specified)
  # Prompts user with $1, using default value of $2, returns true if response starts with y or Y or is empty string

  local DEFAULT=yes
  if [ "$2" ]; then local DEFAULT="$( toLowerCase "$2" )"; fi
  if [[ "$DEFAULT" == y* ]]; then
    local PROMPT="[Y/n]"
  else
    local PROMPT="[y/N]"
  fi
  read -e -p "
$1 $PROMPT " YN

  YN="$( toLowerCase "$YN" )"
  { [ "$YN" == "" ] && [[ "$PROMPT" = *Y* ]]; } || [[ "$YN" = y* ]]
}

Úselo así:

$ if yesNo "asfd" n; then echo "true"; else echo "false"; fi

asfd [y/N]
false

$ if yesNo "asfd" n; then echo "true"; else echo "false"; fi

asfd [y/N] y
true

$ if yesNo "asfd" y; then echo "true"; else echo "false"; fi

asfd [Y/n] n
false

Otra cosa que puedes hacer es catdescubrir qué es lo que estás haciendo eco yinline cut -c 1-1