Script bash: fractionner le mot sur chaque lettre

Comment puis-je diviser les lettres d'un mot, avec chaque lettre sur une ligne distincte?

Par exemple, étant donné "StackOver" que j'aimerais voir

S
t
a
c
k
O
v
e
r

Je suis nouveau à bash donc je n'ai aucune idée par où commencer.

J'utiliserais grep:

$ grep -o . <<<"StackOver"
S
t
a
c
k
O
v
e
r

ou sed:

$ sed 's/./&\n/g' <<<"StackOver"
S
t
a
c
k
O
v
e
r

Et si l'espace vide à la fin est un problème:

sed 's/\B/&\n/g' <<<"StackOver"

Tout cela en supposant GNU / Linux.

Vous souhaiterez peut-être casser les grappes de graphèmes au lieu des caractères si l'intention est d'imprimer le texte verticalement. Par exemple avec un eavec un accent aigu:

• Avec des grappes de graphèmes ( eavec son accent aigu serait un grappe de graphèmes):

  $ perl -CLAS -le 'for (@ARGV) {print for /\X/g}' $'Ste\u301phane'
  S
  t
  é
  p
  h
  a
  n
  e
  

  (ou grep -Po '\X'avec GNU grep construit avec le support PCRE)

• Avec des personnages (ici avec GNU grep):

  $ printf '%s\n' $'Ste\u301phane' | grep -o .
  S
  t
  e
  
  p
  h
  a
  n
  e
  

• foldest censé casser les caractères, mais GNU foldne prend pas en charge les caractères multi-octets, il se brise donc sur les octets à la place:

  $ printf '%s\n' $'Ste\u301phane' | fold -w 1
  S
  t
  e
  �
  �
  p
  h
  a
  n
  e
  

Sur StackOver qui ne se compose que de caractères ASCII (donc un octet par caractère, un caractère par grappe de graphèmes), les trois donneraient le même résultat.

Si vous avez perl6 dans votre boîte:

$ perl6 -e 'for @*ARGS -> $w { .say for $w.comb }' 'cường'       
c
ư
ờ
n
g

travailler quel que soit votre environnement local.

Avec de nombreuses awkversions

awk -F '' -v OFS='\n' '{$1=$1};1' <<<'StackOver'

Ce qui suit sera générique:

$ awk -F '' \
   'BEGIN { RS = ""; OFS = "\n"} {for (i=1;i<=NF;i++) $i = $i; print }' <file_name>

echo StackOver | sed -e 's/./&\n/g'
S
t
a
c
k
O
v
e
r

Puisque vous avez spécifiquement demandé une réponse en bash, voici une façon de le faire en bash pur:

while read -rn1; do echo "$REPLY" ; done <<< "StackOver"

Notez que cela interceptera la nouvelle ligne à la fin du " document ici ". Si vous voulez éviter cela, mais toujours parcourir les caractères avec une boucle bash, utilisez printfpour éviter la nouvelle ligne.

printf StackOver | while read -rn1; do echo "$REPLY" ; done

Aussi Python 2 peut être utilisé à partir de la ligne de commande:

python <<< "for x in 'StackOver':
   print x"

ou:

echo "for x in 'StackOver':
    print x" | python

ou (comme commenté par 1_CR) avec Python 3 :

python3 -c "print(*'StackOver',sep='\n')"

Vous pouvez utiliser la fold (1)commande. Il est plus efficace que grepet sed.

$ time grep -o . <bigfile >/dev/null

real    0m3.868s
user    0m3.784s
sys     0m0.056s
$ time fold -b1 <bigfile >/dev/null

real    0m0.555s
user    0m0.528s
sys     0m0.016s
$

Une différence significative est que le pli reproduira les lignes vides dans la sortie:

$ grep -o . <(printf "A\nB\n\nC\n\n\nD\n")
A
B
C
D
$ fold -b1 <(printf "A\nB\n\nC\n\n\nD\n")
A
B

C


D
$ 

Vous pouvez gérer des caractères multi-octets comme:

<input \
dd cbs=1 obs=2 conv=unblock |
sed -e:c -e '/^.*$/!N;s/\n//;tc'

Ce qui peut être assez pratique lorsque vous travaillez avec une entrée en direct car il n'y a pas de mise en mémoire tampon et un caractère est imprimé dès qu'il est entier .

Vous pouvez également utiliser des limites de mots ..

$ perl -pe 's/(?<=.)(\B|\b)(?=.)/\n/g' <<< "StackOver"
S
t
a
c
k
O
v
e
r

En bash:

Cela fonctionne avec n'importe quel texte et avec uniquement des internes bash (aucun utilitaire externe appelé), donc, devrait être rapide sur des chaînes très courtes.

str="Stéphane áàéèëêếe"

[[ $str =~ ${str//?/(.)} ]]
(set -- "${BASH_REMATCH[@]:1}"; IFS=$'\n'; echo "$*")

Production:

S
t
é
p
h
a
n
e

á
à
é
è
ë
ê
ế
e

S'il est correct de changer IFS et de changer les paramètres de position, vous pouvez également éviter l'appel de sous-shell:

str="Stéphane áàéèëêếe"
[[ $str =~ ${str//?/(.)} ]]
set -- "${BASH_REMATCH[@]:1}"
IFS=$'\n'
echo "$*"

s=stackoverflow;

$ time echo $s | fold -w1                                                                                                                                          
s                                                                                                                                                                          
t                                                                                                                                                                          
a                                                                                                                                                                          
c                                                                                                                                                                          
k                                                                                                                                                                          
o                                                                                                                                                                          
v
e
r

real    0m0.014s
user    0m0.000s
sys     0m0.004s

mises à jour ici est la manière la plus rapide | pureBashBased!

$ time eval eval printf \'%s\\\\n\' \\\${s:\{0..$((${#s}-1))}:1}
s
t
a
c
k
o
v
e
r

real    0m0.001s
user    0m0.000s
sys     0m0.000s

pour plus de génialité

function foldh () 
{ 
    if (($#)); then
        local s="$@";
        eval eval printf \'%s\\\\n\' \\\"\\\${s:\{0..$((${#s}-1))}:1}\\\";
    else
        while read s; do
            eval eval printf \'%s\\\\n\' \\\"\\\${s:\{0..$((${#s}-1))}:1}\\\";
        done;
    fi
}
function foldv () 
{ 
    if (($#)); then
        local s="$@";
        eval eval echo \\\"\\\${s:\{0..$((${#s}-1))}:1}\\\";
    else
        while read s; do
            eval eval echo \\\"\\\${s:\{0..$((${#s}-1))}:1}\\\";
        done;
    fi
}

read -a var <<< $(echo "$yourWordhere" | grep -o "." | tr '\n' ' ')

cela divisera votre mot et le stockera dans un tableau var.

for x in $(echo "$yourWordhere" | grep -o '.')
do
    code to perform operation on individual character $x of your word
done