Linux Command Line & Bash Scripting Mastery · Ders

getopts ile Bayrakları ve Bağımsız Değişkenleri Ayrıştırma

Kısa seçenekler, zorunlu bağımsız değişkenler ve kullanım iletileri için getopts kullanarak profesyonel komut satırı arayüzleri uygulayın.

3. ders / 413 adım

getopts ile Bayrakları ve Bağımsız Değişkenleri Ayrıştırma, CoddyKit'te ücretsiz bir Linux Command Line & Bash Scripting Mastery dersidir. Bu, 4 dersinin 3. dersidir. Aşağıdan dersin tamamını ücretsiz okuyabilir, sonra tarayıcıda yerleşik kod editörü ve 7/24 yapay zeka koçu ile uygulamalı olarak pratik yapabilirsin. Bu, Linux Command Line & Bash Scripting Mastery öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. Linux Command Line & Bash Scripting Mastery kursu toplamda 4 dersten oluşur.

getopts Neden Var

Gerçek dünyadaki her betiğin er ya da geç -v, -o output.txt veya -n 5 gibi seçenekleri kabul etmesi gerekir. Bunları $1, $2… ile elle ayrıştırmak kısa sürede kırılgan hâle gelir.

getopts, kısa seçenekleri (-a, -b) (bağımsız değişken alan seçenekler de dâhil) güvenilir biçimde işleyen, POSIX standardındaki yerleşik komuttur. Her POSIX kabuğunda yerleşik olduğundan bağımlılık gerektirmez.

Birleştirilmiş bayrakları işler: -vn 5 = -v -n 5
Bilinmeyen seçenekleri uygun biçimde bildirir
Standart OPTIND ve OPTARG değişkenlerini otomatik olarak ayarlar

Bu derste sıfırdan eksiksiz ve profesyonel bir CLI oluşturacaksınız.

getopts Sözdizimi

Temel sözdizimi, her yinelemede getopts çağıran bir while döngüsüdür:

while getopts "optstring" varname; do
  case "$varname" in
    ...
  esac
done

seçenek dizesi — kabul edilen her seçenek harfini listeleyen bir dizedir. Bir harften sonra gelen iki nokta, o seçeneğin bir bağımsız değişken gerektirdiği anlamına gelir.
değişken adı — her yinelemede mevcut seçenek harfini alır.
OPTARG — harften sonra iki nokta geldiğinde bağımsız değişken değerine otomatik olarak ayarlanır.
OPTIND — işlenecek sonraki bağımsız değişkenin dizinidir; kalan konumsal parametreleri görünür hâle getirmek için döngüden sonra shift $((OPTIND - 1)) ile kaydırın.

#!/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

Bir Seçenek Dizisi Tanımlama

Seçenek dizisi, CLI sözleşmenizin kısa bir bildirimidir. Her karakter, kabul edilen bir bayrağı temsil eder.

'abc' — -a, -b, -c seçeneklerini kabul eder (bağımsız değişken yok)
'a:bc' — -a bir bağımsız değişken gerektirir; -b ve -c gerektirmez
':abc' — baştaki iki nokta sessiz hata kipini etkinleştirir (kabuğun ileti yazdırması yerine hatalı seçenekleri betiğiniz işler)

Sessiz kip, hata iletileri ve çıkış kodları üzerinde tam denetim sağladığı için üretim betiklerinde tercih edilir.

#!/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 ve Gerekli Bağımsız Değişkenler

Bir bayrağın seçenek dizisinde ardından iki nokta geliyorsa getopts, değerini OPTARG içinde saklar. Kullanıcı bağımsız değişkeni araya boşluk koyarak veya koymadan yazabilir:

-o report.txt
-oreport.txt

Her iki biçim de aynı şekilde ayrıştırılır. Bu, elle yapılan $1/shift ayrıştırmasına göre temel avantajlardan biridir.

Sessiz kipte (seçenek dizisinin başındaki ':'), eksik bir bağımsız değişken getopts'in varname değerini : ve OPTARG değerini seçenek harfi olarak ayarlamasına neden olur; bu, hedefe yönelik bir hata iletisi için idealdir.

#!/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>}"

OPTIND ile Seçenekleri Geride Bırakma

getopts tamamlandığında OPTIND, seçenek olmayan ilk bağımsız değişkenin dizinini tutar. İşlenmiş tüm seçenekleri kaldırmak için shift kullanın; böylece $1, $2… kalan konumsal parametreleri (örneğin dosya adlarını) gösterir.

Kullanılması gereken kalıp her zaman şöyledir:

shift $((OPTIND - 1))

Kaydırmadan sonra $@ yalnızca bayrak olmayan bağımsız değişkenleri, yani komutunuzun işlenenlerini içerir.

#!/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: $*"

Bir Kullanım İşlevi Yazma

Profesyonel bir betik her zaman bir yardım iletisi yazdırıp çıkan bir usage() işlevi sağlar. Kural şöyledir:

Yönlendirilmiş çıktıyı kirletmemesi için stderr (fd 2) üzerine yazdırın
-h / --help için 0 koduyla, geçersiz kullanım için 1 koduyla çıkın
Hata yollarında usage 1, -h işleyicisinde usage 0 çağırın

#!/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:--}"

Varsayılan Değerler ve Doğrulama

Ayrıştırmadan sonra gerçek bir iş yapmadan önce doğrulama yapın ve varsayılanları ayarlayın. Ayrıştırma aşamasını (döngüyü) mantık aşamasından ayrı tutun. Bu, her iki bölümün okunmasını ve sınanmasını kolaylaştırır.

Satır içi varsayılanlar için ${VAR:-default} kullanın
Sayısal bağımsız değişkenleri bir düzenli ifadeyle veya aritmetik denetimle doğrulayın
Gerekli seçeneklerin gerçekten sağlandığını doğrulayın

#!/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

Komut Satırında Bayrakları Birleştirme

getopts, boşluk olmadan yazılan birleştirilmiş kısa bayrakları standart Unix kuralına uygun olarak otomatik biçimde işler:

-v -q, -vq ile eşdeğerdir
-n 5 -v, -n5 -v veya -vn5 ile eşdeğerdir

Bunu desteklemek için ek kod yazmanız gerekmez; getopts, birleştirilmiş seçenek dizesindeki her karakteri otomatik olarak yineler. Elle ayrıştırma yerine getopts kullanmanın bir diğer önemli nedeni de budur.

#!/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"

Çift Tire Ayırıcısını İşleme

Unix komutları, seçenek işleme sürecinin durması gerektiğini açıkça belirtmek için -- (çift tire) kabul eder. -- sonrasındaki her şey, bayrak gibi görünse bile konumsal bağımsız değişken olarak ele alınır.

getopts, -- ile karşılaştığında otomatik olarak durur. shift $((OPTIND - 1)) sonrasında çift tire ortadan kalkar ve $@ yalnızca işlenenleri içerir.

Bu, tireyle başlayabilecek dosya adları üzerinde işlem yapan betikler için önemlidir; örneğin:

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

getopts'i Bir Kitaplık İşlevine Sarmalama

Modüler betiklerde getopts'i, genel (veya nameref) değişkenleri ayarlayan bir parse_args() işlevinin içine alabilirsiniz. Bu, main() işlevini temiz tutar ve ayrıştırıcıyı başka betiklerden kaynak olarak yüklemenize olanak tanır.

Bu kalıp için temel kurallar:

İşlevi çağırmadan önce seçenek değişkenlerini bildirin
global değişkenleri kullanın veya değerleri nameref (declare -n) aracılığıyla aktarın
Hatalı girdide sıfır olmayan bir çıkış kodu döndürün; böylece main tepki verebilir

#!/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 "$@"

Tam Gerçek Dünya Örneği: Bir Günlük Arşivleyici

Bu derste ele alınan her şeyi kullanan eksiksiz, gerçek dünyaya uygun bir betik aşağıda verilmiştir: gerekli bağımsız değişkenlere sahip seçenek dizisi, sessiz hata kipi, kullanım işlevi, varsayılan değerler, doğrulama ve OPTIND kaydırması.

Yapıyı inceleyin; CLI arayüzüne ihtiyaç duyan yazdığınız her betikte izlemeniz gereken şablon budur.

#!/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."

Hızlı Kontrol: getopts Seçenek Dizisi

Aşağıdaki getopts çağrısını okuyun ve davranışının doğru açıklamasını seçin:

while getopts ':f:vq' opt; do

İnteraktif derste cevapla

Ders Özeti: getopts Ustalığı

getopts kullanarak Bash'te profesyonel komut satırı arayüzleri oluşturmayı öğrendiniz. Temel noktaların özeti şöyledir:

Seçenek dizisi sözdizimi — iki nokta içermeyen harfler mantıksal bayraklardır; bir harften sonra gelen iki nokta, o harfin bir bağımsız değişken gerektirdiği anlamına gelir; baştaki iki nokta sessiz hata kipini etkinleştirir.
OPTARG — bağımsız değişken gerektiren seçeneklerin değerini otomatik olarak tutar.
OPTIND — döngüden sonra shift $((OPTIND - 1)) kullanarak kalan konumsal parametreleri $@ içinde görünür hâle getirin.
Sessiz hata kipi — üretimde tercih edilir; tam denetim için : (eksik bağımsız değişken) ve \? (bilinmeyen seçenek) durumlarını kendiniz işleyin.
usage() işlevi — her zaman yazın; stderr üzerine yazdırın, -h için 0, hatalar için 1 koduyla çıkın.
Birleştirilmiş bayraklar — getopts, ek kod gerektirmeden -vq ve -n5 seçeneklerini otomatik olarak işler.
Modüler kalıp — temiz ve yeniden kullanılabilir betikler için getopts'i bir parse_args() işlevinin içine alın.

getopts'te ustalaşmak, betiklerinizi tek amaçlı araçlardan Unix kurallarını izleyen güvenilir ve kullanıcı dostu CLI programlarına dönüştürür.

Başlamak ücretsiz

Yapay zeka eğitmeniyle Bash öğren — ücretsiz

Tarayıcında gerçek kod yaz ve çalıştır, 7/24 yapay zeka eğitmeninden anında yardım al; web'de ya da uygulamada kaldığın yerden devam et.

Kurslar: 22
Dersler: 88

Ücretsiz öğrenmeye başla Tüm kursu görüntüle

Sıkça Sorulan Sorular

“getopts ile Bayrakları ve Bağımsız Değişkenleri Ayrıştırma” dersi ücretsiz mi?

Evet — “getopts ile Bayrakları ve Bağımsız Değişkenleri Ayrıştırma” dersin tüm metni burada web'de ücretsiz olarak okunabilir. Etkileşimli olarak pratik yapmak (yerleşik kod editörü ve 7/24 yapay zeka koçu) ve Linux Command Line & Bash Scripting Mastery kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. Linux Command Line & Bash Scripting Mastery kursu toplamda 4 dersten oluşur.

“getopts ile Bayrakları ve Bağımsız Değişkenleri Ayrıştırma” dersinde ne öğreneceğim?

Kısa seçenekler, zorunlu bağımsız değişkenler ve kullanım iletileri için getopts kullanarak profesyonel komut satırı arayüzleri uygulayın. Linux Command Line & Bash Scripting Mastery ile uygulamalı kodu tarayıcıda doğrudan çalıştırarak pratik yaparsın ve 7/24 yapay zeka koçu dersi çalışırken sorularını yanıtlar.

Linux Command Line & Bash Scripting Mastery öğrenmeye başlamak için deneyim gerekli mi?

Önceden deneyim gerekmez. CoddyKit'te Linux Command Line & Bash Scripting Mastery, başlangıçtan ileri seviyeye kadar yapılandırıldığı için buradan başlayabilir veya başından başlayıp kendi hızında ilerleme yapabilirsin. Bu, 4 dersinin 3. dersidir.

“getopts ile Bayrakları ve Bağımsız Değişkenleri Ayrıştırma” dersi ne kadar sürer?

Çoğu CoddyKit dersi yaklaşık 5–10 dakika sürer. Her biri kısa ve etkileşimli olduğu için sabit ilerleme yaparsın ve web ile uygulama arasında tam olarak bıraktığın yerden devam edebilirsin.

Bu Linux Command Line & Bash Scripting Mastery dersinde kod yazıp çalıştırabilir miyim?

Evet. Her Linux Command Line & Bash Scripting Mastery dersi yerleşik bir kod editörü içerir, bu sayede tarayıcıda gerçek kod yazıp çalıştırabilir ve anlık yapay zeka geri bildirimi alırsın — yerel kurulum gerekli değildir.

Bu kursun tüm dersleri

Yerel Kapsam ve Dönüş Kodlarıyla İşlev Tasarlama
Yeniden Kullanılabilir Bash Kitaplıkları Oluşturma ve Kaynak Alma
getopts ile Bayrakları ve Bağımsız Değişkenleri Ayrıştırma
Dizileri ve İlişkilendirilebilir Haritaları İşlevler Arasında Geçirme

← Linux Command Line & Bash Scripting Mastery Sayfasına Dön