Sử dụng awk để in tất cả các cột từ thứ n đến cuối cùng

Dòng này hoạt động cho đến khi tôi có khoảng trắng trong trường thứ hai.

svn status | grep '\!' | gawk '{print $2;}' > removedProjs

Có cách nào để awk in mọi thứ bằng $ 2 trở lên không? ($ 3, $ 4 .. cho đến khi chúng tôi không còn cột nữa?)

Tôi cho rằng tôi nên thêm rằng tôi đang làm điều này trong môi trường Windows với Cygwin.

sẽ in tất cả nhưng cột đầu tiên:

awk '{$1=""; print $0}' somefile

sẽ in tất cả trừ hai cột đầu tiên:

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

Có một câu hỏi trùng lặp với một câu trả lời đơn giản hơn bằng cách sử dụng cắt:

 svn status |  grep '\!' | cut -d\  -f2-

-dchỉ định dấu phân cách (dấu cách) , -fchỉ định danh sách các cột (tất cả bắt đầu bằng thứ 2)

Bạn có thể sử dụng vòng lặp for để lặp qua các trường in $ 2 đến $ NF (biến tích hợp thể hiện số lượng trường trên dòng).

Chỉnh sửa: Vì "in" sẽ thêm một dòng mới, bạn sẽ muốn đệm kết quả:

awk '{out=""; for(i=2;i<=NF;i++){out=out" "$i}; print out}'

Ngoài ra, sử dụng printf:

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

awk '{out=$2; for(i=3;i<=NF;i++){out=out" "$i}; print out}'

Câu trả lời của tôi dựa trên một trong VeeArr , nhưng tôi nhận thấy nó bắt đầu bằng một khoảng trắng trước khi nó in cột thứ hai (và phần còn lại). Vì tôi chỉ có 1 điểm danh tiếng, tôi không thể nhận xét về nó, vì vậy đây là một câu trả lời mới:

bắt đầu với "out" là cột thứ hai và sau đó thêm tất cả các cột khác (nếu chúng tồn tại). Điều này diễn ra tốt miễn là có một cột thứ hai.

Hầu hết các giải pháp với awk để lại một khoảng trống. Các tùy chọn ở đây tránh vấn đề đó.

lựa chọn 1

Một giải pháp cắt đơn giản (chỉ hoạt động với các dấu phân cách đơn):

command | cut -d' ' -f3-

Lựa chọn 2

Buộc một awk calc lại đôi khi loại bỏ không gian hàng đầu được thêm vào (OFS) bằng cách xóa các trường đầu tiên (hoạt động với một số phiên bản của awk):

command | awk '{ $1=$2="";$0=$0;} NF=NF'

Lựa chọn 3

In từng trường được định dạng printfsẽ cung cấp thêm quyền kiểm soát:

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

Tuy nhiên, tất cả các câu trả lời trước đó thay đổi tất cả FS lặp lại giữa các trường thành OFS. Hãy xây dựng một vài tùy chọn không làm điều đó.

Tùy chọn 4 (được khuyến nghị)

Một vòng lặp với phụ để loại bỏ các trường và dấu phân cách ở phía trước.
Và sử dụng giá trị của FS thay vì không gian (có thể thay đổi).
Dễ mang theo hơn và không kích hoạt thay đổi FS thành OFS: LƯU Ý: Việc ^[FS]*chấp nhận đầu vào có khoảng trắng ở đầu.

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

Lựa chọn 5

Hoàn toàn có thể xây dựng một giải pháp không thêm khoảng trắng (dẫn hoặc theo dõi) và bảo toàn (các) khoảng trắng hiện có bằng cách sử dụng hàm gensubtừ GNU awk, như sau:

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

Nó cũng có thể được sử dụng để trao đổi một nhóm các trường được tính n:

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

Tất nhiên, trong trường hợp như vậy, OFS được sử dụng để phân tách cả hai phần của dòng và khoảng trắng ở cuối của các trường vẫn được in.

LƯU Ý: [FS]* được sử dụng để cho phép các không gian hàng đầu trong dòng đầu vào.

Cá nhân tôi đã thử tất cả các câu trả lời được đề cập ở trên, nhưng hầu hết chúng đều hơi phức tạp hoặc chỉ không đúng. Cách dễ nhất để làm điều đó theo quan điểm của tôi là:

awk -F" " '{ for (i=4; i<=NF; i++) print $i }'

1. Trong đó -F "" định nghĩa dấu phân cách cho awk sử dụng. Trong trường hợp của tôi là khoảng trắng, cũng là dấu phân cách mặc định cho awk. Điều này có nghĩa là -F "" có thể bị bỏ qua.

2. Trong đó NF xác định tổng số trường / cột. Do đó, vòng lặp sẽ bắt đầu từ trường thứ 4 cho đến trường / cột cuối cùng.

3. Trong đó $ N lấy giá trị của trường thứ N. Do đó, in $ i sẽ in trường / cột hiện tại dựa trên số vòng lặp.

awk '{ for(i=3; i<=NF; ++i) printf $i""FS; print "" }'

lauhub đề xuất giải pháp chính xác, đơn giản và nhanh chóng ở đây

Điều này đã gây khó chịu cho tôi rất nhiều, tôi ngồi xuống và viết một cuttrình phân tích cú pháp đặc tả trường giống như, được thử nghiệm với GNU Awk 3.1.7.

Đầu tiên, tạo một tập lệnh thư viện Awk mới được gọi pfcut, với vd

sudo nano /usr/share/awk/pfcut

Sau đó, dán vào đoạn script bên dưới và lưu lại. Sau đó, đây là cách sử dụng trông như sau:

$ echo "t1 t2 t3 t4 t5 t6 t7" | awk -f pfcut --source '/^/ { pfcut("-4"); }'
t1 t2 t3 t4

$ echo "t1 t2 t3 t4 t5 t6 t7" | awk -f pfcut --source '/^/ { pfcut("2-"); }'
t2 t3 t4 t5 t6 t7

$ echo "t1 t2 t3 t4 t5 t6 t7" | awk -f pfcut --source '/^/ { pfcut("-2,4,6-"); }'
t1 t2 t4 t6 t7

Để tránh gõ tất cả những điều đó, tôi đoán cách tốt nhất có thể làm (xem cách khác Tự động tải chức năng người dùng khi khởi động bằng awk? - Unix & Linux Stack Exchange ) là thêm một bí danh ~/.bashrc; ví dụ với:

$ echo "alias awk-pfcut='awk -f pfcut --source'" >> ~/.bashrc
$ source ~/.bashrc     # refresh bash aliases

... sau đó bạn chỉ có thể gọi:

$ echo "t1 t2 t3 t4 t5 t6 t7" | awk-pfcut '/^/ { pfcut("-2,4,6-"); }'
t1 t2 t4 t6 t7

Đây là nguồn của pfcutkịch bản:

# pfcut - print fields like cut
#
# sdaau, GNU GPL
# Nov, 2013

function spfcut(formatstring)
{
  # parse format string
  numsplitscomma = split(formatstring, fsa, ",");
  numspecparts = 0;
  split("", parts); # clear/initialize array (for e.g. `tail` piping into `awk`)
  for(i=1;i<=numsplitscomma;i++) {
    commapart=fsa[i];
    numsplitsminus = split(fsa[i], cpa, "-");
    # assume here a range is always just two parts: "a-b"
    # also assume user has already sorted the ranges
    #print numsplitsminus, cpa[1], cpa[2]; # debug
    if(numsplitsminus==2) {
     if ((cpa[1]) == "") cpa[1] = 1;
     if ((cpa[2]) == "") cpa[2] = NF;
     for(j=cpa[1];j<=cpa[2];j++) {
       parts[numspecparts++] = j;
     }
    } else parts[numspecparts++] = commapart;
  }
  n=asort(parts); outs="";
  for(i=1;i<=n;i++) {
    outs = outs sprintf("%s%s", $parts[i], (i==n)?"":OFS); 
    #print(i, parts[i]); # debug
  }
  return outs;
}

function pfcut(formatstring) {
  print spfcut(formatstring);
}

In ra các cột bắt đầu từ # 2 (đầu ra sẽ không có dấu cách ở đầu):

ls -l | awk '{sub(/[^ ]+ /, ""); print $0}'

Điều này sẽ làm việc?

awk '{print substr($0,length($1)+1);}' < file

Nó để lại một số khoảng trắng ở phía trước mặc dù.

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

cái này sử dụng awk để in tất cả trừ trường cuối cùng

Đây là những gì tôi thích từ tất cả các khuyến nghị:

In từ cột thứ 6 đến cột cuối cùng.

ls -lthr | awk '{out=$6; for(i=7;i<=NF;i++){out=out" "$i}; print out}'

hoặc là

ls -lthr | awk '{ORS=" "; for(i=6;i<=NF;i++) print $i;print "\n"}'

Nếu bạn cần các cột cụ thể được in với dấu phân cách tùy ý:

awk '{print $3 "  " $4}'

col # 3 col # 4

awk '{print $3 "anything" $4}'

col # 3anythingcol # 4

Vì vậy, nếu bạn có khoảng trắng trong một cột, nó sẽ là hai cột, nhưng bạn có thể kết nối nó với bất kỳ dấu phân cách nào hoặc không có nó.

Giải pháp Perl:

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

Các tùy chọn dòng lệnh này được sử dụng:

• -n lặp xung quanh mỗi dòng của tệp đầu vào, không tự động in mọi dòng

• -l xóa các dòng mới trước khi xử lý và thêm chúng trở lại sau đó

• -achế độ tự động - chia dòng đầu vào thành mảng @F. Mặc định để phân tách trên khoảng trắng

• -e thực thi mã perl

splice @F,0,1 xóa sạch cột 0 khỏi mảng @F

join " ",@F nối các phần tử của mảng @F, sử dụng khoảng trắng ở giữa mỗi phần tử

Giải pháp Python:

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

Nếu bạn không muốn định dạng lại một phần của dòng mà bạn không cắt, giải pháp tốt nhất tôi có thể nghĩ đến được viết trong câu trả lời của tôi trong:

Làm cách nào để in tất cả các cột sau một số cụ thể bằng awk?

Nó chọn những gì trước số trường N đã cho và in tất cả phần còn lại của dòng, bao gồm số trường N và duy trì khoảng cách ban đầu (nó không định dạng lại). Nó không phải là vấn đề nếu chuỗi của trường xuất hiện ở một nơi khác trong dòng.

Xác định hàm:

fromField () { 
awk -v m="\x01" -v N="$1" '{$N=m$N; print substr($0,index($0,m)+1)}'
}

Và sử dụng nó như thế này:

$ echo "  bat   bi       iru   lau bost   " | fromField 3
iru   lau bost   
$ echo "  bat   bi       iru   lau bost   " | fromField 2
bi       iru   lau bost 

Đầu ra duy trì mọi thứ, bao gồm cả dấu cách

Trong trường hợp cụ thể của bạn:

svn status | grep '\!' | fromField 2 > removedProjs

Nếu tệp / luồng của bạn không chứa các ký tự dòng mới ở giữa các dòng (bạn có thể đang sử dụng Trình phân tách Bản ghi khác), bạn có thể sử dụng:

awk -v m="\x0a" -v N="3" '{$N=m$N ;print substr($0, index($0,m)+1)}'

Trường hợp đầu tiên sẽ chỉ thất bại trong các tệp / luồng chứa char thập lục phân hiếm gặp số 1

Điều này sẽ hoạt động nếu bạn đang sử dụng Bash và bạn có thể sử dụng bao nhiêu 'x' như các phần tử bạn muốn loại bỏ và nó bỏ qua nhiều khoảng trắng nếu chúng không được thoát.

while read x b; do echo "$b"; done < filename

Perl:

@m=`ls -ltr dir | grep ^d | awk '{print \$6,\$7,\$8,\$9}'`;
foreach $i (@m)
{
        print "$i\n";

}

awkHàm này trả về chuỗi con $0bao gồm các trường từ beginđến end:

function fields(begin, end,    b, e, p, i) {
    b = 0; e = 0; p = 0;
    for (i = 1; i <= NF; ++i) {
        if (begin == i) { b = p; }
        p += length($i);
        e = p;
        if (end == i) { break; }
        p += length(FS);
    }
    return substr($0, b + 1, e - b);
}

Để có được mọi thứ bắt đầu từ trường 3:

tail = fields(3);

Để có được phần $0đó bao gồm các trường từ 3 đến 5:

middle = fields(3, 5);

b, e, p, ivô nghĩa trong danh sách tham số hàm chỉ là một awkcách khai báo các biến cục bộ.

Tôi muốn mở rộng các câu trả lời được đề xuất cho tình huống các trường được phân định bởi có thể một số khoảng trắng Lý do tại sao OP không sử dụngcut tôi cho rằng.

Tôi biết OP đã hỏi về awk, nhưng một sedcách tiếp cận sẽ hoạt động ở đây (ví dụ với các cột in từ thứ 5 đến cuối cùng):

• phương pháp sed thuần túy

  sed -r 's/^\s*(\S+\s+){4}//' somefile

  Giải trình:

  • s/// được sử dụng cách tiêu chuẩn để thực hiện thay thế
  • ^\s* khớp với bất kỳ khoảng trắng liên tiếp nào ở đầu dòng
  • \S+\s+ nghĩa là một cột dữ liệu (ký tự không phải khoảng trắng theo sau là ký tự khoảng trắng)
  • (){4} có nghĩa là mô hình được lặp lại 4 lần.

• sed và cắt

  sed -r 's/^\s+//; s/\s+/\t/g' somefile | cut -f5-

  bằng cách chỉ thay thế các khoảng trắng liên tiếp bằng một tab duy nhất;

• tr và cắt: trcũng có thể được sử dụng để ép các ký tự liên tiếp với -stùy chọn.

  tr -s [:blank:] <somefile | cut -d' ' -f5-

Các ví dụ Awk có vẻ phức tạp ở đây, đây là cú pháp shell Bash đơn giản:

command | while read -a cols; do echo ${cols[@]:1}; done

Cột thứ n1 của bạn ở đâu tính từ 0.

Thí dụ

Cho nội dung này của tệp ( in.txt):

c1
c1 c2
c1 c2 c3
c1 c2 c3 c4
c1 c2 c3 c4 c5

đây là đầu ra:

$ while read -a cols; do echo ${cols[@]:1}; done < in.txt 

c2
c2 c3
c2 c3 c4
c2 c3 c4 c5

Tôi không hài lòng với bất kỳ awkgiải pháp nào được trình bày ở đây vì tôi muốn trích xuất một vài cột đầu tiên và sau đó in phần còn lại, vì vậy tôi đã chuyển sang perlthay thế. Đoạn mã sau trích xuất hai cột đầu tiên và hiển thị phần còn lại như sau:

echo -e "a  b  c  d\te\t\tf g" | \
  perl -ne 'my @f = split /\s+/, $_, 3; printf "first: %s second: %s rest: %s", @f;'

Lợi thế so với perlgiải pháp từ Chris Koknat là thực sự chỉ có n phần tử đầu tiên được tách ra khỏi chuỗi đầu vào; phần còn lại của chuỗi không bị phân tách chút nào và do đó vẫn hoàn toàn nguyên vẹn. Ví dụ của tôi chứng minh điều này với sự kết hợp của không gian và các tab.

Để thay đổi số lượng cột cần trích xuất, hãy thay thế 3trong ví dụ bằng n + 1.

ls -la | awk '{o=$1" "$3; for (i=5; i<=NF; i++) o=o" "$i; print o }'

Từ câu trả lời này không tệ nhưng khoảng cách tự nhiên không còn nữa.
Sau đó, hãy so sánh nó với cái này:

ls -la | cut -d\  -f4-

Sau đó, bạn sẽ thấy sự khác biệt.

Ngay cả ls -la | awk '{$1=$2=""; print}'dựa trên câu trả lời được bình chọn tốt nhất cho đến nay vẫn không giữ được định dạng.

Vì vậy, tôi sẽ sử dụng như sau, và nó cũng cho phép các cột chọn lọc rõ ràng ngay từ đầu:

ls -la | cut -d\  -f1,4-

Lưu ý rằng mọi không gian cũng được tính cho các cột, vì vậy, ví dụ ở bên dưới, cột 1 và 3 trống, 2 là INFO và 4 là:

$ echo " INFO  2014-10-11 10:16:19  main " | cut -d\  -f1,3

$ echo " INFO  2014-10-11 10:16:19  main " | cut -d\  -f2,4
INFO 2014-10-11
$

Nếu bạn muốn văn bản được định dạng, hãy xâu chuỗi các lệnh của bạn với echo và sử dụng $ 0 để in trường cuối cùng.

Thí dụ:

for i in {8..11}; do
   s1="$i"
   s2="str$i"
   s3="str with spaces $i"
   echo -n "$s1 $s2" | awk '{printf "|%3d|%6s",$1,$2}'
   echo -en "$s3" | awk '{printf "|%-19s|\n", $0}'
done

Bản in:

|  8|  str8|str with spaces 8  |
|  9|  str9|str with spaces 9  |
| 10| str10|str with spaces 10 |
| 11| str11|str with spaces 11 |

Bởi vì một anwser được đánh giá cao nhất với 340 phiếu bầu, tôi chỉ mất 5 phút của cuộc đời mình! Có ai đã thử câu trả lời này trước khi nâng cao điều này chưa? Không cẩn thận. Hoàn toàn vô dụng.

Tôi có một bản ghi trong đó sau $ 5 với địa chỉ IP có thể là văn bản nhiều hơn hoặc không có văn bản. Tôi cần mọi thứ từ địa chỉ IP đến cuối dòng nên sẽ có bất cứ thứ gì sau 5 đô la. Trong trường hợp của tôi, đây là một chương trình awk thực tế, không phải là một oneliner awk vì vậy awk phải giải quyết vấn đề. Khi tôi cố gắng loại bỏ 4 trường đầu tiên bằng cách sử dụng câu trả lời sai nhất nhưng hoàn toàn sai:

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

nó phun ra phản ứng sai và vô ích (tôi đã thêm [..] để chứng minh):

[    37.244.182.218 one two three]

Thậm chí có một số loại đường để kết hợp chất nền với câu trả lời sai này. Giống như sự phức tạp đó là một sự cải thiện.

Thay vào đó, nếu các cột có chiều rộng cố định cho đến khi cần cắt điểm và awk, câu trả lời đúng là:

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

tạo ra đầu ra mong muốn:

[37.244.182.218 one two three]