Penguasaan Baris Perintah Linux & Penskripan Bash · Pelajaran

Menganalisis Prestasi Skrip dan Mengelakkan Subcangkerang Tidak Berguna

Q: Adakah pelajaran “Menganalisis Prestasi Skrip dan Mengelakkan Subcangkerang Tidak Berguna” percuma?

Ya — teks penuh “Menganalisis Prestasi Skrip dan Mengelakkan Subcangkerang Tidak Berguna” boleh dibaca secara percuma di web ini. Untuk berlatih secara interaktif menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7, serta membuka kunci baki kursus Penguasaan Baris Perintah Linux & Penskripan Bash, tingkat taraf kepada CoddyKit PRO. Kursus Penguasaan Baris Perintah Linux & Penskripan Bash merangkumi sejumlah 4 pelajaran.

Q: Adakah saya memerlukan pengalaman untuk memulakan Penguasaan Baris Perintah Linux & Penskripan Bash?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Penguasaan Baris Perintah Linux & Penskripan Bash di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 1 daripada 4.

Q: Berapa lamakah pelajaran “Menganalisis Prestasi Skrip dan Mengelakkan Subcangkerang Tidak Berguna” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Q: Bolehkah saya menulis dan menjalankan kod dalam pelajaran Penguasaan Baris Perintah Linux & Penskripan Bash ini?

Ya. Setiap pelajaran Penguasaan Baris Perintah Linux & Penskripan Bash menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Ukur masa skrip dan gantikan corak yang banyak menggunakan fork seperti rangkaian cat-grep dengan alternatif terbina dalam

Pelajaran 1 daripada 413 langkah

Menganalisis Prestasi Skrip dan Mengelakkan Subcangkerang Tidak Berguna ialah pelajaran Penguasaan Baris Perintah Linux & Penskripan Bash percuma di CoddyKit. Ini ialah pelajaran 1 daripada 4. Anda boleh membaca keseluruhan pelajaran di bawah secara percuma — kemudian berlatih secara praktikal dalam pelayar menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Penguasaan Baris Perintah Linux & Penskripan Bash, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Penguasaan Baris Perintah Linux & Penskripan Bash merangkumi sejumlah 4 pelajaran.

Sebab Prestasi Skrip Penting

Skrip Bash yang berjalan perlahan membazirkan masa CI, menyekat tugas cron dan mengecewakan pengguna. Kebanyakan kelambatan bukan berpunca daripada logik yang kompleks — sebaliknya berpunca daripada percabangan proses yang tidak perlu: setiap perintah luaran yang anda panggil akan memulakan proses anak baharu.

Dalam pelajaran ini, anda akan belajar untuk:

Mengukur ke mana masa sebenarnya digunakan dengan time dan bash -x
Mengenal pasti corak anti seperti penggunaan cat yang tidak berguna dan memerlukan banyak percabangan
Menggantikan perintah luaran dengan bina dalam shell yang lebih pantas
Menggunakan subshell dengan sengaja dan mengelakkannya apabila tidak memberikan manfaat

Matlamatnya adalah untuk menulis skrip yang melakukan kerja yang sama dengan lebih sedikit proses anak dan masa jam dinding yang lebih singkat.

Menentukan Masa Skrip dengan Binaan time

Alat pemprofilan paling mudah ialah binaan shell time. Letakkannya di hadapan apa-apa perintah atau saluran paip untuk mendapatkan tiga ukuran:

real — masa berlalu mengikut jam dinding (masa yang sebenarnya anda tunggu)
user — masa CPU yang digunakan dalam kod ruang pengguna
sys — masa CPU yang digunakan dalam kernel (panggilan sistem, I/O)

Perbezaan besar antara real dengan user+sys biasanya bermaksud skrip sedang menunggu I/O atau memulakan banyak proses anak. Jalankan time pada keseluruhan skrip terlebih dahulu untuk mengesahkan bahawa terdapat masalah sebelum anda mengoptimumkan apa-apa.

#!/usr/bin/env bash
# Time a whole script block
time {
  for i in $(seq 1 1000); do
    echo "line $i"
  done | grep -c "5"
}
# Output example:
# 271
# real  0m0.045s
# user  0m0.038s
# sys   0m0.012s

Menjejak Pelaksanaan dengan bash -x dan PS4

bash -x mencetak setiap perintah sebelum perintah itu dijalankan — ini ialah penjejakan pelaksanaan. Ia menunjukkan baris yang paling kerap dilaksanakan dan sama ada program luaran dipanggil lebih banyak daripada jangkaan anda.

Secara lalai, setiap baris yang dijejak diawali dengan +. Anda boleh memperkayakan awalan itu menggunakan PS4 untuk memasukkan cap masa, lalu menjadikan penjejakan sebagai pemprofil ringan:

PS4 dikembangkan sebelum setiap perintah yang dijejak
Memasukkan $EPOCHREALTIME (bash 5+) atau $(date +%s%N) memberikan ketepatan nanosaat
Halakan stderr ke fail dan proseskannya selepas itu untuk mencari bahagian yang perlahan

#!/usr/bin/env bash
# Run with:  bash -x ./myscript.sh  2>trace.log
# Or embed tracing inside the script:
export PS4='+ [${EPOCHREALTIME}] ${BASH_SOURCE}:${LINENO}: '
set -x

slow_function() {
  local result
  result=$(cat /etc/hostname)   # fork — slow
  echo "host: $result"
}

slow_function
set +x

# trace.log now contains timestamps so you can diff
# adjacent lines to find which step took longest.

Apakah Subshell yang Tidak Berguna?

Subshell ialah salinan anak bagi proses shell semasa. Ia dicipta oleh:

Penggantian perintah: $(command)
Pengumpulan dengan tanda kurung: ( commands )
Penyaluran ke dalam binaan shell: cmd | while read ...

Subshell adalah diperlukan apabila anda benar-benar memerlukan pengasingan atau saluran paip. Subshell menjadi tidak berguna apabila anda menggunakannya hanya untuk memanggil program luaran yang boleh dikendalikan oleh shell sendiri, atau apabila anda membungkus binaan dalam lapisan percabangan tambahan tanpa sebab.

Setiap percabangan subshell menelan kos kira-kira 1–5 ms pada sistem Linux moden. Dalam gelung yang berjalan 10,000 kali, 1000 subshell yang tidak berguna menambah 1–5 saat overhed semata-mata.

Corak Anti Klasik: Penggunaan cat yang Tidak Berguna

cat file | grep pattern ialah corak anti paling terkenal yang memerlukan banyak percabangan. Ia memulakan dua proses (cat + grep) yang disambungkan melalui saluran paip, sedangkan grep sahaja boleh membaca fail itu secara terus.

Penyelesaiannya mudah: hantarkan nama fail secara terus kepada perintah yang memahami fail. Ini dipanggil hala semula input apabila alat itu tidak menerima nama fail, atau sekadar menggugurkan cat apabila alat itu menerimanya.

Lambat: cat file | grep pattern — 2 proses, 1 saluran paip
Pantas: grep pattern file — 1 proses, tiada saluran paip
Juga pantas: grep pattern < file — 1 proses, hala semula stdin (tiada penimbal saluran paip)

#!/usr/bin/env bash
# Create a sample file
seq 1 10000 > /tmp/numbers.txt

# --- Slow: useless cat ---
time cat /tmp/numbers.txt | grep -c "^5"

# --- Fast: grep reads the file directly ---
time grep -c "^5" /tmp/numbers.txt

# Both print the same count; the second is measurably faster
# because it skips the cat process and the inter-process pipe.

Menggantikan Perintah Luaran dengan Binaan Shell

Banyak transformasi satu baris mempunyai padanan binaan yang mengelakkan percabangan sepenuhnya. Bandingkan penggantian biasa berikut:

echo ${#var} dan bukannya echo "$var" | wc -c — panjang rentetan
${var^^} dan ${var,,} dan bukannya echo "$var" | tr 'a-z' 'A-Z' — penukaran huruf besar dan kecil (bash 4+)
${var//search/replace} dan bukannya echo "$var" | sed 's/search/replace/' — penggantian mudah
[[ "$var" =~ pattern ]] dan bukannya echo "$var" | grep -q pattern — padanan ungkapan nalar
read -r line < file dan bukannya line=$(head -n1 file) — membaca baris pertama

Tiada satu pun binaan ini yang mencabangkan proses anak. Penjimatan bagi setiap panggilan adalah kecil, tetapi terkumpul dengan ketara dalam gelung.

#!/usr/bin/env bash
sentence="hello world from bash"

# --- Fork-heavy ---
upper_slow=$(echo "$sentence" | tr 'a-z' 'A-Z')
length_slow=$(echo "$sentence" | wc -c)

# --- Builtin equivalents (zero extra processes) ---
upper_fast=${sentence^^}
length_fast=${#sentence}

echo "Slow upper : $upper_slow"
echo "Fast upper : $upper_fast"
echo "Slow length: $length_slow"
echo "Fast length: $length_fast"

Mengelakkan Subshell dalam Gelung

Penggantian perintah dalam gelung menggandakan kos percabangan mengikut bilangan lelaran. Gelung yang berjalan 500 kali dengan satu panggilan $(date) memulakan 500 proses anak hanya untuk mendapatkan cap masa.

Strategi untuk mengurangkan overhed gelung:

Alihkan perintah tak berubah ke luar gelung (kira sekali, guna semula)
Utamakan pengembangan aritmetik $(( expr )) — ia ialah binaan, bukannya percabangan
Gunakan printf dan bukannya memanggil date apabila hanya pemformatan diperlukan
Kelompokkan panggilan luaran: kumpulkan data dahulu, kemudian proses sekali di luar gelung

#!/usr/bin/env bash
# Demonstrate: compute-once vs fork-per-iteration

# Bad: $(date) forks 1000 times
time (
  for i in $(seq 1 1000); do
    ts=$(date +%s)   # fork each iteration
    echo "$i $ts" > /dev/null
  done
)

# Good: capture once, reuse
time (
  ts=$(date +%s)   # fork exactly once
  for i in $(seq 1 1000); do
    echo "$i $ts" > /dev/null
  done
)

Subshell Saluran Paip dan Perangkap Skop Pemboleh Ubah

Dalam bash (tidak seperti ksh/zsh), setiap perintah dalam saluran paip berjalan dalam subshellnya sendiri. Ini bermaksud pemboleh ubah yang ditetapkan di dalam saluran paip akan hilang selepas saluran paip selesai.

Ini ialah pepijat ketepatan dan juga isu prestasi — anda mungkin menyalurkan data kepada while read dengan harapan dapat mengumpulkannya, tetapi mendapati pemboleh ubah itu kosong selepas itu.

Dua penyelesaian:

Gunakan penggantian proses while read line; do ...; done < <(command) — gelung while berjalan dalam shell semasa, bukan subshell
Gunakan pilihan lastpipe (shopt -s lastpipe) — menjadikan segmen saluran paip terakhir berjalan dalam shell semasa (bash 4.2+)

#!/usr/bin/env bash
count=0

# --- Bug: count is always 0 after pipe (subshell) ---
seq 1 5 | while read -r n; do
  (( count++ ))
done
echo "After pipe   : count=$count"   # prints 0

# --- Fix 1: process substitution (no subshell for while) ---
count=0
while read -r n; do
  (( count++ ))
done < <(seq 1 5)
echo "Process sub  : count=$count"   # prints 5

# --- Fix 2: lastpipe option ---
shopt -s lastpipe
count=0
seq 1 5 | while read -r n; do
  (( count++ ))
done
echo "lastpipe     : count=$count"   # prints 5

Mengukur Kos Subshell dengan Penanda Aras Mikro

Mudah untuk membuktikan overhed subshell dengan penanda aras kecil. Bandingkan operasi aritmetik yang dilakukan melalui $(( )) (binaan) dengan operasi yang sama disalurkan melalui expr (proses luaran).

Keputusan pada komputer Linux biasa menunjukkan bahawa 10,000 panggilan kepada expr mengambil kira-kira 5 saat, manakala bilangan panggilan $(( )) yang sama mengambil masa kurang daripada 0.1 saat — perbezaan 50x untuk output yang sama.

Corak penanda aras ini juga berguna apabila anda ingin mengukur apa-apa pengoptimuman: jalankan kedua-dua versi sebanyak N kali dalam gelung dan bandingkan dengan time.

#!/usr/bin/env bash
N=500

# External command (fork per call)
time (
  x=0
  for ((i=0; i<N; i++)); do
    x=$(expr $x + 1)   # forks expr each time
  done
  echo "expr result: $x"
)

# Arithmetic builtin (no fork)
time (
  x=0
  for ((i=0; i<N; i++)); do
    (( x++ ))          # pure builtin
  done
  echo "builtin result: $x"
)

Menggunakan Rentetan di Sini untuk Mengelakkan Saluran Paip echo

Corak biasa ialah echo "$var" | command untuk menghantar pemboleh ubah sebagai stdin. Ini mencabangkan dua proses (echo + command) dan mencipta saluran paip. Rentetan di sini (<<<) mencapai hasil yang sama dengan hanya satu proses — perintah luaran membaca daripada penimbal sementara yang diurus kernel.

grep pattern <<< "$var" — satu proses, tiada saluran paip
read -r field1 field2 <<< "$line" — memisahkan pemboleh ubah tanpa alat luaran
wc -w <<< "$sentence" — kiraan perkataan daripada pemboleh ubah

Rentetan di sini amat bernilai dalam gelung yang ketat, apabila setiap percabangan penting.

#!/usr/bin/env bash
data="The quick brown fox"

# --- Fork-heavy: echo spawns a child ---
word_count_slow=$(echo "$data" | wc -w)
echo "Slow word count: $word_count_slow"

# --- Fast: here-string, only wc spawns ---
word_count_fast=$(wc -w <<< "$data")
echo "Fast word count: $word_count_fast"

# --- Even better: use parameter expansion (zero forks) ---
# Split into array, count elements
read -ra words <<< "$data"
echo "Zero-fork count: ${#words[@]}"

Pemfaktoran Semula Praktikal: Sebelum dan Selepas

Mari kita teliti skrip realistik yang memproses fail log dan gunakan semua yang telah dipelajari. Versi asal merangkaikan cat, grep, awk dan tr dengan saluran paip. Versi yang difaktorkan semula mengurangkan bilangan proses daripada 8 kepada 2.

Perubahan utama yang dibuat:

Menggugurkan cat — grep membaca fail secara terus
Menggantikan tr '[:lower:]' '[:upper:]' dengan ${var^^}
Menggantikan echo "$line" | grep -q dengan [[ $line =~ ]]
Menggunakan read -r dengan penggantian proses dan bukannya gelung while bersaluran paip

Selepas pemfaktoran semula, jalankan time ./script.sh sekali lagi untuk mengesahkan peningkatan. Sentiasa ukur — jangan membuat andaian.

#!/usr/bin/env bash
# Create a sample log
printf 'ERROR: disk full\nINFO: started\nERROR: timeout\nINFO: done\n' \
  > /tmp/sample.log

# === BEFORE (fork-heavy) ===
time (
  cat /tmp/sample.log \
    | grep 'ERROR' \
    | while read -r line; do
        label=$(echo "$line" | tr '[:lower:]' '[:upper:]')
        echo "[ALERT] $label"
      done
)

# === AFTER (builtin-first) ===
time (
  while IFS= read -r line; do
    echo "[ALERT] ${line^^}"
  done < <(grep 'ERROR' /tmp/sample.log)
)

Semakan Pengetahuan: Skop Subcangkerang

Uji pemahaman Anda tentang subcangkerang saluran paip dan cara mengelakkan perubahan pemboleh ubah yang dibuat di dalam saluran paip daripada hilang.

Jawab dalam pelajaran interaktif

Rumusan Pelajaran: Profil Dahulu, Kurangkan Fork

Dalam pelajaran ini, Anda telah mempelajari cara mengenal pasti dan menghapuskan sumber penciptaan proses yang tidak diperlukan dan paling lazim dalam skrip bash.

Inti pati utama:

Gunakan time dan bash -x yang diperkaya dengan PS4 untuk membuat pengukuran sebelum mengoptimumkan
cat yang tidak berguna ialah antipola yang paling meluas — hantarkan nama fail terus kepada arahan yang menerimanya
Gantikan echo "$var" | command dengan rentetan di sini (command <<< "$var") atau fungsi terbina dalam
Pengembangan parameter (${var^^}, ${var//s/r}, ${#var}) menggantikan banyak panggilan tr, sed dan wc
Subcangkerang saluran paip menelan perubahan pemboleh ubah — gunakan penggantian proses atau shopt -s lastpipe
Alihkan panggilan arahan yang tidak berubah ke luar gelung; utamakan aritmetik $(( )) berbanding expr

Peraturan praktikalnya: buat pengukuran dahulu, gantikan arahan luaran dengan fungsi terbina dalam jika boleh, kemudian sahkan peningkatan itu dengan pengukuran kedua.

Percuma untuk bermula

Pelajari Bash dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 22
Pelajaran: 88

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Menganalisis Prestasi Skrip dan Mengelakkan Subcangkerang Tidak Berguna” percuma?