Comment diviser une chaîne en plusieurs chaînes séparées par au moins un espace dans le shell bash?

J'ai une chaîne contenant de nombreux mots avec au moins un espace entre les deux. Comment puis-je diviser la chaîne en mots individuels afin de pouvoir les parcourir?

La chaîne est passée en argument. Par exemple ${2} == "cat cat file". Comment puis-je le parcourir?

De plus, comment puis-je vérifier si une chaîne contient des espaces?

Avez-vous essayé de simplement passer la variable chaîne à une forboucle? Bash, pour sa part, se divisera automatiquement sur les espaces.

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

This
is
a
sentence.

J'aime la conversion en tableau, pour pouvoir accéder aux éléments individuels:

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

vous pouvez maintenant accéder directement aux éléments individuels (il commence par 0):

echo ${stringarray[0]}

ou reconvertissez en chaîne pour boucler:

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

Bien sûr, le fait de boucler directement dans la chaîne a été répondu auparavant, mais cette réponse avait l'inconvénient de ne pas suivre les éléments individuels pour une utilisation ultérieure:

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

Voir aussi Bash Array Reference .

Utilisez simplement les coques "set" intégrées. Par exemple,

définir $ text

Après cela, les mots individuels dans $ text seront dans $ 1, $ 2, $ 3, etc. Pour la robustesse, on fait généralement

set - junk $ text
décalage

pour gérer le cas où $ text est vide ou commencez par un tiret. Par exemple:

text = "Ceci est un test"
set - junk $ text
décalage
pour mot; faire
  echo "[$ word]"
terminé

Ceci imprime

[Ce]
[est]
[une]
[tester]

Le moyen probablement le plus simple et le plus sûr dans BASH 3 et supérieur est:

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

(où arrest le tableau qui prend les parties fractionnées de la chaîne) ou, s'il peut y avoir des sauts de ligne dans l'entrée et que vous voulez plus que la première ligne:

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

(veuillez noter l'espace dans -d '', il ne peut pas être laissé de côté), mais cela pourrait vous donner une nouvelle ligne inattendue de <<<"$var"(car cela ajoute implicitement un LF à la fin).

Exemple:

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

Produit les résultats attendus

[*]
[a]
[*]

car cette solution (contrairement à toutes les solutions précédentes ici) n'est pas sujette à un globbing shell inattendu et souvent incontrôlable.

Cela vous donne également la pleine puissance d'IFS comme vous le souhaitez probablement:

Exemple:

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

Produit quelque chose comme:

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

Comme vous pouvez le voir, les espaces peuvent également être préservés de cette façon:

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

les sorties

[ split  ]
[   this    ]

Veuillez noter que la gestion de IFSBASH est un sujet en soi, alors faites vos tests, quelques sujets intéressants à ce sujet:

• unset IFS: Ignore les exécutions de SPC, TAB, NL et commence et se termine en ligne
• IFS='': Pas de séparation de champ, lit tout
• IFS=' ': Exécutions de SPC (et SPC uniquement)

Un dernier exemple

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

les sorties

1 [this is]
2 [a test]

tandis que

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

les sorties

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

BTW:

• Si vous n'avez pas l'habitude de $'ANSI-ESCAPED-STRING'vous y habituer, c'est un gain de temps.

• Si vous n'incluez pas -r(comme dans read -a arr <<<"$var"), alors read n'échappe pas à la barre oblique inverse. Ceci est laissé comme exercice pour le lecteur.

Pour la deuxième question:

Pour tester quelque chose dans une chaîne, je m'en tiens habituellement case, car cela peut vérifier plusieurs cas à la fois (remarque: la casse n'exécute que la première correspondance, si vous avez besoin d'utiliser des caseinstructions de multiplication ), et ce besoin est assez souvent le cas (pun prévu):

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

Vous pouvez donc définir la valeur de retour pour vérifier le SPC comme ceci:

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

Pourquoi case? Parce qu'il est généralement un peu plus lisible que les séquences d'expression régulière, et grâce aux métacaractères Shell, il gère très bien 99% de tous les besoins.

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

Pour vérifier les espaces, utilisez grep:

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

(A) Pour diviser une phrase en ses mots (séparés par des espaces), vous pouvez simplement utiliser l'IFS par défaut en utilisant

array=( $string )

Exemple d' exécution de l'extrait de code suivant

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

affichera

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

Comme vous pouvez le voir, vous pouvez également utiliser des guillemets simples ou doubles sans aucun problème

Remarques:
- c'est fondamentalement la même chose que la réponse de mob , mais de cette façon, vous stockez le tableau pour tout autre besoin. Si vous n'avez besoin que d'une seule boucle, vous pouvez utiliser sa réponse, qui est d'une ligne plus courte :)
- veuillez vous référer à cette question pour d'autres méthodes pour diviser une chaîne en fonction du délimiteur.


(B) Pour rechercher un caractère dans une chaîne, vous pouvez également utiliser une correspondance d'expression régulière.
Exemple pour vérifier la présence d'un caractère espace que vous pouvez utiliser:

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

Pour vérifier les espaces uniquement avec bash:

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

echo $WORDS | xargs -n1 echo

Cela génère chaque mot, vous pouvez traiter cette liste comme bon vous semble par la suite.