En mi bashscript tengo una cadena y su prefijo / sufijo. Necesito eliminar el prefijo / sufijo de la cadena original.

Por ejemplo, supongamos que tengo los siguientes valores:

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

¿Cómo llego al siguiente resultado?

result="o-wor"

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

Usando sed:

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

Dentro del comando sed, el ^ carácter coincide con el texto que comienza con $prefix, y el final $coincide con el texto que termina con $suffix.

Adrian Frühwirth hace algunos buenos puntos en los comentarios a continuación, pero sed para este propósito puede ser muy útil. El hecho de que los contenidos de $ prefix y $ suffix son interpretados por sed puede ser bueno o malo, siempre que prestes atención, deberías estar bien. La belleza es que puedes hacer algo como esto:

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

que puede ser lo que quieras, y es más elegante y más poderoso que la sustitución de variables bash. Si recuerdas que con un gran poder viene una gran responsabilidad (como dice Spiderman), deberías estar bien.

Se puede encontrar una introducción rápida a sed en http://evc-cit.info/cit052/sed_tutorial.html

Una nota sobre el shell y su uso de cadenas:

Para el ejemplo particular dado, lo siguiente funcionaría también:

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

... pero solo porque:

1. echo no le importa cuántas cadenas hay en su lista de argumentos, y
2. No hay espacios en $ prefix y $ suffix

En general, es una buena práctica citar una cadena en la línea de comando porque incluso si contiene espacios, se presentará al comando como un argumento único. Citamos $ prefix y $ suffix por la misma razón: cada comando de edición para sed se pasará como una cadena. Usamos comillas dobles porque permiten la interpolación variable; Si hubiéramos usado comillas simples, el comando sed habría obtenido un literal $prefixy $suffixque ciertamente no es lo que queríamos.

Observe también mi uso de comillas simples al establecer las variables prefixy suffix. Ciertamente no queremos que se interprete nada en las cadenas, por lo que las citamos con una sola cita para que no se realice ninguna interpolación. De nuevo, puede que no sea necesario en este ejemplo, pero es un muy buen hábito.

¿Conoces la longitud de tu prefijo y sufijo? En tu caso:

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

O más general:

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

¡Pero la solución de Adrian Frühwirth es genial! ¡No sabía sobre eso!

Uso grep para eliminar prefijos de rutas (que no se manejan bien sed):

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

\K elimina del partido todos los personajes anteriores.

$ 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

Notas:

# $ prefijo: agregar # asegura que la subcadena "infierno" se elimine solo si se encuentra al principio. % $ sufijo: agregar% asegura que la subcadena "ld" se elimine solo si se encuentra al final.

Sin estos, las subcadenas "infierno" y "ld" se eliminarán en todas partes, incluso si se encuentran en el medio.

Usando el =~operador :

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

Solución pequeña y universal:

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

Usando la respuesta de @Adrian Frühwirth:

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

úsalo así

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

Haría uso de grupos de captura en 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})).)*)se asegura de que el contenido de ${suffix}se excluirá del grupo de captura. En términos de ejemplo, es la cadena equivalente a [^A-Z]*. De lo contrario, obtendrá:

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