Stampa tutto tranne le prime tre colonne

Troppo ingombrante:

awk '{print " "$4" "$5" "$6" "$7" "$8" "$9" "$10" "$11" "$12" "$13}' things

Una soluzione che non aggiunge spazi bianchi iniziali o finali extra :

awk '{ for(i=4; i<NF; i++) printf "%s",$i OFS; if(NF) printf "%s",$NF; printf ORS}'

### Example ###
$ echo '1 2 3 4 5 6 7' |
  awk '{for(i=4;i<NF;i++)printf"%s",$i OFS;if(NF)printf"%s",$NF;printf ORS}' |
  tr ' ' '-'
4-5-6-7

Sudo_O propone un elegante miglioramento utilizzando l'operatore ternarioNF?ORS:OFS

$ echo '1 2 3 4 5 6 7' |
  awk '{ for(i=4; i<=NF; i++) printf "%s",$i (i==NF?ORS:OFS) }' |
  tr ' ' '-'
4-5-6-7

EdMorton offre una soluzione che preserva gli spazi bianchi originali tra i campi:

$ echo '1   2 3 4   5    6 7' |
  awk '{ sub(/([^ ]+ +){3}/,"") }1' |
  tr ' ' '-'
4---5----6-7

BinaryZebra fornisce anche due fantastiche soluzioni:
^{(queste soluzioni preservano anche gli spazi finali dalla stringa originale)}

$ echo -e ' 1   2\t \t3     4   5   6 7 \t 8\t ' |
  awk -v n=3 '{ for ( i=1; i<=n; i++) { sub("^["FS"]*[^"FS"]+["FS"]+","",$0);} } 1 ' |
  sed 's/ /./g;s/\t/->/g;s/^/"/;s/$/"/'
"4...5...6.7.->.8->."

$ echo -e ' 1   2\t \t3     4   5   6 7 \t 8\t ' |
  awk -v n=3 '{ print gensub("["FS"]*([^"FS"]+["FS"]+){"n"}","",1); }' |
  sed 's/ /./g;s/\t/->/g;s/^/"/;s/$/"/'
"4...5...6.7.->.8->."

La soluzione data da larsr nei commenti è quasi corretta:

$ echo '1 2 3 4 5 6 7' | 
  awk '{for (i=3;i<=NF;i++) $(i-2)=$i; NF=NF-2; print $0}' | tr  ' ' '-'
3-4-5-6-7

Questa è la versione fissa e parametrizzata della soluzione larsr :

$ echo '1 2 3 4 5 6 7' | 
  awk '{for(i=n;i<=NF;i++)$(i-(n-1))=$i;NF=NF-(n-1);print $0}' n=4 | tr ' ' '-'
4-5-6-7

Tutte le altre risposte prima di settembre 2013 sono belle ma aggiungono spazi extra:

• Esempio di risposta aggiunta di spazi iniziali extra :

  $ echo '1 2 3 4 5 6 7' | 
    awk '{$1=$2=$3=""}1' | 
    tr  ' ' '-'
  ---4-5-6-7

• Esempio di risposta che aggiunge spazio finale aggiuntivo

  $ echo '1 2 3 4 5 6 7' | 
    awk '{for(i=4;i<=13;i++)printf "%s ",$i;printf "\n"}' | 
    tr ' ' '-'
  4-5-6-7-------

awk '{for(i=1;i<4;i++) $i="";print}' file

usa il taglio

$ cut -f4-13 file

o se insisti su awk e $ 13 è l'ultimo campo

$ awk '{$1=$2=$3="";print}' file

altro

$ awk '{for(i=4;i<=13;i++)printf "%s ",$i;printf "\n"}' file

Prova questo:

awk '{ $1=""; $2=""; $3=""; print $0 }'

Il modo corretto per farlo è con un intervallo RE perché ti consente di indicare semplicemente quanti campi saltare e mantiene la spaziatura tra i campi per i campi rimanenti.

ad esempio, saltare i primi 3 campi senza influenzare la spaziatura tra i campi rimanenti dato che il formato di input che sembriamo discutere in questa domanda è semplicemente:

$ echo '1   2 3 4   5    6' |
awk '{sub(/([^ ]+ +){3}/,"")}1'
4   5    6

Se vuoi inserire spazi iniziali e non vuoti, ma di nuovo con il FS predefinito, allora è:

$ echo '  1   2 3 4   5    6' |
awk '{sub(/[[:space:]]*([^[:space:]]+[[:space:]]+){3}/,"")}1'
4   5    6

Se hai una FS che è una RE che non puoi negare in un set di caratteri, puoi convertirla prima in un singolo carattere (RS è l'ideale se è un singolo carattere poiché un RS NON PU apparire all'interno di un campo, altrimenti considera SUBSEP), quindi applicare la sostituzione dell'intervallo RE, quindi convertire in OFS. es. se catene di "." s separano i campi:

$ echo '1...2.3.4...5....6' |
awk -F'[.]+' '{gsub(FS,RS);sub("([^"RS"]+["RS"]+){3}","");gsub(RS,OFS)}1'
4 5 6

Ovviamente se OFS è un singolo carattere E non può apparire nei campi di input puoi ridurlo a:

$ echo '1...2.3.4...5....6' |
awk -F'[.]+' '{gsub(FS,OFS); sub("([^"OFS"]+["OFS"]+){3}","")}1'
4 5 6

Quindi hai lo stesso problema di tutte le soluzioni basate su loop che riassegnano i campi: gli FS vengono convertiti in OFS. Se questo è un problema, è necessario esaminare la funzione patsplit () di GNU awks.

Praticamente tutte le risposte attualmente aggiungono spazi iniziali, spazi finali o qualche altro problema di separazione. Per selezionare dal quarto campo in cui il separatore è uno spazio bianco e il separatore di output è un singolo spazio utilizzando awksarebbe:

awk '{for(i=4;i<=NF;i++)printf "%s",$i (i==NF?ORS:OFS)}' file

Per parametrizzare il campo di partenza potresti fare:

awk '{for(i=n;i<=NF;i++)printf "%s",$i (i==NF?ORS:OFS)}' n=4 file

E anche il campo finale:

awk '{for(i=n;i<=m=(m>NF?NF:m);i++)printf "%s",$i (i==m?ORS:OFS)}' n=4 m=10 file

awk '{$1=$2=$3="";$0=$0;$1=$1}1'

Ingresso

1 2 3 4 5 6 7

Produzione

4 5 6 7

echo 1 2 3 4 5| awk '{ for (i=3; i<=NF; i++) print $i }'

Un altro modo per evitare di utilizzare l'istruzione print:

 $ awk '{$1=$2=$3=""}sub("^"FS"*","")' file

In awk quando una condizione è vera print è l'azione predefinita.

Non posso credere che nessuno abbia offerto un semplice guscio:

while read -r a b c d; do echo "$d"; done < file

Le opzioni da 1 a 3 hanno problemi con più spazi bianchi (ma sono semplici). Questo è il motivo per sviluppare le opzioni 4 e 5, che elaborano più spazi bianchi senza problemi. Ovviamente, se le opzioni 4 o 5 vengono utilizzate con n=0entrambe, manterrà qualsiasi spazio bianco iniziale comen=0 non suddivisi.

opzione 1

Una semplice soluzione di taglio (funziona con singoli delimitatori):

$ echo '1 2 3 4 5 6 7 8' | cut -d' ' -f4-
4 5 6 7 8

opzione 2

Forzare un ricalcolo di awk a volte risolve il problema (funziona con alcune versioni di awk) degli spazi iniziali aggiunti:

$ echo '1 2 3 4 5 6 7 8' | awk '{ $1=$2=$3="";$0=$0;} NF=NF'
4 5 6 7 8

Opzione 3

La stampa di ogni campo formattato con printfdarà più controllo:

$ echo '    1    2  3     4   5   6 7     8  ' |
  awk -v n=3 '{ for (i=n+1; i<=NF; i++){printf("%s%s",$i,i==NF?RS:OFS);} }'
4 5 6 7 8

Tuttavia, tutte le risposte precedenti modificano tutte le FS tra i campi in OFS. Creiamo un paio di soluzioni a questo.

Opzione 4

Un ciclo con sottotitoli per rimuovere campi e delimitatori è più portabile e non attiva una modifica di FS in OFS:

$ echo '    1    2  3     4   5   6 7     8  ' |
awk -v n=3 '{ for(i=1;i<=n;i++) { sub("^["FS"]*[^"FS"]+["FS"]+","",$0);} } 1 '
4   5   6 7     8

NOTA: "^ [" FS "] *" accetta un input con spazi iniziali.

Opzione 5

È del tutto possibile creare una soluzione che non aggiunga spazi bianchi iniziali o finali extra e preservare gli spazi bianchi esistenti usando la funzione gensubdi GNU awk, come questo:

$ echo '    1    2  3     4   5   6 7     8  ' |
awk -v n=3 '{ print gensub("["FS"]*([^"FS"]+["FS"]+){"n"}","",1); }'
4   5   6 7     8 

Può anche essere utilizzato per scambiare un elenco di campi dato un conteggio n:

$ echo '    1    2  3     4   5   6 7     8  ' |
  awk -v n=3 '{ a=gensub("["FS"]*([^"FS"]+["FS"]+){"n"}","",1);
                b=gensub("^(.*)("a")","\\1",1);
                print "|"a"|","!"b"!";
               }'
|4   5   6 7     8  | !    1    2  3     !

Naturalmente, in tal caso, l'OFS viene utilizzato per separare entrambe le parti della riga e lo spazio bianco finale dei campi viene ancora stampato.

Nota 1: ["FS"]* viene utilizzato per consentire spazi iniziali nella riga di input.

Cut ha un flag --complement che rende facile (e veloce) eliminare le colonne. La sintassi risultante è analoga a ciò che si desidera fare, rendendo la soluzione più facile da leggere / comprendere. Il complemento funziona anche nel caso in cui desideri eliminare colonne non contigue.

$ foo='1 2 3 %s 5 6 7'
$ echo "$foo" | cut --complement -d' ' -f1-3
%s 5 6 7
$

Soluzione Perl che non aggiunge spazi bianchi iniziali o finali:

perl -lane 'splice @F,0,3; print join " ",@F' file

L' @Farray perl autosplit inizia all'indice 0mentre i campi awk iniziano con$1

Soluzione Perl per dati delimitati da virgole:

perl -F, -lane 'splice @F,0,3; print join ",",@F' file

Soluzione Python:

python -c "import sys;[sys.stdout.write(' '.join(line.split()[3:]) + '\n') for line in sys.stdin]" < file

Per me la soluzione più compatta e conforme alla richiesta è

$ a='1   2\t \t3     4   5   6 7 \t 8\t '; 
$ echo -e "$a" | awk -v n=3 '{while (i<n) {i++; sub($1 FS"*", "")}; print $0}'

E se hai più righe da elaborare come ad esempio il file foo.txt , non dimenticare di reimpostare i su 0:

$ awk -v n=3 '{i=0; while (i<n) {i++; sub($1 FS"*", "")}; print $0}' foo.txt

Grazie del tuo forum.

Dato che ero infastidito dalla prima risposta altamente votata ma sbagliata, ho trovato abbastanza per scrivere una risposta lì, e qui le risposte sbagliate sono contrassegnate come tali, ecco la mia parte. Non mi piacciono le soluzioni proposte perché non vedo motivo per rendere la risposta così complessa.

Ho un registro in cui dopo $ 5 con un indirizzo IP può essere più testo o nessun testo. Ho bisogno di tutto, dall'indirizzo IP alla fine della riga se ci fosse qualcosa dopo $ 5. Nel mio caso, questo è effettivamente con un programma awk, non un oneliner awk, quindi awk deve risolvere il problema. Quando provo a rimuovere i primi 4 campi usando la vecchia risposta carina e più votata ma completamente sbagliata:

echo "  7 27.10.16. Thu 11:57:18 37.244.182.218 one two three" | awk '{$1=$2=$3=$4=""; printf "[%s]\n", $0}'

sputa una risposta sbagliata e inutile (ho aggiunto [] per dimostrare):

[    37.244.182.218 one two three]

Invece, se le colonne hanno una larghezza fissa fino a quando il punto di taglio e awk è necessario, la risposta corretta e abbastanza semplice è:

echo "  7 27.10.16. Thu 11:57:18 37.244.182.218 one two three" | awk '{printf "[%s]\n", substr($0,28)}'

che produce l'output desiderato:

[37.244.182.218 one two three]

Ho trovato quest'altra possibilità, forse potrebbe essere utile anche ...

awk 'BEGIN {OFS=ORS="\t" }; {for(i=1; i<14; i++) print $i " "; print $NF "\n" }' your_file

_{^{Nota: 1. Per dati tabulari e dalla colonna $ 1 a $ 14}}

Usa taglio:

cut -d <The character between characters> -f <number of first column>,<number of last column> <file name>

ad esempio: se hai file1contenuto:car.is.nice.equal.bmw

Esegui: cut -d . -f1,3 file1 verrà stampatocar.is.nice

Questo non è molto lontano da alcune delle risposte precedenti, ma risolve un paio di problemi:

cols.sh:

#!/bin/bash
awk -v s=$1 '{for(i=s; i<=NF;i++) printf "%-5s", $i; print "" }'

Che ora puoi chiamare con un argomento che sarà la colonna di partenza:

$ echo "1 2 3 4 5 6 7 8 9 10 11 12 13 14" | ./cols.sh 3 
3    4    5    6    7    8    9    10   11   12   13   14

O:

$ echo "1 2 3 4 5 6 7 8 9 10 11 12 13 14" | ./cols.sh 7 
7    8    9    10   11   12   13   14

Questo è 1 indicizzato; se preferisci zero indicizzato, usa i=s + 1invece.

Inoltre, se desideri avere argomenti per l'indice iniziale e l' indice finale, modifica il file in:

#!/bin/bash
awk -v s=$1 -v e=$2 '{for(i=s; i<=e;i++) printf "%-5s", $i; print "" }'

Per esempio:

$ echo "1 2 3 4 5 6 7 8 9 10 11 12 13 14" | ./cols.sh 7 9 
7    8    9

Il %-5sallinea il risultato come colonne di 5 caratteri; se questo non è sufficiente, aumenta il numero o usa %s(con uno spazio) invece se non ti interessa l'allineamento.

Soluzione basata su printf di AWK che evita% problem ed è unica in quanto non restituisce nulla (nessun carattere di ritorno) se ci sono meno di 4 colonne da stampare:

awk 'NF > 3 { for(i=4; i<NF; i++) printf("%s ", $(i)); print $(i) }'

test:

$ x='1 2 3 %s 4 5 6'
$ echo "$x" | awk 'NF > 3 { for(i=4; i<NF; i++) printf("%s ", $(i)); print $(i) }'
%s 4 5 6
$ x='1 2 3'
$ echo "$x" | awk 'NF > 3 { for(i=4; i<NF; i++) printf("%s ", $(i)); print $(i) }'
$ x='1 2 3 '
$ echo "$x" | awk 'NF > 3 { for(i=4; i<NF; i++) printf("%s ", $(i)); print $(i) }'
$