Mert Özen Her Satırda Daha İleri
DevOps Bash Scripting — #03

Koşullar ve Döngüler: if, [[ ]], case, for, while read ve Dosyalar Üzerinde Güvenle Dönmek

Mert Özen 15 Kas 2026 15 dk 16 görüntülenme
Koşullar ve Döngüler: if, [[ ]], case, for, while read ve Dosyalar Üzerinde Güvenle Dönmek

Bash'te if bir koşula değil bir komutun exit code'una bakar; bash script'lerinde [[ ]], sayılar için (( )), satır satır okumak için while IFS= read -r, dosya adları için glob ya da find -print0 kullanılır. Bookstore sunucusunda alt komutlu bir bookstore-ctl.sh ve son beş release'i tutan bir temizlik script'i yazarken glob sıralamasının canlı release'i silebildiği tuzağı, [ ] içindeki > ile oluşan dosyayı ve pipe'taki while döngüsünün kaybettiği sayacı gösteriyoruz.

Sürüm notu: Bu yazıdaki örnekler Ubuntu 24.04 LTS (uzun süreli destek sürümü) üzerinde Bash 5.2.21 ve kaynaktan derlenen Bash 5.3.20 ile, coreutils 9.4, findutils 4.9 ve ShellCheck 0.11.0 kullanılarak denenmiştir.

Önce Tahmin Et

Bookstore sunucusunda her deploy /opt/bookstore/releases altına 2026-11-14-N adında yeni bir klasör açıyor ve current symlink'i en yenisini gösteriyor. Bugün 11 deploy yapılmış:

$ for d in releases/*/; do printf '%s ' "${d#releases/}"; done; echo
2026-11-14-1/ 2026-11-14-10/ 2026-11-14-11/ 2026-11-14-2/ 2026-11-14-3/ 2026-11-14-4/ 2026-11-14-5/ 2026-11-14-6/ 2026-11-14-7/ 2026-11-14-8/ 2026-11-14-9/
$ readlink current
/opt/bookstore/releases/2026-11-14-11
$ releases=(releases/*/); echo "${#releases[@]} releases"
11 releases

Disk dolmasın diye son beşi dışındakileri silmek istiyorsun ve silinecekleri array'in ilk "toplam eksi beş" element'i olarak alıyorsun: "${releases[@]:0:${#releases[@]}-5}". Sence bu liste hangi klasörleri içeriyor? Cevap for bölümünde; listeyi silmeden önce görmüş olmana sevineceksin.

Önceki yazıda variable'ları güvenle kullanmayı gördük. Bu yazıda onlarla karar veriyoruz: if ve test komutları, [ ], [[ ]] ve (( )) farkı, regex eşleşmesi, case ile alt komutlar, for ve while read döngüleri ve dosyalar üzerinde güvenle dönmek. Sonunda eski release'leri temizleyen gerçek bir script ve Bookstore sunucusundaki işler için tek bir giriş noktası olacak.

if, test ve Exit Code

if bir koşula değil, bir komuta bakar: komut 0 ile biterse then, değilse else çalışır. Köşeli parantez de aslında bir komut:

$ type [ [[ test
[ is a shell builtin
[[ is a shell keyword
test is a shell builtin
$ if grep -q '^release 11$' /opt/bookstore/current/VERSION; then echo "11 is live"; fi
11 is live

[, test komutunun başka bir adı ve son argümanı ] olmak zorunda. Bu yüzden içindeki her şey sıradan argüman: word splitting'e de, globbing'e de girer. [[ ise bash'in keyword'ü; içini bash kendisi parse eder, variable'ları bölmez ve glob'ları genişletmez. grep -q gibi her komutu doğrudan koşul olarak kullanabilirsin; if [ $(grep -c ...) -gt 0 ] yazmana gerek yok. Farkı boş bir variable'la görmek kolay:

$ env_name=""
$ [ $env_name = production ] && echo "prod"
bash: [: =: unary operator expected
$ [[ $env_name = production ]] || echo "not prod"
not prod
$ [ "$env_name" = production ] || echo "not prod"
not prod

Tırnaksız $env_name boş olunca [ komutu yalnız = production ] görüyor ve hata veriyor. [[ ]] içinde aynı ifade sorunsuz; [ ] kullanacaksan tırnak şart. Bu seride bash script'lerinde [[ ]] kullanıyoruz; #!/bin/sh script'lerinde ise yalnız [ ] var.

Üçüncü form (( )) sayılar için. Karşılaştırma operatörlerinin anlamı burada değişiyor:

$ version=10; [ "$version" > 9 ] && echo "bigger?"; ls
bigger?
9
$ [[ 10 < 9 ]] && echo "string compare: 10 < 9"
string compare: 10 < 9
$ (( 10 < 9 )) || echo "arithmetic: 10 is not < 9"
arithmetic: 10 is not < 9
$ [ 10 -lt 9 ] || echo "test -lt: 10 is not < 9"
test -lt: 10 is not < 9

[ ] içinde > bir redirection: test hiç yapılmadı, klasörde 9 adında boş bir dosya oluştu ve "bigger?" yine yazıldı. [[ ]] içinde < ve > string karşılaştırması yapar, "10" alfabetik olarak "9"dan önce gelir. Sayıları (( )) ile ya da -lt, -gt, -eq ile karşılaştır.

String, Dosya ve Regex Testleri

Script'lerde en çok kullanacağın testler:

$ cur=/opt/bookstore/current
$ [[ -L $cur ]] && echo "symlink"; [[ -d $cur ]] && echo "points to a directory"; [[ -f $cur ]] || echo "not a regular file"
symlink
points to a directory
not a regular file
$ [[ -s $cur/VERSION ]] && echo "VERSION is not empty"
VERSION is not empty
$ [[ -x /usr/bin/curl ]] && echo "curl is executable"
curl is executable
$ [[ -e /etc/bookstore/secrets.env ]] || echo "no secrets file"
no secrets file
$ [[ -z $UNSET_VAR && -n $HOME ]] && echo "-z empty, -n not empty"
-z empty, -n not empty
$ f="Bookstore.Api.log"; [[ $f == *.log ]] && echo "log file"
log file
$ [[ $f == "*.log" ]] || echo "quoted pattern is literal"
quoted pattern is literal

-e var mı, -f normal dosya mı, -d klasör mü, -L symlink mi, -s boş olmayan dosya mı, -r/-w/-x okunabilir/yazılabilir/çalıştırılabilir mi; -z string boş mu, -n dolu mu. Symlink'te -d ve -f hedefe bakar, -L link'in kendisine. [[ ]] içinde =='nin sağ tarafı tırnaksızsa bir glob pattern'idir, tırnaklıysa düz metin; && ve || de içeride doğrudan kullanılabilir.

=~ sağ taraftaki extended regex ile eşleştirir ve parantezli grupları BASH_REMATCH array'ine koyar:

$ re='^([0-9]+)\.([0-9]+)\.([0-9]+)$'
$ v=1.4.2; [[ $v =~ $re ]] && echo "major=${BASH_REMATCH[1]} minor=${BASH_REMATCH[2]} patch=${BASH_REMATCH[3]}"
major=1 minor=4 patch=2
$ v=1.4; [[ $v =~ $re ]] || echo "not a version: $v"
not a version: 1.4
$ [[ 1.4.2 =~ "^[0-9]+\.[0-9]+" ]] || echo "quoted regex is matched literally"
quoted regex is matched literally

Regex'i bir variable'a koyup tırnaksız kullanmak en güvenli yol: regex'i tırnak içine yazarsan bash onu düz metin olarak arar. Önceki yazıda HEALTH_TIMEOUT=abc'nin "API sağlıksız" diye raporlandığını görmüştük. Health script'ine artık şu kontrol giriyor ve yanlış yapılandırma, yanlış kullanım kodu olan 2 ile bitiyor:

    local timeout="${HEALTH_TIMEOUT:-5}"
    if [[ ! $timeout =~ ^[1-9][0-9]*$ ]]; then
        echo "HEALTH_TIMEOUT must be a positive integer, got: $timeout" >&2
        exit 2
    fi
$ HEALTH_TIMEOUT=abc ./scripts/bookstore-health.sh; echo "exit=$?"
HEALTH_TIMEOUT must be a positive integer, got: abc
exit=2

case ile Alt Komutlar

Sunucuda bookstore-health.sh, birazdan yazacağımız temizlik script'i ve ileride deploy ile rollback olacak. Hepsini ayrı ayrı hatırlamak yerine git ya da systemctl gibi tek bir komut ve alt komutlar kullanalım. case bir değeri sırayla pattern'lerle karşılaştırır ve ilk eşleşen dalı çalıştırır:

#!/usr/bin/env bash
#
# bookstore-ctl.sh - Bookstore sunucusundaki günlük işler için tek giriş noktası.
#
# Kullanım:   bookstore-ctl.sh COMMAND [ARGS...]
# Komutlar:   status              current release ve health check
#             releases            release'leri listeler, en yenisi en altta
#             prune [-n] [KEEP]   eski release'leri siler (bkz. bookstore-prune-releases.sh)
# Variable'lar: BOOKSTORE_ROOT  kurulum kökü (varsayılan /opt/bookstore)
# Exit code:  0 başarılı, 1 hata, 2 yanlış kullanım

SCRIPT_DIR=$(dirname "$(readlink -f "$0")")
ROOT="${BOOKSTORE_ROOT:-/opt/bookstore}"

usage() {
    echo "Usage: ${0##*/} status|releases|prune [ARGS...]" >&2
}

cmd_status() {
    local current
    current=$(readlink -f "$ROOT/current")
    if [[ -z $current || ! -d $current ]]; then
        echo "No current release under $ROOT" >&2
        return 1
    fi
    echo "current release: ${current##*/}"
    "$SCRIPT_DIR/bookstore-health.sh" "$@"
}

cmd_releases() {
    local current name
    current=$(readlink -f "$ROOT/current")
    shopt -s nullglob
    for name in "$ROOT"/releases/*/; do
        name=${name%/}
        echo "${name##*/}"
    done | sort -V | while IFS= read -r name; do
        if [[ $ROOT/releases/$name == "$current" ]]; then
            echo "* $name"
        else
            echo "  $name"
        fi
    done
}

main() {
    local command="${1:-}"
    if (( $# > 0 )); then
        shift
    fi
    case "$command" in
        status)
            cmd_status "$@"
            ;;
        releases)
            cmd_releases
            ;;
        prune)
            "$SCRIPT_DIR/bookstore-prune-releases.sh" "$@"
            ;;
        -h | --help | help)
            usage
            ;;
        "")
            usage
            exit 2
            ;;
        *)
            echo "Unknown command: $command" >&2
            usage
            exit 2
            ;;
    esac
}

main "$@"; exit
$ ./scripts/bookstore-ctl.sh status
current release: 2026-11-14-11
OK http://127.0.0.1:5000/health
$ ./scripts/bookstore-ctl.sh restart; echo "exit=$?"
Unknown command: restart
Usage: bookstore-ctl.sh status|releases|prune [ARGS...]
exit=2

Her dal ;; ile biter; | birden fazla pattern'i aynı dala bağlar, * en sonda "hiçbiri" dalıdır. Pattern'ler glob kuralıyla çalışır, bu yüzden *.tar.gz) ya da [0-9]*) gibi dallar da yazabilirsin. Tanınmayan bir komutun 0 ile değil 2 ile bitmesi önemli; bir CI adımında yazım hatası yapılan alt komut sessizce "başarılı" geçmemeli. SCRIPT_DIR, script'in bulunduğu klasör: diğer script'leri PATH'e (komutların arandığı klasör listesi) değil kendi yanına göre çağırıyoruz, böylece bookstore-ops klasörü nereye kopyalanırsa kopyalansın çalışıyor. Deploy ve rollback dalları sonraki yazılarda eklenecek.

for, Glob ve nullglob

Önce Tahmin Et'in cevabı:

$ printf '%s\n' "${releases[@]:0:${#releases[@]}-5}"
releases/2026-11-14-1/
releases/2026-11-14-10/
releases/2026-11-14-11/
releases/2026-11-14-2/
releases/2026-11-14-3/
releases/2026-11-14-4/
$ printf '%s\n' "${releases[@]}" | sort -V | tail -n 3
releases/2026-11-14-9/
releases/2026-11-14-10/
releases/2026-11-14-11/

Listede en yeni iki release, üstelik current'ın gösterdiği 11 de var. Glob sonuçlarını sayıya göre değil, alfabetik sıralar ve "10" ile "11", "2"den önce gelir. On deploy'a kadar doğru çalışan script, onuncusundan sonra canlıdaki release'i siler. sort -V (version sort) sayıları sayı olarak karşılaştırır. Bash 5.3 ile gelen GLOBSORT variable'ı glob sıralamasını değiştirebiliyor, ama numeric seçeneği yalnız tamamen rakamdan oluşan adlarda işe yarıyor; bizim adlarda denediğimde sıra değişmedi.

for bir kelime listesi üzerinde döner; liste glob, brace expansion, array ya da komut çıktısı olabilir:

$ for f in logs/*.txt; do echo "found: $f"; done
found: logs/*.txt
$ shopt -s nullglob; for f in logs/*.txt; do echo "found: $f"; done; echo "loop done"
loop done
$ shopt -u nullglob
$ echo {1..5} {01..03} {a,b}.log
1 2 3 4 5 01 02 03 a.log b.log
$ n=3; for i in $(seq 1 "$n"); do printf '%s ' "$i"; done; echo
1 2 3
$ for (( i = 1; i <= n; i++ )); do printf '%s ' "$i"; done; echo
1 2 3
$ for i in {1..10}; do (( i % 2 == 0 )) && continue; (( i > 7 )) && break; printf '%s ' "$i"; done; echo
1 3 5 7

Eşleşen dosya yoksa bash glob'u olduğu gibi bırakır ve döngü bir kez, logs/*.txt adlı var olmayan bir "dosya" ile çalışır. shopt -s nullglob eşleşmeyen glob'u boş listeye çevirir; dosyalar üzerinde dönen her script'te açılmalı (ama ls *.txt gibi bir komutta boş liste "bütün dosyalar" anlamına gelebileceği için dikkat). Önceki yazıda gördüğümüz gibi {1..$n} çalışmaz; sınır bir variable'daysa seq ya da C tarzı for (( )) kullan. continue sıradaki tura geçer, break döngüden çıkar.

while read: Satır Satır Okumak

Bir dosyayı ya da komut çıktısını satır satır işlemenin doğru kalıbı while IFS= read -r line. Her parçasının bir nedeni var:

$ cat deploy.env; echo
# Bookstore deploy settings
BOOKSTORE_ENV=staging

  HEALTH_TIMEOUT=10
SHARE_PATH=\\fileserver\bookstore\releases
$ while read line; do echo "[$line]"; done < deploy.env
[# Bookstore deploy settings]
[BOOKSTORE_ENV=staging]
[]
[HEALTH_TIMEOUT=10]
$ while IFS= read -r line || [[ -n $line ]]; do echo "[$line]"; done < deploy.env
[# Bookstore deploy settings]
[BOOKSTORE_ENV=staging]
[]
[  HEALTH_TIMEOUT=10]
[SHARE_PATH=\\fileserver\bookstore\releases]
$ printf '%s\n' 'SHARE_PATH=\\fileserver\bookstore\releases' | while read line; do echo "[$line]"; done
[SHARE_PATH=\fileserverbookstorereleases]

IFS= satır başındaki ve sonundaki boşlukların silinmesini engeller. -r ters bölüyü kaçış karakteri olarak yorumlamayı kapatır; olmadan Windows yolundaki bütün ters bölüler kayboluyor. Dosyanın son satırında satır sonu yoksa read o satırı okur ama 1 döner ve döngü onu işlemeden biter; Windows'ta düzenlenen dosyalarda sık görülür. || [[ -n $line ]] bu son satırı da kurtarır. IFS'i bir karaktere ayarlayıp satırı alanlara da bölebilirsin; case ile birleşince küçük bir config okuyucu çıkıyor:

$ while IFS='=' read -r key value || [[ -n $key ]]; do case $key in "" | "#"*) continue ;; BOOKSTORE_ENV | HEALTH_TIMEOUT | SHARE_PATH) echo "ok: $key=$value" ;; *) echo "unknown key: [$key]" >&2 ;; esac; done < deploy.env
ok: BOOKSTORE_ENV=staging
unknown key: [  HEALTH_TIMEOUT]
ok: SHARE_PATH=\\fileserver\bookstore\releases

Boşluklu satırı bilinmeyen bir key olarak yakalamak iyi: IFS='=' boşlukları kırpmadığı için key'in başındaki iki boşluk eşleşmeyi bozdu, ama script bunu sessizce yutmadı, stderr'e yazdı.

Dosya adları için satır sonu güvenli bir ayraç değil, çünkü Linux'ta dosya adı satır sonu bile içerebilir. Güvenli ayraç NUL (değeri sıfır olan bayt) karakteri: find -print0 adları NUL ile ayırır, read -d '' NUL'a kadar okur. Bookstore'un bir haftadan eski log'larını sıkıştıralım; bir dosyanın adında boşluk ve parantez var:

$ for f in $(find logs -name '*.log' -mtime +7); do echo "[$f]"; done
[logs/bookstore-2026-11-02]
[(copy).log]
[logs/bookstore-2026-11-01.log]
$ find logs -name '*.log' -mtime +7 -print0 | while IFS= read -r -d '' f; do gzip -- "$f" && echo "compressed $f"; done
compressed logs/bookstore-2026-11-02 (copy).log
compressed logs/bookstore-2026-11-01.log
$ ls logs
bookstore-2026-11-01.log.gz
bookstore-2026-11-02 (copy).log.gz
bookstore-2026-11-14.log

$(find ...) ya da $(ls) üzerinde for, önceki yazıdaki word splitting'in ta kendisi: boşluklu ad ikiye bölündü. gzip --'deki -- "option'lar bitti" demek; tire ile başlayan bir dosya adının option sanılmasını engeller.

Eski Release'leri Temizlemek

Parçaları birleştirelim. Script son N release'i sort -V ile bulur, geri kalanları siler ve current'ın gösterdiği release'e asla dokunmaz; rollback sonrası current eski bir release'i gösteriyor olabilir. -n yalnız ne silineceğini yazar:

#!/usr/bin/env bash
#
# bookstore-prune-releases.sh - eski Bookstore release'lerini siler, en yenilerini tutar.
#
# Kullanım:   bookstore-prune-releases.sh [-n] [KEEP]
#             -n    dry run: yalnız silinecekleri yazar
#             KEEP  tutulacak release sayısı (varsayılan 5)
# Variable'lar: BOOKSTORE_ROOT  kurulum kökü (varsayılan /opt/bookstore)
# Exit code:  0 başarılı, 1 hata, 2 yanlış kullanım

usage() {
    echo "Usage: ${0##*/} [-n] [KEEP]" >&2
}

main() {
    local dry_run=0
    if [[ ${1:-} == "-n" ]]; then
        dry_run=1
        shift
    fi
    if (( $# > 1 )); then
        usage
        exit 2
    fi
    local keep="${1:-5}"
    if [[ ! $keep =~ ^[1-9][0-9]*$ ]]; then
        echo "KEEP must be a positive integer, got: $keep" >&2
        exit 2
    fi

    local root="${BOOKSTORE_ROOT:-/opt/bookstore}"
    local releases_dir="$root/releases"
    if [[ ! -d $releases_dir ]]; then
        echo "Releases directory not found: $releases_dir" >&2
        exit 1
    fi
    local current
    current=$(readlink -f "$root/current")

    shopt -s nullglob
    local dirs=("$releases_dir"/*/)
    if (( ${#dirs[@]} <= keep )); then
        echo "Nothing to prune: ${#dirs[@]} releases, keeping $keep"
        return 0
    fi

    local name dir
    # En yeni en başta; version sort sayesinde 2026-11-14-10, 2026-11-14-9'dan sonra gelir.
    while IFS= read -r name; do
        dir="$releases_dir/$name"
        if [[ $dir == "$current" ]]; then
            echo "skip $name (current)"
            continue
        fi
        if (( dry_run )); then
            echo "would delete $name"
        else
            rm -rf -- "$dir"
            echo "deleted $name"
        fi
    done < <(for dir in "${dirs[@]}"; do dir=${dir%/}; echo "${dir##*/}"; done | sort -V -r | tail -n +"$((keep + 1))")
}

main "$@"; exit

Glob'daki sondaki / yalnız klasörleri eşler. Döngüyü besleyen < <(...) process substitution; bir komutun çıktısını dosya gibi okumayı sağlıyor ve neden pipe yerine onu kullandığımızı beşinci yazıda göreceğiz. sort -V -r en yeniyi başa alır, tail -n +6 altıncı satırdan itibarenkileri, yani silinecekleri verir. Önce dry run, rollback'ten sonra current'ın 4'ü gösterdiği bir durumda:

$ ln -sfn /opt/bookstore/releases/2026-11-14-4 /opt/bookstore/current
$ ./scripts/bookstore-prune-releases.sh -n 3
would delete 2026-11-14-8
would delete 2026-11-14-7
would delete 2026-11-14-6
would delete 2026-11-14-5
skip 2026-11-14-4 (current)
would delete 2026-11-14-3
would delete 2026-11-14-2
would delete 2026-11-14-1
$ ln -sfn /opt/bookstore/releases/2026-11-14-11 /opt/bookstore/current
$ ./scripts/bookstore-prune-releases.sh
deleted 2026-11-14-6
deleted 2026-11-14-5
deleted 2026-11-14-4
deleted 2026-11-14-3
deleted 2026-11-14-2
deleted 2026-11-14-1
$ ./scripts/bookstore-ctl.sh releases
  2026-11-14-7
  2026-11-14-8
  2026-11-14-9
  2026-11-14-10
* 2026-11-14-11
$ ./scripts/bookstore-prune-releases.sh
Nothing to prune: 5 releases, keeping 5

İkinci çalıştırmanın hiçbir şey silmemesi önemli: script'i cron'dan her gece çalıştırabilirsin, tekrar çalışınca zarar vermez. Bu özelliğin adı idempotency (tekrar çalıştırılınca aynı sonucu vermek) ve altıncı yazıda tekrar döneceğiz.

Üretimde Dikkat

Silen her script'e bir dry run ver ve yeni bir sunucuda önce onu çalıştır. Silinecek listenin ekranda göründüğü bir adım, Önce Tahmin Et'teki gibi bir sıralama hatasını canlıdaki release silinmeden yakalar. Silme koşullarını dar tut: yalnız releases altındaki klasörler, yalnız sayıyla belirlenen fazlalık, current hiçbir zaman. rm -rf -- "$dir"'deki $dir her zaman bilinen bir kökle başlıyor; kökü kullanıcıdan alan bir silme komutu yazıyorsan önceki yazıdaki ${var:?} korumasını ekle.

Release adlarını sıralanabilir seç. 2026-11-14-7 gibi bir adın "N" kısmı 10'u geçtiğinde alfabetik sıra bozuluyor; sort -V bunu çözüyor, ama adı 20261114-0007 ya da 20261114T153000Z gibi sabit genişlikte seçmek her aracın (glob, ls, dosya yöneticisi) aynı sırayı görmesini sağlar. Sıralamayı dosyaların değişme zamanına (ls -t) bağlama: bir release klasörüne sonradan dokunmak sırasını değiştirir.

Döngülerde dış komut sayısına dikkat. Döngünün her turunda $(...), sed ya da basename çağırmak birkaç dosyada fark edilmez, on binlerce log satırında dakikalar sürer. Döngü içinde parametre genişletme kullan, toplu işi döngünün dışına, tek bir awk ya da sort çağrısına taşı; log'dan cevap çıkaran bu araçlar Linux ve Shell serisinin text processing yazısında anlatıldı.

Sık Düşülen Tuzaklar

Pipe'tan beslenen while döngüsünde sayaç. Döngü içinde artırılan bir variable, döngüden sonra sıfır görünür:

$ count=0; find logs -name '*.log' -mtime +7 -print0 | while IFS= read -r -d '' f; do echo "[$f]"; (( count++ )); done; echo "count=$count"
[logs/bookstore-2026-11-02 (copy).log]
[logs/bookstore-2026-11-01.log]
count=0

Pipeline'ın her parçası ayrı bir subshell'de çalışır; count o subshell'de artıp onunla birlikte kaybolur. Temizlik script'inde bu yüzden pipe yerine < <(...) kullandık; bookstore-ctl.sh releases'teki pipe ise döngüden sonra hiçbir variable'a ihtiyaç duymadığı için sorunsuz. Nedenini ve diğer çözümleri (lastpipe, process substitution) beşinci yazıda ayrıntılı göreceğiz.

a && b || c'yi if-then-else sanmak. c yalnız a başarısız olunca değil, b başarısız olunca da çalışır:

$ [[ -d /opt/bookstore/current ]] && echo "current exists" || echo "no current release"
current exists
$ [[ -d /opt/bookstore/current ]] && grep -q 'release 99' /opt/bookstore/current/VERSION || echo "no current release"
no current release

İkinci satırda klasör var, ama grep başarısız olduğu için "no current release" yazıldı; mesaj yanlış. b her zaman başarılı olan bir echo değilse if yaz.

[ ] içinde < ve >. Yukarıda gördüğümüz gibi bunlar redirection'dır: [ "$version" > 9 ] karşılaştırma yapmaz, 9 adında bir dosya oluşturur ve her zaman başarılı döner. ShellCheck bunu SC2071 (sayı karşılaştırmasında > kullanımı) ile yakalar ve -gt önerir.

$(ls) ya da $(find) üzerinde for. Boşluklu dosya adlarını böler, eşleşme yoksa garip davranır ve ShellCheck SC2045 (ls çıktısı üzerinde döngü) uyarısı verir. Glob ya da find -print0 | while IFS= read -r -d '' kullan.

Küçük Bir Deneme

★☆☆ bookstore-ctl.sh'ye version alt komutu ekle: current release'in VERSION dosyasını okusun, dosya yoksa ya da boşsa (-s) anlaşılır bir mesajla 1 dönsün. Bilinmeyen komut dalının hâlâ 2 döndüğünü kontrol et.

★★☆ Temizlik script'ine ikinci bir koşul ekle: KEEP'ten fazla release olsa bile 2 günden yeni olanları silmesin. Klasör yaşını find "$releases_dir" -mindepth 1 -maxdepth 1 -type d -mtime -2 ile bulabilirsin. Dry run ile ve touch -d ile tarihlerini değiştirdiğin klasörlerle dene.

★★★ deploy.env okuyucusunu bir function'a çevir: baştaki ve sondaki boşlukları parametre genişletmeyle kırp, yalnız izin verilen key'leri kabul et, değeri tırnak içindeyse tırnakları kaldır ve bilinmeyen key'de 2 ile çık. source deploy.env yerine neden böyle bir okuyucu tercih edebileceğini (ipucu: dosyada $(rm -rf ...) yazsaydı ne olurdu?) bir paragrafta açıkla.

Script'lerimiz artık karar verebiliyor ama argümanları hâlâ elle ayıklıyor: -n'i ilk argümanda arıyoruz, başka bir yerde verilirse anlamıyoruz. Bir sonraki yazıda function'lara, positional parametrelere, shift ve getopts'a geçiyoruz ve bookstore-deploy.sh -e staging -v 1.4.2 --dry-run arayüzünü, iyi bir --help metniyle birlikte kuruyoruz.