Dans mon bash script, j'ai une chaîne et son préfixe / suffixe. J'ai besoin de supprimer le préfixe / suffixe de la chaîne d'origine.

Par exemple, supposons que j'ai les valeurs suivantes:

string="hello-world"
prefix="hell"
suffix="ld"

Comment arriver au résultat suivant?

result="o-wor"

$ foo=${string#"$prefix"}
$ foo=${foo%"$suffix"}
$ echo "${foo}"
o-wor

Utilisation de sed:

$ echo "$string" | sed -e "s/^$prefix//" -e "s/$suffix$//"
o-wor

Dans la commande sed, le ^caractère correspond au texte commençant par $prefixet le dernier $correspond au texte se terminant par$suffix .

Adrian Frühwirth fait quelques bons points dans les commentaires ci-dessous, mais sedà cet effet peut être très utile. Le fait que le contenu de $ prefix et $ suffix soit interprété par sed peut être bon OU mauvais - tant que vous y prêtez attention, ça devrait aller. La beauté est que vous pouvez faire quelque chose comme ça:

$ prefix='^.*ll'
$ suffix='ld$'
$ echo "$string" | sed -e "s/^$prefix//" -e "s/$suffix$//"
o-wor

qui peut être ce que vous voulez, et est à la fois plus sophistiqué et plus puissant que la substitution de variables bash. Si vous vous souvenez qu'avec une grande puissance vient une grande responsabilité (comme le dit Spiderman), tout va bien.

Une introduction rapide à sed peut être trouvée à http://evc-cit.info/cit052/sed_tutorial.html

Une note concernant le shell et son utilisation des cordes:

Pour l'exemple particulier donné, les éléments suivants fonctionneraient également:

$ echo $string | sed -e s/^$prefix// -e s/$suffix$//

... mais uniquement parce que:

1. echo ne se soucie pas du nombre de chaînes dans sa liste d'arguments, et
2. Il n'y a pas d'espaces dans $ prefix et $ suffix

Il est généralement recommandé de citer une chaîne sur la ligne de commande, car même si elle contient des espaces, elle sera présentée à la commande comme un seul argument. Nous citons $ prefix et $ suffix pour la même raison: chaque commande d'édition à sed sera passée comme une chaîne. Nous utilisons des guillemets doubles car ils permettent une interpolation variable; si nous avions utilisé des guillemets simples, la commande sed aurait obtenu un littéral $prefixet $suffixce n'est certainement pas ce que nous voulions.

Notez également mon utilisation de guillemets simples lors de la définition des variables prefixet suffix. Nous ne voulons certainement pas que quoi que ce soit dans les chaînes soit interprété, nous les citons donc pour qu'aucune interpolation n'ait lieu. Encore une fois, cela peut ne pas être nécessaire dans cet exemple, mais c'est une très bonne habitude à prendre.

Connaissez-vous la longueur de votre préfixe et suffixe? Dans ton cas:

result=$(echo $string | cut -c5- | rev | cut -c3- | rev)

Ou plus général:

result=$(echo $string | cut -c$((${#prefix}+1))- | rev | cut -c$((${#suffix}+1))- | rev)

Mais la solution d'Adrian Frühwirth est bien cool! Je n'en savais rien!

J'utilise grep pour supprimer les préfixes des chemins (qui ne sont pas bien gérés par sed):

echo "$input" | grep -oP "^$prefix\K.*"

\K supprime de la correspondance tous les caractères précédents.

$ string="hello-world"
$ prefix="hell"
$ suffix="ld"

$ #remove "hell" from "hello-world" if "hell" is found at the beginning.
$ prefix_removed_string=${string/#$prefix}

$ #remove "ld" from "o-world" if "ld" is found at the end.
$ suffix_removed_String=${prefix_removed_string/%$suffix}
$ echo $suffix_removed_String
o-wor

Remarques:

# $ prefix: l'ajout de # garantit que la sous-chaîne "hell" n'est supprimée que si elle est trouvée au début. % $ suffixe: l'ajout de% garantit que la sous-chaîne "ld" n'est supprimée que si elle est trouvée à la fin.

Sans cela, les sous-chaînes "hell" et "ld" seront supprimées partout, même si elles se trouvent au milieu.

Utilisation de l' =~opérateur :

$ string="hello-world"
$ prefix="hell"
$ suffix="ld"
$ [[ "$string" =~ ^$prefix(.*)$suffix$ ]] && echo "${BASH_REMATCH[1]}"
o-wor

Solution petite et universelle:

expr "$string" : "$prefix\(.*\)$suffix"

Utilisation de la réponse @Adrian Frühwirth:

function strip {
    local STRING=${1#$"$2"}
    echo ${STRING%$"$2"}
}

l'utiliser comme ça

HELLO=":hello:"
HELLO=$(strip "$HELLO" ":")
echo $HELLO # hello

Je voudrais utiliser des groupes de capture dans regex:

$ string="hello-world"
$ prefix="hell"
$ suffix="ld"
$ set +H # Disables history substitution, can be omitted in scripts.
$ perl -pe "s/${prefix}((?:(?!(${suffix})).)*)${suffix}/\1/" <<< $string
o-wor
$ string1=$string$string
$ perl -pe "s/${prefix}((?:(?!(${suffix})).)*)${suffix}/\1/g" <<< $string1
o-woro-wor

((?:(?!(${suffix})).)*)s'assure que le contenu de ${suffix}sera exclu du groupe de capture. En termes d'exemple, c'est la chaîne équivalente à [^A-Z]*. Sinon, vous obtiendrez:

$ perl -pe "s/${prefix}(.*)${suffix}/\1/g" <<< $string1
o-worldhello-wor