Drucken Sie alle bis auf die ersten drei Spalten

Zu umständlich:

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

Eine Lösung, die keine zusätzlichen führenden oder nachfolgenden Leerzeichen hinzufügt :

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 schlägt eine elegante Verbesserung mit dem ternären Operator vorNF?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 bietet eine Lösung, bei der die ursprünglichen Leerzeichen zwischen den Feldern erhalten bleiben :

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

BinaryZebra bietet auch zwei fantastische Lösungen:
^{(Diese Lösungen bewahren sogar nachgestellte Leerzeichen von der ursprünglichen Zeichenfolge)}

$ 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->."

Die von larsr in den Kommentaren angegebene Lösung ist fast richtig:

$ 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

Dies ist die feste und parametrisierte Version der Larsr- Lösung:

$ 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

Alle anderen Antworten vor September 2013 sind nett, aber fügen Sie zusätzliche Leerzeichen hinzu:

• Beispiel für eine Antwort, bei der zusätzliche führende Leerzeichen hinzugefügt werden :

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

• Beispiel für eine Antwort, die zusätzlichen nachgestellten Speicherplatz hinzufügt

  $ 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

Verwenden Sie Schnitt

$ cut -f4-13 file

oder wenn Sie auf awk bestehen und $ 13 das letzte Feld ist

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

sonst

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

Versuche dies:

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

Der richtige Weg, dies zu tun, ist ein RE-Intervall, da Sie einfach angeben können, wie viele Felder übersprungen werden sollen, und den Abstand zwischen den Feldern für die verbleibenden Felder beibehalten.

Die ersten drei Felder zu überspringen, ohne den Abstand zwischen den verbleibenden Feldern zu beeinflussen, ist angesichts des Eingabeformats, das wir in dieser Frage zu diskutieren scheinen, einfach:

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

Wenn Sie führende Leerzeichen und nicht leere Leerzeichen aufnehmen möchten, aber wieder mit dem Standard-FS, dann ist es:

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

Wenn Sie einen FS haben, der ein RE ist, den Sie in einem Zeichensatz nicht negieren können, können Sie ihn zuerst in ein einzelnes Zeichen konvertieren (RS ist ideal, wenn es sich um ein einzelnes Zeichen handelt, da ein RS NICHT in einem Feld angezeigt werden kann, andernfalls SUBSEP in Betracht ziehen). Wenden Sie dann die RE-Intervall-Subsitution an und konvertieren Sie sie in das OFS. zB wenn Ketten von "." die Felder trennten:

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

Wenn OFS ein einzelnes Zeichen ist UND es nicht in den Eingabefeldern angezeigt werden kann, können Sie dies natürlich reduzieren auf:

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

Dann haben Sie das gleiche Problem wie bei allen schleifenbasierten Lösungen, die die Felder neu zuweisen - die FSs werden in OFSs konvertiert. Wenn dies ein Problem ist, müssen Sie sich die patsplit () - Funktion von GNU awks ansehen.

Nahezu alle Antworten fügen derzeit entweder führende Leerzeichen, nachfolgende Leerzeichen oder ein anderes Trennzeichen hinzu. Aus dem vierten Feld auszuwählen, in dem das Trennzeichen ein Leerzeichen und das Ausgabetrennzeichen ein einzelnes Leerzeichen ist, awkwäre:

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

So parametrisieren Sie das Startfeld:

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

Und auch das Endfeld:

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'

Eingang

1 2 3 4 5 6 7

Ausgabe

4 5 6 7

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

Eine andere Möglichkeit, die Verwendung der print-Anweisung zu vermeiden:

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

In awk, wenn eine Bedingung erfüllt ist, ist print die Standardaktion.

Ich kann nicht glauben, dass niemand eine einfache Muschel angeboten hat:

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

Die Optionen 1 bis 3 haben Probleme mit mehreren Leerzeichen (sind jedoch einfach). Aus diesem Grund sollten die Optionen 4 und 5 entwickelt werden, mit denen mehrere Leerzeichen problemlos verarbeitet werden können. Wenn die Optionen 4 oder 5 mit n=0beiden verwendet werden, bleiben natürlich alle führenden Leerzeichen erhalten, da n=0keine Aufteilung erfolgt.

Option 1

Eine einfache Schnittlösung (funktioniert mit einzelnen Trennzeichen):

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

Option 2

Das Erzwingen einer awk-Neuberechnung löst manchmal das Problem (funktioniert mit einigen Versionen von awk) der hinzugefügten führenden Leerzeichen:

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

Option 3

Durch Drucken jedes mit formatierten Felds erhalten Sie printfmehr Kontrolle:

$ 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

Alle vorherigen Antworten ändern jedoch alle FS zwischen Feldern in OFS. Lassen Sie uns ein paar Lösungen dafür entwickeln.

Option 4

Eine Schleife mit Sub zum Entfernen von Feldern und Trennzeichen ist portabler und löst keine Änderung von FS zu OFS aus:

$ 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

HINWEIS: Mit "^ [" FS "] *" wird eine Eingabe mit führenden Leerzeichen akzeptiert.

Option 5

Es ist durchaus möglich, eine Lösung zu erstellen, die keine zusätzlichen führenden oder nachfolgenden Leerzeichen hinzufügt und vorhandene Leerzeichen mithilfe der Funktion gensubvon GNU awk wie folgt beibehält:

$ 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 

Es kann auch verwendet werden, um eine Feldliste mit einer bestimmten Anzahl auszutauschen 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     !

In diesem Fall wird das OFS natürlich verwendet, um beide Teile der Zeile zu trennen, und der nachfolgende Leerraum der Felder wird weiterhin gedruckt.

Hinweis 1: ["FS"]* wird verwendet, um führende Leerzeichen in der Eingabezeile zuzulassen.

Cut verfügt über ein --complement-Flag, mit dem Spalten einfach (und schnell) gelöscht werden können. Die resultierende Syntax entspricht der gewünschten Syntax, sodass die Lösung leichter zu lesen und zu verstehen ist. Komplement funktioniert auch für den Fall, dass Sie nicht zusammenhängende Spalten löschen möchten.

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

Perl-Lösung, die keine führenden oder nachfolgenden Leerzeichen hinzufügt:

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

Das Perl- @FAutosplit-Array beginnt am Index, 0während awk-Felder mit beginnen$1

Perl-Lösung für durch Kommas getrennte Daten:

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

Python-Lösung:

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

Für mich ist die kompakteste und konformste Lösung für die Anfrage

$ 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}'

Und wenn Sie mehr Zeilen als beispielsweise die Datei foo.txt verarbeiten müssen, vergessen Sie nicht, i auf 0 zurückzusetzen:

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

Danke dein Forum.

Da ich mich über die erste hoch bewertete, aber falsche Antwort geärgert habe, habe ich genug gefunden, um dort eine Antwort zu schreiben, und hier sind die falschen Antworten als solche gekennzeichnet, hier ist mein Teil. Ich mag keine vorgeschlagenen Lösungen, da ich keinen Grund sehe, die Antwort so komplex zu gestalten.

Ich habe ein Protokoll, in dem nach $ 5 mit einer IP-Adresse mehr Text oder kein Text sein kann. Ich brauche alles von der IP-Adresse bis zum Ende der Leitung, sollte es nach 5 Dollar etwas geben. In meinem Fall ist dies tatsächlich ein awk-Programm, kein awk-Oneliner, also muss awk das Problem lösen. Wenn ich versuche, die ersten 4 Felder mit der alten, gut aussehenden und am besten bewerteten, aber völlig falschen Antwort zu entfernen:

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}'

es spuckt falsche und nutzlose Antworten aus (ich habe [] hinzugefügt, um zu demonstrieren):

[    37.244.182.218 one two three]

Wenn die Spalten eine feste Breite haben, bis der Schnittpunkt und awk benötigt werden, lautet die richtige und recht einfache Antwort:

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

welches die gewünschte Ausgabe erzeugt:

[37.244.182.218 one two three]

Ich habe diese andere Möglichkeit gefunden, vielleicht könnte sie auch nützlich sein ...

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

_{^{Hinweis: 1. Für tabellarische Daten und von Spalte $ 1 bis $ 14}}

Verwenden Sie Schnitt:

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

zB: Wenn Sie file1enthalten haben:car.is.nice.equal.bmw

Ausführen: cut -d . -f1,3 file1 wird gedrucktcar.is.nice

Dies ist nicht sehr weit von einigen der vorherigen Antworten entfernt, löst jedoch einige Probleme:

cols.sh::

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

Was Sie jetzt mit einem Argument aufrufen können, das die Startspalte sein wird:

$ 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

Oder:

$ 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

Dies ist 1-indiziert; Wenn Sie eine Nullindizierung bevorzugen, verwenden Sie i=s + 1stattdessen.

Wenn Sie außerdem Argumente für den Startindex und den Endindex benötigen, ändern Sie die Datei in:

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

Beispielsweise:

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

Das %-5srichtet das Ergebnis als 5 Zeichen breite Spalten aus. Wenn dies nicht ausreicht, erhöhen Sie die Anzahl oder verwenden %sSie stattdessen (mit einem Leerzeichen), wenn Sie sich nicht für die Ausrichtung interessieren.

AWK printf-basierte Lösung, die% -Probleme vermeidet und insofern einzigartig ist, als sie nichts zurückgibt (kein Rückgabezeichen), wenn weniger als 4 Spalten gedruckt werden müssen:

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

Testen:

$ 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) }'
$