Como dividir uma string em várias strings separadas por pelo menos um espaço no shell bash?

Eu tenho uma string contendo muitas palavras com pelo menos um espaço entre cada dois. Como posso dividir a sequência em palavras individuais para que eu possa fazer um loop através delas?

A cadeia é passada como argumento. Por exemplo ${2} == "cat cat file". Como posso percorrer isso?

Além disso, como posso verificar se uma string contém espaços?

Você tentou passar a variável string para um forloop? O Bash, por exemplo, será dividido automaticamente em espaço em branco.

sentence="This is   a sentence."
for word in $sentence
do
    echo $word
done

This
is
a
sentence.

Eu gosto da conversão para uma matriz, para poder acessar elementos individuais:

sentence="this is a story"
stringarray=($sentence)

agora você pode acessar elementos individuais diretamente (começa com 0):

echo ${stringarray[0]}

ou converta novamente em string para fazer um loop:

for i in "${stringarray[@]}"
do
  :
  # do whatever on $i
done

É claro que o loop direto da string foi respondido anteriormente, mas essa resposta teve a desvantagem de não acompanhar os elementos individuais para uso posterior:

for i in $sentence
do
  :
  # do whatever on $i
done

Consulte também Referência do array bash .

Basta usar as conchas "set" embutidas. Por exemplo,

definir $ texto

Depois disso, palavras individuais em $ text estarão em $ 1, $ 2, $ 3, etc. Para maior robustez, geralmente

set - texto $ lixo eletrônico
mudança

para lidar com o caso em que $ text esteja vazio ou comece com um traço. Por exemplo:

text = "Este é um teste"
set - texto $ lixo eletrônico
mudança
por palavra; Faz
  eco "[$ word]"
feito

Isso imprime

[Este]
[é]
[uma]
[teste]

A maneira provavelmente mais fácil e segura no BASH 3 e acima é:

var="string    to  split"
read -ra arr <<<"$var"

(onde arré a matriz que pega as partes divididas da sequência) ou, se houver novas linhas na entrada e você desejar mais do que apenas a primeira linha:

var="string    to  split"
read -ra arr -d '' <<<"$var"

(observe o espaço -d '', ele não pode ser deixado de fora), mas isso pode fornecer uma nova linha inesperada de <<<"$var"(como isso implicitamente adiciona um LF no final).

Exemplo:

touch NOPE
var="* a  *"
read -ra arr <<<"$var"
for a in "${arr[@]}"; do echo "[$a]"; done

Produz o esperado

[*]
[a]
[*]

como esta solução (em contraste com todas as soluções anteriores aqui) não é propensa a globbing inesperado e muitas vezes incontrolável do shell.

Além disso, isso fornece todo o poder do IFS, como você provavelmente deseja:

Exemplo:

IFS=: read -ra arr < <(grep "^$USER:" /etc/passwd)
for a in "${arr[@]}"; do echo "[$a]"; done

Produz algo como:

[tino]
[x]
[1000]
[1000]
[Valentin Hilbig]
[/home/tino]
[/bin/bash]

Como você pode ver, os espaços também podem ser preservados dessa maneira:

IFS=: read -ra arr <<<' split  :   this    '
for a in "${arr[@]}"; do echo "[$a]"; done

saídas

[ split  ]
[   this    ]

Observe que a manipulação IFSno BASH é um assunto por si só, assim como seus testes, alguns tópicos interessantes sobre isso:

• unset IFS: Ignora execuções de SPC, TAB, NL e on-line inicia e termina
• IFS='': Sem separação de campos, apenas lê tudo
• IFS=' ': Executa o SPC (e somente o SPC)

Algum último exemplo

var=$'\n\nthis is\n\n\na test\n\n'
IFS=$'\n' read -ra arr -d '' <<<"$var"
i=0; for a in "${arr[@]}"; do let i++; echo "$i [$a]"; done

saídas

1 [this is]
2 [a test]

enquanto

unset IFS
var=$'\n\nthis is\n\n\na test\n\n'
read -ra arr -d '' <<<"$var"
i=0; for a in "${arr[@]}"; do let i++; echo "$i [$a]"; done

saídas

1 [this]
2 [is]
3 [a]
4 [test]

BTW:

• Se você não está acostumado a $'ANSI-ESCAPED-STRING'se acostumar com isso, economiza tempo.

• Se você não incluir -r(como em read -a arr <<<"$var"), a leitura será escapada pela barra invertida. Isso é deixado como exercício para o leitor.

Para a segunda pergunta:

Para testar algo em uma string em que costumo me ater case, já que isso pode verificar vários casos de uma só vez (nota: case apenas executa a primeira correspondência, se você precisar de instruções de uso de multiplicação case), e essa necessidade costuma ser o caso (trocadilho pretendido):

case "$var" in
'')                empty_var;;                # variable is empty
*' '*)             have_space "$var";;        # have SPC
*[[:space:]]*)     have_whitespace "$var";;   # have whitespaces like TAB
*[^-+.,A-Za-z0-9]*) have_nonalnum "$var";;    # non-alphanum-chars found
*[-+.,]*)          have_punctuation "$var";;  # some punctuation chars found
*)                 default_case "$var";;      # if all above does not match
esac

Portanto, você pode definir o valor de retorno para verificar o SPC assim:

case "$var" in (*' '*) true;; (*) false;; esac

Por que case? Como geralmente é um pouco mais legível que as sequências de expressões regulares, e graças aos metacaracteres da Shell, ele lida com 99% de todas as necessidades muito bem.

$ echo "This is   a sentence." | tr -s " " "\012"
This
is
a
sentence.

Para verificar espaços, use grep:

$ echo "This is   a sentence." | grep " " > /dev/null
$ echo $?
0
$ echo "Thisisasentence." | grep " " > /dev/null     
$ echo $?
1

(A) Para dividir uma frase em suas palavras (separadas por espaço), você pode simplesmente usar o IFS padrão usando

array=( $string )

Exemplo executando o seguinte trecho

#!/bin/bash

sentence="this is the \"sentence\"   'you' want to split"
words=( $sentence )

len="${#words[@]}"
echo "words counted: $len"

printf "%s\n" "${words[@]}" ## print array

irá produzir

words counted: 8
this
is
the
"sentence"
'you'
want
to
split

Como você pode ver, você pode usar aspas simples ou duplas também sem problemas.

Notas:
- isso é basicamente o mesmo da resposta do mob , mas dessa forma você armazena o array para qualquer necessidade adicional. Se você precisar apenas de um loop único, poderá usar a resposta dele, que é uma linha mais curta :)
- consulte esta pergunta para métodos alternativos para dividir uma string com base no delimitador.


(B) Para procurar um caractere em uma string, você também pode usar uma correspondência de expressão regular.
Exemplo para verificar a presença de um caractere de espaço que você pode usar:

regex='\s{1,}'
if [[ "$sentence" =~ $regex ]]
    then
        echo "Space here!";
fi

Para verificar espaços apenas com o bash:

[[ "$str" = "${str% *}" ]] && echo "no spaces" || echo "has spaces"

echo $WORDS | xargs -n1 echo

Isso gera cada palavra; você pode processar essa lista como desejar depois.