Nel mio bashscript ho una stringa e il suo prefisso / suffisso. Devo rimuovere il prefisso / suffisso dalla stringa originale.

Ad esempio, supponiamo che io abbia i seguenti valori:

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

Come posso ottenere il seguente risultato?

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

All'interno del comando sed, il ^ carattere corrisponde al testo che inizia con $prefixe il finale $corrisponde al testo che termina con $suffix.

Adrian Frühwirth fa alcuni buoni punti nei commenti qui sotto, ma sed a questo scopo può essere molto utile. Il fatto che i contenuti di $ prefix e $ suffix siano interpretati da sed può essere buono o cattivo- finché si presta attenzione, si dovrebbe andare bene. Il bello è che puoi fare qualcosa del genere:

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

che può essere quello che vuoi ed è sia più elaborato che più potente della sostituzione della variabile bash. Se ricordi che da un grande potere derivano grandi responsabilità (come dice Spiderman), dovresti stare bene.

Una rapida introduzione a sed è disponibile all'indirizzo http://evc-cit.info/cit052/sed_tutorial.html

Una nota riguardante la shell e il suo uso delle stringhe:

Per il particolare esempio fornito, funzionerebbe anche:

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

... ma solo perché:

1. a echo non importa quante stringhe ci sono nella sua lista di argomenti, e
2. Non ci sono spazi in $ prefisso e $ suffisso

In genere è buona norma citare una stringa nella riga di comando perché anche se contiene spazi verrà presentato al comando come singolo argomento. Citiamo $ prefisso e $ suffisso per lo stesso motivo: ogni comando di modifica su sed verrà passato come una stringa. Utilizziamo virgolette doppie perché consentono l'interpolazione variabile; se avessimo usato virgolette singole, il comando sed sarebbe diventato letterale $prefixe $suffixquesto non è certamente quello che volevamo.

Notate anche il mio uso di virgolette singole durante l'impostazione delle variabili prefixe suffix. Certamente non vogliamo che nulla venga interpretato nelle stringhe, quindi le citiamo singolarmente in modo che non avvenga alcuna interpolazione. Ancora una volta, potrebbe non essere necessario in questo esempio, ma è un'abitudine molto buona per entrare.

Conosci la lunghezza del prefisso e del suffisso? Nel tuo caso:

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

O più generale:

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

Ma la soluzione di Adrian Frühwirth è davvero fantastica! Non lo sapevo!

Uso grep per rimuovere prefissi dai percorsi (che non sono gestiti bene da sed):

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

\K rimuove dalla partita tutti i personaggi precedenti.

$ 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

Appunti:

# $ prefix: aggiungendo # si assicura che la sottostringa "hell" venga rimossa solo se si trova all'inizio. Suffisso% $: l'aggiunta di% assicura che la sottostringa "ld" venga rimossa solo se viene trovata alla fine.

Senza questi, le sottostringhe "inferno" e "ld" verranno rimosse ovunque, anche se si trova nel mezzo.

Utilizzando l' =~operatore :

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

Soluzione piccola e universale:

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

Utilizzando la risposta di @Adrian Frühwirth:

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

usalo in questo modo

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

Vorrei utilizzare i gruppi di acquisizione in 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})).)*)si assicura che il contenuto di ${suffix}verrà escluso dal gruppo di acquisizione. In termini di esempio, è la stringa equivalente a [^A-Z]*. Altrimenti otterrai:

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