[LinuxFocus-icon]
Ev  |  Eri�imd�zeni  |  ��indekiler  |  Arama

Duyumlar | Belgelikler | Ba�lant�lar | LF Nedir
Bu makalenin farkl� dillerde bulundu�u adresler: English  Castellano  Deutsch  Francais  Nederlands  Portugues  Turkce  

convert to palmConvert to GutenPalm
or to PalmDoc

[Photo of the Authors]
taraf�ndan Katja and Guido Socher

Yazar hakk�nda:

Katja LinuxFocus'un Alman edit�r�d�r. Tux, film, fotograf��l��� ve denizi sever. Ana sayfas�na buradan ula�abiliriz.

Guido uzun zamandan beri bir Linux hayran� ve Linux'u d�r�st ve a��k insanlar taraf�ndan tasarland��� i�in seviyor. ��te bu ona a��k kodlu dememizin bir nedeni... Guido'nun sanaldoku sayfas�: linuxfocus.org/~guido


��erik:

 

Kabuk Programlama

[Illustration]

�eviri : Ceyhun ELMAS ve Erdal MUTLU

�zet:

Bu yaz�da k���k bir kabuk beti�inin nas�l yaz�laca�� pek �ok �rnekle veriliyor.



 

Neden kabuk programlama ?

Linux i�in �ok �e�itli grafiksel aray�zler sa�lansa bile kabuk hen�z en d�zg�n ara�t�r. Kabuk yaln�zca bir komutlar y���n� de�il ayn� zamanda �ok iyi bir programlama dilidir. Pek �ok i�lemi bununla otomatik olarak yapabilirsiniz, �zellikle sistem y�netimiyle ilgili konularda �ok iyidir, E�er tasar�m�n�z do�ruysa hemen deneyebilir ve kullan��l� basit prototipler olu�turabilirsiniz. Verimlili�in yap�land�rman�n, bak�m�n ve uyumun kolayl���ndan daha az �nemli oldu�u basit i�lemli k���k uygulamalar i�in �ok kullan��l�d�r.
Haydi nas�l �al��t���na bakal�m:
 

Beti�in olu�turulmas�

Linux i�in pek �ok kabuk bulunmaktad�r fakat genellikle kabuk programlama i�in, �cretsiz ve kulan�m� kolay olan bash (bourne again shell) kullan�l�r. Dolay�s�yla bu yaz�daki t�m betikleri bash kullanarak yazd�k (ancak zaman�n �o�unda bu ya�l� k�zkarde� bourne kabu�u ile ko�acak).
Kabuk programlar�m�z� yazmak i�in her �e�it metin edit�r� kullanabiliriz, �rne�in, nedit, kedit, emacs, vi... di�er programlama dillerinde oldu�u gibi.
Program a�a��daki sat�rla ba�lamal�d�r.(bu , dosyadaki ilk sat�r olmal�d�r):
    #!/bin/sh

The #! karakterleri sisteme, bu karakterleri takip eden arguman�n bu dosyay� �al��t�rmakta kullanaca��n� s�yler. Burada kulland���m�z kabuk /bin/sh 'd�r.
Bir betik yazd���n�zda ve bunu kay�t etti�inizde bu beti�i kullanabilmek i�in �al��t�r�labilir yapmal�s�n�z.
Beti�i bu �ekilde �al��t�r�labilir yap�n:
chmod +x filename
Sonra beti�i ./filename komutuyla �al��t�rabilirsiniz.
 

Yorumlar

Betik programlar�nda yorumlar # ile ba�lar ve sat�r�n sonuna kadar gider. Biz ger�ekten yorum kullanman�z� �neriyoruz. E�er betik i�ine yorumlar koyarsan�z bu beti�e gereksinim duydu�unuz zamanlarda ne yapt���n� ve nas�l �al��t���n� zaman kaybetmeden anlam�� olacaks�n�z.
 

De�i�kenler

Di�er programlama dillerinde de�i�kenler olmadan ya�ayamazs�n�z. Betik programlar�nda t�m de�i�kenler veritipi dizgisine sahiptir ve bunlar� yay�nlama. De�i�kene de�er atamak ��yle olur:
degisken=deger
De�eri g�rmek i�in de�i�kenin �n�ne dolar i�areti koymak yeterlidir:
#!/bin/sh
# Bir de�er ata:
a="Merhaba D�nya"
# �imdi "a" n�n de�erini yaz:
echo "a n�n de�eri:"
echo $a
Bu sat�rlar� metin edit�r�n�zde yaz�n ve "first" ismiyle kay�t edin. Sonra chmod +x komutuyla beti�i �al��t�r�labilir yap�n ve ./first komutuyla �al��t�r�n.
Beti�in ��kt�s� b�yle olacakt�r :
a n�n de�eri:
Merhaba D�nya
Bazen bu durum yaz�n�n di�er k�s�mlar�yla de�i�ken isimlerinin kar��mas�na yol a�abilir.
num=2
echo "this is the $numnd"
Bu "this is the 2nd" yazmayacakt�r.��kt� : "this is the " olacakt�r. ��nk� betik numnd ad� verilen de�i�keni arayacak ve bir de�ere sahip olmad���n� bulacakt�r. Burada parantezleri kullan�rsak :
num=2
echo "this is the ${num}nd"
Bu istedi�imizi yazacakt�r: this is the 2nd

Burada de�i�kenlerin say�s� herzaman otomatik olarak belirlenir Bunlar� ilk kullan���m�zda tekrar ele alaca��z.

E�er matematiksel ifadelere gereksiniminiz varsa expr gibi programlar kullanmal�s�n�z (a�ag�daki tabloda g�r�n�yor).
Ayr�ca betikte ge�erli olan de�i�kenler ayn� zamanda �evre de�i�kenleridir. De�i�ken a�k�s�zc�k taraf�ndan �nce al�n�r , �evre de�i�kenleri ihra� edilir. Bunlardan burada daha fazla s�zetmeyece�iz. Bunlar normalde yaln�zca sistemgiri� betiklerinde kullan�l�r.  

Kabuk komutlar� ve denetim yap�lar�

Kabuk betiklerinde kullan�lacak �� s�n�f komut vard�r:

1)Unix komutlar�:
Kabuk betiklerinde her Unix komutunun kullan�labilmesine kar��n, di�erlerine g�re daha fazla kullan�m� olan komutlar vard�r. Bu komutlar genellkle dosya ve metin i�lemleri ile ilgilidir.
Standart ��kt� ayg�t�na (sizin ekran�n�z) veri yazmak. Genellikle �u �ekilde kullan�l�r:
herhangikomut | tee ��kt�dosyas�
Komutun ��kt�s�n� ekrana ve dosyaya yazar.
Komut kullan�m� (syntax) Ama�
echo "metin k�sm�" Metin k�sm�n� ekrana yazar.
ls Dosyalar� listeler.
wc -l dosya
wc -w dosya
wc -c dosya
Dosyadaki st�rlar� sayar veya
s�zc�kleri veya
karatkterleri sayar.
cp kaynakdosya hedefdosya Kaynakdosya'y� hedefdosya olarak kopyalar.
mv eskiad yeniad Dosya ad�n� de�i�tirir veya dosyay� ta��r.
rm dosya Dosya siler.
grep 'katar' dosya Dosya i�erisinde katar arar.
�rnek: grep 'aranacak katar' dosya.txt
cut -b s�t�n dosya Sabit uzunluklu metin s�t�nlar�ndan veri elde etme.
�rnek: 5 ile 9 aras�ndaki karakterleri elde eder.
cut -b5-9 dosya.txt
Bu komutu bam ba�ka bir komut olan "cat" ile kar��t�rmay�n.
cat dosya.txt dosya.txt'yi standart ��kt� ayg�t�na yazar (sizin ekran�n�z).
file dosya Dosyan�n tipi hakk�nda bilgi vermektedir.
read de�i�ken Kullan�c�dan ald��� de�eri de�i�ken'e yazar.
sort dosya.txt dosya.txt'daki sat�rlar� s�ralar(dizer).
uniq Tekrarlanan sat�rlar� siler. Sadece arka arkaya gelen ve tekrarlanan sat�rlar� sildi�i i�in sort ile birlikte kullan�labilir.
�rnek: sort dosya.txt | uniq
expr Kabuk i�erisinde matematiksel i�lemler yapar.
�rnek: 2 ile 3 toplamak i�in
expr 2 "+" 3
find Dosya aramas� yapar.
�rnek: dosya ismine g�re arama:
find . -name dosyaismi -print
Asl�nda bu komutun bir�ok kullan�m� vard�r ve hepsini bu yaz�da anlatmak ne yaz�k ki olas� de�ildir.
tee
basename dosya Yoltan�m�(dizin) k�sm�n� atarak sadece dosyan�n ad�n� �retir.
�rnek: basename /bin/tux
Sadece tux elde edilir.
dirname dosya Dosya ad�n�n� atarak sadece yoltan�m�n� (dizin) �retir.
�rnek: dirname /bin/tux
Sadece /bin k�sm� elde edilir.
head dosya Dosya ba��ndan itibaren birka� sat�r yazar.
tail dosya Dosya sonundan itibaren birka� sat�r yazar.
sed sed basit olarak bul ve de�i�tir program�d�r. Ekrandan (veya borudan) okudu�u metinleri standart ��kt� ayg�t�na (genelde ekran) yazar. Aranan metin d�zenli ifadedir (kaynaklar k�sm�na bak�n�z). linuxfocus katar�n� LinuxFocus ile de�i�tirmek i�in :
cat metin.dosyas� | sed 's/linuxfocus/LinuxFocus/' > yenimetin.dosyas�
kullanabilirsiniz. Bu her sat�rdaki linuxfocus'lar� LinuxFocus ile de�i�tirir. E�er, ayn� sat�rda birden fazla linuxfocus varsa, sadece ilkini de�i�tirir. Bir sat�rdan birden fazla ayn� ifadeden varsa ve siz bunu de�i�tirmek istiyorsan�z:
cat metin.dosyas� | sed 's/linuxfocus/LinuxFocus/g' > yenimetin.dosyas�
awk Genellikle awk bir sat�rdaki alanlar� elde etmek i�in kullan�lmaktad�r. Benimsenmi� de�er olarak, alan ayrac�, bo�luk karakteridir. Ba�ka bir alan ayrac� belirtmek i�in -F se�ene�i kullan�labilir.
 cat dosya.txt | awk -F, '{print $1 "," $3 }'

Burada ayra� olarak virg�l (,) karakteri kullan�ld� ve ilk ve ���nc� ($1 $3) alanlar (s�t�nlar) elde edildi. E�er, dosya.txt'nin sat�rlar� �u �ekilde ise:
Adam Bor, 34, India
Kerry Miller, 22, USA

o zaman sonu�:
Adam Bor, India
Kerry Miller, USA

olur. Awk ile bundan �ok daha fazlas�n� yapmak olas�d�r. Bu sadece en �ok kullan�lan �eklidir.


2) Kavramlar: Borular, y�nlendirme ve ters t�rnak
Bunlar ger�ekte komut, ancak ayn� zamanda da �ok �nemli kavramlard�r.

Borular (|) bir program�n ��kt�s�n� (stdout) ba�ka bir program�n girdisi olarak vermektedir (stdin).
    grep "merhaba" dosya.txt | wc -l
dosya.txt dosyas�ndaki merhaba kelimesini i�eren sat�rlar� bulmakta ve onlar� saymaktad�r.
Grep komutunun ��kt�s� wc komutuna girdi olarak kullan�lm��t�r. Belli mant�k s�n�rlar� i�erisinde bu �ekilde istedi�iniz kadar komutu, borular ile arka arkaya kullanabilirsiniz.

Y�nlendirme: bir komutun ��kt�s�n� bir dosyaya yazmaktad�r veya dosyan�n arkas�na eklemektedir.
> ��kt�y� bir dosyaya yazmaktad�r. E�er, dosya varsa, dosyan�n �zerine yazmaktad�r.
>> ��kt�y� dosyan�n arkas�na eklemektedir (Dosya yoksa, yeni bir dosya yaratarak i�erisine yazmaktad�r, ancak hi�bir zaman dosya �zerine yazmamaktad�r.).

Ters t�rnak
Bir komutun ��kt�s� ba�ka bir komuta parametre olarak (Bu yukar�daki standart girdi (stdin) ayg�t� gibi de�ildir, program isminden sonra verilen katarlar parametreleri olu�turmaktad�r.) verilebilir. Ayr�ca, bir program�n ��kt�s�n� bir de�i�kene atamak i�in de kullan�labilir.
find . -mtime -1 -type f -print
Komutu, 24 saat i�erisinde de�i�tirilmi� t�m dosyalar� bulmaktad�r. (-mtime -2 ise, 48 saat olura). E�er, b�t�n bu dosyalar� bir tar dosyas� (dosya.tar) haline getirmek istiyorsan�z :
tar xvf dosya.tar dosya1 dosya2 ...
T�m dosyalar� tek tek yazmaktansa, iki (find ve tar) komutu ters t�rnak kullanarak birle�tirebiliriz. B�ylece, tar komutu, find komutunun buldu�u t�m dosyalar� paketleyecektir:
#!/bin/sh
# T�rnaklar ters t�rnakt�r (`),  normal t�rnak de�il ('):
tar -zcvf ensondegisen.tar.gz `find . -mtime -1 -type f -print`

3) Denetim yap�lar�
"if" ifadesi bir ifadenin do�ru olup olmad���n� denetlemektedir (��k�� durum bilgisi 0 ise, ba�ar�l� demektir). E�er, do�ru ise "then" k�sm� �al��t�r�lmaktad�r:
if ....; then
   ....
elif ....; then
   ....
else
   ....
fi
Genelde, if ifadesi, i�erisinde test ad� verilen bir komut kullan�lmaktad�r. Bu komut katar kar��la�t�r�lmas�nda, dosyan�n var olup olmad���n�n denetlenmesinde, dosyan�n okuma hakk� olup olmad���n� denetlenmesinde ... kullan�lmaktad�r.
"test" komutu " [ ] " k��eli parantezler olarak yaz�lmaktad�r. Burada kullan�lan bo�luklar �nemlidir : Parantezlerden �nce ve sonra bo�luk olmas�na dikkat ediniz. �rnek:
[ -f "dosya" ]     : "dosya" n�n dosya olup olmad���n� denetler.
[ -x "/bin/ls" ]   : /bin/ls �al��t�r�labilir bir dosya olup olmad���n� denetler.
[ -n "$de�isken" ] : $degisken'in herhangi bir de�er ta��y�p ta��mad���n�
                     denetlemektedir.
[ "$a" = "$b" ]    : "$a" n�n  "$b" ye e�it olup olmad���n� denetlemektedir.
"man test" komutunu �al��t�rarak, t�m kar��la�t�rma ve dosya denetleme se�eneklerini elde edeceksiniz.
Bu kabuk program�n� kullanmak olduk�a basittir:
#!/bin/sh
if [ "$SHELL" = "/bin/bash" ]; then
  echo "Giri� kabu�unuz bash (bourne again shell) d�r."
else
  echo "Giri� kabu�unuz bash de�il $SHELL dir"
fi
$SHELL de�i�keni kullan�lan kabu�un ismini i�ermektedir ve biz onu "/bin/bash" ile kar��la�t�r�yoruz.

K�sayol i�lemcileri (operat�rleri)
C ile tan���k olan ki�iler a�a��daki yap�y� hemen benimseyeceklerdir:
[ -f "/etc/shadow" ] && echo "Bu bilgisayar g�lge �ifrelemesi
                                      (shadow passwords) kullan�yor."
&& ifadesi if-ifadesine k�sayol gibi kullan�labilir. �fadenin sa� taraf� ancak sol taraf� do�ru oldu�unda �al��t�r�lmaktad�r. Bunu VE (AND) gibi okuyabilirsiniz. Buna g�re : "/etc/shadow dosyas� var VE echo �al��t�r�lmaktad�r". VEYA (||) i�lemcisi de vard�r. �rnek:
#!/bin/sh
eiletidizini=/var/spool/mail/james
[ -r "$eiletidizini" ] || { echo "$eiletidizini dizinini okuyam�yorum" ; exit 1; }
echo "$eiletidizini de eiletiniz var.:"
grep "^From " $eiletidizini
Bu kabuk beti�i e-ileti dizinini okuyup okuyamad��na bakmaktad�r. E�er, okuyabiliyorsa, dosyadan "From" i�eren sat�rlar� ekrana yazmaktad�r. E�er $eiletidizini dosyas�n� okuyam�yorsa, VEYA i�lemcisi devreye girmektedir. Normal �ngilizce'de program par�as�n� �u �ekilde okuyoruz: "E-ileti dizini okunabilir veya ��k.". Buradaki sorun, VEYA'dan sonra sadece bir komuta yer olmas�d�r, ancak bizim birden fazla komuta gereksinimiz vard�r:
-hata mesaj� g�r�nt�le
-programdan ��k
Bu ikisini bir arada kullanabilmek i�in, bunlar� ad� olmayan bir fonksiyon olarak grupluyoruz. Fonksiyonlar hakk�nda genel bilgi a�a��da verilmektedir.
Her�eyi VE veya VEYA'lar kullanmadan, sadece if-ifadelerinden yararlanarak da ger�ekle�tirebilirsiniz, VE ve VEYA'lar biraz daha kullan��l�d�r.

case ifadesi bir katar� (kabuktaki * ve ? de kullan�labilir) birden fazla se�enekten birine uygun d���rmede kullan�lmaktad�r.
case ... in
...) burada bir�eyler yap;;
esac
Bir �rnek ele alal�m. Bir dosyan�n tipini f�le komutunu kullanarak ��renebiliriz:
file lf.gz

sonu�:

lf.gz: gzip compressed data, deflated, original filename,
last modified: Mon Aug 27 23:09:18 2001, os: Unix
�imdi biz bu komutu smartzip ad�nda, otomatik olarak s�k��t�r�lm�� (uncompress, bzip2, gzip ve zip) dosyalar� a�an bir kabuk program� yaz�m�nda kullanaca��z:
#!/bin/sh
ftype=`file "$1"`
case "$ftype" in
"$1: Zip archive"*)
    unzip "$1" ;;
"$1: gzip compressed"*)
    gunzip "$1" ;;
"$1: bzip2 compressed"*)
    bunzip2 "$1" ;;
*) error "File $1 dosyas� smartzip ile a��lam�yor.";;
esac

E�er, dikkat ettiyseniz, burada �zel bir de�i�ken kulland�k $1. Bu de�i�ken, programa komut sat�r�ndan verilen ilk parametreyi i�ermektedir. Program� :
smartzip yazilar.zip
gibi �al��t�r�rsak, $1'in alaca�� de�er yazilar.zip olacakt�r.

select ifadesi bash kabu�una �zg�d�r ve etkile�imli kullan�mlarda olduk�a yarar sa�lamaktad�r. Kullan�c�, kendisine verilen bir listeden birini se�ebilmektedir:
select var in ... ; do
  break
done
.... �imdi $var kullan�labilir ....
��te �rnek:
#!/bin/sh
echo "En favori i�letim sisteminiz hangisidir?"
select var in "Linux" "Gnu Hurd" "Free BSD" "Di�er"; do
        break
done
echo "Se�iminiz $var dur."
Kabuk program� �unlar� ger�ekle�tirmektedir:
En favori i�letim sisteminiz hangisidir?
1) Linux
2) Gnu Hurd
3) Free BSD
4) Di�er
#? 1
Se�iminiz Linux dur."
Kabukta kullanabilece�iniz d�ng� ifadeleri �unlard�r:
while ...; do
 ....
done
while-d�ng�s� denetlenen ifade do�ru oldu�u s�rece �al���lacakt�r. D�ng�n�n herhangi bir noktas�ndan ��kmak i�in "break" kullan�labilir. D�ng�n�n herhangi bir yerinde "continue" kullan�l�rsa, d�ng�n�n geriye kalan� �al��t�r�lmamakta ve onun yerine d�ng�n�n ba��na d�n�lmektedir.

for-d�ng�s� bo�luklar ile ayr�lm�� katar listesini parametre olarak almaktad�r ve bunlar� s�ras�yla ilgili de�i�kene atamaktad�r:
for de�i�ken in ....; do
  ....
done
A�a��daki �rnekte A dan C'ye kadar olan karakterler ekrana yazmaktad�r:
#!/bin/sh
for degisken in A B C ; do
  echo "de�i�kenin de�eri $degisken"
done
A�a��da daha kullan��l� bir �rnek yer almaktdad�r. �rnek, rpmgoster ad�n� ta��makta ve parametre olarak verilen rpm paketleri hakk�nda bilgi elde etmekte ve ekranda g�stermektedir:
#!/bin/sh
# RPM paketlerinin i�eri�ini listeler
# KULLANIM: rpmgoster rpmdosya1 rpmdosya2 ...
# �RNEK: rpmgoster /cdrom/RedHat/RPMS/*.rpm
for rpmpaketi in $*; do
  if [ -r "$rpmpaketi" ];then
    echo "=============== $rpmpaketi =============="
    rpm -qi -p $rpmpaketi
  else
    echo "HATA: $rpmpaketi dosyas� okunamad�."
  fi
done
Yukar�daki �rnekte komut sat�r�ndan verilen ve t�m parametreleri i�eren $* de�i�kenini g�r�yorsunuz. Program�,
rpmgoster openssh.rpm w3m.rpm webgrep.rpm
olarak �al��t�r�rsak, $* de�i�keni 3 parametreyi birlikte i�erecektir: openssh.rpm, w3m.rpm ve webgrep.rpm.

GNU bash ayr�ca until-d�ng�s�ne de sahiptir, ancak while ve for d�ng�leri genellikle yeterli olmaktad�r.

T�rnak i�ine alma
Programa herhangi bir parametre g�ndermeden �nce, kabuk joker (*, ?) karakterleri ve de�i�kenleri kullanmaya ve yerle�tirmeye �al��maktad�r. Kullanmak ve yerle�tirmeden kas�t, joker (*, ? gibi) karakterlerin yerine uygun dosya adlar� konulmas� ve de�i�kenlerin yerine ta��d�klar� de�erler ile de�i�tirilmesidir. Bu uygulamay� de�i�tirmek i�in t�rnak kullanabilirsiniz: S�zgelimi, bulundu�umuz dizinde yer alan dosyalar aras�nda eileti.jpg ve tux.jpg jpg dosyalar� da olsun.
#!/bin/sh
echo *.jpg
Bu ekrana "eileti.jpg tux.jpg" yazacakt�r.
Bunu �nlemek i�in tek veya �ift t�rnak kullanabiliriz:
#!/bin/sh
echo "*.jpg"
echo '*.jpg'
Bu ise, ekrana "*.jpg" ifadesini iki kez yazmaktad�r.
Tek t�rnaklar daha k�s�tlay�c�d�r. Tek t�rnak kullan�ld���nda, de�ikenlerin yerine de�erlerinin konulmas� bile engellenmektedir:
#!/bin/sh
echo $SHELL
echo "$SHELL"
echo '$SHELL'
Sonu� a�a��daki gibi olacakt�r:
/bin/bash
/bin/bash
$SHELL
Son olarak, �zel anlam ta��yan herhangi bir karakteri yazmak i�in �n�ne ters b�l� �izgisi kullanabiliriz:
echo \*.jpg
echo \$SHELL
dolay�s�yla:
*.jpg
$SHELL
elde edilir.

Bilgilendirme yeri
Bilgilendirme yeri, birden fazla sat�rdan olu�an metni bir komuta g�ndermek istedi�inizde kullan�labilir. Kabuk programlar�n�zda yard�m metni yazarken her sat�r�n ba��na echo komutunu kullanmadan yazabilmek olduk�a kullan��l� olmaktad�r. "Bilgilendirme yeri" << ve metnin sonunda da yaz�lmas� gereken bir ba�l�k ile ba�lamaktad�r. ren ad�ndaki �rnek kabuk program�, yard�m metni i�in bilgilendirme yerinden faydalanmaktad�r ve yapt��� i� ise, birden fazla dosya ismini de�i�tirmmektir:
#!/bin/sh
# E�er, 3'ten daha az paramtre verilmi�se, yard�m mesaj� g�r�nt�lenecektir:
if [ $# -lt 3 ] ; then
cat <<YARDIM
ren -- birden fazla dosyan�n ad�n� s�radan ifadeler kullanarak de�i�tirmektedir.

KULLANIMI: ren 's�radanifade' 'yerinekonulacakifade' dosyalar...

�RNEK: t�m *.HTM dosyalar�n� *.html olarak de�i�tirmek i�in:
  ren 'HTM$' 'html' *.HTM

YARDIM
  exit 0
fi
ESKI="$1"
YENI="$2"
# shift komutu, komut sat�r�ndan verilen parametre listesinden
# bir adet parametreyi silmektedir
shift
shift
# �imdi $* t�m dosyalar� i�ermektedir:
for dosya in $*; do
    if [ -f "$dosya" ] ; then
      yenidosya=`echo "$dosya" | sed "s/${ESKI}/${YENI}/g"`
      if [ -f "$yenidosya" ]; then
        echo "HATA: $yenidosya zaten var"
      else
        echo "$dosya s� $yenidosya olarak de�i�tirilmektedir ..."
        mv "$dosya" "$yenidosya"
      fi
    fi
done
Bu �u ana kadar inceledi�imiz en karma��k betiktir. Bunun �zerinde biraz konu�al�m. �lk if-ifadesi, komut sat�r�ndan verilen parametre say�s�n�n en az�ndan 3 adet olup olmad���n� denetlemektedir. (�zel bir de�i�ken olan $# de parametre say�s�n� tutmaktad�r.) E�er, parametre say�s� yeterli de�il ise, yard�m mesaj� cat komutuna, o da ekrana g�ndermektedir. Yard�m mesaj� g�r�nt�lendikten sonra programdan ��k�lmaktad�r. E�er, 3 veya daha fazla parametre verilmi� ise, ilki ESKI, ikincisi de YENI de�i�kenlerine atanmaktad�r. Daha sonra, shift komutu iki defa kullan�larak 3. paramtreyi ilk parametre olarak elde etmek i�in kayd�r�lmaktad�r. $* daki her parametre tek tek $dosya de�i�kenine atanmaktad�r. �lk �nce dosyan�n var olup olmad��� denetlenmektedir ve ondan sonra yeni dosya ad� eskisi �zerinde sed komutuyla yap�lan de�i�tirme ile elde edilmektedir. Ters t�rnaklar, yeni dosya isminin yenidosya de�i�kenine atamak i�in kullan�lm��t�r. Art�k gereksinim duydu�umuz her�eye sahibiz: eski dosya ad�na ve yenisine. Bu ikisi mv komutuna parametre olarak verilerek, eski dosya ismi yenisi ile de�i�tirilmektedir.

Fonksiyonlar
Daha kar���k programlar yazmaya ba�lar ba�lamaz, ayn� program par�alar�n� birden fazla yerde kulland���n�z� fark ediyorsunuz. Bunun i�in fonksiyonlardan yararlanabiliriz. Bir fonksiyon a�a��daki gibi g�z�kmektedir:
fonksiyonismi()
{
 # Fonksiyon g�vdesinde (i�erisnde) $1, fonksiyona verilen ilk parametre
 # $2 ikinci vs.
 fonksiyonun g�vdesi
}
Fonksiyonu kullanmadan �nce, program�n ba��nda fonksiyonu "tan�mlamak" gerekmektedir.

Konsole penceresinin ba�l���n� de�i�tirmek i�in xtitlebar adl� program kullan�labilir. E�er, ayn� anda birden fazla konsole kullan�yorsan�z, ba�l�klar�ndan hangisinin ne oldu�unu kolayca anlayabilirsiniz. Konsole'un ismi, kendisine g�nderilen ka��� kodu (escape sequence) ile de�i�tirilmektedir. Betik yardim adinda bir fonksiyon kullanmaktad�r. G�r�ld��� �zere, yardim fonksiyonu bir defa tan�mlanm�� ve iki yerde kullan�lm��t�r:
#!/bin/sh
# vim: set sw=4 ts=4 et:

yardim()
{
    cat <<YARDIM
xtitlebar -- xterm, gnome-terminal veya kde konsole un ad� de�i�tirir.

KULLANIMI: xtitlebar [-h] "ba�l�k"

SE�ENEKLER: -h yardim metin

�RNEK: xtitlebar "cvs"

YARDIM
    exit 0
}

# Hata durumunda veya -h parametresi verildi�inde yardim
# fonksiyonunu �a��rmaktay�z:
[ -z "$1" ] && yardim
[ "$1" = "-h" ] && yardim

# konsole'un ba�l���n� de�i�tirmek i�in ka��� kodu g�nder:
echo -e "\033]0;$1\007"
#
Yazd���n�z programlarda geni� yard�m bilgilerine yer vermeniz iyi bir al��kanl�kt�r. Bu size ve ba�kalar�na program� kullan�rken olduk�a faydal� olmaktad�r.

Komut sat�r� parametreleri
$* ve $1, $2 ... $9 komut sat�r�ndan verilen parametreleri (program�n ad�ndan sonra gelen veriler) i�erdiklerini g�rm��t�k. �u ana kadar az say�da ve olduk�a basit yap�da parametre kulland�k (Bir iki gerekli parametre ve -h yard�m i�in). Ancak, �ok ge�meden, komut sat�r�ndan verilen parametreleri i�leyecek bir i�lemciye gereksinim duyacaks�n�z. Genelde, se�ime ba�l� t�m parametrelerin ba�� eksi i�aretini koymak ve bunlar�n di�er parametrelerden (dosya ad� vs.) �nce gelmesi al���lagelmi� bir uygulamad�r.

Parametre i�lemcisi olu�turman�n bir�ok yolu vard�r. A�a��daki while d�ng�s� ve case ifadesi genel bir parametre i�lemci i�in �ok uygun bir ��z�md�r:
#!/bin/sh
yardim()
{
  cat <<YARDIM
Bu genel bir parametre i�lemcisidir.
�RNEK KULLANIM: cmdparser -l merhaba -f -- -dosya1 dosya2
YARDIM
  exit 0
}

while [ -n "$1" ]; do
case $1 in
    -h) yardim;shift 1;; # yard�m fonksiyonu �a�r�ld�
    -f) opt_f=1;shift 1;; # opt_f de�i�kenine de�er atand�
    -l) opt_l=$2;shift 2;; # -l parametresi de�er almaktad�r,
       -> shift ile 2 kayd�r�ld�ktan sonar
    --) shift;break;; # se�enekler b�l�m�n�n sonu
    -*) echo "hata: $1 se�ene�i tan�ml� de�ildir. yard�m i�in -h";exit 1;;
    *)  break;;
esac
done

echo "opt_f nin de�eri $opt_f"
echo "opt_l nin de�eri $opt_l"
echo "ilk parametre $1"
echo "ikinci parametre $2"
Bunu bir deneyin! Program� a�a��daki gibi �al��t�rabilirsiniz:
cmdparser -l merhaba -f -- -dosya1 dosya2
sonu�
opt_f nin de�eri 1
opt_l nin de�eri merhaba
ilk parametre -dosya1
ikinci parametre dosya2
Bu nas�l �al��maktad�r? D�ng� i�inde t�m parametreler tek tek case ifadesindekilere uyup uymad��� kar��la�t�r�lmaktad�r. Uyuan bir parametre bulundu�unda, de�eri ilgili de�i�kene atanmakta ve bir kayd�r�lmaktad�r. Unix'te, se�imler (- eksi i�areti ile ba�layanlar) �nce gelmektedir. �ki eksi (--) �izgisiyle se�imlerin bitti�ini belirtebilirsiniz. Buna, eksi ile ba�layan bir katar� grep ile ararken gereksiminiz olacakt�r:
f.txt dosyas�nda -xx- arama:
grep -- -xx- f.txt
Bizim parametre i�lemcimiz, yukar�da da g�r�ld��� gibi, -- ile ba�layan parametreleri de i�leyebilmektedir.  

�rnekler

Genel ama�l� program iskeleti

Bir kabuk program� yazmak i�in gerekli olan t�m bile�enleri inceledik. T�m iyi programlarda yard�m bulunmal�d�r ve se�enekleri i�lemek, tek bir se�enek olsa bile, i�in genel ama�l� �e�enek i�lemcimizden yararlanabilirsiniz. Dolay�s�yla, ba�ka programlar�n yaz�m�nda temel alabilece�iniz framework.sh, bir �er�eve program�n�z�n olmas�, hi� de fena fikir de�ildir. Yeni bir program yazaca��n�z zaman, bundan bir kopya ��kartman�z yeterlidir:
cp framework.sh benimprogram
ve bundan sonra "benimprogram" adl� programda gerekli de�i�iklikler yap�labilir.

�imdi �u iki program� inceleyelim:

�kili say� tabanda verilen bir say�s�, onlu tabana �eviren program

b2d program�, ikili say� taban�nda verilen bir say�y� (1101 gibi) kar��l��� olan onlu tabana �evirmektedir. Bu program expr kullanarak basit matematiksel i�lemlerin nas�l yap�labilece�iniz g�stermektedir:
#!/bin/sh
# vim: set sw=4 ts=4 et:
yardim()
{
  cat <<YARDIM
b2h -- ikili say� sisteminde verilen bir say�y�, onlu say� sisteme �evirir

KULANIM: b2h [-h] ikilisayi

SE�ENEKLER: -h yard�m metin

�RNEK: b2h 111010
i�in sonu� 58 olur
YARDIM
  exit 0
}

hata()
{
    # hata mesaj�n� g�r�nt�le ve ��k
    echo "$1"
    exit 1
}

sonkarakter()
{
    # $rval de�i�keni i�erisine, verilen katar�n son karakterini yerle�tirir
    if [ -z "$1" ]; then
        # bo� katar
        rval=""
        return
    fi
    # wc, ��kt�n�n sonuna biraz bo�luk koymaktad�r,
    # sed'e gereksinim duymam�z�n nedeni budur:
    karaktersayisi=`echo -n "$1" | wc -c | sed 's/ //g' `
    # �imdi son karakteri elde et
    rval=`echo -n "$1" | cut -b $karaktersayisi`
}

kes()
{
    # verilen bir katar�n son karakterini kesip, geriye kalan�
    # $rval i�ine yerle�tirir
    if [ -z "$1" ]; then
        # bo� katar
        rval=""
        return
    fi
    # wc, ��kt�n�n sonuna biraz bo�luk koymaktad�r, sed'e gereksinim
    # duymam�z�n nedeni budur:
    karaktersayisi=`echo -n "$1" | wc -c | sed 's/ //g' `
    if [ "$karaktersayisi" = "1" ]; then
        # katarda sadece bir karakter var
        rval=""
        return
    fi
    karaktersayisieksi1=`expr $karaktersayisi "-" 1`
    # son hari� hepsini al:
    rval=`echo -n "$1" | cut -b 0-${karaktersayisieksi1}`
}


while [ -n "$1" ]; do
case $1 in
    -h) yardim;shift 1;; # yard�m fonksiyonu �a��r�ld�
    --) shift;break;; # se�eneklerin sonu
    -*) hata "hata: b�yle bir se�enek yok. Yrd�m i�in $1. -h ";;
    *)  break;;
esac
done

# Program�n ana k�sm�
toplam=0
agirlik=1
# bir parametre mutlaka verilmelidir:
[ -z "$1" ] && yardim
ikilisayi="$1"
orjikilisayi="$1"

while [ -n "$ikilisayi" ]; do
    sonkarakter "$ikilisayi"
    if [ "$rval" = "1" ]; then
        toplam=`expr "$agirlik" "+" "$toplam"`
    fi
    # $ikilisayi'daki son karakteri ��kart
    kes "$ikilisayi"
    ikilisayi="$rval"
    agirlik=`expr "$agirlik" "*" 2`
done

echo "�kili say� sistemindeki $orjikilisayi n�n
      onlu say� sistemindeki de�eri $toplam d�r"

Kullan�lan algoritma, sa� taraftan ba�layarak, her basamaktaki say�n�n a��rl���n� (1,2,4,8,16,..) kullanarak, e�er ilgili basamaktaki say� 1 ise, toplam de�i�kenine eklemektedir. S�zgelimi "10", 0 * 1 + 1 * 2 = 2 dir.
Katar�n her bir basmak say�s�n� elde etmek i�in sonkarakter fonksiyonunu kullan�yoruz. Bu fonksiyon, katardaki toplam karakter say�s�n� bulabilmek i�in wc -c komutundan yararlanmaktad�r. Daha sonra da, son karakteri elde etmek i�in cut komutundan yararlanmaktad�r. kes fonksiyonu da benzer bir mant�kla �al��maktad�r, ancak yapt��� i� katardaki sona karakterden kurtulup, ona kadar olan� elde etmektir.

Dosya �evirme program�
Belkide siz, g�ndermi� oldu�unuz t�m e-iletilerinizi bir dosyada saklayanlardans�n�zd�r. Birka� aydan sonra bu dosyan�n boyutu olduk�a b�y�mekte ve e-ileti program�yla dosyaya olan eri�imi yava�latnmaktad�r. rotatefile program� size yard�mc� olabilir. Program, eileti dizininizin ad�n�, ad� gideneileti olsun, gidenelileti.1, gidenelileti.2 vs. olarak de�i�tirmektedir.
#!/bin/sh
# vim: set sw=4 ts=4 et:
surum="0.1"
yardim()
{
    cat <<YARDIM
rotatefile -- dosya ad�n� �evirir

KULLANIM: rotatefile [-h]  dosyaadi

SE�ENEKLER: -h yardim metin

�RNEK: rotatefile giden
Bu program giden.2 yi giden.3, giden.1 i giden.2, giden i  giden.1 olarak
de�i�tirerek bo� bir giden dosyas� yaratacakt�r

En fazla 10'a kadar de�i�tirmektedir.

s�r�m $surum
YARDIM
    exit 0
}

hata()
{
    echo "$1"
    exit 1
}
while [ -n "$1" ]; do
case $1 in
    -h) yardim;shift 1;;
    --) break;;
    -*) echo "hata: b�yle bir se�enek yoktur $1. Yard�m i�in -h";exit 1;;
    *)  break;;
esac
done

# girilen verileri denetleme:
if [ -z "$1" ] ; then
 error "HATA: parametre olarak dosya vermeniz gerekmektedir,
        yard�m i�in -h kullan�n�z"
fi
dosyan="$1"
# .1 , .2 vs. dosyalr�n� ad�n� de�i�tir:
for n in  9 8 7 6 5 4 3 2 1; do
    if [ -f "$dosyan.$n" ]; then
        p=`expr $n + 1`
        echo "mv $dosyan.$n $dosyan.$p"
        mv $dosyan.$n $dosyan.$p
    fi
done
# orijinal dosyay�:
if [ -f "$dosyan" ]; then
    echo "mv $dosyan $dosyan.1"
    mv $dosyan $dosyan.1
fi
echo touch $ya
touch $dosyan

Bu nas�l �al��maktad�r? Kullan�c�n�n parametre olarak dosya verdi�ini denetledikten sonra, program, 9'dan 1'e do�ru bir d�ng� i�erisine girmektedir. Dolay�s�yla, 9. dosya 10, 8. dosya 9 vs. olmaktad�r. D�ng� bittikten sonra, orijinal dosyayi 1 olarak ad�n� de�i�tirdikten sonra orijinal dosya ad�nda bo� bir dosya yarat�lmaktad�r.  

Hata ay�klama

Hata ay�klamada kullan�lan en basit y�ntem echo komutunu kullanmakt�r. Bu komutu hatan�n olabilece�ini d���nd���n�z yerde kullanabilirsiniz. Bu belkide hata bulmada, kabuk programlar� yazan ki�ilerin %80'ninin kulland��� y�ntemdir. Kabuk programlar�n�n avantaj� derlemeye gereksinim duymamalar� ve bu y�zden echo komutunu eklemek uzun s�rmemektedir.

Kabukta, ger�ek hata ay�klama se�ene�i de vard�r. E�er, "garipbetik" adl� programda hata varsa, hatay�:
sh -x garipbetik
kullanarak bulabilirsiniz.
Program� bu �ekilde �al��t�rd���n�zda, �al��t�r�lan t�m komutlar�, de�i�kenlerin de�erleri ve joker karakterler (*,? gibi) varsa, yerlerine kar��l�klar�n� yerle�tirerek g�r�nt�lemektedir.

Ayr�ca, kabukta, program� �al��t�rmadan, yaz�m hatalar�n� denetleyen se�ene�i de vard�r. Bunun i�in:
sh -n sizin_programiniz
E�er, sonu�ta hi� bir �ey g�r�nt�lenmiyorsa, yaz�l�m hatas� yok demektir.

Bundan sonra kabuk programlar� yazmaya ba�lman�z dile�i ile. �yi eylenceler!
 

Kaynaklar

 

Bu yaz� i�in g�r�� bildiriminde bulunabilirsiniz

Her yaz� kendi g�r�� bildirim sayfas�na sahiptir. Bu sayfaya yorumlar�n�z� yazabilir ve di�er okuyucular�n yorumlar�na bakabilirsiniz.
 talkback page 

G�rsely�re sayfalar�n�n bak�m�, LinuxFocus Edit�rleri taraf�ndan yap�lmaktad�r
© Katja and Guido Socher, FDL
LinuxFocus.org

Buray� klikleyerek hatalar� rapor edebilir ya da yorumlar�n�z� LinuxFocus'a g�nderebilirsiniz
�eviri bilgisi:
en -> -- Katja and Guido Socher
en -> tr Ceyhun ELMAS ve Erdal MUTLU

2001-09-17, generated by lfparser version 2.17