## Kabuk Programlama (Shell Scripting) Nedir?Kabuk programlama, Linux ortamında komutlar yazarak ve çalıştırarak görevleri otomatikleştirmenizi ve düzenlemenizi sağlayan güçlü bir programlama yöntemidir. Özellikle şu alanlarda değerlidir:- Sistem yönetimi- Görev otomatizasyonu- Verimliliği...
# Kabuk Programlama (Shell Scripting) Nedir?
Kabuk programlama, Linux ortamında komutlar yazarak ve çalıştırarak görevleri otomatikleştirmenizi ve düzenlemenizi sağlayan güçlü bir programlama yöntemidir. Özellikle şu alanlarda değerlidir:
- Sistem yönetimi
- Görev otomatizasyonu
- Verimliliği artırma
Başlıklar:
# Shell Script (Kabuk Programlama) İndeksi
1. **Temel Kavramlar**
— Shell (Kabuk) Nedir?
— Shell Türleri (bash, sh, ksh, zsh)
2. **Değişkenler ve Veri Tipleri**
— Değişken Tanımlama
— Sabitler
— Diziler
— İlişkisel Diziler
3. **Temel Operatörler**
— Metin İşlemleri
— Aritmetik İşlemler
— Mantıksal Operatörler
4. **Kontrol Yapıları**
— if-else İfadeleri
— case İfadeleri
— Döngüler (for, while, until)
— break ve continue
— exit ve sleep
5. **Fonksiyonlar**
— Fonksiyon Tanımlama
— Parametre Geçirme
— Dönüş Değerleri
— Özyineleme
6. **Komut Satırı İşlemleri**
— getopts Kullanımı
— Seçenek ve Argüman İşleme
— basename ve dirname
— Dosya ve Dizin Kontrolleri
7. **Gelişmiş Özellikler**
— Süslü Parantez Genişletmesi
— seq Komutu
— nohup Kullanımı
— Rastgele Sayılar
8. **Örnek Proje**
— Hesap Makinesi Uygulaması
— Kurulum ve Çalıştırma
— Kod Açıklamaları
— Geliştirme Önerileri
## Kabuk (Shell) Türleri
İşte en yaygın kullanılan kabuklar:
1. **Bash (Bourne Again Shell)**
— En yaygın kullanılan kabuk
— Birçok Linux dağıtımında varsayılan kabuk
2. **sh (Bourne Shell)**
— Orijinal Unix kabuğu
— Bash’in öncüsü
3. **ksh (Korn Shell)**
— csh ve sh’nin özelliklerini birleştirir
— Unix ortamlarında popüler
4. **zsh (Z Shell)**
— Gelişmiş özelliklere sahip modern kabuk
— Yeni macOS sürümlerinde varsayılan kabuk
# Kabuk Türünüzü Kontrol Etme
Mevcut kabuğunuzu belirlemek için aşağıdaki komutu çalıştırın:
```bash
echo $0
```
# Dosya Oluşturma ve Kullanma
Unix ve Linux ortamlarında vi komutunu kullanarak dosya oluşturma ve düzenleme temel bir beceridir. İşte vi ile dosya oluşturma, içerik girme ve kaydetme adımları:
## 1. Yeni Dosya Oluşturmak için vi’yi Açma
- Terminalinizi açın
- Şu komutu yazın: `vi my_script.sh`
- Not: my_script.sh mevcut değilse, vi bu isimde yeni bir dosya oluşturacaktır
## 2. Temel vi Düzenleme Komutları
vi’yi açtığınızda, komut modundasınız. Yazma moduna geçmek için:
- `i` tuşuna basın. Artık dosyaya içerik yazabilirsiniz
## 3. vi’de İçerik Yazma
“Merhaba, Dünya!” yazan ve mevcut tarih/saati gösteren basit bir betik oluşturalım:
```bash
#!/bin/bash
# Bu betik bir karşılama mesajı ve mevcut tarih/saati yazdırır
echo “Merhaba, Dünya!”
echo “Mevcut tarih ve saat:”
date
```
## 4. Yazma Modundan Çıkma
- Komut moduna dönmek için `Esc` tuşuna basın
## 5. vi’de Kaydetme ve Çıkma
- Kaydet ve çık: `:wq` yazıp Enter’a basın
- Sadece kaydet: `:w` yazıp Enter’a basın
- Kaydetmeden çık: `:q!` yazıp Enter’a basın
## 6. Betiği Çalıştırılabilir Yapma
```bash
chmod +x my_script.sh
```
## 7. Betiği Çalıştırma
```bash
./my_script.sh
```
## 8. Çalıştırılabilir Yapmadan Betiği Çalıştırma
```bash
bash my_script.sh
```
Çıktı şuna benzer olacaktır:
```
Merhaba, Dünya!
Mevcut tarih ve saat:
Sal Kas 6 12:34:56 UTC 2023
```
# İşlem Kontrol Kısayolları
- `Ctrl + C`: Çalışan işlemi anında sonlandırır
- `Ctrl + Z`: İşlemi duraklatır ve arka plana gönderir (fg veya bg ile devam ettirilebilir)
# Kabuk Programlamada Yorumlar
Tek Satırlık Yorumlar:
```bash
# Bu bir tek satırlık yorumdur
echo “Merhaba, Dünya!”
```
# Çok Satırlı Yorumlar
Bash’te çok satırlı yorumlar için doğrudan bir sözdizimi yoktur, ancak bunu iki farklı yöntemle yapabilirsiniz:
## 1. Here-Document Kullanarak:
```bash
: <<’COMMENT’
Bu bir çok satırlı yorumdur.
Buraya birden fazla satır ekleyebilirsiniz.
İstediğiniz kadar satır yazabilirsiniz.
COMMENT
```
## 2. << Sözdizimini Doğrudan Kullanarak:
```bash
<<COMMENT
Bu da çok satırlı yorum için
alternatif bir yöntemdir.
İstediğiniz kadar satır ekleyebilirsiniz.
COMMENT
```
Not: Her iki yöntemde de ‘COMMENT’ yerine istediğiniz herhangi bir kelime kullanabilirsiniz, ancak başlangıç ve bitiş kelimeleri aynı olmalıdır.
# Değişkenler ve Dizilerle Çalışma
Değişkenler ve diziler, betiklerde veri depolama ve işleme olanağı sağlar, bu da otomasyonu daha esnek hale getirir.
## Değişkenler
Değişken tanımlama ve değerine erişmek için $ kullanma:
```bash
NAME=”Linux”
echo “Welcome to $NAME Scripting”
```
## Sabitler
readonly ile salt okunur değişkenler oluşturma:
```bash
readonly VERSION=”1.0"
```
## Diziler
Birden fazla değer depolama:
```bash
myArray=(1 2 3 “Hello” “World”)
echo “${myArray}”
# Çıktı: 2
```
### Dizi İşlemleri:
#### Dizi Uzunluğunu Alma:
```bash
echo “${#myArray}” # veya
echo “${#myArray}”
# Dizideki toplam eleman sayısını döndürür
```
#### Diziden Belirli Değerleri Alma:
Belirli bir indeksten başlayarak değerleri alma:
```bash
echo “${myArray:1}”
# İkinci elemandan (indeks 1) başlayarak tüm elemanları getirir
```
#### Belirli Aralıktaki Değerleri Alma:
```bash
echo “${myArray:1:2}”
# İndeks 1'den başlayarak 2 eleman getirir
```
#### Dizi Güncelleme (Yeni eleman ekleme):
```bash
myArray+=(5 6 8)
```
### İlişkisel Dizilerle Çalışma:
#### Tanımlama ve Başlatma:
```bash
declare -A myArray
myArray=( =Paul =20 )
```
#### Değerlere Erişim:
```bash
echo “${myArray}”
```
#### Dizi Uzunluğunu Alma:
```bash
echo “${#myArray}”
```
#### Dizi Güncelleme:
```bash
myArray+=( =NewYork )
```
💡 **İpucu**: Diziler, dosya adları veya yapılandırmalar gibi değer listelerini yönetmek için kullanışlıdır.
# Metin ve Aritmetik İşlemler
## Metin İşleme Örnekleri:
### Temel Metin İşlemleri:
```bash
str=”Shell Scripting”
# Uzunluk
echo ${#str} # Çıktı: 15
# Değiştirme
echo ${str/Scripting/Programming} # Çıktı: Shell Programming
# Alt Metin Çıkarma
echo ${str:6:9} # Çıktı: Scripting
```
### Gelişmiş Metin İşlemleri:
```bash
myVar=”Hello World!”
# Metin uzunluğunu alma
length=${#myVar}
echo $length # Çıktı: 12
# Büyük harfe çevirme
upper=${myVar^^}
echo $upper # Çıktı: HELLO WORLD!
# Küçük harfe çevirme
lower=${myVar,,}
echo $lower # Çıktı: hello world!
# Alt metin değiştirme
replace=${myVar/World/Buddy}
echo $replace # Çıktı: Hello Buddy!
# Alt metin çıkarma (dilim)
slice=${myVar:6:5}
echo $slice # Çıktı: World
```
# KULLANICI ETKİLEŞİMLERİ
## Kullanıcıdan Veri Alma
### Temel Veri Alma:
```bash
read var_name
echo “Girdiğiniz: $var_name”
# Örnek Çıktı: (Kullanıcı “John” yazar)
# Girdiğiniz: John
```
### İstemle Veri Alma:
```bash
read -p “Adınız: “ NAME
echo “Merhaba, $NAME!”
# Örnek Çıktı:
# Adınız: John
# Merhaba, John!
```
Temel Farklar:
- Temel Veri Alma: İstem olmadan veri alır
- İstemli Veri Alma: Kullanıcıyı yönlendiren bir istem gösterir
## Aritmetik İşlemler
### let Komutu Kullanımı:
```bash
# Artırma
let a++ # a değerini 1 artırır
```
# Kabuk Programlamada Koşullu İfadeler ve İşlemler
## Aritmetik İşlemler
### Çarpma ile Atama:
```bash
# let kullanarak
let a=5*10
echo $a # Çıktı: 50
# (( )) kullanarak
((a=5*10))
echo $a # Çıktı: 50
```
### Karmaşık Hesaplamalar:
```bash
echo $((5 * (3 + 2))) # Çıktı: 25
```
Not: `let` geleneksel, `(( ))` ise daha modern ve karmaşık aritmetik ifadelere izin verir.
## Koşullu İfadeler
### if İfadesi:
```bash
if ; then
echo “a, b’den büyüktür”
fi
```
### if-else İfadesi:
```bash
if ; then
echo “a, b’den büyüktür”
else
echo “a, b’den büyük değildir”
fi
```
### elif (else if) İfadesi:
```bash
if ; then
echo “a, b’den büyüktür”
elif ; then
echo “a, b’ye eşittir”
else
echo “a, b’den küçüktür”
fi
```
### case İfadesi:
```bash
case $a in
a) echo “a değeri 1” ;;
b) echo “a değeri 2” ;;
*) echo “a değeri ne 1 ne de 2” ;;
esac
```
## Karşılaştırma Operatörleri
- **Eşittir**: `-eq` veya `==`
```bash
```
- **Büyük Eşittir**: `-ge`
```bash
```
- **Küçük Eşittir**: `-le`
```bash
```
- **Eşit Değildir**: `-ne` veya `!=`
```bash
```
- **Büyüktür**: `-gt`
```bash
```
- **Küçüktür**: `-lt`
```bash
```
- *Önemli Notlar:**
- Koşullarda operatörlerin etrafında boşluk bırakın
- `elif` ve `else` isteğe bağlıdır ama çoklu koşullar için kullanışlıdır. - *Önemli Notlar:**
- Koşullarda operatörlerin etrafında boşluk bırakın
- `elif` ve `else` isteğe bağlıdır ama çoklu koşullar için kullanışlıdır.
# Mantıksal Operatörler ve Döngüler
## Mantıksal Operatörler
### && (VE) Operatörü:
```bash
a=10
b=5
if && ; then
echo “Her iki koşul da doğru”
else
echo “Bir veya her iki koşul yanlış”
fi
```
### || (VEYA) Operatörü:
```bash
a=10
b=15
if || ; then
echo “En az bir koşul doğru”
else
echo “Hiçbir koşul doğru değil”
fi
```
### && ve || Operatörlerini Birleştirme:
```bash
a=10
b=5
c=15
if && || ; then
echo “Koşul sağlandı”
else
echo “Koşul sağlanmadı”
fi
```
Açıklama:
- `&&` her iki koşulun da doğru olmasını gerektirir
- `||` ilk koşul başarısız olursa ikinci koşulu kontrol eder
### Üçlü Operatör (Tek Satırlık If-Else):
```bash
a=10
&& echo “Büyük” || echo “Büyük Değil”
```
## Döngüler
### For Döngüsü
Liste veya değer aralığı üzerinde yineleme yapar.
Temel Sözdizimi:
```bash
for item in liste; do
# Her öğe için çalıştırılacak komutlar
done
```
Örnek:
```bash
for i in 1 2 3; do
echo “Sayı: $i”
done
# Çıktı:
# Sayı: 1
# Sayı: 2
# Sayı: 3
```
Aralık Örneği:
```bash
for i in {1..3}; do
echo “Sayaç: $i”
done
# Çıktı:
# Sayaç: 1
# Sayaç: 2
# Sayaç: 3
```
### While Döngüsü
Belirtilen koşul doğru olduğu sürece çalışır.
Sözdizimi:
```bash
while ; do
# Çalıştırılacak komutlar
done
```
Örnek:
```bash
count=1
while ; do
echo “Sayaç: $count”
((count++)) # Sayacı artır
done
# Çıktı:
# Sayaç: 1
# Sayaç: 2
# Sayaç: 3
```
# Döngü Türleri ve Kullanımları
## Until Döngüsü
Koşul doğru oluncaya kadar çalışmaya devam eder.
Sözdizimi:
```bash
until ; do
# Çalıştırılacak komutlar
done
```
Örnek:
```bash
count=1
until ; do
echo “Sayaç: $count”
((count++))
done
# Çıktı:
# Sayaç: 1
# Sayaç: 2
# Sayaç: 3
```
## Sonsuz Döngüler
Manuel olarak durdurulana kadar (örn: Ctrl+C) çalışmaya devam eder.
### For ile Sonsuz Döngü:
```bash
for (( ; ; )); do
echo “Bu bir sonsuz döngüdür”
done
```
### While ile Sonsuz Döngü:
```bash
while :; do
echo “While ile sonsuz döngü”
done
```
### Until ile Sonsuz Döngü:
```bash
until false; do
echo “Until ile sonsuz döngü”
done
```
## Select Döngüsü
Kullanıcının bir listeden seçim yapmasını sağlayan basit bir menü sistemi oluşturur.
Sözdizimi:
```bash
select seçenek in liste; do
# Kullanıcı seçimine göre komutlar
done
```
Örnek:
```bash
PS3=”Bir meyve seçin: “
select meyve in Elma Muz Portakal Çıkış; do
case $meyve in
Elma) echo “Elma’yı seçtiniz”;;
Muz) echo “Muz’u seçtiniz”;;
Portakal) echo “Portakal’ı seçtiniz”;;
Çıkış) break;;
*) echo “Geçersiz seçenek”;;
esac
done
```
Örnek Çıktı:
```
1) Elma
2) Muz
3) Portakal
4) Çıkış
Bir meyve seçin: 2
Muz’u seçtiniz
```
Açıklama:
- `PS3` istem mesajını belirler
- `select` döngüsü seçenekleri gösterir ve her seçim ilgili case ifadesini çalıştırır
- `break` komutu kullanıcı “Çıkış”ı seçtiğinde döngüden çıkar
## Döngü Türlerinin Özeti
- **For Döngüsü**: Liste veya aralık üzerinde yineleme yapar
- **While Döngüsü**: Koşul doğru olduğu sürece devam eder
- **Until Döngüsü**: Koşul doğru oluncaya kadar devam eder
- **Sonsuz Döngü**: Kesintiye uğratılana kadar çalışır
- **Select Döngüsü**: Kullanıcı seçimi için menü gösterir
💡 **İpucu**: Döngüler tekrarlayan görevleri otomatikleştirmek için güçlü araçlardır. Dosyalar, diziler veya aralıklar üzerinde yineleme yapmak gibi çeşitli amaçlar için kullanılabilirler. Örneğin, bir dizindeki tüm dosyaları yeniden adlandırmak için döngü kullanabilirsiniz.
# Kabuk Programlamada Fonksiyonlar
## 1. Fonksiyon Tanımlama
İki farklı sözdizimi kullanılabilir:
```bash
function fonksiyon_adı {
# kodlar
}
# veya
fonksiyon_adı() {
# kodlar
}
```
## 2. Temel Fonksiyon
```bash
selamla() {
echo “Merhaba, kabuk betiğine hoş geldiniz!”
}
selamla # Fonksiyonu çağırma
```
## 3. Parametreli Fonksiyonlar
```bash
kullanici_selamla() {
echo “Merhaba, $1!”
}
kullanici_selamla “Ahmet”
```
## 4. Dönüş Değerleri
```bash
sayilari_topla() {
s $1 + $2 ))
echo $sonuc
}
toplam=$(sayilari_topla 3 5)
echo “Toplam: $toplam”
```
## 5. Koşullu Mantık ve Döngüler
```bash
cift_kontrol() {
if (( $1 % 2 == 0 )); then
echo “$1 çift sayıdır”
else
echo “$1 tek sayıdır”
fi
}
cift_kontrol 7 # Çıktı: “7 tek sayıdır”
```
## 7. Varsayılan Değerler
```bash
selamla() {
local isim=${1:-Misafir}
echo “Merhaba, $isim!”
}
selamla “Ahmet” # Çıktı: “Merhaba, Ahmet!”
selamla # Çıktı: “Merhaba, Misafir!”
```
## 8. Referans ile Parametre Geçme
```bash
deger_degistir() {
eval $1=\$2
}
deger_degistir degisken 100
echo “Değişkenin yeni değeri: $degisken”
```
## 9. Argüman Geçme
### Konumsal Argümanlar ($1, $2, $3, vb.)
```bash
selamla() {
echo “Merhaba, $1! $2 yaşındasın.”
}
selamla “Ahmet” 25
```
### Tüm Argümanlar ($@)
```bash
hepsini_yazdir() {
for arg in “$@”; do
echo “$arg”
done
}
hepsini_yazdir “Elma” “Armut” “Kiraz”
```
### Tek String Olarak Tüm Argümanlar ($*)
```bash
string_olarak_yazdir() {
echo “$*”
}
string_olarak_yazdir “Elma” “Armut” “Kiraz”
```
### Argüman Sayısı ($#)
```bash
arguman_say() {
echo “Argüman sayısı: $#”
}
arguman_say “Elma” “Armut” “Kiraz”
```
## Özet
- Fonksiyonlar kodu düzenli ve yeniden kullanılabilir hale getirir
- Argümanlar $1, $2 vb. ile erişilebilir ve varsayılan değerler atanabilir
- Fonksiyonlar içinde döngüler ve koşullar kullanılabilir
- Fonksiyonlar echo ile değer döndürür ve bu değerler değişkenlerde saklanabilir.
# Kabuk Programlamada Özel Komutlar ve Kontrol Yapıları
## shift Operatörü
Konumsal parametreleri (argümanları) sola kaydırmak için kullanılır.
Sözdizimi:
```bash
shift # Bir pozisyon sola kaydırır
shift n # n pozisyon sola kaydırır
```
### Örnek 1: Tek Pozisyon Kaydırma
```bash
kaydirma_ornegi() {
echo “Orijinal argümanlar: $1, $2, $3”
shift
echo “Kaydırma sonrası: $1, $2, $3”
}
kaydirma_ornegi “bir” “iki” “üç”
# Çıktı:
# Orijinal argümanlar: bir, iki, üç
# Kaydırma sonrası: iki, üç
```
### Örnek 2: Çoklu Kaydırma
```bash
coklu_kaydirma() {
echo “Orijinal argümanlar: $1, $2, $3, $4”
shift 2
echo “2 kez kaydırma sonrası: $1, $2”
}
coklu_kaydirma “elma” “armut” “kiraz” “erik”
```
### Örnek 3: Döngü ile Kullanım
```bash
argumanlari_isle() {
while ; do
echo “İşlenen argüman: $1”
shift
done
}
argumanlari_isle “arg1” “arg2” “arg3” “arg4”
```
## Kontrol Komutları
### 1. break Komutu
Döngüyü erken sonlandırır.
```bash
for i in {1..5}; do
if ; then
break
fi
echo $i
done
```
### 2. continue Komutu
Mevcut döngü iterasyonunu atlar.
```bash
for i in {1..5}; do
if ; then
continue
fi
echo $i
done
```
### 3. İç İçe Döngülerde break ve continue
```bash
for i in {1..3}; do
for j in {1..3}; do
if && ; then
break 2 # İki seviye döngüden çıkar
fi
echo “i=$i, j=$j”
done
done
```
### 4. sleep Komutu
Betiği belirli bir süre duraklatır.
```bash
sleep 5 # 5 saniye bekler
```
- *Önemli Noktalar:**
- `shift` ilk argümanı ($1) kaldırır ve diğerlerini sola kaydırır
- `break n` ile iç içe döngülerden çıkılabilir
- `continue n` ile iç içe döngülerde iterasyon atlanabilir
- `sleep` komutu betik yürütmesini duraklatmak için kullanılır. - *Önemli Noktalar:**
- `shift` ilk argümanı ($1) kaldırır ve diğerlerini sola kaydırır
- `break n` ile iç içe döngülerden çıkılabilir
- `continue n` ile iç içe döngülerde iterasyon atlanabilir
- `sleep` komutu betik yürütmesini duraklatmak için kullanılır.
# Temel Komutlar ve Genişletme Özellikleri
## Kontrol Komutları
### 1. exit Komutu
Betiği durum koduyla sonlandırır (0: başarılı, 0 dışı: hata)
```bash
exit 1 # Hata durumuyla çıkış
```
### 2. $? (Son Komut Çıkış Durumu)
Son çalıştırılan komutun çıkış durumunu saklar
```bash
mkdir myklasor
echo $? # Başarılıysa 0, başarısızsa 1 döndürür
```
## seq Komutu
Sayı dizileri oluşturmak için kullanılır.
### Temel Kullanım:
```bash
# 1'den 5'e kadar sayılar
seq 1 5
# Çıktı: 1 2 3 4 5
# Özel adım boyutu (1'den 10'a 2'şer artarak)
seq 1 2 10
# Çıktı: 1 3 5 7 9
# Ondalık sayılar
seq 0 0.2 1
# Çıktı: 0.0 0.2 0.4 0.6 0.8 1.0
# Ters sıralama
seq 5 -1 1
# Çıktı: 5 4 3 2 1
```
### Döngü ile Kullanım:
```bash
for i in $(seq 1 5); do
echo “Sayı: $i”
done
```
### seq Seçenekleri:
```bash
# Biçimlendirme (-f)
seq -f “Sayı: %.2f” 1 5
# Çıktı: Sayı: 1.00 Sayı: 2.00 …
# Ayırıcı değiştirme (-s)
seq -s “,” 1 5
# Çıktı: 1,2,3,4,5
# Sıfırla doldurma (-w)
seq -w 1 5
# Çıktı: 01 02 03 04 05
```
## Süslü Parantez Genişletmesi
Tek bir ifadeden birden çok metin dizisi oluşturma özelliği.
### Temel Örnekler:
```bash
# Kelime listesi
echo {elma,armut,kiraz}
# Çıktı: elma armut kiraz
# Sayı aralığı
echo {1..5}
# Çıktı: 1 2 3 4 5
# Harf aralığı
echo {a..e}
# Çıktı: a b c d e
```
- *Özet:**
- `exit`: Betikten çıkış yapar
- `$?`: Son komutun durumunu kontrol eder
- `seq`: Sayı dizileri oluşturur
- Süslü parantez genişletmesi: Metin dizileri oluşturur. - *Özet:**
- `exit`: Betikten çıkış yapar
- `$?`: Son komutun durumunu kontrol eder
- `seq`: Sayı dizileri oluşturur
- Süslü parantez genişletmesi: Metin dizileri oluşturur.
# Süslü Parantez Genişletmesi ve getops Komutu
## Gelişmiş Süslü Parantez Kullanımı
### Adım Boyutlu Aralık:
```bash
echo {1..10..2}
# Çıktı: 1 3 5 7 9
```
### Metin ile Değişken Birleştirme:
```bash
echo dosya{1..3}.txt
# Çıktı: dosya1.txt dosya2.txt dosya3.txt
```
### İç İçe Genişletme:
```bash
echo {A,B}{1,2}
# Çıktı: A1 A2 B1 B2
```
### Çoklu Eleman Genişletme:
```bash
echo {A,B,C}{1,2,3}
# Çıktı: A1 A2 A3 B1 B2 B3 C1 C2 C3
```
### Dosya ve Dizinlerle Kullanım:
```bash
mkdir klasor{1,2,3}
# klasor1, klasor2 ve klasor3 dizinlerini oluşturur
```
## getopts Komutu
Komut satırı seçeneklerini (bayrakları) işlemek için kullanılır.
### Temel Sözdizimi:
```bash
getopts “secenek_dizisi” degisken
```
### Örnek 1: Basit Seçenek İşleme
```bash
#!/bin/bash
while getopts “ab” secenek; do
case $secenek in
a) echo “A seçeneği seçildi” ;;
b) echo “B seçeneği seçildi” ;;
\?) echo “Geçersiz seçenek”; exit 1 ;;
esac
done
# Kullanım:
# ./betik.sh -a
# Çıktı: A seçeneği seçildi
```
### Örnek 2: Argümanlı Seçenekler
```bash
#!/bin/bash
while getopts “f:n:” secenek; do
case $secenek in
f) echo “F seçeneği seçildi, argüman: $OPTARG” ;;
n) echo “N seçeneği seçildi, argüman: $OPTARG” ;;
\?) echo “Geçersiz seçenek”; exit 1 ;;
esac
done
# Kullanım:
# ./betik.sh -f dosya.txt
# Çıktı: F seçeneği seçildi, argüman: dosya.txt
```
### Örnek 3: Uzun Seçeneklerle Kullanım
```bash
#!/bin/bash
while getopts “f:n:” secenek; do
case $secenek in
f) echo “Dosya seçeneği: $OPTARG” ;;
n) echo “İsim seçeneği: $OPTARG” ;;
\?) echo “Geçersiz seçenek”; exit 1 ;;
esac
done
# Kullanım:
# ./betik.sh -f metin.txt -n Ahmet
```
- *Önemli Noktalar:**
- Süslü parantez genişletmesi diğer kabuk işlemlerinden önce gerçekleşir
- Virgüller arasında boşluk olmamalıdır
- getopts ile seçenekler sistematik şekilde işlenebilir
- Argüman gerektiren seçenekler için `:` kullanılır - *Önemli Noktalar:**
- Süslü parantez genişletmesi diğer kabuk işlemlerinden önce gerçekleşir
- Virgüller arasında boşluk olmamalıdır
- getopts ile seçenekler sistematik şekilde işlenebilir
- Argüman gerektiren seçenekler için `:` kullanılır
# Gelişmiş Komut Satırı İşlemleri ve Örnek Proje
## getopts Ayrıntılı Kullanımı
### Örnek 4: Çoklu Argüman ve Seçenek İşleme
```bash
#!/bin/bash
while getopts “a:b:c:” secenek; do
case $secenek in
a) echo “A seçeneği değeri: $OPTARG” ;;
b) echo “B seçeneği değeri: $OPTARG” ;;
c) echo “C seçeneği değeri: $OPTARG” ;;
\?) echo “Geçersiz seçenek”; exit 1 ;;
esac
done
```
## Dosya İşleme Komutları
### basename
```bash
# Dosya adını yoldan ayırır
basename /home/kullanici/dosya.txt # Çıktı: dosya.txt
basename /home/kullanici/dosya.txt .txt # Çıktı: dosya
```
### dirname
```bash
# Dizin yolunu döndürür
dirname /home/kullanici/dosya.txt # Çıktı: /home/kullanici
```
### realpath
```bash
# Mutlak yolu döndürür
realpath dosya.txt # Çıktı: /home/kullanici/belgeler/dosya.txt
```
## Dosya ve Dizin Kontrolleri
```bash
if ; then
echo “Dizin mevcut”
fi
if ; then
echo “Dosya mevcut değil”
fi
```
## nohup Kullanımı
```bash
# Arka planda çalıştırma
nohup ./betik.sh &
# Çıktıyı yönlendirme
nohup ./betik.sh > /dev/null 2>&1 &
# Çalışan işlemleri kontrol etme
ps aux | grep betik.sh
```
## Örnek Proje: Hesap Makinesi
```bash
#!/bin/bash
# Toplama fonksiyonu
topla() {
echo “Sonuç: $(($1 + $2))”
}
# Çıkarma fonksiyonu
cikar() {
echo “Sonuç: $(($1 — $2))”
}
# Çarpma fonksiyonu
carp() {
echo “Sonuç: $(($1 * $2))”
}
# Bölme fonksiyonu
bol() {
if ; then
echo “Hata: Sıfıra bölme hatası!”
else
echo “Sonuç: $(($1 / $2))”
fi
}
# Menü
echo “Basit Hesap Makinesi”
echo “İşlem seçin:”
echo “1. Toplama”
echo “2. Çıkarma”
echo “3. Çarpma”
echo “4. Bölme”
read -p “Seçiminiz (1/2/3/4): “ secim
read -p “İlk sayı: “ sayi1
read -p “İkinci sayı: “ sayi2
case $secim in
1) topla $sayi1 $sayi2 ;;
2) cikar $sayi1 $sayi2 ;;
3) carp $sayi1 $sayi2 ;;
4) bol $sayi1 $sayi2 ;;
*) echo “Geçersiz seçim” ;;
esac
```
# Hesap Makinesi Betiği — Kurulum ve Kullanım
## Kurulum Adımları
### 1. Betiği Çalıştırılabilir Yapma
```bash
chmod +x calculator.sh
```
### 2. Betiği Çalıştırma
```bash
./calculator.sh
```
## Betiğin Çalışma Mantığı
- Kullanıcıdan bir işlem seçmesini ister (toplama, çıkarma, çarpma, bölme)
- İki sayı girmesini bekler
- Seçilen işlemi gerçekleştirir
- Bölme işleminde sıfıra bölme kontrolü yapar
## Örnek Çalıştırma
```
$ ./calculator.sh
Basit Hesap Makinesi
İşlem seçin:
1. Toplama
2. Çıkarma
3. Çarpma
4. Bölme
Seçiminiz (1/2/3/4): 1
İlk sayı: 10
İkinci sayı: 5
Sonuç: 15
```
## Geliştirme Önerileri
Bu basit projeyi şu özelliklerle geliştirebilirsiniz:
- Karekök alma ve üs alma gibi ileri matematik işlemleri
- Sürekli çalışan bir döngü ile tekrarlı hesaplama
- Ondalıklı sayı desteği
- Hata kontrollerinin artırılması
- Geçmiş işlemleri kaydetme
- Bilimsel hesap makinesi özellikleri
Bu proje, kabuk programlamada temel kavramları öğrenmek için iyi bir örnektir:
- Koşullu ifadeler
- Kullanıcı girdisi alma
- Matematiksel işlemler
- Fonksiyon kullanımı
- Hata kontrolü
