Come funziona awk '! A [$ 0] ++'?

Questo one-liner rimuove le righe duplicate dall'inserimento del testo senza pre-ordinamento.

Per esempio:

$ cat >f
q
w
e
w
r
$ awk '!a[$0]++' <f
q
w
e
r
$ 

Il codice originale che ho trovato su Internet recita:

awk '!_[$0]++'

Questo è stato ancora più sconcertante per me dato che ho assunto _un significato speciale in awk, come in Perl, ma si è rivelato essere solo un nome di un array.

Ora capisco la logica dietro il one-liner: ogni riga di input viene utilizzata come chiave in un array di hash, quindi, al termine, l'hash contiene righe uniche nell'ordine di arrivo.

Quello che vorrei imparare è come esattamente questa notazione è interpretata da awk. Ad esempio, ciò che significa il segno di botto ( !) e gli altri elementi di questo frammento di codice.

Come funziona?

Vediamo,

 !a[$0]++

primo

 a[$0]

esaminiamo il valore di a[$0](matrice acon l'intera riga di input ( $0) come chiave).

Se non esiste (la !negazione in test sarà valutata vera)

 !a[$0]

stampiamo la riga di input $0(azione predefinita).

Inoltre, aggiungiamo uno ( ++) a a[$0], quindi la prossima volta !a[$0]verrà valutato falso.

Bello, trova !! Dovresti dare un'occhiata al codice golf!

Ecco l'elaborazione:

• a[$0]: guarda il valore della chiave $0, nell'array associativo a. Se non esiste, crearlo.

• a[$0]++: incrementa il valore di a[$0], restituisce il vecchio valore come valore dell'espressione. Se a[$0]non esiste, ritorna 0e incrementa a[$0]su 1(l' ++operatore restituisce un valore numerico).

• !a[$0]++: nega il valore dell'espressione. Se a[$0]++restituito 0, l'intera espressione viene valutata su true, awkeseguire l'azione predefinita eseguita print $0. Altrimenti, l'intera espressione viene valutata come falsa, le cause awknon fanno nulla.

Riferimenti:

• Espressione in awk
• gawk - Operatori di incremento e decremento

Con gawk, possiamo usare dgawk (o awk --debugcon la versione più recente) per eseguire il debug di uno gawkscript. Innanzitutto, crea uno gawkscript, chiamato test.awk:

BEGIN {                                                                         
    a = 0;                                                                      
    !a++;                                                                       
}

Quindi eseguire:

dgawk -f test.awk

o:

gawk --debug -f test.awk

Nella console di debugger:

$ dgawk -f test.awk
dgawk> trace on
dgawk> watch a
Watchpoint 1: a
dgawk> run
Starting program: 
[     1:0x7fe59154cfe0] Op_rule             : [in_rule = BEGIN] [source_file = test.awk]
[     2:0x7fe59154bf80] Op_push_i           : 0 [PERM|NUMCUR|NUMBER]
[     2:0x7fe59154bf20] Op_store_var        : a [do_reference = FALSE]
[     3:0x7fe59154bf60] Op_push_lhs         : a [do_reference = TRUE]
Stopping in BEGIN ...
Watchpoint 1: a
  Old value: untyped variable
  New value: 0
main() at `test.awk':3
3           !a++;
dgawk> step
[     3:0x7fe59154bfc0] Op_postincrement    : 
[     3:0x7fe59154bf40] Op_not              : 
Watchpoint 1: a
  Old value: 0
  New value: 1
main() at `test.awk':3
3           !a++;
dgawk>

Si può vedere, è Op_postincrementstato eseguito prima Op_not.

Puoi anche usare sio stepiinvece di so stepper vedere più chiaramente:

dgawk> si
[     3:0x7ff061ac1fc0] Op_postincrement    : 
3           !a++;
dgawk> si
[     3:0x7ff061ac1f40] Op_not              : 
Watchpoint 1: a
  Old value: 0
  New value: 1
main() at `test.awk':3
3           !a++;