Alat Bash untuk mendapatkan baris ke-n dari file

Apakah ada cara "kanonik" untuk melakukan itu? Saya telah menggunakan head -n | tail -1yang melakukan trik, tetapi saya bertanya-tanya apakah ada alat Bash yang secara khusus mengekstrak baris (atau berbagai baris) dari file.

Yang dimaksud dengan "kanonik" adalah program yang fungsi utamanya adalah melakukan itu.

headdan pipa dengan tailakan lambat untuk file besar. Saya akan menyarankan sedseperti ini:

sed 'NUMq;d' file

Di mana NUMnomor baris yang ingin Anda cetak; jadi, misalnya, sed '10q;d' fileuntuk mencetak baris ke 10 file.

Penjelasan:

NUMqakan segera berhenti ketika nomor barisnya NUM.

dakan menghapus baris alih-alih mencetaknya; ini terhambat pada baris terakhir karena qmenyebabkan sisa skrip dilewati ketika berhenti.

Jika Anda memiliki NUMvariabel, Anda ingin menggunakan tanda kutip ganda dan bukan tunggal:

sed "${NUM}q;d" file

sed -n '2p' < file.txt

akan mencetak baris ke-2

sed -n '2011p' < file.txt

Baris 2011

sed -n '10,33p' < file.txt

baris 10 hingga baris 33

sed -n '1p;3p' < file.txt

Baris 1 dan 3

dan seterusnya...

Untuk menambahkan garis dengan sed, Anda dapat memeriksa ini:

sed: masukkan garis pada posisi tertentu

Saya memiliki situasi unik di mana saya dapat membandingkan solusi yang diusulkan pada halaman ini, jadi saya menulis jawaban ini sebagai konsolidasi dari solusi yang diusulkan dengan menyertakan waktu berjalan untuk masing-masing.

Mendirikan

Saya memiliki file data teks ASCII 3,261 gigabyte dengan satu pasangan nilai kunci per baris. File ini berisi total 3.339.550.320 baris dan menentang pembukaan di editor apa pun yang saya coba, termasuk masuk ke Vim saya. Saya perlu mengatur ulang file ini untuk menyelidiki beberapa nilai yang saya temukan hanya sekitar baris ~ 500.000.000.

Karena file memiliki begitu banyak baris:

• Saya perlu mengekstrak hanya sebagian dari baris untuk melakukan sesuatu yang berguna dengan data.
• Membaca setiap baris yang mengarah ke nilai-nilai yang saya pedulikan akan memakan waktu lama.
• Jika solusinya membaca melewati baris yang saya pedulikan dan terus membaca sisa file itu akan membuang waktu membaca hampir 3 miliar baris yang tidak relevan dan memakan waktu 6x lebih lama dari yang diperlukan.

Skenario terbaik saya adalah solusi yang mengekstrak hanya satu baris dari file tanpa membaca baris lain dalam file, tetapi saya tidak bisa memikirkan bagaimana saya akan mencapai ini di Bash.

Untuk keperluan kewarasan saya, saya tidak akan mencoba membaca 500.000.000 baris penuh yang saya butuhkan untuk masalah saya sendiri. Sebaliknya saya akan mencoba untuk mengekstrak baris 50.000.000 dari 3.339.550.320 (yang berarti membaca file lengkap akan memakan waktu 60x lebih lama dari yang diperlukan).

Saya akan menggunakan timebuilt-in untuk benchmark setiap perintah.

Baseline

Pertama mari kita lihat bagaimana head tailsolusinya:

$ time head -50000000 myfile.ascii | tail -1
pgm_icnt = 0

real    1m15.321s

Garis dasar untuk baris 50 juta adalah 00: 01: 15.321, jika saya langsung ke baris 500 juta mungkin akan ~ 12,5 menit.

memotong

Saya ragu dengan yang ini, tapi patut dicoba:

$ time cut -f50000000 -d$'\n' myfile.ascii
pgm_icnt = 0

real    5m12.156s

Yang ini membutuhkan waktu 00: 05: 12.156 untuk berjalan, yang jauh lebih lambat dari baseline! Saya tidak yakin apakah itu membaca seluruh file atau hanya hingga 50 juta baris sebelum berhenti, tetapi terlepas dari ini sepertinya bukan solusi yang layak untuk masalah ini.

AWK

Saya hanya menjalankan solusi dengan exitkarena saya tidak akan menunggu file lengkap berjalan:

$ time awk 'NR == 50000000 {print; exit}' myfile.ascii
pgm_icnt = 0

real    1m16.583s

Kode ini berjalan pada 00: 01: 16.583, yang hanya lebih lambat ~ 1 detik, tetapi masih belum ada perbaikan pada baseline. Pada tingkat ini jika perintah keluar telah dikecualikan mungkin akan memakan waktu sekitar ~ 76 menit untuk membaca seluruh file!

Perl

Saya menjalankan solusi Perl yang ada juga:

$ time perl -wnl -e '$.== 50000000 && print && exit;' myfile.ascii
pgm_icnt = 0

real    1m13.146s

Kode ini berjalan di 00: 01: 13.146, yang ~ 2 detik lebih cepat dari baseline. Jika saya menjalankannya pada 500.000.000 penuh mungkin akan memakan waktu ~ 12 menit.

sed

Jawaban teratas di papan tulis, inilah hasil saya:

$ time sed "50000000q;d" myfile.ascii
pgm_icnt = 0

real    1m12.705s

Kode ini berjalan di 00: 01: 12.705, yang 3 detik lebih cepat dari garis dasar, dan ~ 0,4 detik lebih cepat dari Perl. Jika saya menjalankannya pada baris 500.000.000 penuh mungkin akan memakan waktu ~ 12 menit.

mapfile

Saya memiliki bash 3.1 dan karenanya tidak dapat menguji solusi mapfile.

Kesimpulan

Sepertinya, sebagian besar, sulit untuk memperbaiki head tailsolusinya. Paling-paling sedsolusi ini memberikan peningkatan efisiensi ~ 3%.

(persentase dihitung dengan rumus % = (runtime/baseline - 1) * 100)

Baris 50,000,000

1. 00: 01: 12.705 (-00: 00: 02.616 = -3.47%) sed
2. 00: 01: 13.146 (-00: 00: 02.175 = -2.89%) perl
3. 00: 01: 15.321 (+00: 00: 00.000 = + 0,00%) head|tail
4. 00: 01: 16.583 (+00: 00: 01.262 = + 1,68%) awk
5. 00: 05: 12.156 (+00: 03: 56.835 = + 314.43%) cut

Baris 500.000.000

1. 00: 12: 07.050 (-00: 00: 26.160) sed
2. 00: 12: 11.460 (-00: 00: 21.750) perl
3. 00: 12: 33.210 (+00: 00: 00.000) head|tail
4. 00: 12: 45.830 (+00: 00: 12.620) awk
5. 00: 52: 01.560 (+00: 40: 31.650) cut

Baris 3.338.559.320

1. 01: 20: 54.599 (-00: 03: 05.327) sed
2. 01: 21: 24.045 (-00: 02: 25.227) perl
3. 01: 23: 49.273 (+00: 00: 00.000) head|tail
4. 01: 25: 13.548 (+00: 02: 35.735) awk
5. 05: 47: 23.026 (+04: 24: 26.246) cut

Dengan awkcukup cepat:

awk 'NR == num_line' file

Bila ini benar, perilaku default awkyaitu dilakukan: {print $0}.

Versi alternatif

Jika file Anda berukuran besar, sebaiknya Anda exitmembaca baris yang diperlukan. Dengan cara ini Anda menghemat waktu CPU ^{Lihat perbandingan waktu di akhir jawaban} .

awk 'NR == num_line {print; exit}' file

Jika Anda ingin memberikan nomor baris dari variabel bash, Anda dapat menggunakan:

awk 'NR == n' n=$num file
awk -v n=$num 'NR == n' file   # equivalent

Lihat berapa banyak waktu yang dihemat dengan menggunakan exit, khususnya jika garis kebetulan berada di bagian pertama file:

# Let's create a 10M lines file
for ((i=0; i<100000; i++)); do echo "bla bla"; done > 100Klines
for ((i=0; i<100; i++)); do cat 100Klines; done > 10Mlines

$ time awk 'NR == 1234567 {print}' 10Mlines
bla bla

real    0m1.303s
user    0m1.246s
sys 0m0.042s
$ time awk 'NR == 1234567 {print; exit}' 10Mlines
bla bla

real    0m0.198s
user    0m0.178s
sys 0m0.013s

Jadi perbedaannya adalah 0,198 vs 1,303, sekitar 6x lebih cepat.

Menurut tes saya, dalam hal kinerja dan keterbacaan rekomendasi saya adalah:

tail -n+N | head -1

Nadalah nomor baris yang Anda inginkan. Misalnya, tail -n+7 input.txt | head -1akan mencetak baris ke 7 file tersebut.

tail -n+Nakan mencetak semuanya mulai dari baris N, dan head -1akan membuatnya berhenti setelah satu baris.

Alternatifnya head -N | tail -1mungkin sedikit lebih mudah dibaca. Misalnya, ini akan mencetak baris ke-7:

head -7 input.txt | tail -1

Ketika datang ke kinerja, tidak ada banyak perbedaan untuk ukuran yang lebih kecil, tetapi akan dikalahkan oleh tail | head(dari atas) ketika file menjadi besar.

Pilihan teratas sed 'NUMq;d'menarik untuk diketahui, tetapi saya berpendapat bahwa itu akan dipahami oleh lebih sedikit orang di luar kotak daripada solusi kepala / ekor dan juga lebih lambat dari pada ekor / kepala.

Dalam pengujian saya, kedua versi ekor / kepala mengungguli sed 'NUMq;d'secara konsisten. Itu sejalan dengan tolok ukur lain yang diposting. Sulit untuk menemukan kasus di mana ekor / kepala benar-benar buruk. Ini juga tidak mengejutkan, karena ini adalah operasi yang Anda harapkan akan sangat dioptimalkan dalam sistem Unix modern.

Untuk mendapatkan gambaran tentang perbedaan kinerja, ini adalah angka yang saya dapatkan untuk file besar (9.3G):

• tail -n+N | head -1: 3,7 dtk
• head -N | tail -1: 4,6 dtk
• sed Nq;d: 18,8 dtk

Hasil mungkin berbeda, tetapi kinerja head | taildan tail | head, secara umum, sebanding untuk input yang lebih kecil, dan sedselalu lebih lambat oleh faktor yang signifikan (sekitar 5x atau lebih).

Untuk mereproduksi tolok ukur saya, Anda dapat mencoba yang berikut, tetapi berhati-hatilah bahwa itu akan membuat file 9.3G di direktori kerja saat ini:

#!/bin/bash
readonly file=tmp-input.txt
readonly size=1000000000
readonly pos=500000000
readonly retries=3

seq 1 $size > $file
echo "*** head -N | tail -1 ***"
for i in $(seq 1 $retries) ; do
    time head "-$pos" $file | tail -1
done
echo "-------------------------"
echo
echo "*** tail -n+N | head -1 ***"
echo

seq 1 $size > $file
ls -alhg $file
for i in $(seq 1 $retries) ; do
    time tail -n+$pos $file | head -1
done
echo "-------------------------"
echo
echo "*** sed Nq;d ***"
echo

seq 1 $size > $file
ls -alhg $file
for i in $(seq 1 $retries) ; do
    time sed $pos'q;d' $file
done
/bin/rm $file

Ini adalah output dari pelarian pada mesin saya (ThinkPad X1 Carbon dengan SSD dan memori 16G). Saya berasumsi pada akhirnya menjalankan semuanya akan datang dari cache, bukan dari disk:

*** head -N | tail -1 ***
500000000

real    0m9,800s
user    0m7,328s
sys     0m4,081s
500000000

real    0m4,231s
user    0m5,415s
sys     0m2,789s
500000000

real    0m4,636s
user    0m5,935s
sys     0m2,684s
-------------------------

*** tail -n+N | head -1 ***

-rw-r--r-- 1 phil 9,3G Jan 19 19:49 tmp-input.txt
500000000

real    0m6,452s
user    0m3,367s
sys     0m1,498s
500000000

real    0m3,890s
user    0m2,921s
sys     0m0,952s
500000000

real    0m3,763s
user    0m3,004s
sys     0m0,760s
-------------------------

*** sed Nq;d ***

-rw-r--r-- 1 phil 9,3G Jan 19 19:50 tmp-input.txt
500000000

real    0m23,675s
user    0m21,557s
sys     0m1,523s
500000000

real    0m20,328s
user    0m18,971s
sys     0m1,308s
500000000

real    0m19,835s
user    0m18,830s
sys     0m1,004s

Wow, semua kemungkinan!

Coba ini:

sed -n "${lineNum}p" $file

atau salah satunya tergantung pada versi Awk Anda:

awk  -vlineNum=$lineNum 'NR == lineNum {print $0}' $file
awk -v lineNum=4 '{if (NR == lineNum) {print $0}}' $file
awk '{if (NR == lineNum) {print $0}}' lineNum=$lineNum $file

( Anda mungkin harus mencoba nawkatau gawkperintah ).

Apakah ada alat yang hanya mencetak garis tertentu? Bukan salah satu alat standar. Namun, sedmungkin yang paling dekat dan paling sederhana untuk digunakan.

# print line number 52
sed '52!d' file

Script satu baris yang berguna untuk sed

Pertanyaan ini ditandai dengan Bash, inilah cara melakukan Bash (≥4): gunakan mapfiledengan opsi -s(lewati) dan -n(hitung).

Jika Anda perlu mendapatkan baris file ke-42 file:

mapfile -s 41 -n 1 ary < file

Pada titik ini, Anda akan memiliki array aryyang bidangnya berisi baris file(termasuk baris baru), tempat kami melewatkan 41 baris pertama ( -s 41), dan berhenti setelah membaca satu baris ( -n 1). Jadi itu benar-benar garis ke-42. Untuk mencetaknya:

printf '%s' "${ary[0]}"

Jika Anda membutuhkan rentang garis, ucapkan kisaran 42-666 (inklusif), dan katakan Anda tidak ingin menghitung sendiri, dan cetaklah di stdout:

mapfile -s $((42-1)) -n $((666-42+1)) ary < file
printf '%s' "${ary[@]}"

Jika Anda perlu memproses garis-garis ini juga, itu tidak benar-benar nyaman untuk menyimpan baris tambahan. Dalam hal ini gunakan -topsi (trim):

mapfile -t -s $((42-1)) -n $((666-42+1)) ary < file
# do stuff
printf '%s\n' "${ary[@]}"

Anda dapat memiliki fungsi untuk melakukannya:

print_file_range() {
    # $1-$2 is the range of file $3 to be printed to stdout
    local ary
    mapfile -s $(($1-1)) -n $(($2-$1+1)) ary < "$3"
    printf '%s' "${ary[@]}"
}

Tidak ada perintah eksternal, hanya Bash bawaan!

Anda juga dapat menggunakan cetak sed dan keluar:

sed -n '10{p;q;}' file   # print line 10

Anda juga dapat menggunakan Perl untuk ini:

perl -wnl -e '$.== NUM && print && exit;' some.file

Solusi tercepat untuk file besar selalu tail | head, asalkan dua jarak:

• dari awal file ke baris awal. Mari kita sebut sajaS
• jarak dari baris terakhir ke akhir file. Jadilah ituE

dikenal. Lalu, kita bisa menggunakan ini:

mycount="$E"; (( E > S )) && mycount="+$S"
howmany="$(( endline - startline + 1 ))"
tail -n "$mycount"| head -n "$howmany"

berapa banyak hanya hitungan garis yang diperlukan.

Beberapa detail lainnya di https://unix.stackexchange.com/a/216614/79743

Semua jawaban di atas langsung menjawab pertanyaan. Tapi ini solusi yang kurang langsung tetapi ide yang berpotensi lebih penting, untuk memancing pemikiran.

Karena panjang garis arbitrer, semua byte file sebelum baris ke-n perlu dibaca. Jika Anda memiliki file besar atau perlu mengulangi tugas ini berkali-kali, dan proses ini memakan waktu, maka Anda harus serius memikirkan apakah Anda harus menyimpan data Anda dengan cara yang berbeda di tempat pertama.

Solusi sebenarnya adalah memiliki indeks, misalnya di awal file, yang menunjukkan posisi di mana garis dimulai. Anda bisa menggunakan format database, atau cukup tambahkan tabel di awal file. Atau buat file indeks terpisah untuk menemani file teks besar Anda.

mis. Anda dapat membuat daftar posisi karakter untuk baris baru:

awk 'BEGIN{c=0;print(c)}{c+=length()+1;print(c+1)}' file.txt > file.idx

kemudian baca dengan tail, yang sebenarnya seeks langsung ke titik yang sesuai dalam file!

mis. untuk mendapatkan baris 1000:

tail -c +$(awk 'NR=1000' file.idx) file.txt | head -1

• Ini mungkin tidak bekerja dengan karakter 2-byte / multibyte, karena awk adalah "karakter-aware" tetapi tail tidak.
• Saya belum menguji ini terhadap file besar.
• Lihat juga jawaban ini .
• Atau - bagi file Anda menjadi file yang lebih kecil!

Sebagai tindak lanjut dari jawaban benchmark benchmark CaffeineConnoisseur yang sangat membantu ... Saya ingin tahu seberapa cepat metode 'mapfile' dibandingkan dengan yang lain (karena itu tidak diuji), jadi saya mencoba perbandingan kecepatan cepat dan kotor sendiri sebagai Saya punya bash 4 berguna. Melemparkan tes metode "ekor | kepala" (bukan kepala | ekor) yang disebutkan dalam salah satu komentar pada jawaban teratas ketika saya berada di sana, ketika orang-orang menyanyikan pujiannya. Saya tidak punya apa-apa hampir ukuran testfile yang digunakan; yang terbaik yang dapat saya temukan dalam waktu singkat adalah file 14M silsilah (garis panjang yang dipisahkan spasi, hanya di bawah 12.000 baris).

Versi pendek: mapfile muncul lebih cepat daripada metode cut, tetapi lebih lambat dari yang lainnya, jadi saya akan menyebutnya tak berguna. ekor | head, OTOH, sepertinya itu bisa menjadi yang tercepat, meskipun dengan ukuran file ini perbedaannya tidak terlalu besar dibandingkan dengan sed.

$ time head -11000 [filename] | tail -1
[output redacted]

real    0m0.117s

$ time cut -f11000 -d$'\n' [filename]
[output redacted]

real    0m1.081s

$ time awk 'NR == 11000 {print; exit}' [filename]
[output redacted]

real    0m0.058s

$ time perl -wnl -e '$.== 11000 && print && exit;' [filename]
[output redacted]

real    0m0.085s

$ time sed "11000q;d" [filename]
[output redacted]

real    0m0.031s

$ time (mapfile -s 11000 -n 1 ary < [filename]; echo ${ary[0]})
[output redacted]

real    0m0.309s

$ time tail -n+11000 [filename] | head -n1
[output redacted]

real    0m0.028s

Semoga ini membantu!

Menggunakan apa yang disebutkan orang lain, saya ingin ini menjadi fungsi cepat & keren di shell bash saya.

Buat file: ~/.functions

Tambahkan ke dalamnya isinya:

getline() { line=$1 sed $line'q;d' $2 }

Kemudian tambahkan ini ke ~/.bash_profile:

source ~/.functions

Sekarang ketika Anda membuka jendela bash baru, Anda bisa memanggil fungsi seperti ini:

getline 441 myfile.txt

Jika Anda mendapatkan beberapa baris dengan dibatasi oleh \ n (baris biasanya baru). Anda dapat menggunakan 'cut' juga:

echo "$data" | cut -f2 -d$'\n'

Anda akan mendapatkan baris ke-2 dari file. -f3memberi Anda garis ke-3.

Untuk mencetak baris ke-n menggunakan sed dengan variabel sebagai nomor baris:

a=4
sed -e $a'q:d' file

Di sini bendera '-e' adalah untuk menambahkan skrip ke perintah yang akan dieksekusi.

Sudah banyak jawaban bagus. Saya pribadi pergi dengan awk. Untuk kenyamanan, jika Anda menggunakan bash, cukup tambahkan di bawah ini untuk ~/.bash_profile. Dan, saat berikutnya Anda masuk (atau jika Anda mendapatkan .bash_profile setelah pembaruan ini), Anda akan memiliki fungsi "n" yang bagus dan baru yang tersedia untuk menyalurkan file Anda.

Jalankan ini atau letakkan di ~ / .bash_profile Anda (jika menggunakan bash) dan buka kembali bash (atau jalankan source ~/.bach_profile)

# print just the nth piped in line nth () { awk -vlnum=${1} 'NR==lnum {print; exit}'; }

Kemudian, untuk menggunakannya, cukup pipa melalui itu. Misalnya,:

$ yes line | cat -n | nth 5 5 line

Setelah mengambil melihat jawaban atas dan yang patokan , saya telah menerapkan fungsi pembantu kecil:

function nth {
    if (( ${#} < 1 || ${#} > 2 )); then
        echo -e "usage: $0 \e[4mline\e[0m [\e[4mfile\e[0m]"
        return 1
    fi
    if (( ${#} > 1 )); then
        sed "$1q;d" $2
    else
        sed "$1q;d"
    fi
}

Pada dasarnya Anda dapat menggunakannya dalam dua mode:

nth 42 myfile.txt
do_stuff | nth 42

Saya telah memasukkan beberapa jawaban di atas ke dalam skrip bash pendek yang dapat Anda masukkan ke file yang dipanggil get.shdan ditautkan /usr/local/bin/get(atau nama lain apa pun yang Anda inginkan).

#!/bin/bash
if [ "${1}" == "" ]; then
    echo "error: blank line number";
    exit 1
fi
re='^[0-9]+$'
if ! [[ $1 =~ $re ]] ; then
    echo "error: line number arg not a number";
    exit 1
fi
if [ "${2}" == "" ]; then
    echo "error: blank file name";
    exit 1
fi
sed "${1}q;d" $2;
exit 0

Pastikan itu dapat dieksekusi dengan

$ chmod +x get

Tautkan untuk membuatnya tersedia saat PATHbersama

$ ln -s get.sh /usr/local/bin/get

Nikmati secara bertanggung jawab!

P