Bash Komut Dosyasına Giriş

By onurbaburDetection Engineer

Bash’e Giriş

Bash’in Tarihi

Unix kabuğu, kullanıcıların işletim sistemleriyle etkileşime girmesine olanak tanıyan bir arayüz görevi görür. Bu kabuk kullanıcının komutlarını alır ve bu komutları işletim sistemine iletir. Shell hem bir betik dili hem de komutları yorumlayabilen bir programdır.

İlk Unix kabuğu, Unix’in orijinal yaratıcılarından Stephen R. Bourne tarafından 1979 yılında geliştirildi ve bu nedenle Bourne Shell adını aldı. Bourne kabuğu (“sh”) Unix ve Unix benzeri sistemlerde en yaygın kullanılan kabuk haline geldi.

1980’lerin ortalarında Brian Fox, Bourne Shell’in yerine geçmek amacıyla GNU projesi için Bash’i (Bourne Again Shell) geliştirdi. Bash, Bourne Shell’in özelliklerini kapsayan ancak aynı zamanda daha gelişmiş özellikler ve kullanıcı dostu bir arayüz sağlayan bir kabuktur. Bash, Linux ve macOS dahil olmak üzere birçok Unix benzeri sistem için standart kabuk olarak kullanılır.

Bash’in gelişimi, çeşitli hataların düzeltilmesinin yanı sıra komut satırı düzenleme, kabuk işi kontrolü, kabuk işlevleri ve daha pek çok yeni özelliğin eklenmesiyle devam etti.

Bash’in hem kabuğun önemini ve esnekliğini kanıtlaması hem de script yazmayı kolaylaştırması nedeniyle birçok sistem yöneticisi ve geliştiricisinin tercih ettiği araç olduğunu söyleyebiliriz. Bu da Bash’in özellikle sistem yönetimi ve otomatikleştirilmiş görevlerde sıklıkla kullanılmasını sağlamıştır.

Eksileri ve Artıları

Bash, UNIX sistemlerinde oluşturulduğundan, o ortamın doğasında olan sağlamlığa ve problem çözme yeteneklerine sahiptir. Bash’i karakterize eden güçlü yönlere bir göz atalım:

Her Yerde Çalışır

Bash’i neredeyse her yerde bulabilirsiniz. Linux, Mac ve hatta Windows’ta çalışır (Linux için Windows Alt Sistemi sayesinde). Aslında siz görmeseniz de arabanızda, evinizdeki televizyonunuzda bir BASH var. Bu, yazdığınız scriptlerin hemen hemen her platformda çalışacağı anlamına gelir.

Otomasyon Yetenekleri

Bash, görevleri otomatikleştirmenin bir numaralı yöntemidir. Tekrarlanan görevleri gerçekleştirebileceğiniz güçlü bir araçtır. Bash’in yeteneklerini kullanmak, zamandan tasarruf etmenin ve hataları azaltmanın harika bir yoludur.

Verimlilik

Bash sayesinde karmaşık komutları birleştirme ve birçok görevi aynı anda gerçekleştirme olanağına sahipsiniz. Bu daha üretken olmanıza yardımcı olur.

Birçok Farklı Araçla Entegrasyon Yeteneği

Bash, birçok Unix komutu ve aracıyla mükemmel bir şekilde bütünleşir. Bu, daha karmaşık işlemleri gerçekleştirmenize ve aynı komut dosyasında birçok farklı araç kullanmanıza olanak tanır.

Bash’in güçlü yönlerini yukarıda gördük. Ne yazık ki bazı zayıf yönleri de var. Bunları listelemeden önce Bash’in aslında bir sistem yönetim aracı olarak mükemmel olduğunu, diğer modern betik dilleriyle karşılaştırıldığında dezavantajlarının ortaya çıktığını belirtelim:

Karmaşıklık

Bash özellikle yeni başlayanlar için biraz karmaşık olabilir. Sözdizimi biraz tuhaf olabilir ve zaman zaman hatırlanması zor olabilir.

Hata Ayıklama: Bash’te hata ayıklamak biraz zahmetli olabilir. Bash genellikle satır numarasını hatalı görüntülemez ve bu da hataların bulunmasını zorlaştırır.

Verim

Bash performans açısından diğer dillere göre biraz daha yavaştır. Bu genellikle bir sorun olmasa da zaman zaman çok büyük veri kümeleriyle çalışırken veya görevleri çok hızlı bir şekilde gerçekleştirmeniz gerektiğinde ortaya çıkabilir.

Gelişmiş özellikler

Bash, Python veya JavaScript gibi dillerin sunduğu bazı gelişmiş özelliklere sahip değildir. Örneğin, Bash birinci sınıf işlevler, veri yapıları vb. gibi özelliklerden yoksundur.

Özetlemek gerekirse, Bash birçok durumda, özellikle sistem yönetimi ve otomasyonla ilgili görevler için mükemmel bir seçenektir. Ancak bazı durumlar ve gereksinimler için diğer diller daha uygun olabilir.

Terminoloji

Bu bölümde Unix dünyasına aşina olmayanlar için çok temel bazı kavramları açıklayalım. Bunlar dersin ilerleyen aşamalarını daha anlaşılır hale getirecektir.

Kabuk

Shell, kullanıcıların işletim sistemiyle iletişim kurmasını sağlar. Kabuk bir tür kullanıcı arayüzüdür ve genellikle metin tabanlıdır. Kabuklar aynı zamanda bir betik dili içerir ve kullanıcıların komutları yazılı bir betik olarak kaydetmesine ve bu betiği daha sonra otomatik olarak çalıştırmasına olanak tanır. Bash, en popüler Unix kabuklarından biridir ve genellikle Linux ve macOS’ta varsayılan kabuk olarak gelir.

Komut Satırı (CLI)

Komut satırı, kullanıcıların kabuğa komutlar girdiği bir arayüzdür. Genellikle bir terminal veya konsol uygulaması aracılığıyla erişilir. Kullanıcılar, metin tabanlı komutlar yazıp “Enter” tuşuna basarak işletim sistemine ne yapması gerektiğini söyler.

Emretmek

Komut, belirli bir eylemi gerçekleştirmek için işletim sistemine verilen talimattır. Örneğin ‘ls’, geçerli dizindeki dosyaları ve dizinleri kullanıcıya listeleyen bir Unix komutudur. ‘cd’ başka bir komuttur ve mevcut çalışma dizinini değiştirir.

Senaryo

Komut dosyası, otomatikleştirilmiş bir komutlar kümesidir. Bu komutlar bir dosyada saklanır ve daha sonra kabuk tarafından yorumlanır ve yürütülür. Bash betikleri genellikle “.sh” uzantısıyla biten dosyalarda saklanır ve bir dizi komut ve kontrol yapısı (if-else yapıları, döngüler vb.) içerebilir.

Boru hattı

Pipelining, bir komutun çıktısını başka bir komutun girdisi olarak kullanma yeteneğidir. Bu ‘|’ sembolüyle yapılır. Örneğin, ‘ls | Grep .txt komutu, ls komutunun çıktısını grep komutuna iletir ve yalnızca .txt uzantılı dosyaları listeler.

Ortam Değişkenleri

Ortam değişkenleri, kabuğun ve çalıştırdığı programların belirli değerleri depolamasına ve bunlara erişmesine olanak tanır. Örneğin, ‘PATH’ ortam değişkeni, kabuğun komutlar için hangi dizinleri kontrol edeceğini belirtir. Bu ortam değişkenleri sistem genelinde veya belirli bir kullanıcı için ayarlanabilir.

STDIN, STDOUT ve STDERR

Bu terimler, kabuğun ve programların giriş ve çıkışına ilişkin standart kanalları ifade eder. STDIN genellikle klavyeden gelen girişi temsil eder, STDOUT doğru çıkışı temsil eder ve STDERR hatalı çıkışı temsil eder.

Yürütme İzinleri

Unix tabanlı sistemlerde bir dosyanın veya betiğin çalıştırılabilir olup olmadığını belirler. Bu izinler ‘chmod’ komutuyla değiştirilebilir.

Bu terimler Bash ve genel Unix dünyasında karşılaşacağınız temel kavramlardan bazılarıdır. Bunları anlamak, Unix tabanlı bir sistemde etkili bir şekilde çalışmanın ve Bash komut dosyaları yazmanın önemli bir parçasıdır.

Selam Dünya

Birlikte küçük bir bash betiği yazalım:

İlk önce bir metin düzenleyici açın. Linux’ta genellikle ‘nano’, ‘vi’ veya ’emacs’ olabilir. Windows’ta Not Defteri’ni veya başka bir metin düzenleyiciyi kullanabilirsiniz. Temel olarak yapacağımız şey .sh uzantılı bir metin dosyası oluşturmak

Metin düzenleyicisine aşağıdaki iki satırı yazın:

#!/bin/bash
echo "Hello World"

‘#!/bin/bash’ satırı bu betiğin Bash’te çalıştırılması gerektiğini belirtir.

Öte yandan ‘echo’ komutu metni ekrana yazdırır.

Bu dosyayı hello_word.sh olarak kaydedin .

Şimdi betiğin çalıştırılabilir olduğundan emin olmalıyız. Bunu terminalde aşağıdaki komutu çalıştırarak yapabiliriz:

                    
chmod +x hello_word.sh

Bu komut, “hello_world.sh” dosyasına yürütülebilir izinler ekler.

Son olarak betiğimizi çalıştırabiliriz:

                    
./hello_word.sh

Bash Ortamını Kurma

Bash neredeyse tüm Linux, Unix, BSD ve MacOS platformlarında yüklü olarak gelir ve genellikle varsayılan kabuk uygulamasıdır. Bu sistemlerin bazılarında (örn. Kali Linux) ZSH vb. öntanımlıdır. Her ne kadar kabuk ortamları kullanılsa da, bash kullanmanız için ihtiyacınız olan tüm paketler sistemde mevcuttur ve bash yazıp enter tuşuna basarak bash kabuğuna düşebilirsiniz. Ayrıca bash betiklerinin genellikle “zsh” vb. kabuklar altında sorunsuzca çalışacağını da unutmamalıyız.

Windows ortamlarında bash varsayılan olarak dahil değildir ancak Windows işletim sistemlerinde bash kullanmanın birden fazla yolu vardır. Şimdi bunlara bir göz atalım:

WSL (Linux için Windows Alt Sistemi)

Microsoft, Windows 10 ve sonraki sürümlerde kullanıcıların Linux işletim sistemlerini doğrudan çalıştırmasına olanak tanıyan Linux için Windows Alt Sistemi özelliğini sunmaktadır. Bu özellik Bash’i Windows sistemlerinde kullanmamızın yollarından biridir. Bu özelliği kullanabilmek için yapılandırmamız gereken bir dizi kurulum ve ayar bulunmaktadır.

Öncelikle Yönetici haklarına sahip bir PowerShell konsolu açıp aşağıdaki komutu çalıştırıp kurulumun tamamlanmasını beklememiz gerekiyor:

wsl --install

Kurulum tamamlandıktan sonra Başlat menüsünden Ubuntu uygulamasını bulup çalıştırarak Linux ortamınıza erişebilirsiniz. Ancak bazı durumlarda aşağıdaki gibi bir hata mesajı almanız muhtemeldir.

Bu hata mesajını alıyorsanız iki şeyi deneyebilirsiniz. Öncelikle bilgisayarınızın BIOS ayarlarında “Sanallaştırma Desteği” seçeneğini bulup etkinleştirin. Bu işlemleri yaptıktan sonra da sorununuz çözülmediyse aşağıdaki komutları çalıştırdıktan sonra bilgisayarınızı yeniden başlatabilirsiniz:

DISM /Online /Enable-Feature /All /FeatureName:Microsoft-Hyper-V
bcdedit /set hypervisorlaunchtype auto

Her şey yolunda gittiyse ve Ubuntu Sisteminiz WSL’de düzgün çalışmaya başladıysa, bash konsolunu başlatmadan önce bizden bir kullanıcı adı ve şifre tanımlamamızı isteyecektir.

Dosya sistemi ile ilgili bir hatırlatma yapmamız gerekiyor. Ubuntu WSL kendi sanal dosya sisteminde çalışır. Windows’unuzun dosya sistemlerini /mnt/ dizini altına bağlar. Yani Windows sisteminizin C:/ diskindeki dosya ve dizinleri görüntülemek istiyorsanız ls /mnt/c komutunu çalıştırmanız gerekmektedir. Bu, komut dosyalarınızı yazarken ve çalıştırırken dikkate almanız gereken önemli bir durumdur.

Windows’ta Ubuntu WSL ortamındaki ana dizininize erişmek için “ explorer.exe” kullanmalısınız . ” (sondaki noktaya dikkat edin) ana dizininizde ve enter tuşuna basın.

CygWIN

Cygwin, Windows işletim sistemlerinde POSIX uyumlu bir ortam sağlamak için tasarlanmış bir yazılım paketidir. POSIX, bir işletim sisteminin nasıl çalışması gerektiğini tanımlayan bir dizi standarttır ve Unix ve Unix benzeri sistemlerin çoğu (Linux, BSD, vb.) bu standartları takip eder.

Cygwin, POSIX API’lerini Windows API’lerine çeviren bir kitaplık (cygwin1.dll) ve bu uygulamaların Windows’ta yerel olarak çalışabilmesini sağlayan birçok GNU ve açık kaynaklı uygulama içerir.

Birçok Unix/Linux komutu ve hizmeti (örneğin, bash kabuğu, ssh, tar, awk, make, grep ve daha fazlası) Cygwin ile Windows’ta kullanılabilir hale gelir. Ayrıca Cygwin ile Unix/Linux programlarını Windows üzerinde derleyip çalıştırabilirsiniz.

Cygwin’in nasıl çalıştığını detaylı olarak anlatmak gerekirse; Cygwin, Unix/Linux işletim sistemi çağrılarını nasıl gerçekleştireceğini bilen (örneğin, bir dosyayı açmak veya bir işlem oluşturmak) Unix/Linux uygulamalarına olanak tanıyan ve bu uygulamaların bunları Windows’un anlayacağı bir formata dönüştürmesine olanak tanıyan bir araçtır.

Bu, uygulamanın Unix/Linux ortamında çalışıyormuş gibi “sanki” hissetmesini sağlar. Ancak bu tür bir dönüştürme her zaman mükemmel olmayabilir ve bazen uygulamaların beklenmedik şekillerde davranmasına neden olabilir.

Cygwin’i yüklemek için Cygwin web sitesinden ( https://www.cygwin.com ) setup-x86.exe’yi (32 bit sistemler için) veya setup-x86_64.exe’yi (64 bit sistemler için) indirip çalıştırmanız gerekir. . Kurulum sırasında hangi paketlerin kurulacağını seçebilirsiniz. Bash kabuğu ve bazı temel araçlar için varsayılan seçenekler genellikle yeterlidir. Kurulum tamamlandıktan sonra Cygwin’i başlatabilir ve bash kabuğunu kullanabilirsiniz.

Şimdi kurulum adımlarına bir göz atalım:

Karşılama ekranının ardından dosyaların nasıl indirileceği ve nasıl kurulacağı ile ilgili seçenekleri göreceğiz. Varsayılan seçenekle devam edebiliriz.

Bir sonraki adımda CygWIN’i nereye kuracağımızı seçmemiz gerekiyor. Varsayılan olarak bırakmanızı öneririz.

Bir sonraki adımda “Yerel Paket Dizini” ayarlarını seçmemiz gerekiyor. Bu, paketlerin indirileceği dizin olacaktır. Yalnızca hesabınızın erişebileceği, size güvenlik sağlayacak bir dizin seçmeniz güvenliğiniz açısından önemlidir. Farklı bir şeye ihtiyacınız yoksa bunu varsayılan olarak da bırakabilirsiniz:

Bir sonraki adımda paketleri nereden indirmek istediğimizi seçmemiz gerekiyor. Seçeneklerde hemen hemen herhangi bir indirme sitesini seçebilirsiniz ancak bağlantınızın yavaş olduğu durumlarda kendi ülkenizde bir ayna seçmeniz gerekebilir. Veya bazı ülkelere erişiminiz kısıtlıysa, kısıtlama olmayan bir ülkeden bir ayna seçebilirsiniz, genellikle bunlardan herhangi birine tıklayın:

Bir sonraki adımda CygWIN ile kullanmak istediğiniz uygulama ve paketleri seçmeniz gerekmektedir. Burada Shells altında Bash ile ilgili paketlerin güncel versiyonlarını seçtik . Ancak rahat bir çalışma alanı için çok daha fazla pakete ihtiyacımız olacağını unutmayın.

Ve şimdi kurulum başlayabilir:

Kurulum işlemi tamamlandığında masaüstünüzde ve başlat menünüzde yer alan Cygwin64 Terminal simgelerinden birine tıklayarak kabuğunuza erişebilirsiniz.

Gördüğünüz gibi Bash’i Windows sistemlerde de kullanmak mümkün. Etkin bir şekilde kullanabilmek için alışmak biraz zaman alır, ancak yetenekleri göz önüne alındığında buna değer.

Bash Komut Dosyasının Temelleri

Bu bölümde Bash scriptleri yazabilmek için bilmemiz gereken temel kavramları ve bunların nasıl kullanılacağını göreceğiz.

Değişkenler

Tüm programlama/komut dosyası yazma dillerinde olduğu gibi Bash’te de değişkenlerin kullanımı kritik öneme sahiptir. Değişkenleri daha sonra kullanmak üzere bazı verileri sakladığımız kaplar olarak düşünebilirsiniz. Bash’te değişkenleri iki farklı başlık altında ele alabiliriz:

Normal Değişkenler

Bash’te bir değişken tanımlamak oldukça basittir. Tek yapmanız gereken değişken adını belirtmek ve eşittir işaretiyle (=) bir değer atamak. Örneğin:

Bu örnekte “our_variable” adında bir değişken oluşturduk ve ona “Merhaba Dünya” değerini atadık.

Bir değişkenin değerini kullanmak için değişken adının önüne bir dolar işareti (`$`) koyarız:

Bu komut “our_variable” yani “Merhaba Dünya” değerini yazdırır.

Bu tanımın üzerinde çalıştığımız konsol oturumu boyunca geçerli olduğunu unutmayın. Yeni bir konsol açtığımızda bu değişkenin değerine ulaşamıyoruz.

Bir kullanıcının oturumu sırasında herhangi bir yerden erişilebilen bir değişken tanımlamak istiyorsak çevresel değişkenleri kullanmamız gerekir.

Çevresel değişkenler

Çevresel değişkenler, belirli bir kabuk oturumu boyunca var olan değişkenlerdir ve genellikle sistem bilgilerini, kullanıcı ayarlarını veya programların çalışması için gereken bilgileri içerir.

Çevresel değişkenlerin adları zorunlu olmasa da genellikle büyük harfle yazılır. Örneğin, ‘PATH’ ortam değişkeni, kabuğun komutları aramak için hangi dizinleri kontrol etmesi gerektiğini belirtir.

Bir çevresel değişkeni okumak için normal bir değişken gibi bir dolar işareti (`$`) koyarız:

echo $PATH

Bu komut, ‘PATH’ çevresel değişkeninin değerini ekrana yazdırır.

Bir çevresel değişken oluşturmak veya değiştirmek için ‘export’ komutunu kullanırız:

export NEW_VARIABLE="Hello World, Again…"

Bu örnekte, `NEW_VARIABLE` adında bir çevresel değişken oluşturduk ve ona “Merhaba Dünya, Yeniden…” değerini atadık. Bu ortam değişkeni mevcut kabuk oturumu boyunca mevcut olacak ve diğer programlar tarafından okunabilecektir.

Değişkenler ve ortam değişkenleri Bash betiklerindeki en önemli kavramlardan bazılarıdır ve Bash betiklerini dinamik ve etkileşimli hale getirirler.

Ekran görüntüsündeki örnekte de görebileceğiniz gibi, Linux komut satırındaki “env” komutu ile aktif oturumumuzda tüm geçerli çevresel değişkenlerin listesini görmek de mümkündür.

Değişkenlerdeki kapsam

Bash betiğinde kullandığımız değişkenlerin kapsamları vardır. Bunlar “Yerel” ve “Global” kapsamlardır.

“Global Değişkenler” bir betiğin herhangi bir yerinden erişilebilen değişkenlerdir.

“Yerel Değişkenler” yalnızca kullanıldıkları “Fonksiyon” içerisinde geçerli olan değişkenlerdir.

İlerleyen zamanlarda “Fonksiyonlar” konusunu işlediğimizde bu konuya tekrar değineceğiz.

Kontrol Yapıları

Bash, görevlerimizi otomatikleştirmek için çok kullanışlı bir araçtır. Ancak her şeyi tek yönlü, sabit bir yolda yapmaktan daha fazlasını yapabilmek istediğimiz zamanlar vardır. Kontrol yapılarının devreye girdiği yer burasıdır!

Kontrol yapıları, betiğimizin farklı koşullar için farklı yollar izlemesine olanak tanır. Diyelim ki bir dosyanın var olup olmadığını kontrol etmek istiyorsunuz. Burada “if” kontrol yapısını kullanabilirsiniz. Bash’teki “if” yapıları tıpkı diğer programlama dilleri gibi çalışır. Belirli bir koşul doğruysa belirli bir kod bloğunu çalıştırır.

Döngüler aynı zamanda kontrol yapılarının bir parçasıdır. Diyelim ki bir dizindeki tüm dosyaları listelemek ve her biri için belirli bir işlem yapmak istiyorsunuz. Burada “for” döngüsünü kullanabilirsiniz. Bu, belirli bir kod bloğunu bir dizi öğesi üzerinde tekrar tekrar çalıştırır.

Betiklerimizi daha akıllı ve esnek hale getiren kontrol yapıları, Bash betiklerinin gerçek gücünü ortaya çıkarır. Ayrıca daha karmaşık süreçleri otomatikleştirmemize de olanak tanıyorlar. Yani Bash’teki kontrol yapıları işleri yalnızca daha hızlı değil aynı zamanda daha akıllı yapmamızı sağlar!

Şimdi Bash’teki kontrol yapılarını tek tek inceleyelim:

“if-else-if” Yapısı

Bu yapı, belirli bir koşulun doğru olup olmadığını kontrol eder ve buna göre farklı komutları çalıştırır.

Örneğin, bu örnekte, kullanıcıdan bir sayı girmesini ister, kullanıcı tarafından girilen değeri bir değişkene atar ve ardından bu değişkenin değerinin şu şekilde olup olmadığını kontrol eder:

  • 10’dan büyüktür,
  • 10’a eşittir veya
  • 10’dan küçüktür.

Burada henüz kullanıcıdan gelen değerin tam sayı olup olmadığını kontrol etmediğimizi unutmayın.

#!/bin/bash
echo "Please Input Number:"
read variable_number

if [ "$variable_number" -gt "10" ]
then
    echo "The number you entered is GREATER THAN 10"
elif [ "$variable_number" -eq "10" ]
then
    echo "The number you entered is EQUAL TO 10"
else
    echo "The number you entered is LESS THAN 10"
fi

Yukarıdaki örnekte “Eşitse”, “Büyükse” ve “Küçükse” karşılaştırma operatörlerini kullandık. Aşağıdaki tablo Bash’te kullanabileceğiniz tüm standart karşılaştırma operatörlerini listelemektedir. “String” ve “Integer” veri türleri için eşitliği kontrol etmenin farklı yollarına özellikle dikkat etmelisiniz:

Döngüler

“Döngü için

Bu döngü, bir dizi öğe üzerinde belirli komutları yürütür. Örneğin:

#!/bin/bash

for count_variable in 1 2 3 4 5
do
    echo "Current Value: 
$count_variable
"
done

Bu örnekte 1’den 5’e kadar olan sayılar arasında bir döngü oluşturduk ve her birinin değerini yazdırdık.

Bash betiğinin “For” yapısı yalnızca bu örnekte kullandığımız tamsayı dizilerini kullanmaz. “For loop” için dosya sistemindeki stringleri, dosyaları ve dizinleri ya da herhangi bir komutun çıktısını string olarak kullanabiliriz.

#!/bin/bash

for count_variable in 1 2 3 4 5
do
    echo "Current Value: $count_variable"
done

for string_variable in Torvalds Stallman Raymond Linux Bash
do
    echo "$string_variable is Great"
done

for filesystem_variable in /home/letsdefend/ex*
do
    echo "Example File: $filesystem_variable"
done

for output_variable in $(cut -d: -f1 /etc/passwd)
do
    echo "User in Passwd File: $output_variable"
done

Şimdi bu betiğin çıktısına bakalım:


Bu örnekte görebileceğiniz gibi Bash scriptleri içinden işletim sistemiyle kolaylıkla etkileşim kurabilirsiniz.

“Döngü sırasında

“While” döngüsü, belirli bir koşul doğru olduğu sürece belirli komutları çalıştırır. Örneğin:

#!/bin/bash

our_variable=1
while [ $our_variable -le 5 ]
do
    echo "Value: $our_variable"
    ((our_variable++))
done

Bu örnekte değişkenin değeri 5’ten küçük veya eşit olduğu sürece bir döngü oluşturduk. Daha sonra başlattığımız “While” döngüsünde her döngüde değeri ekrana yazdırıp değerini arttırıyoruz. değişkenimiz 1’e eşit. İşte sonuç:

Yukarıdaki örnekte “While” ile sadece sayısal bir kontrol yaptık ve daha fazlasını da yapabiliriz.

Aşağıdaki örnekte:

  • Öncelikle bir “requested_value” (“Yes”) belirtiyoruz
  • Daha sonra “requested_value” değeri “Yes” olduğu sürece devam edecek bir döngü başlatıyoruz.
  • Döngünün her turu için kullanıcıdan bir girdi talep ediyoruz.
  • Döngü, kullanıcı “Yes” dışında bir giriş sağlayana kadar devam eder.
#!/bin/bash
requested_value="Yes"
while [ "$requested_value" = "Yes" ]
do
   echo "While is working..."
   echo "Do you want to continue? (Yes/No)"
   read requested_value
done

Başka bir örnek yapalım. Bu örnek için “/tmp” dizini altında “test.txt” isimli bir dosya olmadığı sürece devam eden bir döngü oluşturalım:

#!/bin/bash
while [ ! -f /tmp/test.txt ]
do
   echo "Loop Working..."
   sleep 10
done
echo "File Found, Done."

Betiği çalıştırdığımızda döngü, “/tmp” dizininde “test.txt” dosyasını oluşturana kadar devam eder ve dosyayı oluşturduğumuzda sona erer:

“Case” Yapısı

Şimdi başka bir kontrol yapısı olan “durum”u inceleyelim.

“Case” bir değişkenin alabileceği farklı değerlere göre farklı işlemler yapmamızı sağlar.

Farklı alt programlara dallanmamız gerektiğinde, farklı durumlarda özellikle faydalıdır.

Aşağıdaki örnekte belirlediğimiz koşulları karşılamayan her durumu “*” ile işaretlediğimizi unutmayın.

#!/bin/bash

echo "Please input value"
read our_variable

case $our_variable in
    1 )
        echo "our_variable value is Equal To 1"
        ;;
    2 )
        echo "our_variable value is Equal To 2"
        ;;
    * )
        echo "our_variable value is NOT Equal To 1 or 2"
        ;;
esac

Bu örnekte değişkenin değerinin 1’e mi yoksa 2’ye mi eşit olduğunu kontrol ediyoruz ve buna göre farklı mesajlar görüntülüyoruz:

Bu yapılar Bash betik dilinin temel kontrol yapılarıdır ve bir Bash betiği içerisinde çok çeşitli mantıksal işlemleri gerçekleştirmenize olanak tanır.

Fonksiyonlar

Bash kodlama dilinde işlevler, belirli bir işlevi gerçekleştiren kod bloğunun adını temsil eder. İşlevler, çok yönlü yetenekleri sayesinde komut dosyalarımızı düzenlememize, kodlarımızı yeniden kullanmamıza ve genel olarak hayatımızı kolaylaştırmamıza yardımcı olur.

Bir eylemi birden çok kez tekrarlamamız gerektiğinde, onu bir fonksiyona yerleştirebilir ve betiğimizin herhangi bir yerinde çağırabiliriz. Bu şekilde aynı kodu tekrar tekrar yazmak zorunda kalmıyoruz, bu da kodumuzu daha temiz ve daha yönetilebilir hale getiriyor. Daha da önemlisi, bir değişiklik yapmamız gerektiğinde bunu yalnızca tek bir yerde, fonksiyonun kendisinde yapmamız gerekiyor.

Bash işlevleri parametreleri alıp çıktı olarak alabilir. Bu sayede belirli bir girdiye dayanarak belirli bir eylemi gerçekleştirmemize veya bir eylemin sonucunu başka bir yerde kullanmamıza olanak tanırlar.

Bir Bash işlevi şu şekilde tanımlanabilir:

function_name
() {
    Commands
}

Örneğin, bir “merhaba” işlevi oluşturabilir ve onun bir ad parametresi almasını sağlayabiliriz:

hello() {
    echo "Hello, $1!"
}

Bu fonksiyonu çağırmak için aşağıdakileri yapabiliriz:

Hello "Bash"

Tahmin edebileceğiniz gibi bir komut dosyasında istediğiniz sayıda fonksiyon oluşturabilir ve bunları istediğiniz zaman çağırabilirsiniz. Bir fonksiyonu başka bir fonksiyonun içinden çağırmak bile mümkündür. Aşağıda buna bir örnek verilmiştir.

  • Öncelikle “ekle” fonksiyonunu tanımlıyoruz. Bu fonksiyon kendisine gönderilen iki değeri toplayarak sonucu döndürür.
  • Daha sonra “çarpma” fonksiyonunu tanımlıyoruz. Bu fonksiyon kendisine gönderilen iki değeri çarpar ve sonucu döndürür.
  • Son olarak “hesapla” fonksiyonunu tanımlıyoruz. Bu fonksiyon ise kendisine gönderilen değerleri hem “topla” hem de “çarpma” fonksiyonlarına göndererek sonuçları ekrana yazar.





#!/bin/bash

# A function that adds two numbers
add() {
    local result=$(( $1 + $2 ))
    echo $result
}

# A function that multiplies two numbers
multiply() {
    local result=$(( $1 * $2 ))
    echo $result
}

# A function that uses both add and multiply functions
calculate() {
    local sum=$(add $1 $2)
    local product=$(multiply $1 $2)
    echo "The sum of $1 and $2 is $sum."
    echo "The product of $1 and $2 is $product."
}

# Call the calculate function
calculate 5 3
                    





Yukarıdaki örnek kodda bir şey fark ettiniz mi?





“local” tabirini ilk defa gördünüz. Dikkatli olanlar bunun “Değişkenler” bölümünde bahsettiğimiz “local” ve “global” değişkenlerle ilgili olduğunu hemen fark etmişlerdir.





#!/bin/bash

# Global variable
greeting="Hello, World!"

function displayGreeting {
    # Local variable
    local greeting="Hello, User!"
    echo $greeting # This will print "Hello, User!" because local variable takes precedence in this scope
}

# Call the function
displayGreeting

# Print the global variable
echo $greeting # This will print "Hello, World!" because the scope here has only access to the global variable
                    





Öncelikle ‘greeting’ adında global bir değişken oluşturuyoruz. Bu değişkene herhangi bir yerden, herhangi bir işlevin içinden veya dışından erişilebilir. “Hello, World!” Bu değişkene değer. Yani ne zaman ‘greeting’ desek, “Hello, World!” çıktı.





Daha sonra ‘displayGreeting’ adında bir fonksiyon oluşturuyoruz. Bu fonksiyonun içinde ‘selamlama’ adında başka bir değişken yaratıyoruz. Ama bu sefer değişkeni ‘local’ anahtar kelimesiyle tanımlıyoruz, yani değişken bu fonksiyonun dışında değil, sadece bu fonksiyonun içinde geçerli oluyor. “Merhaba Kullanıcı!” Bu yerel ‘selamlamanın’ değeri.





Peki ‘displayGreeting’ fonksiyonunu çağırdığımızda ne olur? Fonksiyonun içindeki ‘echo $greeting’ kodu çalışıyor ve “Hello User!” diyor. bizi selamlıyor. Çünkü fonksiyonun içindeki yerel değişken, aynı isimdeki global değişkenin üzerinde yükselir.





Fonksiyonu çağırdıktan sonra bir kez daha ‘echo $greeting’ diyoruz. Ancak bu sefer “Merhaba Dünya!” ‘greeting’ değişkeni global olduğundan tebrik ve yerel sürümün kapsamı yalnızca ‘displayGreeting’ işlevi olduğundan, global sürümün değerini alır:










Hata yönetimi





Tüm programlama/komut dosyası yazma dillerinde olduğu gibi Bash komut dosyası oluşturmada da hata yönetimi çok önemlidir ve asla göz ardı edilmemelidir.





İyi hata işleme, komut dosyanızın beklenmedik durumları daha iyi ele almasına yardımcı olur ve bu da genel güvenilirliğini artırır. Betiğinizin her şey yolunda gittiğinde değil, hatalar ve beklenmedik durumlar oluştuğunda da düzgün çalışmasını istiyorsunuz.





Komut dosyanız bir hata durumunda yararlı hata mesajları üretiyorsa, hataların nerede ve neden oluştuğunu belirlemek daha kolaydır. Bu, özellikle büyük ve karmaşık komut dosyalarında hata ayıklamayı büyük ölçüde kolaylaştırabilir.





Komut dosyanızın hataları doğru bir şekilde ele alması ve yararlı hata mesajları sağlaması durumunda, son kullanıcılar için kesinlikle daha iyi bir kullanıcı deneyimi yaratır. Hata mesajları kullanıcının neyin yanlış gittiğini ve muhtemelen ne yapması gerektiğini anlamasına yardımcı olabilir.





Bazı durumlarda hatalar güvenlik açıklarına neden olabilir. Örneğin, uygun bir dosya mevcut olmadığında bir dosyayı okumaya çalışıyorsa ve bir hata durumunda betiğinizden düzgün bir şekilde çıkamıyorsa, betiğiniz öngörülemeyen veya istenmeyen şekillerde çalışabilir ve istenmeyen sonuçlar doğurabilir.





Beklenmeyen bir hata, otomatikleştirilmiş iş süreçlerini durdurabilir veya yavaşlatabilir. Bu, özellikle büyük ölçekli sistemlerde veya ortamlarda çok sayıda kullanıcıyı ve iş sürecini etkileyebilir. Bu nedenle iş sürekliliğini sağlamak için hataları etkin bir şekilde yönetmek çok önemlidir.





Hata Yakalama





Bash komut dosyası oluşturmada, komut dosyanızın durumunu kontrol etmek ve hataları yakalamak için `$?` değişkenini kullanabilirsiniz. Bu değişken, yürütülen son komutun çıkış durumunu saklar. Genellikle ‘0’ başarılı bir çıkışı temsil ederken, ‘0’ dışındaki herhangi bir değer bir hata durumunu belirtir.





Örnek olarak, bir dosyayı silmeye çalışan bir komut dosyasını ele alalım. Dosyanın var olup olmadığını kontrol etmeden silmeye çalışırsanız bu bir hata durumu oluşturabilir. Bu durumu kontrol etmek için `$?` değişkenini kullanabiliriz:





#!/bin/bash





#!/bin/bash

rm some_file.txt
if [ $? -ne 0 ]; then
    echo "Failed to delete the file"
    exit 1
fi
                    










Bazılarınız, komut dosyası çalıştırıldığında zaten bir hata mesajı aldığımız için komut dosyasında buna neden ihtiyaç duyduğunuzu merak edebilir. Cevap basit. İşletim sisteminin ekranda görüntülediği “rm: ‘some_file.txt’ kaldırılamıyor: Böyle bir dosya veya dizin yok” mesajını scriptimizde fark etmeyebilir ve programımızın akışını buna göre kontrol edebiliriz. Ancak betiği hatalara karşı kontrol ettiğimizde bir hatanın oluştuğunu kolayca fark edebiliriz. Örneğin aşağıdaki kodda eğer dosya yoksa dosyayı oluşturuyoruz:





#!/bin/bash

rm some_file.txt
if [ $? -ne 0 ]; then
    echo "Failed to delete the file because it does not exist, creating the file now..."
    touch some_file.txt
fi
                 





Hata ayıklama





Bash komut dosyasında hata ayıklamanın birkaç yolu vardır. En basit yol, betiğinizin öne çıkan kısımlarına ‘echo’ komutlarını eklemektir. Bu sayede scriptin hangi noktada olduğunu, hangi değişkenlerin hangi değerlere sahip olduğunu görebilirsiniz. Ancak bu yöntem karmaşık scriptlerde kontrolün kolaylıkla kaybedilmesine neden olabilir.





Bunun yerine Bash komut dosyasının hata ayıklama modunu kullanabilirsiniz. ‘-x’ parametresini kullanarak bash’ı hata ayıklama modunda başlatabilirsiniz:





#!/bin/bash
set -x # turn on trace mode

# some operations
echo "This is a test"
var="Hello, World!"
echo $var

set +x # turn off trace mode
                    





Bu modda Bash her komutu ekrana yazdırır ve komut yürütüldükten sonra bir sonraki satıra geçer. Bu, betiğin ne yaptığını takip etmenize ve hataların nerede oluştuğunu adım adım belirlemenize olanak tanır.










Başka bir hata ayıklama yöntemi set -e (veya bash -e) kullanmaktır. set -e (veya bash -e), Bash betiğindeki herhangi bir komutun dönüş değeri sıfırdan farklı olduğunda betiğin durmasına neden olur (bu, betiğin başarısız olması anlamına gelir). Bu, hataların kontrolsüz yayılmasını önlemek için faydalıdır. Normal şartlarda bir script çalıştırılırken herhangi bir satırda hata oluşursa Bash bir sonraki satırdan devam eder. Hataya rağmen scriptin devam etmesinin istenmediği durumlarda “-e” hayat kurtarıcı bir seçenektir.





#!/bin/bash
set -e  # stop script execution on failure

# This command will succeed
echo "This command will succeed"
var="Hello, World!"
echo $var

# This command will fail (assuming file_does_not_exist.txt does not exist)
echo "Trying to display the contents of a file that does not exist..."
cat file_does_not_exist.txt

echo "This message will not be printed because the script already exited"
                    





Gördüğünüz gibi “-e” kullandığımız için script son satırdan önce çıkıyor:












			


	

		




	
	
			



	
	
	
		

		
Bir yanıt yazın 
E-posta adresiniz yayınlanmayacak. Gerekli alanlar * ile işaretlenmişlerdir