0Pricing
Linux Command Line & Bash Scripting Mastery · Pelajaran

Mengurai Bendera dan Argumen dengan getopts

Implementasikan antarmuka baris perintah profesional menggunakan getopts untuk opsi singkat, argumen wajib, dan pesan penggunaan.

Mengurai Bendera dan Argumen dengan getopts adalah pelajaran Linux Command Line & Bash Scripting Mastery gratis di CoddyKit. Ini adalah pelajaran 3 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Linux Command Line & Bash Scripting Mastery, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Linux Command Line & Bash Scripting Mastery mencakup 4 pelajaran total.

Mengapa getopts Ada

Setiap skrip di dunia nyata pada akhirnya perlu menerima opsi seperti -v, -o output.txt, atau -n 5. Menguraikannya secara manual dengan $1, $2… akan cepat menjadi rapuh.

getopts adalah perintah bawaan berstandar POSIX yang menangani opsi pendek (-a, -b) dengan andal, termasuk opsi yang menerima argumen. Perintah ini sudah tersedia di setiap shell POSIX, sehingga tidak diperlukan dependensi.

  • Menangani tanda gabungan: -vn 5 = -v -n 5
  • Melaporkan opsi yang tidak dikenal dengan baik
  • Mengatur variabel standar OPTIND dan OPTARG secara otomatis

Dalam pelajaran ini, Anda akan membangun CLI lengkap dan profesional dari awal menggunakan getopts.

Sintaks getopts

Sintaks intinya adalah perulangan while yang memanggil getopts pada setiap iterasi:

while getopts "optstring" varname; do
  case "$varname" in
    ...
  esac
done
  • optstring — string yang mencantumkan setiap huruf opsi yang diterima. Titik dua setelah sebuah huruf berarti opsi tersebut memerlukan argumen.
  • varname — menerima huruf opsi saat ini pada setiap iterasi.
  • OPTARG — otomatis diatur ke nilai argumen ketika titik dua mengikuti huruf tersebut.
  • OPTIND — indeks argumen berikutnya yang akan diproses; gunakan shift $((OPTIND - 1)) setelah perulangan untuk menampilkan parameter posisi yang tersisa.
#!/usr/bin/env bash
# Minimal skeleton — shows the loop structure
while getopts 'vn:' opt; do
  case "$opt" in
    v) echo "Verbose mode on" ;;
    n) echo "Count = $OPTARG" ;;
    ?) echo "Unknown option: -$OPTARG" >&2; exit 1 ;;
  esac
done

Mendefinisikan Optstring

optstring adalah deklarasi ringkas kontrak CLI Anda. Setiap karakter mewakili satu tanda yang diterima.

  • 'abc' — menerima -a, -b, -c (tanpa argumen)
  • 'a:bc' — -a memerlukan argumen; -b dan -c tidak memerlukannya
  • ':abc' — titik dua di awal mengaktifkan mode kesalahan senyap (skrip Anda menangani opsi yang salah, bukan shell yang mencetak pesan)

Mode senyap lebih disukai dalam skrip produksi karena memberi Anda kendali penuh atas pesan kesalahan dan kode keluar.

#!/usr/bin/env bash
# optstring ':o:vq'
# -o  requires an argument (output file)
# -v  verbose flag (no argument)
# -q  quiet flag  (no argument)
# Leading ':' = silent error mode

while getopts ':o:vq' opt; do
  case "$opt" in
    o) OUTPUT="$OPTARG" ;;
    v) VERBOSE=1 ;;
    q) QUIET=1 ;;
    :) echo "Error: -$OPTARG requires an argument" >&2; exit 1 ;;
    \?) echo "Error: unknown option -$OPTARG" >&2; exit 1 ;;
  esac
done
echo "OUTPUT=$OUTPUT  VERBOSE=$VERBOSE  QUIET=$QUIET"

OPTARG dan Argumen yang Diperlukan

Ketika sebuah tanda diikuti titik dua dalam optstring, getopts menyimpan nilainya di OPTARG. Pengguna dapat menulis argumen dengan atau tanpa spasi:

  • -o report.txt
  • -oreport.txt

Kedua bentuk tersebut diuraikan dengan cara yang sama. Ini adalah salah satu keunggulan utama dibandingkan penguraian manual dengan $1/shift.

Dalam mode senyap (optstring diawali ':'), argumen yang hilang menyebabkan getopts mengatur varname menjadi : dan OPTARG menjadi huruf opsi—sempurna untuk pesan kesalahan yang terarah.

#!/usr/bin/env bash
# Demonstrate OPTARG with a file-processing script

while getopts ':i:o:' opt; do
  case "$opt" in
    i) INPUT="$OPTARG" ;;
    o) OUTPUT="$OPTARG" ;;
    :) echo "Error: option -$OPTARG needs a value" >&2; exit 1 ;;
    \?) echo "Error: unknown flag -$OPTARG" >&2; exit 1 ;;
  esac
done

echo "Input  : ${INPUT:-<not set>}"
echo "Output : ${OUTPUT:-<not set>}"

Melewati Opsi dengan OPTIND

Setelah getopts selesai, OPTIND berisi indeks argumen pertama yang bukan opsi. Gunakan shift untuk menghapus semua opsi yang telah diproses sehingga $1, $2… merujuk pada parameter posisi yang tersisa (misalnya, nama berkas).

Idiomnya selalu:

shift $((OPTIND - 1))

Setelah pergeseran, $@ hanya berisi argumen yang bukan tanda—operand perintah Anda.

#!/usr/bin/env bash
# Shows OPTIND shift and leftover positional args

VERBOSE=0
while getopts ':vn:' opt; do
  case "$opt" in
    v) VERBOSE=1 ;;
    n) COUNT="$OPTARG" ;;
    :) echo "Error: -$OPTARG requires an argument" >&2; exit 1 ;;
    \?) echo "Error: unknown option -$OPTARG" >&2; exit 1 ;;
  esac
done
shift $((OPTIND - 1))

echo "VERBOSE=$VERBOSE  COUNT=${COUNT:-1}"
echo "Remaining args: $*"

Menulis Fungsi Usage

Skrip profesional selalu menyediakan fungsi usage() yang mencetak pesan bantuan dan keluar. Konvensinya adalah:

  • Cetak ke stderr (fd 2) agar tidak mengotori keluaran yang dialirkan melalui pipeline
  • Keluar dengan kode 0 untuk -h / --help, dan dengan kode 1 untuk penggunaan yang tidak valid
  • Panggil usage 1 dari jalur kesalahan dan usage 0 dari penangan -h
#!/usr/bin/env bash

usage() {
  cat >&2 <<EOF
Usage: $(basename "$0") [-v] [-n COUNT] [-o FILE] [FILE...]

Options:
  -v          Verbose output
  -n COUNT    Repeat COUNT times (default: 1)
  -o FILE     Write output to FILE
  -h          Show this help
EOF
  exit "${1:-0}"
}

while getopts ':vn:o:h' opt; do
  case "$opt" in
    v) VERBOSE=1 ;;
    n) COUNT="$OPTARG" ;;
    o) OUTFILE="$OPTARG" ;;
    h) usage 0 ;;
    :) echo "Error: -$OPTARG requires a value" >&2; usage 1 ;;
    \?) echo "Error: unknown option -$OPTARG" >&2; usage 1 ;;
  esac
done
shift $((OPTIND - 1))
echo "Parsed OK — verbose=${VERBOSE:-0} count=${COUNT:-1} out=${OUTFILE:--}"

Nilai Bawaan dan Validasi

Setelah penguraian, validasi dan tetapkan nilai bawaan sebelum melakukan pekerjaan sebenarnya. Pisahkan fase penguraian (perulangan) dari fase logika. Dengan demikian, kedua bagian lebih mudah dibaca dan diuji.

  • Gunakan ${VAR:-default} untuk nilai bawaan sebaris
  • Validasi argumen numerik dengan regex atau pemeriksaan aritmetika
  • Validasi bahwa opsi yang diperlukan benar-benar telah diberikan
#!/usr/bin/env bash

usage() { echo "Usage: $(basename "$0") -n COUNT [-v]" >&2; exit 1; }

VERBOSE=0
COUNT=''

while getopts ':n:v' opt; do
  case "$opt" in
    n) COUNT="$OPTARG" ;;
    v) VERBOSE=1 ;;
    :) echo "Error: -$OPTARG needs a value" >&2; usage ;;
    \?) echo "Error: -$OPTARG unknown" >&2; usage ;;
  esac
done
shift $((OPTIND - 1))

# Validation phase
[[ -z "$COUNT" ]] && { echo "Error: -n COUNT is required" >&2; usage; }
[[ "$COUNT" =~ ^[0-9]+$ ]] || { echo "Error: COUNT must be a positive integer" >&2; usage; }

for (( i=1; i<=COUNT; i++ )); do
  [[ $VERBOSE -eq 1 ]] && echo "Iteration $i of $COUNT"
  echo "Hello, world!"
done

Menggabungkan Tanda pada Baris Perintah

getopts secara otomatis menangani tanda pendek gabungan yang ditulis tanpa spasi, sesuai konvensi Unix:

  • -v -q setara dengan -vq
  • -n 5 -v setara dengan -n5 -v atau -vn5

Anda tidak perlu menulis kode tambahan untuk mendukungnya—getopts secara otomatis mengiterasi setiap karakter dari string opsi gabungan. Ini adalah alasan penting lainnya untuk menggunakan getopts, bukan penguraian manual.

#!/usr/bin/env bash
# Test combined flag parsing
# Run as:  bash script.sh -vq -n3

VERBOSE=0; QUIET=0; COUNT=1

while getopts ':vqn:' opt; do
  case "$opt" in
    v) VERBOSE=1 ;;
    q) QUIET=1 ;;
    n) COUNT="$OPTARG" ;;
    :) echo "Error: -$OPTARG needs value" >&2; exit 1 ;;
    \?) echo "Error: unknown -$OPTARG" >&2; exit 1 ;;
  esac
done
shift $((OPTIND - 1))

echo "verbose=$VERBOSE quiet=$QUIET count=$COUNT"

Menangani Pemisah Tanda Hubung Ganda

Perintah Unix menerima -- (tanda hubung ganda) sebagai sinyal eksplisit bahwa pemrosesan opsi harus berhenti. Semua hal setelah -- diperlakukan sebagai argumen posisi, meskipun tampak seperti tanda.

getopts berhenti secara otomatis ketika menemukan --. Setelah shift $((OPTIND - 1)), tanda hubung ganda tersebut hilang dan $@ hanya berisi operand.

Hal ini penting bagi skrip yang bekerja pada nama berkas yang dapat diawali tanda hubung, misalnya:

myscript.sh -v -- -strangefile.txt
#!/usr/bin/env bash
# Demonstrate -- separator
# Run as:  bash script.sh -v -- file1.txt -oddname.txt

VERBOSE=0
while getopts ':v' opt; do
  case "$opt" in
    v) VERBOSE=1 ;;
    \?) echo "Unknown option -$OPTARG" >&2; exit 1 ;;
  esac
done
shift $((OPTIND - 1))   # removes -v and the '--' separator

echo "Verbose: $VERBOSE"
echo "Files to process:"
for f in "$@"; do
  echo "  -> $f"
done

Membungkus getopts dalam Fungsi Pustaka

Dalam skrip modular, Anda dapat merangkum getopts di dalam fungsi parse_args() yang menetapkan variabel global (atau variabel nameref). Ini menjaga main() tetap bersih dan memungkinkan Anda memuat sumber pengurai dari skrip lain.

Aturan utama untuk pola ini:

  • Deklarasikan variabel opsi sebelum memanggil fungsi
  • Gunakan variabel global atau teruskan nilai melalui nameref (declare -n)
  • Kembalikan kode keluar bukan nol untuk masukan yang salah agar main dapat merespons
#!/usr/bin/env bash

# Global option variables
VERBOSE=0; OUTPUT=''; COUNT=1

parse_args() {
  local opt
  while getopts ':vn:o:h' opt; do
    case "$opt" in
      v) VERBOSE=1 ;;
      n) COUNT="$OPTARG" ;;
      o) OUTPUT="$OPTARG" ;;
      h) echo "Usage: $(basename "$0") [-v] [-n N] [-o FILE]"; exit 0 ;;
      :) echo "Error: -$OPTARG needs a value" >&2; return 1 ;;
      \?) echo "Error: unknown option -$OPTARG" >&2; return 1 ;;
    esac
  done
  shift $((OPTIND - 1))
  ARGS=("$@")   # leftover positional args stored in array
}

main() {
  parse_args "$@" || exit 1
  echo "verbose=$VERBOSE count=$COUNT output=${OUTPUT:--} args=${ARGS[*]}"
}

main "$@"

Contoh Lengkap di Dunia Nyata: Pengarsip Log

Berikut skrip lengkap di dunia nyata yang menggunakan semua hal yang dibahas dalam pelajaran ini: optstring dengan argumen yang diperlukan, mode kesalahan senyap, fungsi usage, nilai bawaan, validasi, dan pergeseran OPTIND.

Pelajari strukturnya—inilah templat yang harus Anda ikuti dalam setiap skrip yang Anda tulis dan memerlukan antarmuka CLI.

#!/usr/bin/env bash
# archive_logs.sh — compress and move logs older than N days

set -euo pipefail

DESTDIR='/tmp/log_archive'
DAYS=30
VERBOSE=0

usage() {
  cat >&2 <<EOF
Usage: $(basename "$0") [-v] [-d DAYS] [-o DIR] SOURCE_DIR

  -d DAYS   Archive logs older than DAYS (default: 30)
  -o DIR    Destination directory (default: /tmp/log_archive)
  -v        Verbose output
  -h        Show this help
EOF
  exit "${1:-0}"
}

while getopts ':d:o:vh' opt; do
  case "$opt" in
    d) DAYS="$OPTARG" ;;
    o) DESTDIR="$OPTARG" ;;
    v) VERBOSE=1 ;;
    h) usage 0 ;;
    :) echo "Error: -$OPTARG requires a value" >&2; usage 1 ;;
    \?) echo "Error: unknown option -$OPTARG" >&2; usage 1 ;;
  esac
done
shift $((OPTIND - 1))

# Validation
[[ $# -lt 1 ]] && { echo "Error: SOURCE_DIR is required" >&2; usage 1; }
[[ "$DAYS" =~ ^[0-9]+$ ]] || { echo "Error: DAYS must be numeric" >&2; exit 1; }
SOURCE="$1"
[[ -d "$SOURCE" ]] || { echo "Error: '$SOURCE' is not a directory" >&2; exit 1; }

mkdir -p "$DESTDIR"
[[ $VERBOSE -eq 1 ]] && echo "Archiving logs older than $DAYS days from $SOURCE to $DESTDIR"

find "$SOURCE" -name '*.log' -mtime "+$DAYS" -print | while read -r f; do
  gzip -c "$f" > "$DESTDIR/$(basename "$f").gz"
  [[ $VERBOSE -eq 1 ]] && echo "  archived: $f"
done

echo "Done."

Pemeriksaan Singkat: Optstring getopts

Baca pemanggilan getopts berikut dan pilih uraian yang benar tentang perilakunya:

while getopts ':f:vq' opt; do

Rangkuman Pelajaran: Menguasai getopts

Anda telah mempelajari cara membangun antarmuka baris perintah profesional dalam Bash menggunakan getopts. Berikut rangkuman poin-poin pentingnya:

  • Sintaks optstring — huruf tanpa titik dua adalah tanda boolean; titik dua setelah huruf berarti opsi tersebut memerlukan argumen; titik dua di awal mengaktifkan mode kesalahan senyap.
  • OPTARG — otomatis menyimpan nilai argumen untuk opsi yang memerlukannya.
  • OPTIND — gunakan shift $((OPTIND - 1)) setelah perulangan untuk menampilkan parameter posisi yang tersisa dalam $@.
  • Mode kesalahan senyap — lebih disukai dalam produksi; tangani sendiri kasus : (argumen hilang) dan \? (opsi tidak dikenal) agar memiliki kendali penuh.
  • Fungsi usage() — selalu tulis fungsi ini; cetak ke stderr, keluar dengan 0 untuk -h, dan keluar dengan 1 untuk kesalahan.
  • Tanda gabungan — getopts menangani -vq dan -n5 secara otomatis tanpa kode tambahan.
  • Pola modular — bungkus getopts dalam fungsi parse_args() untuk skrip yang bersih dan dapat digunakan kembali.

Menguasai getopts mengubah skrip Anda dari alat dengan satu tujuan menjadi program CLI yang andal dan mudah digunakan, serta mengikuti konvensi Unix.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Mengurai Bendera dan Argumen dengan getopts” gratis?

Ya — teks lengkap “Mengurai Bendera dan Argumen dengan getopts” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Linux Command Line & Bash Scripting Mastery, upgrade ke CoddyKit PRO. Kursus Linux Command Line & Bash Scripting Mastery mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Mengurai Bendera dan Argumen dengan getopts”?

Implementasikan antarmuka baris perintah profesional menggunakan getopts untuk opsi singkat, argumen wajib, dan pesan penggunaan. Kamu berlatih Linux Command Line & Bash Scripting Mastery dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Linux Command Line & Bash Scripting Mastery?

Tidak diperlukan pengalaman sebelumnya. Linux Command Line & Bash Scripting Mastery di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 3 dari 4.

Berapa lama pelajaran “Mengurai Bendera dan Argumen dengan getopts” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Linux Command Line & Bash Scripting Mastery ini?

Ya. Setiap pelajaran Linux Command Line & Bash Scripting Mastery menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

  1. Merancang Fungsi dengan Lingkup Lokal dan Kode Kembalian
  2. Membangun dan Memuat Pustaka Bash yang Dapat Digunakan Ulang
  3. Mengurai Bendera dan Argumen dengan getopts
  4. Meneruskan Larik dan Peta Asosiatif antar Fungsi
← Kembali ke Linux Command Line & Bash Scripting Mastery