Cerca e sostituisci in bash usando le espressioni regolari

Ho visto questo esempio:

hello=ho02123ware38384you443d34o3434ingtod38384day
echo ${hello//[0-9]/}

Che segue questa sintassi: ${variable//pattern/replacement}

Sfortunatamente il patterncampo non sembra supportare la sintassi della regex completa (se uso .o \s, ad esempio, cerca di abbinare i caratteri letterali).

Come posso cercare / sostituire una stringa usando la sintassi regex completa?

Usa sed :

MYVAR=ho02123ware38384you443d34o3434ingtod38384day
echo "$MYVAR" | sed -e 's/[a-zA-Z]/X/g' -e 's/[0-9]/N/g'
# prints XXNNNNNXXXXNNNNNXXXNNNXNNXNNNNXXXXXXNNNNNXXX

Si noti che i successivi -evengono elaborati in ordine. Anche ilg flag per l'espressione corrisponderà a tutte le occorrenze nell'input.

Puoi anche scegliere il tuo strumento preferito usando questo metodo, ad esempio perl, awk, ad esempio:

echo "$MYVAR" | perl -pe 's/[a-zA-Z]/X/g and s/[0-9]/N/g'

Ciò può consentire di eseguire corrispondenze più creative ... Ad esempio, nella sezione precedente, la sostituzione numerica non verrebbe utilizzata a meno che non vi fosse una corrispondenza sulla prima espressione (a causa di una andvalutazione pigra ). E, naturalmente, hai il supporto linguistico completo di Perl per fare le tue offerte ...

Questo in realtà può essere fatto in puro bash:

hello=ho02123ware38384you443d34o3434ingtod38384day
re='(.*)[0-9]+(.*)'
while [[ $hello =~ $re ]]; do
  hello=${BASH_REMATCH[1]}${BASH_REMATCH[2]}
done
echo "$hello"

... i rendimenti ...

howareyoudoingtodday

Questi esempi funzionano anche in bash senza bisogno di usare sed:

#!/bin/bash
MYVAR=ho02123ware38384you443d34o3434ingtod38384day
MYVAR=${MYVAR//[a-zA-Z]/X} 
echo ${MYVAR//[0-9]/N}

puoi anche usare le espressioni di parentesi della classe di caratteri

#!/bin/bash
MYVAR=ho02123ware38384you443d34o3434ingtod38384day
MYVAR=${MYVAR//[[:alpha:]]/X} 
echo ${MYVAR//[[:digit:]]/N}

produzione

XXNNNNNXXXXNNNNNXXXNNNXNNXNNNNXXXXXXNNNNNXXX

Ciò che @Lanaru voleva sapere, tuttavia, se capisco correttamente la domanda, è perché le estensioni "complete" o PCRE \s\S\w\W\d\D ecc. Non funzionano come supportate in php ruby ​​python ecc. Queste estensioni provengono da espressioni regolari compatibili con Perl (PCRE) e potrebbe non essere compatibile con altre forme di espressioni regolari basate su shell.

Questi non funzionano:

#!/bin/bash
hello=ho02123ware38384you443d34o3434ingtod38384day
echo ${hello//\d/}


#!/bin/bash
hello=ho02123ware38384you443d34o3434ingtod38384day
echo $hello | sed 's/\d//g'

output con tutti i caratteri "d" letterali rimossi

ho02123ware38384you44334o3434ingto38384ay

ma quanto segue funziona come previsto

#!/bin/bash
hello=ho02123ware38384you443d34o3434ingtod38384day
echo $hello | perl -pe 's/\d//g'

produzione

howareyoudoingtodday

Spero che chiarisca un po 'di più le cose, ma se non sei ancora confuso perché non provi questo su Mac OS X che ha il flag REG_ENHANCED abilitato:

#!/bin/bash
MYVAR=ho02123ware38384you443d34o3434ingtod38384day;
echo $MYVAR | grep -o -E '\d'

Sulla maggior parte dei gusti di * nix vedrai solo il seguente output:

d
d
d

nJoy!

Se stai effettuando chiamate ripetute e sei preoccupato per le prestazioni, questo test rivela che il metodo BASH è ~ 15 volte più veloce di un fork di sed e probabilmente di qualsiasi altro processo esterno.

hello=123456789X123456789X123456789X123456789X123456789X123456789X123456789X123456789X123456789X123456789X123456789X

P1=$(date +%s)

for i in {1..10000}
do
   echo $hello | sed s/X//g > /dev/null
done

P2=$(date +%s)
echo $[$P2-$P1]

for i in {1..10000}
do
   echo ${hello//X/} > /dev/null
done

P3=$(date +%s)
echo $[$P3-$P2]

Utilizzare [[:digit:]](notare le doppie parentesi) come modello:

$ hello=ho02123ware38384you443d34o3434ingtod38384day
$ echo ${hello//[[:digit:]]/}
howareyoudoingtodday

Volevo solo riassumere le risposte (in particolare @ https://stackoverflow.com/a/22261334/2916086 di @ nickl- ).

So che questo è un thread antico, ma è stato il mio primo successo su Google e volevo condividere quanto segue resubche ho messo insieme, il che aggiunge il supporto per più riferimenti secondari da $ 1, $ 2, ecc ...

#!/usr/bin/env bash

############################################
###  resub - regex substitution in bash  ###
############################################

resub() {
    local match="$1" subst="$2" tmp

    if [[ -z $match ]]; then
        echo "Usage: echo \"some text\" | resub '(.*) (.*)' '\$2 me \${1}time'" >&2
        return 1
    fi

    ### First, convert "$1" to "$BASH_REMATCH[1]" and 'single-quote' for later eval-ing...

    ### Utility function to 'single-quote' a list of strings
    squot() { local a=(); for i in "$@"; do a+=( $(echo \'${i//\'/\'\"\'\"\'}\' )); done; echo "${a[@]}"; }

    tmp=""
    while [[ $subst =~ (.*)\${([0-9]+)}(.*) ]] || [[ $subst =~ (.*)\$([0-9]+)(.*) ]]; do
        tmp="\${BASH_REMATCH[${BASH_REMATCH[2]}]}$(squot "${BASH_REMATCH[3]}")${tmp}"
        subst="${BASH_REMATCH[1]}"
    done
    subst="$(squot "${subst}")${tmp}"

    ### Now start (globally) substituting

    tmp=""
    while read line; do
        counter=0
        while [[ $line =~ $match(.*) ]]; do
            eval tmp='"${tmp}${line%${BASH_REMATCH[0]}}"'"${subst}"
            line="${BASH_REMATCH[$(( ${#BASH_REMATCH[@]} - 1 ))]}"
        done
        echo "${tmp}${line}"
    done
}

resub "$@"

##################
###  EXAMPLES  ###
##################

###  % echo "The quick brown fox jumps quickly over the lazy dog" | resub quick slow
###    The slow brown fox jumps slowly over the lazy dog

###  % echo "The quick brown fox jumps quickly over the lazy dog" | resub 'quick ([^ ]+) fox' 'slow $1 sheep'
###    The slow brown sheep jumps quickly over the lazy dog

###  % animal="sheep"
###  % echo "The quick brown fox 'jumps' quickly over the \"lazy\" \$dog" | resub 'quick ([^ ]+) fox' "\"\$low\" \${1} '$animal'"
###    The "$low" brown 'sheep' 'jumps' quickly over the "lazy" $dog

###  % echo "one two three four five" | resub "one ([^ ]+) three ([^ ]+) five" 'one $2 three $1 five'
###    one four three two five

###  % echo "one two one four five" | resub "one ([^ ]+) " 'XXX $1 '
###    XXX two XXX four five

###  % echo "one two three four five one six three seven eight" | resub "one ([^ ]+) three ([^ ]+) " 'XXX $1 YYY $2 '
###    XXX two YYY four five XXX six YYY seven eight

Da H / T a @Charles Duffy in riferimento a :(.*)$match(.*)