Sono confuso dai due concetti in sed: hold space e pattern space. Qualcuno può aiutarli a spiegarli?
Ecco uno snippet del manuale:
h H Copy/append pattern space to hold space. g G Copy/append hold space to pattern space. n N Read/append the next line of input into the pattern space.
Questi sei comandi mi confondono davvero.
info sed. È molto più dettagliato della semplice pagina man.
Risposte:
Quando sed legge un file riga per riga, la riga che è stata attualmente letta viene inserita nel pattern buffer (pattern space). Il buffer del pattern è come il buffer temporaneo, lo scratchpad in cui sono memorizzate le informazioni correnti. Quando dici a sed di stampare, stampa il pattern buffer.
Hold buffer / hold space è come una memoria a lungo termine, in modo tale da poter catturare qualcosa, salvarlo e riutilizzarlo in seguito quando sed sta elaborando un'altra riga. Non si elabora direttamente lo spazio di attesa, invece, è necessario copiarlo o aggiungerlo allo spazio del pattern se si desidera fare qualcosa con esso. Ad esempio, il comando print pstampa solo lo spazio pattern. Allo stesso modo, sopera sullo spazio del pattern.
Ecco un esempio:
sed -n '1!G;h;$p'
(l'opzione -n sopprime la stampa automatica delle righe)
Ci sono tre comandi qui: 1!G, he $p. 1!Gha un indirizzo, 1(prima riga), ma !significa che il comando verrà eseguito ovunque tranne che sulla prima riga. $pd'altra parte verrà eseguito solo sull'ultima riga. Quindi cosa succede è questo:
hcopia la prima riga nello spazio di attesa .G , aggiungendo il contenuto del buffer di blocco al buffer del pattern, separandolo con una nuova riga. Lo spazio del modello ora contiene la seconda riga, una nuova riga e la prima riga.hcomando inserisce il contenuto concatenato del buffer del pattern nello spazio di blocco, che ora contiene le righe invertite due e una.Infine, dopo che l'ultima riga è stata letta e lo spazio di blocco (contenente tutte le righe precedenti in ordine inverso) è stato aggiunto allo spazio del motivo, viene stampato lo spazio del motivo p. Come hai intuito, quanto sopra fa esattamente quello che fa il taccomando: stampa il file al contrario.
'195,210{/add/p}'… È possibile estrarre l'ultima riga di un gruppo di linee coinvolte in uno schema?
@ Ed Morton: non sono d'accordo con te qui. Ho trovato sedmolto utile e semplice (una volta che hai approfondito il concetto del pattern e hai tenuto i buffer) trovare un modo elegante per eseguire il grepping su più righe.
Ad esempio, prendiamo un file di testo che ha nomi host e alcune informazioni su ogni host, con un sacco di spazzatura in mezzo che non mi interessa.
Host: foo1
some junk, doesnt matter
some junk, doesnt matter
Info: about foo1 that I really care about!!
some junk, doesnt matter
some junk, doesnt matter
Info: a second line about foo1 that I really care about!!
some junk, doesnt matter
some junk, doesnt matter
Host: foo2
some junk, doesnt matter
Info: about foo2 that I really care about!!
some junk, doesnt matter
some junk, doesnt matter
Per me, uno script awk per ottenere solo le righe con il nome host e la inforiga corrispondente richiederebbe un po 'più di quello che sono in grado di fare con sed:
sed -n '/Host:/{h}; /Info/{x;p;x;p;}' myfile.txt
l'output è simile a:
Host: foo1
Info: about foo1 that I really care about!!
Host: foo1
Info: a second line about foo1 that I really care about!!
Host: foo2
Info: about foo2 that I really care about!!
(Nota che Host: foo1appare due volte nell'output.)
Spiegazione:
-n disabilita l'output a meno che non venga stampato esplicitamenteHost:linea in hold buffer (h)Host:riga, quindi scambia nuovamente (x) e stampa (p) la riga Info :.Sì, questo è un esempio semplicistico, ma sospetto che questo sia un problema comune che è stato rapidamente risolto da un semplice sed one-liner. Per compiti molto più complessi, come quelli in cui non puoi fare affidamento su una data sequenza prevedibile, awk potrebbe essere più adatto.
grep 'Host\|Info'
awkequivalente del tuo codice sed è piuttosto breve:awk '/Host:/{hold=$0}; /Info/{print hold; print;}' myfile.txt
Sebbene la risposta di @ gennaio e l'esempio siano carini, la spiegazione non è stata sufficiente per me. Ho dovuto cercare e imparare molto fino a quando non sono riuscito a capire esattamente come sed -n '1!G;h;$p'funziona. Quindi vorrei approfondire il comando per uno come me.
Prima di tutto, vediamo cosa fa il comando.
$ echo {a..d} | tr ' ' '\n' # Prints from 'a' to 'd' in each line
a
b
c
d
$ echo {a..d} | tr ' ' '\n' | sed -n '1!G;h;$p'
d
c
b
a
Inverte l'input come tacfa il comando.
sedlegge riga per riga, quindi vediamo cosa succede nello spazio del patten e nello spazio di attesa su ogni riga. Poiché il hcomando copia il contenuto dello spazio del pattern nello spazio di attesa, entrambi gli spazi hanno lo stesso testo.
Read line Pattern Space / Hold Space Command executed
-----------------------------------------------------------
a a$ h
b b\na$ 1!G;h
c c\nb\na$ 1!G;h
d d\nc\nb\na$ 1!G;h;$p
Nell'ultima riga, $pstampa quello d\nc\nb\na$formattato in
d
c
b
a
Se vuoi vedere lo spazio del pattern per ogni riga, puoi aggiungere un lcomando.
$ echo {a..d} | tr ' ' '\n' | sed -n '1!G;h;l;$p'
a$
b\na$
c\nb\na$
d\nc\nb\na$
d
c
b
a
Ho trovato molto utile guardare questo video tutorial Capire come funziona sed , poiché il ragazzo mostra come ogni spazio verrà utilizzato passo dopo passo. Lo spazio di attesa è indicato nel 4 ° tutorial, ma consiglio di guardare tutti i video se non hai familiarità sed.
Anche il documento GNU sed e il tutorial Sed di Bruce Barnett sono ottimi riferimenti.
echo $'1\n2\n3\n4' | sed -n '1~2h;2~2{p;x;p}'