Howto diviser une chaîne sur un multi-caractère délimiteur dans le bash?

Pourquoi ne pas travailler les suivantes bash code?

for i in $( echo "emmbbmmaaddsb" | split -t "mm"  )
do
    echo "$i"
done

résultat attendu:

e
bb
aaddsb

...hein? Ce n'est pas ce split le fait. Comme dans complètement sans rapport avec sa fonction réelle.
Voulez-vous savoir comment découper une chaîne de caractères arbitraire arbitraire de caractères multi-séparateur en bash? Pourquoi pas de modifier une question à poser que, au contraire, si c'est ce que vous voulez vraiment le savoir?
Donc, ce n'est fractionner faire à votre avis?
split de diviser un fichier en un tas de petits fichiers. Pas de noms écrits sur la sortie standard, comme votre script attend, mais de vrais fichiers. Et -t donne un caractère unique qu'il utilise pour déterminer si les dossiers de début et de fin, et donc de faire des fentes sur enregistrements.
Ne fonctionne pas avec de simples caractères.
Bien sûr que non, PARCE que VOUS attendez des NOMS ÉCRITS sur la sortie standard STDOUT. Je vous ai déjà dit qu'il ne veut pas écrire les noms sur la sortie standard stdout.
Dans la page de manuel de split lecture à partir d'un tuyau est mentionné
Si rien n'est écrit sur la sortie standard, rien n'est capturé par une substitution de commande.
Oui, il peut lire à partir d'un tuyau. Il ne peut toujours pas écrire sur la sortie standard, et donc de ne pas générer du contenu que de la substitution de commande va lire.
OK, comment puis-je rediriger la sortie vers std sortie?
La rédaction de contenu dans des fichiers séparés pas plus grand qu'une taille maximale de chaque est le but que split existe. Avez-vous pensé que peut-être ce que vous voulez peut être un outil autre que split, puisque ce n'est pas ce que vous essayez de faire?
Laissez-nous continuer cette discussion dans le chat.

InformationsquelleAutor v217 | 2016-11-18

Puisque vous attendez des retours à la ligne, vous pouvez simplement remplacer toutes les instances de mm dans votre chaîne avec un saut de ligne. Dans le plus pur natif bash:

in='emmbbmmaaddsb'
sep='mm'
printf '%s\n' "${in//$sep/$'\n'}"

Si vous vouliez faire un tel remplacement à plus de flux d'entrée, vous pourriez être mieux à l'aide de awk, que bash est intégré dans la manipulation de la chaîne n'a pas d'échelle bien plus que quelques kilo-octets de contenu. Le gsub_literal fonction shell (backending en awk) donné dans BashFAQ #21 est applicable:

# Taken from http://mywiki.wooledge.org/BashFAQ/021

# usage: gsub_literal STR REP
# replaces all instances of STR with REP. reads from stdin and writes to stdout.
gsub_literal() {
  # STR cannot be empty
  [[ $1 ]] || return

  # string manip needed to escape '\'s, so awk doesn't expand '\n' and such
  awk -v str="${1//\\/\\\\}" -v rep="${2//\\/\\\\}" '
    # get the length of the search string
    BEGIN {
      len = length(str);
    }

    {
      # empty the output string
      out = "";

      # continue looping while the search string is in the line
      while (i = index($0, str)) {
        # append everything up to the search string, and the replacement string
        out = out substr($0, 1, i-1) rep;

        # remove everything up to and including the first instance of the
        # search string from the line
        $0 = substr($0, i + len);
      }

      # append whatever is left
      out = out $0;

      print out;
    }
  '
}

...utilisé, dans ce contexte, comme:

gsub_literal "mm" $'\n' <your-input-file.txt >your-output-file.txt

InformationsquelleAutor Charles Duffy

4

Plus général de l'exemple, sans avoir à remplacer les caractères multi-séparateur avec un seul caractère délimiteur est donnée ci-dessous :

À l'aide du paramètre expansions : (à partir du commentaire de @gniourf_gniourf)
```
#!/bin/bash

str="LearnABCtoABCSplitABCaABCString"
delimiter=ABC
s=$str$delimiter
array=();
while [[ $s ]]; do
    array+=( "${s%%"$delimiter"*}" );
    s=${s#*"$delimiter"};
done;
declare -p array
```
Plus brut de décoffrage de façon
```
#!/bin/bash

# main string
str="LearnABCtoABCSplitABCaABCString"

# delimiter string
delimiter="ABC"

#length of main string
strLen=${#str}
#length of delimiter string
dLen=${#delimiter}

#iterator for length of string
i=0
#length tracker for ongoing substring
wordLen=0
#starting position for ongoing substring
strP=0

array=()
while [ $i -lt $strLen ]; do
    if [ $delimiter == ${str:$i:$dLen} ]; then
        array+=(${str:strP:$wordLen})
        strP=$(( i + dLen ))
        wordLen=0
        i=$(( i + dLen ))
    fi
    i=$(( i + 1 ))
    wordLen=$(( wordLen + 1 ))
done
array+=(${str:strP:$wordLen})

declare -p array
```
De référence - Bash Tutoriel - Bash Scinde Une Chaîne
- C'est cassé (échouera si la chaîne contient glob caractères ou des espaces, etc.). En outre, vous ne l'utilisez pas moderne Bash idiomes, ce qui rend le code à l'air vraiment bizarre. Vous avez seulement besoin d'une simple boucle: str="LearnABCtoABCSplitABCaABCString" delimiter=ABC s=$str$delimiter array=(); while [[ $s ]]; do array+=( "${s%%"$delimiter"*}" ); s=${s#*"$delimiter"}; done; declare -p array. C'est tout.
- Merci @gniourf_gniourf pour le commentaire. Je vient juste de débuter avec Bash Scripting, et votre suggestion est vraiment utile de penser en idiomatiques approche.
- Merci @MallikarjunM pour l'affichage de votre solution (venant d'un collègue de Bash débutant). Il m'a aidé à résoudre un problème d'analyse de chaînes dans des tableaux avec un multi-caractère délimiteur, où les FI / lire le tableau n'était pas approprié.
- Votre "simple boucle" échoue pour str="Nope:" delimiter="::"
- Cela devrait fonctionner: s="a::b:" delimiter="::" array=(); while [[ $s ]]; do array+=( "${s%%"$delimiter"*}" ); c="${array[@]: -1}"; s="${s:${#c}}"; [[ $s != "$delimiter" ]] || { array+=(""); break; }; s="${s#"$delimiter"}"; done; declare -p array
InformationsquelleAutor Mallikarjun M
3

L'outil recommandé pour le personnage de subtitution est sed's de commande s/regexp/replacement/ pour une regexp occurence ou mondial s/regexp/replacement/g, vous n'avez même pas besoin d'une boucle ou variables.

Tuyau de votre echo de sortie et d'essayer de remplacer les caractères mm avec le caractère de saut de ligne \n:

echo "emmbbmmaaddsb" | sed 's/mm/\n/g'

La sortie est:
```
e
bb
aaddsb
```
- "Recommandé"? Voir BashFAQ #100 pour des conseils pratiques sur la manipulation de chaîne de bash. Vous aurez remarque que le paramètre d'expansion est généralement considéré comme la meilleure pratique de l'approche à court entrées (alors que la echo | sed approche, bien que laconique, a beaucoup de frais généraux en termes de la façon dont il est mis en œuvre sous le capot-exigeant, en général, deux fourchettes, une mkfifo, un execv d'un outil externe qui doit être lié-et-chargé, etc).
- ...si vous étiez dans une boucle de traitement d'entrée ligne par ligne, par exemple (ou une itération sur un glob résultat avec des centaines ou des milliers de noms de fichiers), l'appel de echo | sed pour chaque ligne absolument être un antipattern. (L'appel de sed une fois pour traiter l'intégralité du flux entrant, en revanche, est souvent le cas).
InformationsquelleAutor John Goofy
2

Avec awk vous pouvez utiliser le gsub pour remplacer toutes les correspondances regex.

Que dans votre question, à remplacer toutes les sous-chaînes de deux ou plus de deux 'm' caractères avec une nouvelle ligne, exécutez:
```
echo "emmbbmmaaddsb" | awk '{ gsub(/mm+/, "\n" ); print; }'
```
e

bb

aaddsb

Le ‘g’ de gsub() est l'acronyme de “global”, ce qui signifie remplacer partout.

Vous pouvez également demander à imprimer N match, par exemple:
```
echo "emmbbmmaaddsb" | awk '{ gsub(/mm+/, " " ); print $2; }'
```
bb

InformationsquelleAutor Noam Manos

Vous devez vous connecter pour publier un commentaire.