¿Cómo dividir una cadena en varias cadenas separadas por al menos un espacio en bash shell?

Tengo una cadena que contiene muchas palabras con al menos un espacio entre cada dos. ¿Cómo puedo dividir la cadena en palabras individuales para poder recorrerlas?

La cadena se pasa como argumento. Por ej ${2} == "cat cat file". ¿Cómo puedo recorrerlo?

Además, ¿cómo puedo verificar si una cadena contiene espacios?

¿Intentó simplemente pasar la variable de cadena a un forbucle? Bash, por ejemplo, se dividirá en espacios en blanco automáticamente.

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

This
is
a
sentence.

Me gusta la conversión a una matriz, para poder acceder a elementos individuales:

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

ahora puede acceder a elementos individuales directamente (comienza con 0):

echo ${stringarray[0]}

o convertir de nuevo a cadena para hacer un bucle:

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

Por supuesto, el bucle a través de la cadena directamente se respondió antes, pero esa respuesta tenía la desventaja de no realizar un seguimiento de los elementos individuales para su uso posterior:

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

Consulte también Referencia de matriz de bash .

Solo use los shells "set" incorporados. Por ejemplo,

establecer $ texto

Después de eso, las palabras individuales en $ texto estarán en $ 1, $ 2, $ 3, etc. Para mayor solidez, generalmente se hace

conjunto - basura $ texto
cambio

para manejar el caso donde $ text está vacío o comienza con un guión. Por ejemplo:

text = "Esto es una prueba"
conjunto - basura $ texto
cambio
por palabra; hacer
  echo "[$ palabra]"
hecho

Esto imprime

[Esta]
[es]
[una]
[prueba]

La forma probablemente más fácil y segura en BASH 3 y superior es:

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

(donde arrestá la matriz que toma las partes divididas de la cadena) o, si puede haber nuevas líneas en la entrada y desea más que solo la primera línea:

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

(tenga en cuenta el espacio adentro -d '', no se puede dejar de lado), pero esto podría darle una nueva línea inesperada <<<"$var"(ya que esto agrega implícitamente un LF al final).

Ejemplo:

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

Salidas de lo esperado

[*]
[a]
[*]

ya que esta solución (en contraste con todas las soluciones anteriores aquí) no es propensa a un bloqueo inesperado y, a menudo, incontrolable.

Además, esto le brinda todo el poder de IFS como probablemente desee:

Ejemplo:

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

Produce algo como:

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

Como puede ver, los espacios también se pueden preservar de esta manera:

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

salidas

[ split  ]
[   this    ]

Tenga en cuenta que el manejo de IFSen BASH es un tema en sí mismo, así que haga sus pruebas, algunos temas interesantes sobre esto:

• unset IFS: Ignora ejecuciones de SPC, TAB, NL y en línea comienza y termina
• IFS='': Sin separación de campo, solo lee todo
• IFS=' ': Ejecuciones de SPC (y solo SPC)

Algun ultimo ejemplo

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

salidas

1 [this is]
2 [a test]

mientras

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

salidas

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

Por cierto:

• Si no estás acostumbrado $'ANSI-ESCAPED-STRING', es un ahorro de tiempo.

• Si no incluye -r(como en read -a arr <<<"$var"), la lectura hace que la barra invertida se escape. Esto se deja como ejercicio para el lector.

Para la segunda pregunta:

Para probar algo en una cadena, generalmente me quedo case, ya que esto puede verificar si hay varios casos a la vez (nota: el caso solo ejecuta la primera coincidencia, si necesita fallos, use casedeclaraciones multiplce ), y esta necesidad suele ser el caso (juego de palabras destinado a):

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

Por lo tanto, puede establecer el valor de retorno para verificar SPC de esta manera:

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

¿Por qué case? Debido a que generalmente es un poco más legible que las secuencias de expresiones regulares, y gracias a los metacaracteres de Shell, maneja muy bien el 99% de todas las necesidades.

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

Para verificar espacios, use grep:

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

(A) Para dividir una oración en sus palabras (separadas por espacios), simplemente puede usar el IFS predeterminado usando

array=( $string )

Ejemplo ejecutando el siguiente fragmento

#!/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

saldrá

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

Como puede ver, también puede usar comillas simples o dobles sin ningún problema.

Notas:
esto es básicamente lo mismo de respuesta mafia , pero de esta manera almacena la matriz para cualquier otra necesidad. Si solo necesita un solo bucle, puede usar su respuesta, que es una línea más corta :)
: consulte esta pregunta para obtener métodos alternativos para dividir una cadena en función del delimitador.


(B) Para buscar un carácter en una cadena, también puede usar una coincidencia de expresión regular.
Ejemplo para verificar la presencia de un carácter de espacio que puede usar:

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

Para comprobar espacios solo con bash:

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

echo $WORDS | xargs -n1 echo

Esto genera cada palabra, puede procesar esa lista como mejor le parezca después.