No meu bashscript eu tenho uma string e seu prefixo / sufixo. Preciso remover o prefixo / sufixo da string original.

Por exemplo, digamos que tenho os seguintes valores:

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

Como chego ao seguinte 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 do comando sed, o ^caractere corresponde ao texto que começa com $prefix, e o final $corresponde ao texto que termina com $suffix.

Adrian Frühwirth faz bons comentários nos comentários abaixo, mas sedcom esse objetivo pode ser muito útil. O fato de o conteúdo do prefixo $ e do sufixo $ ser interpretado pelo sed pode ser bom ou ruim - desde que você preste atenção, você deve estar bem. A beleza é que você pode fazer algo assim:

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

que pode ser o que você deseja e é mais sofisticado e mais poderoso que a substituição de variáveis ​​do bash. Se você se lembra que com grande poder vem uma grande responsabilidade (como o Homem-Aranha diz), você deve ficar bem.

Uma rápida introdução ao sed pode ser encontrada em http://evc-cit.info/cit052/sed_tutorial.html

Uma observação sobre o shell e seu uso de strings:

Para o exemplo específico dado, o seguinte também funcionaria:

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

... mas apenas porque:

1. eco não se importa com quantas seqüências de caracteres estão em sua lista de argumentos e
2. Não há espaços no prefixo $ e no sufixo $

Geralmente, é uma boa prática citar uma sequência na linha de comando porque, mesmo que contenha espaços, ela será apresentada ao comando como um único argumento. Citamos o prefixo $ e o sufixo $ pelo mesmo motivo: cada comando de edição para sed será passado como uma sequência. Usamos aspas duplas porque elas permitem interpolação variável; se tivéssemos usado aspas simples, o comando sed teria obtido um literal $prefixe $suffixque certamente não é o que queríamos.

Observe também o uso de aspas simples ao definir as variáveis prefixe suffix. Certamente, não queremos que nada nas seqüências seja interpretado, por isso as aspas simples, para que não ocorra interpolação. Novamente, pode não ser necessário neste exemplo, mas é um hábito muito bom entrar.

Você sabe o tamanho do seu prefixo e sufixo? No seu caso:

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

Ou mais geral:

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

Mas a solução de Adrian Frühwirth é muito legal! Eu não sabia disso!

Eu uso grep para remover prefixos de caminhos (que não são bem tratados por sed):

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

\K remove da partida todos os caracteres 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:

# $ prefix: adicionando # garante que a subcadeia "hell" seja removida somente se for encontrada no início. Sufixo% $: adicionar% garante que a subcadeia "ld" seja removida apenas se for encontrada no final.

Sem eles, os substrings "hell" e "ld" serão removidos em todos os lugares, mesmo que sejam encontrados no meio.

Usando o =~operador :

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

Solução pequena e universal:

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

Usando a resposta @Adrian Frühwirth:

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

use assim

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

Eu usaria grupos de captura no 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})).)*)garante que o conteúdo de ${suffix}será excluído do grupo de captura. Em termos de exemplo, é a string equivalente a [^A-Z]*. Caso contrário, você receberá:

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