No Bash, como posso verificar se uma sequência começa com algum valor?

Gostaria de verificar se uma string começa com "node", por exemplo, "node001". Algo como

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

Como posso fazer isso corretamente?

Preciso ainda combinar expressões para verificar se o HOST é "user1" ou começa com "node"

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

> > > -bash: [: too many arguments

Como posso fazer isso corretamente?

Este snippet no Advanced Bash Scripting Guide diz:

# 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).

Então você quase acertou; você precisava de colchetes duplos , não de colchetes simples.

Com relação à sua segunda pergunta, você pode escrevê-lo desta maneira:

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

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

Qual eco

yes1
yes2

ifÉ difícil se acostumar com a sintaxe do Bash (IMO).

Se você estiver usando uma versão recente do Bash (v3 +), sugiro o operador de comparação de expressões regulares do Bash =~, por exemplo,

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

Para corresponder a this or thatuma regex, use |, por exemplo,

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

Nota - esta é uma sintaxe de expressão regular 'adequada'.

• user*significa usee zero ou mais ocorrências de r, portanto, usee userrrrcorresponderão.
• user.*médias usere zero ou mais ocorrências de qualquer caractere, portanto user1, userXcorresponderão.
• ^user.*significa corresponder ao padrão user.*no início de $ HOST.

Se você não estiver familiarizado com a sintaxe da expressão regular, tente consultar este recurso .

Eu sempre tento manter o POSIX em shvez de usar extensões Bash, pois um dos principais pontos de script é a portabilidade (além de conectar programas, não substituí-los).

Em sh, existe uma maneira fácil de verificar uma condição "é prefixo".

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

Dada a idade, o arcano e o crocante sh (e o Bash não é a cura: é mais complicado, menos consistente e menos portátil), eu gostaria de destacar um aspecto funcional muito agradável: embora alguns elementos de sintaxe casesejam incorporados , as construções resultantes não são diferentes de qualquer outro trabalho. Eles podem ser compostos da mesma maneira:

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

Ou ainda mais curto

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

Ou ainda mais curto (apenas para apresentar !como um elemento de linguagem - mas esse é um estilo ruim agora)

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

Se você gosta de ser explícito, crie seu próprio elemento de linguagem:

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

Isso não é realmente muito bom?

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

E como shsão basicamente apenas trabalhos e listas de strings (e processos internamente, dos quais os trabalhos são compostos), agora podemos fazer alguma programação funcional leve:

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

Isso é elegante. Não que eu advogasse o uso shde algo sério - ele quebra muito rapidamente os requisitos do mundo real (sem lambdas, portanto, devemos usar strings. Mas aninhar chamadas de função com strings não é possível, tubos não são possíveis, etc.)

Você pode selecionar apenas a parte da sequência que deseja verificar:

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

Para sua pergunta de acompanhamento, você pode usar um OR :

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

Eu prefiro os outros métodos já publicados, mas algumas pessoas gostam de usar:

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

Editar:

Adicionei seus suplentes à declaração de caso acima

Na sua versão editada, você tem muitos colchetes. Deve ficar assim:

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

Embora eu ache a maioria das respostas aqui bastante corretas, muitas delas contêm bashismos desnecessários. A expansão do parâmetro POSIX oferece tudo o que você precisa:

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

e

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

${var#expr}retira o menor correspondente prefixo expra partir ${var}e que retorna. Portanto, se ${host}é que não começar com user( node), ${host#user}( ${host#node}) é o mesmo que ${host}.

exprpermite fnmatch()curingas, portanto, ${host#node??}e amigos também funcionam.

Como #tem um significado no Bash, cheguei à seguinte solução.

Além disso, eu gosto mais de empacotar strings com "" para superar espaços, etc.

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

Adicionando um pouco mais de detalhes de sintaxe à resposta de classificação mais alta de Mark Rushakoff.

A expressão

$HOST == node*

Também pode ser escrito como

$HOST == "node"*

O efeito é o mesmo. Apenas verifique se o curinga está fora do texto citado. Se o curinga estiver dentro das aspas, ele será interpretado literalmente (ou seja, não como curinga).

@OP, para ambas as perguntas, você pode usar case / esac:

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

Segunda questão

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

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

Or Bash 4.0

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

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

não funciona, porque todos [, [[e testreconhecer a mesma gramática não recursiva. Consulte a seção EXPRESSÕES CONDICIONAIS na sua página de manual do Bash.

Como um aparte, o SUSv3 diz

O comando condicional derivado do KornShell (colchete duplo [[]] ) foi removido da descrição da linguagem de comando do shell em uma proposta anterior. Surgiram objeções de que o problema real é o uso indevido do comando test ( [ ), e colocá-lo no shell é a maneira errada de corrigir o problema. Em vez disso, a documentação adequada e uma nova palavra reservada do shell ( ! ) São suficientes.

Testes que requerem várias operações de teste podem ser realizados no nível do shell usando invocações individuais do comando test e da lógica do shell, em vez de usar o sinalizador de teste com tendência a erro -o .

Você precisaria escrever dessa maneira, mas o teste não suporta:

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

test usa = para igualdade de strings e, mais importante, não suporta correspondência de padrões.

case/ esactem um bom suporte para correspondência de padrões:

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

Ele tem o benefício adicional de não depender do Bash, e a sintaxe é portátil. Na especificação Unix única , a linguagem de comandos do shell :

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

grep

Esquecendo o desempenho, este é o POSIX e parece melhor do que as casesoluções:

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

Explicação:

• printf '%s'impedir a printfexpansão de escapes de barra invertida: Bash printf literal verbatim string
• grep -qimpede o eco de correspondências no stdout: como verificar se um arquivo contém uma sequência específica usando o Bash
• grep -E permite expressões regulares estendidas, necessárias para o ^

Ajustei a resposta de @ markrushakoff para torná-la uma função que pode ser chamada:

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" == "" ]]
}

Use-o assim:

$ 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

Aqui está uma versão mais complexa que fornece um valor padrão 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* ]]
}

Use-o assim:

$ 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

Outra coisa que você pode fazer é catdescobrir o que está ecoando e canalizarinline cut -c 1-1