Haruskah saya peduli dengan kucing yang tidak perlu?

Banyak utilitas baris perintah dapat mengambil inputnya baik dari pipa atau sebagai argumen nama file. Untuk skrip shell panjang, saya menemukan memulai rantai dengan catmembuatnya lebih mudah dibaca, terutama jika perintah pertama akan membutuhkan argumen multi-line.

Membandingkan

sed s/bla/blaha/ data \
| grep blah \
| grep -n babla

dan

cat data \
| sed s/bla/blaha/ \
| grep blah \
| grep -n babla

Apakah metode yang terakhir kurang efisien? Jika demikian, apakah perbedaannya cukup untuk dipedulikan jika skrip dijalankan, katakanlah, satu detik sekali? Perbedaan dalam keterbacaan tidak besar.

Jawaban "pasti" tentu saja diajukan kepada Anda oleh The Use of catAward yang Tidak Berguna .

Tujuan dari kucing adalah untuk menggabungkan file (atau "catenate"). Jika hanya satu file, menggabungkannya dengan tidak sama sekali adalah buang-buang waktu, dan biaya proses.

Instantiating cat hanya agar kode Anda membaca berbeda membuat hanya satu proses lagi dan satu set input / output stream yang tidak diperlukan. Biasanya penangguhan nyata dalam skrip Anda akan menjadi loop yang tidak efisien dan pemrosesan aktual. Pada kebanyakan sistem modern, satu tambahan cattidak akan mematikan kinerja Anda, tetapi hampir selalu ada cara lain untuk menulis kode Anda.

Sebagian besar program, seperti yang Anda perhatikan, dapat menerima argumen untuk file input. Namun, selalu ada builtin shell <yang dapat digunakan di mana pun aliran STDIN diharapkan yang akan menyelamatkan Anda satu proses dengan melakukan pekerjaan dalam proses shell yang sudah berjalan.

Anda bahkan dapat berkreasi dengan DIMANA Anda menulisnya. Biasanya itu akan ditempatkan di akhir perintah sebelum Anda menentukan pengalihan atau pipa keluaran seperti ini:

sed s/blah/blaha/ < data | pipe

Tetapi tidak harus seperti itu. Bahkan bisa didahulukan. Misalnya kode contoh Anda dapat ditulis seperti ini:

< data \
    sed s/bla/blaha/ |
    grep blah |
    grep -n babla

Jika keterbacaan skrip menjadi perhatian Anda dan kode Anda cukup berantakan sehingga menambahkan baris untuk catdiharapkan untuk membuatnya lebih mudah diikuti, ada cara lain untuk membersihkan kode Anda. Salah satu yang saya gunakan banyak yang membantu membuat skrip mudah untuk mencari tahu nanti adalah memecah pipa menjadi set logis dan menyimpannya dalam fungsi. Kode skrip kemudian menjadi sangat alami, dan salah satu bagian dari pipline lebih mudah di-debug.

function fix_blahs () {
    sed s/bla/blaha/ |
    grep blah |
    grep -n babla
}

fix_blahs < data

Anda kemudian dapat melanjutkan fix_blahs < data | fix_frogs | reorder | format_for_sql. Sebuah pipleline yang bertuliskan seperti itu sangat mudah diikuti, dan masing-masing komponen dapat di-debug dengan mudah di fungsinya masing-masing.

Berikut ringkasan dari beberapa kekurangan:

cat $file | cmd

lebih

< $file cmd

• Pertama, sebuah catatan: ada (sengaja untuk tujuan diskusi) ada tanda kutip ganda di $fileatas. Dalam kasus cat, itu selalu menjadi masalah kecuali untuk zsh; dalam kasus pengalihan, itu hanya masalah untuk bashatau ksh88dan, untuk beberapa shell lain hanya ketika interaktif (bukan dalam skrip).
• Kelemahan yang paling sering dikutip adalah proses ekstra yang dihasilkan. Perhatikan bahwa jika cmdbuiltin, itu bahkan 2 proses di beberapa shell seperti bash.
• Masih di depan kinerja, kecuali di shell di mana catbuiltin, itu juga perintah tambahan dieksekusi (dan tentu saja dimuat, dan diinisialisasi (dan perpustakaan itu terhubung juga)).
• Masih di depan kinerja, untuk file besar, itu berarti sistem harus menjadwalkan catdan cmdmemproses secara bergantian dan terus-menerus mengisi dan mengosongkan buffer pipa. Bahkan jika cmdtidak 1GBbesar read()panggilan sistem pada suatu waktu, kontrol harus bolak-balik antara catdan cmdkarena pipa tidak bisa menahan lebih dari beberapa kilobyte data pada suatu waktu.
• Beberapa cmd(seperti wc -c) dapat melakukan beberapa optimasi ketika stdin mereka adalah file biasa yang tidak dapat mereka lakukan cat | cmdkarena stdin mereka hanyalah sebuah pipa saja. Dengan catdan sebuah pipa, itu juga berarti mereka tidak dapat seek()berada di dalam file. Untuk perintah seperti tacatau tail, itu membuat perbedaan besar dalam kinerja karena itu berarti bahwa catmereka perlu menyimpan seluruh input dalam memori.
• Versi cat $file, dan bahkan versi yang lebih benar cat -- "$file"tidak akan berfungsi dengan baik untuk beberapa nama file tertentu seperti -( --helpatau apa pun yang dimulai dengan -jika Anda lupa --). Jika seseorang bersikeras menggunakan cat, ia mungkin harus menggunakan cat < "$file" | cmdsebagai gantinya untuk keandalan.
• Jika $filetidak dapat dibuka untuk dibaca (akses ditolak, tidak ada ...), < "$file" cmdakan melaporkan pesan kesalahan yang konsisten (oleh shell) dan tidak berjalan cmd, sementara cat $file | cmdmasih akan berjalan cmdtetapi dengan stdin yang terlihat seperti itu adalah file kosong. Itu juga berarti bahwa dalam hal-hal seperti < file cmd > file2, file2tidak musnah jika filetidak bisa dibuka.

Memasang <fileujung pipa kurang bisa dibaca daripada memiliki cat filedi awal. Bahasa Inggris Alami berbunyi dari kiri ke kanan.

Menempatkan <fileawal pipa juga kurang dapat dibaca daripada kucing, saya akan mengatakan. Sebuah kata lebih mudah dibaca daripada simbol, terutama simbol yang sepertinya menunjuk ke arah yang salah.

Menggunakan catmempertahankan command | command | commandformat.

Satu hal yang tampaknya tidak dijawab langsung oleh jawaban lain di sini adalah bahwa menggunakan catseperti ini bukan "tidak berguna" dalam arti bahwa "proses kucing asing muncul yang tidak bekerja"; tidak ada gunanya dalam arti "proses kucing muncul yang hanya bekerja tidak perlu".

Dalam hal ini keduanya:

sed 's/foo/bar/' somefile
<somefile sed 's/foo/bar/'

shell memulai proses sed yang membaca dari somefile atau stdin (masing-masing) dan kemudian melakukan beberapa pemrosesan - ia membaca sampai menyentuh baris baru, menggantikan 'foo' pertama (jika ada) pada baris itu dengan 'bar', kemudian mencetak baris ke stdout dan loop.

Dalam kasus:

cat somefile | sed 's/foo/bar/'

Shell memunculkan proses kucing dan proses sed, dan kabel stdout kucing ke stdin sed. Proses cat membaca beberapa kilo atau mungkin potongan mega-byte dari file, kemudian menuliskannya ke stdout, di mana perintah sed mengambil dari sana seperti pada contoh kedua di atas. Sementara sed sedang memproses potongan itu, kucing membaca potongan lain dan menulisnya di stdout untuk sed untuk mengerjakan selanjutnya.

Dengan kata lain, pekerjaan tambahan yang diperlukan dengan menambahkan catperintah bukan hanya pekerjaan ekstra untuk menghasilkan catproses tambahan , tetapi juga pekerjaan ekstra membaca dan menulis byte file dua kali alih-alih sekali. Sekarang, secara praktis berbicara dan pada sistem modern, itu tidak membuat perbedaan besar - itu mungkin membuat sistem Anda melakukan beberapa mikrodetik dari pekerjaan yang tidak perlu. Tetapi jika itu untuk skrip yang Anda rencanakan untuk didistribusikan, berpotensi untuk orang yang menggunakannya pada mesin yang sudah kurang bertenaga, beberapa mikrodetik dapat menambahkan lebih banyak iterasi.