Apakah pemipaan, pemindahan, atau perluasan parameter lebih efisien?

Saya mencoba menemukan cara paling efisien untuk beralih melalui nilai-nilai tertentu yang merupakan jumlah nilai yang konsisten dari satu sama lain dalam daftar kata yang dipisahkan oleh ruang (saya tidak ingin menggunakan array). Sebagai contoh,

list="1 ant bat 5 cat dingo 6 emu fish 9 gecko hare 15 i j"

Jadi saya ingin bisa beralih melalui daftar dan hanya mengakses 1,5,6,9 dan 15.

EDIT: Seharusnya saya menjelaskan bahwa nilai yang saya coba dapatkan dari daftar tidak harus berbeda dalam format dari sisa daftar. Apa yang membuat mereka istimewa adalah semata-mata posisi mereka dalam daftar (Dalam hal ini, posisi 1,4,7 ...). Jadi daftarnya bisa saja1 2 3 5 9 8 6 90 84 9 3 2 15 75 55tetapi saya masih menginginkan angka yang sama. Dan juga, saya ingin dapat melakukannya dengan asumsi saya tidak tahu panjang daftar.

Metode yang saya pikirkan sejauh ini adalah:

Metode 1

set $list
found=false
find=9
count=1
while [ $count -lt $# ]; do
    if [ "${@:count:1}" -eq $find ]; then
    found=true
    break
    fi
    count=`expr $count + 3`
done

Metode 2

set list
found=false
find=9
while [ $# ne 0 ]; do
    if [ $1 -eq $find ]; then
    found=true
    break
    fi
    shift 3
done

Metode 3 Saya cukup yakin perpipaan membuat ini pilihan terburuk, tetapi saya mencoba menemukan metode yang tidak menggunakan set, karena penasaran.

found=false
find=9
count=1
num=`echo $list | cut -d ' ' -f$count`
while [ -n "$num" ]; do
    if [ $num -eq $find ]; then
    found=true
    break
    fi
    count=`expr $count + 3`
    num=`echo $list | cut -d ' ' -f$count`
done

Jadi apa yang paling efisien, atau saya melewatkan metode yang lebih sederhana?

Cukup sederhana awk. Ini akan memberi Anda nilai setiap bidang keempat untuk input dengan panjang berapa pun:

$ awk -F' ' '{for( i=1;i<=NF;i+=3) { printf( "%s%s", $i, OFS ) }; printf( "\n" ) }' <<< $list
1 5 6 9 15

Ini berfungsi memanfaatkan awkvariabel bawaan seperti NF(jumlah bidang dalam catatan), dan melakukan beberapa forperulangan sederhana untuk beralih di sepanjang bidang untuk memberi Anda yang Anda inginkan tanpa perlu tahu sebelumnya berapa banyak akan ada.

Atau, jika Anda memang hanya ingin bidang-bidang tertentu seperti yang ditentukan dalam contoh Anda:

$ awk -F' ' '{ print $1, $4, $7, $10, $13 }' <<< $list
1 5 6 9 15

Adapun pertanyaan tentang efisiensi, rute paling sederhana adalah dengan menguji ini atau masing-masing metode Anda yang lain dan gunakan timeuntuk menunjukkan berapa lama waktu yang dibutuhkan; Anda juga bisa menggunakan alat seperti straceuntuk melihat bagaimana sistem panggilan mengalir. Penggunaan timeterlihat seperti:

$ time ./script.sh

real    0m0.025s
user    0m0.004s
sys     0m0.008s

Anda dapat membandingkan output tersebut antara berbagai metode untuk melihat mana yang paling efisien dalam hal waktu; alat lain dapat digunakan untuk metrik efisiensi lainnya.

• Aturan pertama optimasi perangkat lunak: Jangan .

  Sampai Anda tahu kecepatan program adalah masalah, Anda tidak perlu memikirkan seberapa cepatnya. Jika daftar Anda panjangnya atau hanya ~ 100-1000 item, Anda mungkin tidak akan menyadari berapa lama. Ada kemungkinan Anda menghabiskan lebih banyak waktu untuk memikirkan pengoptimalan daripada apa perbedaannya.
  
  

• Aturan kedua: Ukur .

  Itu cara yang pasti untuk mencari tahu, dan yang memberi jawaban untuk sistem Anda. Terutama dengan kerang, ada begitu banyak, dan mereka tidak semuanya identik. Jawaban untuk satu shell mungkin tidak berlaku untuk Anda.

  Dalam program yang lebih besar, pembuatan profil juga dilakukan di sini. Bagian paling lambat mungkin bukan yang Anda pikirkan.
  
  

• Ketiga, aturan pertama optimasi skrip shell: Jangan gunakan shell .

  Ya benar Banyak shell tidak dibuat menjadi cepat (karena meluncurkan program eksternal tidak harus), dan mereka bahkan dapat mengurai baris kode sumber lagi setiap kali.

  Gunakan sesuatu seperti awk atau Perl sebagai gantinya. Dalam patokan mikro sepele yang saya lakukan,awk adalah puluhan kali lebih cepat daripada shell umum dalam menjalankan loop sederhana (tanpa I / O).

  Namun, jika Anda menggunakan shell, gunakan fungsi builtin shell bukan perintah eksternal. Di sini, Anda menggunakan expryang tidak dibangun di shell yang saya temukan di sistem saya, tetapi yang dapat diganti dengan ekspansi aritmatika standar. Misalnya i=$((i+1))alih-alih i=$(expr $i + 1)menambah i. Penggunaan Anda cutdalam contoh terakhir mungkin juga dapat diganti dengan ekspansi parameter standar.

  Lihat juga: Mengapa menggunakan shell loop untuk memproses teks dianggap praktik buruk?

Langkah # 1 dan # 2 seharusnya berlaku untuk pertanyaan Anda.

Saya hanya akan memberikan beberapa saran umum dalam jawaban ini, dan bukan tolok ukur. Benchmark adalah satu-satunya cara untuk secara andal menjawab pertanyaan tentang kinerja. Tetapi karena Anda tidak mengatakan berapa banyak data yang Anda manipulasi dan seberapa sering Anda melakukan operasi ini, tidak ada cara untuk melakukan benchmark yang berguna. Apa yang lebih efisien untuk 10 item dan apa yang lebih efisien untuk 1000000 item seringkali tidak sama.

Sebagai aturan umum, menjalankan perintah eksternal lebih mahal daripada melakukan sesuatu dengan konstruksi shell murni, selama kode shell murni tidak melibatkan loop. Di sisi lain, perulangan shell yang beriterasi pada string besar atau sejumlah besar string cenderung lebih lambat dari satu permintaan alat tujuan khusus. Misalnya, menjalankan loop Anda cutbisa terasa lambat dalam praktik, tetapi jika Anda menemukan cara untuk melakukan semuanya dengan satucut pemanggilan yang mungkin lebih cepat daripada melakukan hal yang sama dengan manipulasi string dalam shell.

Perhatikan bahwa titik batas dapat sangat bervariasi antar sistem. Itu dapat bergantung pada kernel, pada bagaimana penjadwal kernel dikonfigurasikan, pada sistem file yang berisi executable eksternal, pada seberapa banyak tekanan CPU vs memori yang ada saat ini, dan banyak faktor lainnya.

Jangan menelepon expruntuk melakukan aritmatika jika Anda benar-benar khawatir tentang kinerja. Bahkan, jangan menelepon expruntuk melakukan aritmatika sama sekali. Kerang memiliki aritmatika bawaan, yang lebih jelas dan lebih cepat daripada memohon expr.

Anda tampaknya menggunakan bash, karena Anda menggunakan konstruksi bash yang tidak ada di sh. Jadi mengapa Anda tidak menggunakan array? Array adalah solusi yang paling alami, dan kemungkinan akan menjadi yang tercepat juga. Perhatikan bahwa indeks array mulai dari 0.

list=(1 2 3 5 9 8 6 90 84 9 3 2 15 75 55)
for ((count = 0; count += 3; count < ${#list[@]})); do
  echo "${list[$count]}"
done

Skrip Anda mungkin lebih cepat jika Anda menggunakan sh, jika sistem Anda memiliki tanda hubung atau ksh shdaripada bash. Jika Anda menggunakan sh, Anda tidak mendapatkan array bernama, tetapi Anda masih mendapatkan array salah satu parameter posisi, yang dapat Anda atur set. Untuk mengakses elemen pada posisi yang tidak diketahui sampai runtime, Anda perlu menggunakan eval(berhati-hatilah mengutip sesuatu dengan benar!).

# List elements must not contain whitespace or ?*\[
list='1 2 3 5 9 8 6 90 84 9 3 2 15 75 55'
set $list
count=1
while [ $count -le $# ]; do
  eval "value=\${$count}"
  echo "$value"
  count=$((count+1))
done

Jika Anda hanya ingin mengakses array sekali dan bergerak dari kiri ke kanan (melewatkan beberapa nilai), Anda dapat menggunakan shiftsebagai ganti indeks variabel.

# List elements must not contain whitespace or ?*\[
list='1 2 3 5 9 8 6 90 84 9 3 2 15 75 55'
set $list
while [ $# -ge 1 ]; do
  echo "$1"
  shift && shift && shift
done

Pendekatan mana yang lebih cepat tergantung pada shell dan jumlah elemen.

Kemungkinan lain adalah menggunakan pemrosesan string. Ini memiliki keuntungan karena tidak menggunakan parameter posisi, sehingga Anda dapat menggunakannya untuk hal lain. Ini akan lebih lambat untuk sejumlah besar data, tetapi itu tidak mungkin membuat perbedaan nyata untuk sejumlah kecil data.

# List elements must be separated by a single space (not arbitrary whitespace)
list='1 2 3 5 9 8 6 90 84 9 3 2 15 75 55'
while [ -n "$list" ]; do
  echo "${list% *}"
  case "$list" in *\ *\ *\ *) :;; *) break;; esac
  list="${list#* * * }"
done

awkadalah pilihan yang bagus, jika Anda dapat melakukan semua pemrosesan di dalam skrip Awk. Jika tidak, Anda hanya akan mengirim output Awk ke utilitas lain, menghancurkan perolehan kinerja awk.

bashiterasi atas array juga bagus, jika Anda bisa memasukkan seluruh daftar Anda ke dalam array (yang untuk shell modern mungkin merupakan jaminan) dan Anda tidak keberatan dengan senam sintaks array.

Namun, pendekatan saluran pipa:

xargs -n3 <<< "$list" | while read -ra a; do echo $a; done | grep 9

Dimana:

• xargs mengelompokkan daftar yang dipisahkan spasi menjadi tiga, masing-masing baris baru dipisahkan
• while read mengkonsumsi daftar itu dan menampilkan kolom pertama dari setiap grup
• grep memfilter kolom pertama (sesuai dengan setiap posisi ketiga dalam daftar asli)

Meningkatkan pemahaman, menurut saya. Orang-orang sudah tahu apa yang dilakukan alat-alat ini, sehingga mudah dibaca dari kiri ke kanan dan alasan tentang apa yang akan terjadi. Pendekatan ini juga secara jelas mendokumentasikan panjang langkah ( -n3) dan pola filter ( 9), sehingga mudah untuk membuat variasi:

count=3
find=9
xargs -n "$count" <<< "$list" | while read -ra a; do echo $a; done | grep "$find"

Ketika kita mengajukan pertanyaan "efisiensi", pastikan untuk memikirkan "efisiensi seumur hidup total". Perhitungan itu mencakup upaya pengelola untuk menjaga agar kode tetap berfungsi, dan kami, kantung daging adalah mesin yang paling tidak efisien di seluruh operasi.

Mungkin ini

cut -d' ' -f1,4,7,10,13 <<<$list
1 5 6 9 15

Jangan gunakan perintah shell jika Anda ingin menjadi efisien. Batasi diri Anda untuk pipa, pengalihan, pergantian dll, dan program. Itu sebabnya xargsdan parallelutilitas ada - karena bash sementara loop tidak efisien dan sangat lambat. Gunakan bash loop hanya sebagai resolusi terakhir.

list="1 ant bat 5 cat dingo 6 emu fish 9 gecko hare 15 i j"
if 
    <<<"$list" tr -d -s '[0-9 ]' | 
    tr -s ' ' | tr ' ' '\n' | 
    grep -q -x '9'
then
    found=true
else 
    found=false
fi
echo ${found} 

Tapi Anda mungkin harus agak lebih cepat dengan yang baik awk.

Menurut pendapat saya solusi yang paling jelas (dan mungkin yang paling performan juga) adalah dengan menggunakan variabel awk RS dan ORS:

awk -v RS=' ' -v ORS=' ' 'NR % 3 == 1' <<< "$list"

1. Menggunakan skrip shell GNU sed dan POSIX :

   echo $(printf '%s\n' $list | sed -n '1~3p')

2. Atau dengan bash's substitusi parameter :

   echo $(sed -n '1~3p' <<< ${list// /$'\n'})

3. Non- GNU ( yaitu POSIX ) sed, dan bash:

   sed 's/\([^ ]* \)[^ ]* *[^ ]* */\1/g' <<< "$list"

   Atau lebih mudah dibawa, menggunakan POSIX sed dan skrip shell:

   echo "$list" | sed 's/\([^ ]* \)[^ ]* *[^ ]* */\1/g'

Output dari semua ini:

1 5 6 9 15