Bash betikleri oluşturma. komut dosyalarında bash işlevleri. Koşullar. Çoktan seçmeli

İçin basit bir bash betiği yazma aşağıdaki basit adımları yapmamız gerekiyor:

Her şey nasıl çalışır:

Komut dosyamızın ilk satırı #!/bin/bash, komut dosyamızın başarılı bir şekilde çalışması için gereklidir.

ikinci satır mkdir testdir, testdir dizinini oluşturur

üçüncü satır cd testdir, oluşturulan dizine geçmenizi sağlar testdir

takım dokunmak sonraki satırda dosya1 dosya2 dosya3'e dokunun üç dosya oluşturur

ve betiğimizin satırındaki son komut ls -al, önceki satır sayesinde üç boş dosyanın göründüğü mevcut dizinin içeriğini görüntülememize izin veriyor.

Gördüğümüz gibi, ülkemizde basit komut dosyası tüm komutlar yeni bir satırda başlar. Komut dosyası başlatıldığında her satır, belirli eylemleri gerçekleştirerek sırayla işini gerçekleştirir.

Linux'ta her gün bazı özdeş komutlardan (sabit parametrelerle) oluşan bir zincir çalıştırırsanız, aynısını yazmanız sizin için mantıklı olabilir. basit bash betiği, zamandan tasarruf etmenizi ve işinizi otomatikleştirmenizi sağlar.

Linux'ta komut dosyası yazma (örneklerle öğrenme)

———————————————————————————-

1. Giriş

Senaryo yazmak için gerekenler
Komut satırı araçları ve bunların gerekli seçenekleri hakkında bilgi.
İlkokul düzeyinde temel İngilizce bilgisi müdahale etmeyecektir.

Komut dosyalarına neden ihtiyaç duyulur?
İlk olarak, bir linux sunucusunun yönetimi, bir dereceye kadar, aynı komutların sistematik olarak yürütülmesine bağlıdır. Üstelik bu komutların bir kişi tarafından yapılması gerekli değildir. Bir makine tarafından yürütülmek üzere programlanabilirler.
İkinci olarak, (birdenbire) 20-1000'e varan normal bir görevi yapmak bile ... tekrarlayan işlemleri bir komut dosyasında uygulamak ÇOK daha kolaydır.

komut dosyası nedir
Komut dosyası, bir bilgisayarın belirli bir sırada ve belirli bir zamanda yürütmesi gereken bir dizi talimattır. Talimatlar, dahili kabuk komutları (döngüler, koşullar, metin bilgilerinin işlenmesi, ortam değişkenleriyle çalışma vb.) veya gerekli parametrelerle konsolda yürüttüğümüz herhangi bir program olabilir.

Senaryo nasıl yazılır
Bizim durumumuzda, komut dosyası yürütme özniteliklerine sahip bir metin dosyası olacaktır. Bir betik dosyası, UNIX dünyasında sha-bang olarak adlandırılan #! ile başlıyorsa, bu, sisteme betiği çalıştırmak için hangi yorumlayıcıyı kullanacağını söyler. Bunu anlamak zorsa, tüm komut dosyalarını #!/bin/bash veya #!/bin/sh satırıyla yazmaya başlayacağımızı ve ardından komutların ve yorumların onlara gideceğini unutmayın.

ayrılık sözü
Senaryodaki hemen hemen her satıra mümkün olduğunca çok yorum yazmanızı içtenlikle tavsiye ederim. Zaman geçecek ve bir kez yazılan senaryoyu değiştirmeniz veya modernleştirmeniz gerekecek. Senaryoda ne yazdığını hatırlamıyorsanız veya anlamıyorsanız, onu değiştirmek zorlaşır, sıfırdan yazmak daha kolaydır.

Hangi komut dosyalarına ihtiyacımız olabilir:

sistem önyüklendiğinde güvenlik duvarı kurallarının ayarlanması.

ayarların ve verilerin yedeklenmesi.

posta sunucusuna posta kutuları ekleme (daha doğrusu mysql veritabanına)

belirli bir saatte (tercihen her gece) proxy sunucu günlüklerini tarayan ve indirilen trafik miktarı hakkında uygun bir web raporu yayınlayan bir programın başlatılması.

birinin ssh, bağlantı süresi ve müşteri adresi aracılığıyla sunucumuza erişim kazandığı bilgilerini bize posta yoluyla göndermek.

Komut dosyası tekniği hakkında
Bir metin dosyası oluşturur, düzenler, yürütme haklarını ayarlar, çalıştırır, hataları kontrol eder, düzeltir, çalıştırır, hataları kontrol ederiz ...
Her şey yalandığında ve düzgün çalıştığında, belirli bir süre için otomatik yüklemeye veya zamanlayıcıya koyarız.

———————————————————————————-

2. Dahili BASH dilinde komut dosyası yazmayı öğrenmek
orijinal: https://www.linuxconfig.org/Bash_scripting_Tutorial

Bu öğretici, Bash dahili dilini kullanarak komut dosyalarının (bundan böyle komut dosyaları olarak anılacaktır) nasıl yazılacağına dair önceden bilgi sahibi olmadığını varsayar. Bu kılavuzun yardımıyla, kısa sürede komut dosyası yazmanın çok kolay bir iş olduğunu keşfedeceksiniz. Eğitimimize "Merhaba Dünya!" dizesini yazdıran basit bir komut dosyasıyla başlayalım. (İngilizce'den çevrilmiştir - Herkese merhaba!)

1. Senaryo "Herkese merhaba"
İşte ilk bash betiği örneğiniz:

#!/bin/bash
yankı "Merhaba Dünya"

Hello_world.sh dosyamızı içeren dizine geçin ve onu çalıştırılabilir hale getirin:

Kod: Tüm $ chmod +x hello_world.sh öğelerini seçin

Yürütme için komut dosyasını çalıştırın

Kod: Tümünü seçin $ ./hello_world.sh

2. Basit bir arşivleme bash betiği

#!/bin/bash
tar -czf myhome_directory.tar.gz /home/user

Kod: Tümünü seçin $ ./backup.sh

$ du -sh myhome_directory.tar.gz
41M myhome_directory.tar.gz

3. Değişkenlerle Çalışmak
Bu örnekte, basit bir değişken tanımladık ve bunu echo komutunu kullanarak ekranda görüntülüyoruz.

#!/bin/bash
STRING="MERHABA DÜNYA!!!"
yankı $STRING

Kod: Tümünü seçin $ ./hello_world.sh
SELAM DÜNYA!!!

Değişkenler içeren arşivleme betiğimiz:

#!/bin/bash
OF=myhome_directory_$(tarih +%Y%m%d).tar.gz
EĞER=/ev/kullanıcı
tar -czf $OF $IF

Kod: Tümünü seçin $ ./backup.sh
tar: Üye adlarından baştaki "\" kaldırılıyor
$ du -sh *tar.gz
41M myhome_directory_201000123.tar.gz

3.1 Küresel ve yerel değişkenler

#!/bin/bash
# Global bir değişken tanımlayın
# Bu değişken, bu komut dosyasında herhangi bir yerde kullanılabilir
VAR="genel değişken"
işlev bash(
# Yerel bir değişken tanımlayın
# Böyle bir değişken sadece tanımlandığı fonksiyon için geçerlidir.
yerel VAR="yerel değişkenler"
yankı $VAR
}
yankı $VAR
bash
# Global değişkenin değişmediğine dikkat edin
yankı $VAR

Kod: Tüm $ ./variables.sh'yi seçin
küresel değişken
yerel değişken
küresel değişken

4. Argümanları Komut Dosyasına Geçmek

#!/bin/bash
# Argümanlara erişmek için önceden tanımlanmış değişkenleri kullanın
# Argümanları ekrana yazdır
yankı $1 $2 $3 ‘ -> echo $1 $2 $3’

#Ayrıca argümanlara özel bir dizi args=(" aracılığıyla da erişebiliriz. [e-posta korumalı]»)
# Argümanları ekrana yazdır
echo $(args) $(args) $(args) ‘ -> argümanlar=(“ [e-posta korumalı]»); echo $(args) $(args) $(args)'

# Bir değişken kullanın [e-posta korumalı] tüm argümanları bir kerede görüntülemek için
Eko [e-posta korumalı]' -> yankı [e-posta korumalı]’

Komut dosyasına iletilen bağımsız değişkenlerin sayısını görüntülemek için $# değişkenini kullanın
echo Geçilen argüman sayısı: $# ‘ -> echo Geçilen argüman sayısı: $#'

Kod: Tümünü seçin $ ./arguments.sh Bash Komut Dosyası Eğitimi
Bash Komut Dosyası Eğitimi -> echo $1 $2 $3
Bash Komut Dosyası Eğitimi -> args=(" [e-posta korumalı]"); echo $(args) $(args) $(args)
Bash Komut Dosyası Eğitimi -> yankı [e-posta korumalı]
Geçilen argüman sayısı: 3 -> echo Geçilen argüman sayısı: $#

5. Bir Komut Dosyasında Kabuk Komutlarını Yürütme

#!/bin/bash
# bir kabuk komutunu yürütmek için » ` ` » ters tırnakları kullanın
echo 'isim -o'
# şimdi tırnak işaretleri olmadan deneyelim
yankı uname -o

Kod: Tümünü seçin $ uname -o
GNU/Linux
$ ./bash_backtricks.sh
GNU/Linux
uname-o

Gördüğünüz gibi, ikinci durumda, yürütmenin sonucu değil, komutun kendisi görüntülendi.

6. Kullanıcı girdisini okuyun (etkileşim)

#!/bin/bash
echo -e "Merhaba, lütfen şu kelimeyi yazın: \c"
kelime oku
echo "Girdiğiniz kelime: $word"
echo -e "Lütfen iki kelime girer misiniz? »
kelime1 kelime2 oku
echo "İşte girdiniz: \"$word1\" \"$word2\""
echo -e "Bash komut dosyası oluşturma hakkında ne düşünüyorsunuz? »
# read komutu artık bir yanıtı varsayılan yerleşik değişken $REPLY'ye kaydeder
okuman
echo "$REPLY dediniz, bunu duyduğuma sevindim! »
echo -e "En sevdiğiniz renkler nelerdir? »
# -a bir diziye okumak için okuma komutu yapar
-a renkleri oku
echo "En sevdiğim renkler ayrıca $(renkler), $(renkler) ve $(renkler):-)"

Kod: Tümünü seçin $ ./read.sh
Merhaba, lütfen kelimeyi yazın: bir şey
Girdiğiniz kelime: bir şey
Lütfen iki kelime girer misiniz?
Debian Linux'u
İşte girdiniz: "Debian" "Linux"
Bash komut dosyası oluşturma hakkında ne düşünüyorsunuz?
iyi
İyi dedin, bunu duyduğuma sevindim!
En sevdiğin renkler neler?
mavi yeşil siyah
En sevdiğim renkler de mavi, yeşil ve siyah :-)

7. Tuzağı kullanma

#!/bin/bash
# tuzak ilan et
tuzak bashtrap INT
# ekranı temizle
açık;
# kanca işlevi, kullanıcı CTRL-C'ye bastığında yürütülür:
# Gösterilecek => Bash trap alt programı yürütülüyor !
# ancak komut dosyası çalışmaya devam edecek
bashtrap()
{
echo "CTRL+C Algılandı !…bash tuzağı yürütülüyor!"
}
# komut dosyası 10'a kadar sayacak
"seq 1 10"daki a için; yapmak
echo "$a/10 Çıkmak için."
uyku1;
tamamlamak
echo "Bash Tuzağı Örneğinden Çık!!!"

Kod: Tümünü seçin $ ./trap.sh
1/10
2/10
3/10
4/10
5/10
6/10

7/10
8/10
9/10
CTRL+C Algılandı !... bash tuzağı yürütülüyor !
10/10
Bash Trap Örneğinden Çıkın !!!

Gördüğünüz gibi, Ctrl-C tuş kombinasyonu komut dosyasının yürütülmesini durdurmadı.

8. Diziler
8.1 Basit bir dizi bildirme

#!/bin/bash
# 4 elemanlı basit bir dizi tanımlayın
ARRAY=('Debian Linux' 'Redhat Linux' Ubuntu Linux)
# Dizideki eleman sayısını alın
ELEMENTS=$(#ARRAY[@])

# dizinin her bir elemanı arasında döngü
için ((i=0;i<$ELEMENTS;i++)); do
echo $(ARRAY[$(i)])
tamamlamak

Kod: Tüm $./arrays.sh'yi seçin
Debian Linux'u
redhat linux
ubuntu
linux

8.2 Bir diziyi bir dosyadan değerlerle doldurma

#!/bin/bash
# Bir dizi bildir
-a ARRAY bildir
# exec komutu # stdin (genellikle klavye) bu dosyadan üretilecektir. Bu okumayı mümkün kılar
# dosyanın içeriğini satır satır ve sed ve/veya awk ile girilen her satırı ayrıştırın.
yürütme 10 letcount=0

LINE okurken<&10; do

DİZİ[$count]=$LINE
((sayım++))
tamamlamak

echo Öğe sayısı: $(#ARRAY[@])
# Dizi değerlerini göster
echo $(ARRAY[@])
# dosyayı kapat
yürütme 10>&-

Kod: Tüm $ cat bash.txt dosyasını seçin
Debian Linux'u
redhat linux
ubuntu
linux
$ ./diziler.sh
Eleman sayısı: 4
Debian Linux Redhat Linux Ubuntu Linux

9. If-then-else koşulları
9.1. "if-else" koşullarının basit kullanımı
Durumun çalışmadığı köşeli parantez içindeki boşluklara dikkat edin.

#!/bin/bash
dizin="./BashScripting"

# dizinin var olup olmadığını kontrol edin
if [ -d $dizin ]; sonra
echo "Dizin var"
Başka
echo "Dizin yok"
fi

Kod: Tümünü seçin $ ./if_else.sh
Dizin yok
$ mkdir BashScripting
$ ./if_else.sh
dizin var

9.2 İç içe if-else koşulları

#!/bin/bash
# 4 değerinde bir değişken tanımlayın
seçim=4
# Görüntülemek
yankı "1. bas"
yankı "2. komut dosyası »
yankı "3. Öğretici»

# Değişken dörde eşitken çalıştır
# döngü
while [ $choice -eq 4 ]; yapmak

# kullanıcı girdisini oku
seçimi oku
# iç içe "if-else" koşulu
if [ $seçim -eq 1 ] ; sonra

echo "Kelime seçtiniz: Bash"

if [ $seçim -eq 2 ] ; sonra
echo "Kelime seçtiniz: Komut dosyası"
Başka

if [ $seçim -eq 3 ] ; sonra
echo "Kelime seçtiniz: Öğretici"
Başka
echo "Lütfen 1-3 arasında bir seçim yapın!"
yankı "1. bas"
yankı "2. komut dosyası »
yankı "3. Öğretici»
echo -n "Lütfen bir kelime seçin ? »
seçim=4
fi
fi
fi
tamamlamak

Kod: Tümünü seçin $ ./nested.sh
1. bash
2. Komut dosyası oluşturma
3. Eğitim

5

1. bash
2. Komut dosyası oluşturma
3. Eğitim
Lütfen bir kelime seçin
4
Lütfen 1-3 arasında bir seçim yapın!
1. bash
2. Komut dosyası oluşturma
3. Eğitim
Lütfen bir kelime seçin
3
Kelime seçtiniz: Eğitim

Bu nedenle, önce "while" döngüsünün gövdesi yürütülür, çünkü seçim değişkeni başlangıçta dörde ayarlanır. Sonra kullanıcı girdisini içine okuruz ve eğer girdi 1.2 veya 3'e eşit değilse, o zaman döngü gövdesinin tekrar ettiği bağlantılı olarak değişkenimizi tekrar 4'e eşitleriz (tekrar 1.2 veya 3 girmeniz gerekir).

10. Karşılaştırmalar
10.1 Aritmetik karşılaştırmalar

Lt.<
-gt>
-le<=
-ge >=
-eq ==
-ne !=

#!/bin/bash

NUM1=2
NUM2=2
if [ $NUM1 -eq $NUM2 ]; sonra
echo "İki Değer de Eşittir"
Başka
echo "Değerler eşit DEĞİLDİR"
fi

Kod: Tümünü seçin $ ./equals.sh
Her iki Değer de eşittir

#!/bin/bash
# Değişkenleri tamsayı değerleriyle tanımlayın
NUM1=2
NUM2=3
if [ $NUM1 -eq $NUM2 ]; sonra
echo "İki Değer de Eşittir"
Başka
echo "Değerler eşit DEĞİLDİR"
fi

Kod: Tümünü seçin $ ./equals.sh
Değerler eşit DEĞİLDİR

#!/bin/bash
# Değişkenleri tamsayı değerleriyle tanımlayın
NUM1=2
NUM2=1
if [ $NUM1 -eq $NUM2 ]; sonra
echo "İki Değer de Eşittir"
elif [ $NUM1 -gt $NUM2 ]; sonra
echo "$NUM1, $NUM2'den büyüktür"
Başka
echo "$NUM2, $NUM1'den büyüktür"
fi

Kod: Tümünü seçin $ ./equals.sh
2, 1'den büyük

10.2 Karakter-metin karşılaştırmaları

Aynısı
!= aynı değil
< меньще чем
> daha fazla
-n s1 değişkeni s1 boş değil
-z s1 değişkeni s1 boş

#!/bin/bash

S1="Bas"

S2="Komut Dosyası Oluşturma"
eğer [ $S1 = $S2 ]; sonra

Başka
echo "Dizeler eşit DEĞİLDİR"
fi

Kod: Tümünü seçin $ ./statement.sh
Dizeler eşit DEĞİLDİR

#!/bin/bash
# Sembolik değişken S1 bildir
S1="Bas"
# Sembolik değişken S2 bildir
S2="Bas"
eğer [ $S1 = $S2 ]; sonra
echo "İki Dize de eşittir"
Başka
echo "Dizeler eşit DEĞİLDİR"
fi

Kod: Tümünü seçin $ ./statement.sh
Her iki Dize de eşittir

11. Dosyaları kontrol etme

B dosya adı Özel dosyayı engelle
-c dosya adı Özel karakter dosyası
-d dizin adı Dizin varlığını kontrol edin
-e dosya adı Dosya varlığını kontrol et
-f dosyaadı Bir dizin değil, normal dosya varlığını kontrol edin
-G dosya adı Dosyanın var olup olmadığını ve etkin grup kimliğine ait olup olmadığını kontrol edin.
-g dosya adı dosya varsa ve set-group-id ise true .
-k dosya adı Yapışkan bit
-L dosya adı Sembolik bağlantı
-O dosya adı Dosya varsa ve etkin kullanıcı kimliğine aitse doğrudur.
-r dosya adı Dosyanın okunabilir olup olmadığını kontrol edin
-S dosya adı Dosyanın soket olup olmadığını kontrol edin
-s dosya adı Dosyanın sıfırdan farklı boyutta olup olmadığını kontrol edin
-u dosya adı Dosya set-ser-id bitinin ayarlanıp ayarlanmadığını kontrol edin
-w dosya adı Dosyanın yazılabilir olup olmadığını kontrol edin
-x dosya adı Dosyanın yürütülebilir olup olmadığını kontrol edin

#!/bin/bash
dosya="./dosya"
if [ -e $dosya ]; sonra
echo "Dosya var"
Başka
echo "Dosya yok"
fi

Kod: Tüm $ ls'yi seçin
dosya.sh
$ ./dosya.sh
Dosya bulunmuyor
$ dokunma dosyası
$ls
dosya dosyası.sh
$ ./dosya.sh
dosya var

Örnek için benzer şekilde, dosyanın var olup olmadığını kontrol etmek için "while" döngülerini kullanabiliriz. Bu komut dosyası, dosya var olana kadar uyuyacaktır. Bash negatif "!" bu -e seçeneğini reddeder (ters çevirir).

12. Döngüler
12.1. Döngü için

#!/bin/bash
# döngü için
f için $(ls /var/); yapmak
yankı $f
tamamlamak

Bash komut satırından bir for döngüsü çalıştırma:

Kod: $(ls /var/); içindeki f için tüm $'ları seçin. yankı $f yapın; done Kod: $(ls /var/); içindeki f için tüm $'ları seçin. yankı $f yapın; tamamlamak
yedekler
önbellek
kaza
oyunlar
kitap
yerel
kilit
kayıt
posta
tercih
Çalıştırmak
makara
tmp
www

12.2. döngü sırasında

#!/bin/bash
COUNT=6
# döngü sırasında
while [ $COUNT -gt 0 ]; yapmak

COUNT=COUNT-1 olsun
tamamlamak

Kod: Tüm $ ./while_loop.sh'yi seçin
Sayının değeri: 6
Sayının değeri: 5
Sayının değeri: 4
Sayının değeri: 3
Sayının değeri: 2
Sayının değeri: 1

12.3. döngüye kadar

#!/bin/bash
COUNT=0
#until döngüsü
[ $COUNT -gt 5 ] tarihine kadar; yapmak
echo Sayının değeri: $COUNT
COUNT=COUNT+1 olsun
tamamlamak

Kod: Tümünü seçin $ ./until_loop.sh
Sayının değeri: 0
Sayının değeri: 1
Sayının değeri: 2
Sayının değeri: 3
Sayının değeri: 4
Sayının değeri: 5

12.4. Kapalı Koşullu Döngüler
Aşağıdaki örnekte, while döngüsünün koşulu standart girdinin varlığıdır.
Döngünün gövdesi, standart çıktıdan read komutuna yönlendirilecek bir şey olduğu sürece çalışacaktır.

#!/bin/bash
# Bu komut dosyası boşlukları bulup kaldıracak
# dosyalarda alt çizgi ile değiştiriliyor
DIR="."
Döngüdeki çıktıyı yeniden yönlendirerek döngüyü read komutuyla kontrol etme.
$DIR -type f'yi bulun | dosyayı okurken; yapmak
# dosya adlarındaki boşlukları bulmak için POSIX sınıfını [:space:] kullanın
if [[ "$dosya" = *[[:boşluk:]]* ]]; sonra
# boşlukları alt çizgi ile değiştirin
mv "$dosya" `echo $dosya | tr ' ' _'`
fi;
tamamlamak

Kod: Tümünü seçin $ ls -1
script.sh
$ "boşluklu dosya"ya dokunun
$ l -1
boşluklu dosya
script.sh
$ ./script.sh
$ l -1
file_with_spaces
script.sh

13. Fonksiyonlar

#!/bin/bash
# Fonksiyonlar herhangi bir sırada bildirilebilir
işlev işlev_B(
yankı İşlev B.
}
işlev işlev_A(
yankı $1
}
işlev işlev_D(
yankı İşlev D.
}
işlev_C(
yankı $1
}
# Çağrı işlevleri
# parametreyi A işlevine iletin
function_A "İşlev A."
işlev_B
# parametreyi C işlevine geçir
function_C "Fonksiyon C."
işlev_D

Kod: Tüm $ ./functions.sh öğesini seçin
A işlevi
İşlev B.
İşlev C.
İşlev D.

14. Operatör seç - Seç

#!/bin/bash
PS3='Bir kelime seçin:'
# Seçme
"linux" "bash" "komut dosyası oluşturma" "eğitici" kelimesini seçin
yapmak
echo "Seçtiğiniz kelime: $word"
# Break, aksi takdirde döngü sonsuz olacaktır.
kırmak
tamamlamak
0 çıkışı

Kod: Tümünü seçin $ ./select.sh
1) linux
2) bash
3) komut dosyası oluşturma
4) öğretici
Bir kelime seçin: 4
Seçtiğiniz kelime: öğretici

15. Seçim operatörü - Durum

#!/bin/bash
echo "Tercih ettiğiniz programlama / betik dili nedir"
yankı "1) bash"
yankı "2) perl"
yankı "3) fiton"
yankı "4) c++"
yankı "5) Bilmiyorum!"
vakayı oku;
# basit bir vaka seçimi yapısı
# bu örnekte $vakanın yalnızca bir değişken olduğuna dikkat edin
# ve böyle anılması gerekmez. Bu sadece bir örnek
$ durumda
1) echo "Bash'i seçtiniz";;
2) echo "Perl'i seçtiniz";;
3) echo "Fitonu seçtiniz";;
4) echo "c++ seçtiniz";;
5) çıkış
esac

Kod: Tümünü seçin $ ./case.sh
Tercih ettiğiniz programlama / betik dili nedir
1) bash
2) perl
3) bitki
4) c++
5) Bilmiyorum!
4
c++ seçtiniz

———————————————————————————-

Daha ayrıntılı bilgi çeşitli kaynaklardan elde edilebilir, örneğin burada
orijinal: https://www.linuxconfig.org/Bash_scripting_Tutorial
https://ruslandh.narod.ru/howto_ru/Bash-Prog-Intro/
https://bug.cf1.ru/2005-03-17/programmin … -book.html

https://ubuntologia.ru/forum/viewtopic.php?f=109&t=2296

Bugün bash scriptleri hakkında konuşacağız. Bunlar, bash kabuğu için yazılmış komut satırı komut dosyalarıdır. zsh, tcsh, ksh gibi başka kabuklar da var ama biz bash'a odaklanacağız. Bu materyal herkes için tasarlanmıştır, tek koşul Linux komut satırında çalışma yeteneğidir.

Komut satırı komut dosyaları, klavyeden girilebilen, dosyalarda toplanan ve bazı ortak amaçlarla birleştirilen aynı komutların kümeleridir. Aynı zamanda, ekiplerin çalışmalarının sonuçları ya bağımsız değere sahip olabilir ya da diğer ekipler için girdi işlevi görebilir. Komut dosyaları, sık gerçekleştirilen eylemleri otomatikleştirmenin güçlü bir yoludur.

Bu nedenle, komut satırı hakkında konuşursak, aynı anda birkaç komutu noktalı virgülle girerek yürütmenize izin verir:

şifre; ben kimim
Aslında, bunu terminalinizde denediyseniz, iki komut kullanan ilk bash betiğiniz zaten yazılmıştır. Bu şekilde çalışır. pwd komutu önce mevcut çalışma dizini hakkındaki bilgileri görüntüler, ardından whoami komutu, oturum açtığınız kullanıcı hakkında bilgileri görüntüler.

Benzer bir yaklaşım kullanarak, bir satırda istediğiniz kadar komutu birleştirebilirsiniz, sınır yalnızca programa iletilebilecek maksimum argüman sayısıdır. Bu limiti aşağıdaki komutla tanımlayabilirsiniz:

Getconf ARG_MAX
Komut satırı harika bir araçtır, ancak her ihtiyacınız olduğunda komutları girmeniz gerekir. Bir dosyaya bir dizi komut yazıp bunları yürütmek için o dosyayı çağırırsak ne olur? Aslında bahsettiğimiz dosyanın adı komut satırı betiğidir.

Bash betikleri nasıl çalışır?

Dokunma komutunu kullanarak boş bir dosya oluşturun. İlk satırında hangi kabuğu kullanacağımızı belirtmeniz gerekiyor. Bash ile ilgileniyoruz, bu nedenle dosyanın ilk satırı şöyle olacak:

#!/bin/bash
Bu dosyanın başka bir yerinde, kabuğun işlemediği yorumları belirtmek için hash sembolü kullanılır. Bununla birlikte, ilk satır özel bir durumdur; burada bir hash işaretinin ardından bir ünlem işareti (shebang olarak adlandırılır) ve bir bash yolu sisteme komut dosyasının özellikle bash için yazıldığını gösterir.

Kabuk komutları bir satır beslemesiyle, yorumlar ise bir kare işaretiyle ayrılır. İşte nasıl göründüğü:

#!/bin/bash # Bu bir yorumdur pwd whoami
Burada, tıpkı komut satırında olduğu gibi, komutları noktalı virgülle ayırarak tek satıra yazabilirsiniz. Ancak komutları farklı satırlara yazarsanız, dosyanın okunması daha kolay olur. Her durumda, kabuk onları işleyecektir.

Bir Komut Dosyasında İzinleri Ayarlama

Dosyayı myscript olarak adlandırarak kaydedin ve bash betiğini neredeyse bitirdiniz. Şimdi geriye kalan tek şey bu dosyayı çalıştırılabilir hale getirmek, aksi takdirde çalıştırmayı denediğinizde İzin reddedildi hatasıyla karşılaşacaksınız.

Yanlış yapılandırılmış izinlere sahip bir komut dosyası çalıştırmaya çalışmak

Dosyayı çalıştırılabilir hale getirelim:

Chmod +x ./myscript
Şimdi yürütmeye çalışalım:

./myscript
İzinleri ayarladıktan sonra her şey olması gerektiği gibi çalışıyor.

Bash betiğini başarıyla çalıştır

Mesaj çıkışı

Echo komutu, metni Linux konsoluna yazdırmak için kullanılır. Bu gerçeğin bilgisini kullanalım ve komut dosyamızı düzenleyelim, zaten içinde bulunan komutları veren verilere açıklamalar ekleyerek:

#!/bin/bash # yorumumuz burada echo "Geçerli dizin:" pwd echo "Giriş yapan kullanıcı:" whoami
Güncellenmiş komut dosyasını çalıştırdıktan sonra olanlar.

Bir komut dosyasından mesaj çıktısı alma

Artık eko komutunu kullanarak açıklayıcı etiketleri görüntüleyebiliriz. Linux araçlarını kullanarak bir dosyayı nasıl düzenleyeceğinizi bilmiyorsanız veya daha önce echo komutuyla karşılaşmadıysanız, bu makaleye bir göz atın.

Değişkenleri Kullanma

Değişkenler, komut dosyasında, örneğin diğer komutlar tarafından kullanılacak komutların sonuçları gibi bilgileri saklamanıza izin verir.

Çalışmalarının sonuçlarını kaydetmeden tek tek komutları yürütmekte yanlış bir şey yoktur, ancak bu yaklaşımın olanakları çok sınırlıdır.

Bash betiklerinde kullanılabilecek iki tür değişken vardır:

• Ortam Değişkenleri
• Kullanıcı değişkenleri

Ortam Değişkenleri

Bazen kabuk komutlarının bazı sistem verileriyle çalışması gerekir. Örneğin, geçerli kullanıcının ana dizinini nasıl görüntüleyeceğiniz aşağıda açıklanmıştır:

#!/bin/bash # kullanıcı ana sayfasını görüntüle echo "Geçerli kullanıcının evi: $HOME"
$HOME sistem değişkenini çift tırnak içinde kullanabileceğimizi lütfen unutmayın, bu sistemin onu tanımasını engellemeyecektir. Yukarıdaki betiği çalıştırırsanız ne olur.

Bir Komut Dosyasında Ortam Değişkeni Kullanma

Peki ya bir dolar işareti görüntülemek istiyorsanız? Hadi bunu deneyelim:

Echo "Cebimde 1 dolarım var"
Sistem, tırnak işaretleri ile ayrılmış bir dizgede dolar işaretini algılayacak ve bir değişkene referans verdiğimizi varsayacaktır. Komut dosyası, $1 tanımsız değişkenin değerini görüntülemeye çalışacaktır. İhtiyacımız olan bu değil. Ne yapalım?

Bunun gibi bir durumda, dolar işaretinden önce ters eğik çizgi kontrol karakterini kullanmak yardımcı olur:

Echo "Cebimde \$1 var"
Komut dosyası şimdi tam olarak bekleneni verecektir.

Dolar İşareti Çıktısı Almak İçin Bir Kaçış Dizisi Kullanma

Kullanıcı değişkenleri

Ortam değişkenlerine ek olarak, bash komut dosyaları, komut dosyasında kendi değişkenlerinizi ayarlamanıza ve kullanmanıza izin verir. Bu tür değişkenler, komut dosyası bitene kadar bir değer tutar.

Sistem değişkenlerinde olduğu gibi, kullanıcı değişkenlerine dolar işareti kullanılarak erişilebilir:
TNW-CUS-FMP - hizmetlerimizde %10 indirim için promosyon kodu, 7 gün içinde etkinleştirilmeye hazır
#!/bin/bash # değişkenleri test etme grade=5 person="Adam" echo "$person iyi bir çocuk, $sınıfta"
İşte böyle bir betiği çalıştırdıktan sonra olanlar.

Komut Dosyasında Özel Değişkenler

komut değiştirme

Bash betiklerinin en kullanışlı özelliklerinden biri, komutların çıktısından bilgi çıkarma ve onu değişkenlere atama yeteneğidir, bu da bu bilgiyi betik dosyasında herhangi bir yerde kullanmanıza izin verir.

Bu iki şekilde yapılabilir.

• Backtick karakteri "`" ile
• $() yapısı ile

İlk yaklaşımı kullanırken, geri tepme yerine tek bir alıntı kullanmamaya dikkat edin. Komut, bu tür iki simgeye dahil edilmelidir:

mydir=`pwd`
İkinci yaklaşımda, aynısı şöyle yazılır:

mydir=$(pwd)
Ve senaryo sonunda şöyle görünebilir:

#!/bin/bash mydir=$(pwd) echo $mydir
Çalışması sırasında, pwd komutunun çıktısı, içeriği echo komutunu kullanarak konsola düşecek olan mydir değişkeninde saklanacaktır.

Komutun sonuçlarını bir değişkene kaydeden komut dosyası

matematiksel işlemler

Bir komut dosyasında matematiksel işlemler gerçekleştirmek için $((a+b)) gibi bir yapı kullanabilirsiniz:

#!/bin/bash var1=$((5 + 5)) echo $var1 var2=$(($var1 * 2)) echo $var2

Bir komut dosyasındaki matematik işlemleri

if-then kontrol yapısı

Bazı senaryolarda, komut yürütme akışının kontrol edilmesi gerekir. Örneğin, belirli bir değer beşten büyükse, bir eylem gerçekleştirilmelidir, aksi takdirde başka bir işlem yapılmalıdır. Bu birçok durumda geçerlidir ve if-then kontrol yapısı burada bize yardımcı olacaktır. En basit haliyle, şöyle görünür:

Eğer komut o zaman fi komutu verir
Ve işte çalışan bir örnek:

#!/bin/bash pwd ise yankı "Çalışıyor" fi
Bu durumda pwd komutu başarıyla tamamlanırsa konsola "işe yarar" yazısı yazdırılacaktır.

Sahip olduğumuz bilgiyi kullanalım ve daha karmaşık bir senaryo yazalım. Diyelim ki /etc/passwd içinde bir kullanıcı bulmak istiyorsunuz ve onu bulabilirseniz var olduğunu bildirin.

#!/bin/bash user=likegeeks eğer grep $user /etc/passwd ise yankı "$user kullanıcısı var" fi
Bu betiği çalıştırdıktan sonra olan budur.

Kullanıcı arama

Burada /etc/passwd dosyasında kullanıcıyı bulmak için grep komutunu kullandık. Grep komutu size tanıdık gelmiyorsa, açıklamasını burada bulabilirsiniz.

Bu örnekte, kullanıcı bulunursa, komut dosyası uygun bir mesaj görüntüler. Kullanıcı bulunamazsa ne olur? Bu durumda, komut dosyası bize hiçbir şey söylemeden yürütmeyi tamamlayacaktır. Bize bundan da bahsetmesini istiyorum, o yüzden kodu geliştirelim.

if-then-else kontrol yapısı

Programın hem başarılı bir aramanın hem de bir başarısızlığın sonuçlarını rapor edebilmesi için if-then-else yapısını kullanacağız. İşte nasıl kurulduğu:

if komutu, o zaman else fi komutlarını verir
İlk komut sıfıra dönerse, bu başarılı olduğu anlamına gelir, o zaman koşul doğru olur ve yürütme else dalından aşağı inmez. Aksi takdirde, sıfırdan farklı bir şey döndürülürse, bu, başarısızlık veya yanlış bir sonuç anlamına gelir, else'den sonraki komutlar yürütülür.

Aşağıdaki betiği yazalım:

#!/bin/bash user=anotherUser eğer grep $user /etc/passwd ise echo "$user Kullanıcısı Var" else echo "$user kullanıcısı yok" fi
İcrası else şubesi boyunca devam etti.

if-then-else yapısıyla bir betiği çalıştırma

Pekala, devam edelim ve kendimize daha zor koşulları soralım. Ya bir koşulu değil, birkaç koşulu kontrol etmeniz gerekiyorsa? Örneğin, gerekli kullanıcı bulunursa, bir mesaj görüntülenmelidir, başka bir koşul karşılanırsa, başka bir mesaj görüntülenmelidir, vb. Böyle bir durumda iç içe koşullar bize yardımcı olacaktır. Şuna benziyor:

Komut1 ise elif komutu2'yi ve ardından fi komutlarını verir.
İlk komut sıfıra dönerse, başarıyı gösterir, ilk sonra bloğundaki komutlar yürütülür, aksi takdirde, ilk koşul yanlışsa ve ikinci komut sıfıra dönerse, ikinci kod bloğu yürütülür.

#!/bin/bash user=anotherUser eğer grep $user /etc/passwd ise echo "$user Kullanıcısı Var" elif ls /home sonra echo "Kullanıcı mevcut değil ama yine de /home altında bir dizin var" fi
Böyle bir komut dosyasında, örneğin, arama sonuç vermezse useradd komutunu kullanarak yeni bir kullanıcı oluşturabilir veya başka yararlı bir şey yapabilirsiniz.

Sayı Karşılaştırma

Komut dosyalarında sayısal değerleri karşılaştırabilirsiniz. Aşağıda ilgili komutların bir listesi bulunmaktadır.

n1 -eq n2 n1, n2'ye eşitse true döndürür.
n1 -ge n2 n1, n2'den büyük veya ona eşitse true değerini döndürür.
n1 -gt n2 n1, n2'den büyükse true döndürür.
n1 -le n2 n1, n2'den küçük veya ona eşitse true döndürür.
n1 -lt n2 n1, n2'den küçükse true döndürür.
n1 -ne n2 n1, n2'ye eşit değilse true döndürür.

Örnek olarak, karşılaştırma operatörlerinden birini deneyelim. İfadenin köşeli parantez içine alındığına dikkat edin.

#!/bin/bash val1=6 [ $val1 -gt 5] ise echo "$val1 test değeri 5'ten büyük" değilse echo "$val1 test değeri 5'ten büyük değil" fi
İşte bu komutun çıktısı.

Komut dosyalarındaki sayıları karşılaştırma

val1 değişkeninin değeri 5'ten büyüktür, sonuç olarak, karşılaştırma operatörünün o zaman dalı yürütülür ve ilgili mesaj konsolda görüntülenir.

dize karşılaştırma

Komut dosyaları ayrıca dize değerlerini karşılaştırabilir. Karşılaştırma operatörleri oldukça basit görünüyor, ancak dizi karşılaştırma operatörlerinin aşağıda değineceğimiz belirli özellikleri var. İşte operatörlerin bir listesi.

str1 = str2 Dizeleri eşitlik açısından test eder, dizeler aynıysa true değerini döndürür.
s tr1 != str2 Dizeler aynı değilse true değerini döndürür.
str1< str2 Возвращает истину, если str1 меньше, чем str2 .
str1 > str2 str1 , str2'den büyükse true değerini döndürür.
-n str1 str1'in uzunluğu sıfırdan büyükse true değerini döndürür.
-z str1 str1'in uzunluğu sıfır ise true değerini döndürür.

Bir komut dosyasındaki dize karşılaştırmasına bir örnek:

#!/bin/bash user ="likegeeks" eğer [$user = $USER] ise yankı "$user kullanıcısı mevcut oturum açmış kullanıcıdır" fi
Komut dosyasının yürütülmesinin bir sonucu olarak aşağıdakileri elde ederiz.

Komut Dosyalarında Dize Karşılaştırması

İşte dize karşılaştırmanın bahsetmeye değer bir özelliği. Yani, ">" ve " operatörleri<» необходимо экранировать с помощью обратной косой черты, иначе скрипт будет работать неправильно, хотя сообщений об ошибках и не появится. Скрипт интерпретирует знак «>' bir çıktı yönlendirme komutu olarak.

Bu operatörlerle çalışmanın kodda nasıl göründüğü aşağıda açıklanmıştır:

#!/bin/bash val1=metin val2="başka bir metin" ise [ $değer1 \>
İşte senaryonun sonuçları.

Dize karşılaştırma, uyarı atıldı

Komut dosyasının yürütülüyor olmasına rağmen bir uyarı verdiğini unutmayın:

./myscript: satır 5: [: çok fazla argüman var
Bu uyarıdan kurtulmak için $val2'yi çift tırnak içine alın:

#!/bin/bash val1=text val2="another text" eğer [ $val1 \> "$val2" ] ise echo "$val1 is büyüktür $val2" aksi takdirde echo "$val1 $val2'den küçüktür" fi
Şimdi her şey olması gerektiği gibi çalışıyor.

dize karşılaştırma

">" ve " işaretlerinin bir diğer özelliği<» заключается в том, как они работают с символами в верхнем и нижнем регистрах. Для того, чтобы понять эту особенность, подготовим текстовый файл с таким содержимым:

likegeeks likegeeks
myfile adıyla kaydedin ve ardından terminalde aşağıdaki komutu çalıştırın:

Dosyamı sırala
Dosyadaki satırları şu şekilde sıralayacaktır:

Beğeniler
sort komutu, varsayılan olarak, dizeleri artan düzende sıralar, yani örneğimizdeki küçük harf, büyük harften daha küçüktür. Şimdi aynı stringleri karşılaştıracak bir script hazırlayalım:

#!/bin/bash val1=Likegeeks val2=likegeeks eğer [ $val1 \> $val2 ] ise echo "$val1 is büyüktür $val2" yoksa echo "$val1 $val2'den küçüktür" fi
Çalıştırırsanız, bunun tersinin doğru olduğu ortaya çıkıyor - küçük harf artık büyük harften daha büyük.

komut dosyasında sıralama komutu ve dize karşılaştırması

Karşılaştırma komutlarında büyük harfler küçük harflerden daha küçüktür. Burada dizi karşılaştırması, ASCII karakter kodlarını karşılaştırarak yapılır, sıralama düzeni bu nedenle karakter kodlarına bağlıdır.

Sıralama komutu, sistem dili ayarlarında belirtilen sıralama düzenini kullanır.

Dosya kontrolleri

Belki de aşağıdaki komutlar en sık bash betiklerinde kullanılır. Dosyalarla ilgili çeşitli koşulları kontrol etmenizi sağlar. İşte bu komutların bir listesi.

-d dosyası Dosyanın var olup olmadığını ve bir dizin olup olmadığını kontrol eder.
-e dosya Bir dosyanın var olup olmadığını kontrol eder.
-f dosyası Bir dosyanın var olup olmadığını ve bir dosya olup olmadığını kontrol eder.
-r file Dosyanın var olup olmadığını ve okunabilir olup olmadığını kontrol eder.
-s dosyası Dosyanın var olup olmadığını ve boş olmadığını kontrol eder.
-w dosya Dosyanın var olup olmadığını ve yazılabilir olup olmadığını kontrol eder.
-x dosyası Dosyanın var olup olmadığını ve yürütülebilir olup olmadığını kontrol eder.
dosya1 -nt dosya2 dosya1'in dosya2'den daha yeni olup olmadığını kontrol eder.
file1 -ot file2 dosya1'in dosya2'den daha eski olup olmadığını kontrol eder.
-O dosyası Dosyanın mevcut olup olmadığını ve geçerli kullanıcıya ait olup olmadığını kontrol eder.
-G dosyası Dosyanın var olup olmadığını ve grup kimliğinin mevcut kullanıcının grup kimliğiyle eşleşip eşleşmediğini kontrol eder.

Bu komutların yanı sıra bugün tartışılan diğer birçok komutun hatırlanması kolaydır. İsimleri, çeşitli kelimelerin kısaltmaları olduğundan, yaptıkları kontrolleri doğrudan gösterir.

Pratikte komutlardan birini deneyelim:

#!/bin/bash mydir=/home/likegeeks if [ -d $mydir ] ise echo "$mydir dizini mevcut" cd $ mydir ls else echo "$mydir dizini mevcut değil" fi
Bu komut dosyası, mevcut bir dizin için içeriğini görüntüler.

Bir dizinin içeriğini listeleme

Geri kalan komutları kendi başınıza deneyebileceğinize inanıyoruz, hepsi aynı prensibe göre uygulanıyor.

Sonuçlar

Bugün bash betikleri yazmaya nasıl başlayacağımızdan bahsettik ve bazı temel şeyleri ele aldık. Aslında, bash programlama konusu çok büyük. Bu makale, 11 materyalden oluşan geniş bir serinin ilk bölümünün çevirisidir. Hemen devam etmek istiyorsanız - işte bu materyallerin orijinallerinin bir listesi. Kolaylık olması için, çevirisini az önce okuduğunuz buraya dahil edilmiştir.

Linux'ta grafiksel arayüz ne kadar basit olursa olsun ve ne kadar çok fonksiyon olursa olsun, terminal aracılığıyla çözülmesi daha kolay olan görevler vardır. Birincisi, daha hızlı olduğu ve ikincisi, tüm makinelerin, örneğin sunucularda grafiksel bir arayüzü olmadığı için, bilgi işlem kaynaklarından tasarruf etmek için tüm eylemler terminal üzerinden gerçekleştirilir.

Halihazırda daha deneyimli bir kullanıcıysanız, muhtemelen genellikle terminal aracılığıyla çeşitli görevler gerçekleştiriyorsunuzdur. Genellikle sırayla birkaç komutu yürütmeniz gereken görevler vardır, örneğin sistemi güncellemek için önce depoları güncellemelisiniz ve ancak daha sonra paketlerin yeni sürümlerini indirmelisiniz. Bu sadece bir örnek ve bu tür birçok eylem var, hatta yedek alıp kopyalanan dosyaları uzak bir sunucuya yüklemek bile. Bu nedenle aynı komutları birkaç kez yazmamak için scriptleri kullanabilirsiniz. Bu makalede, Bash'te komut dosyası yazmaya, temel operatörlere ve bunların nasıl çalıştıklarına bakacağız, tabiri caizse, bash komut dosyalarını sıfırdan.

Bir komut dosyası veya aynı zamanda bir komut dosyası olarak da adlandırılır, sırayla bir yorumlayıcı program tarafından okunan ve yürütülen bir komut dizisidir, bizim durumumuzda bir komut satırı programıdır - bash.

Komut dosyası, manuel olarak girmeye alıştığımız olağan komutları ve bunları yürütecek programı listeleyen düz bir metin dosyasıdır. Komut dosyasını çalıştıracak yükleyici, ortam değişkenleriyle nasıl çalışacağını bilmiyor, bu nedenle başlatılacak programın tam yolunu iletmesi gerekiyor. Ardından betiğinizi bu programa iletecek ve yürütme başlayacaktır.

Bash kabuğu için en basit komut dosyası örneği:

!/bin/bash
yankı "Merhaba dünya"

Echo yardımcı programı, kendisine iletilen dizeyi ekrana parametre olarak yazdırır. İlk satır özeldir, komutları yürütecek programı belirtir. Genel olarak konuşursak, başka herhangi bir programlama dilinde bir komut dosyası oluşturabilir ve örneğin python'da istenen yorumlayıcıyı belirtebiliriz:

!/usr/bin/env piton
print("Merhaba dünya")

Veya PHP'de:

!/usr/bin/env php
echo "Merhaba dünya";

İlk durumda doğrudan komutları yürütecek programa işaret ettik, sonraki ikisinde programın tam adresini bilmiyoruz bu yüzden env yardımcı programından ismiyle bulup çalıştırmasını istiyoruz. Bu yaklaşım birçok komut dosyasında kullanılır. Ama hepsi bu değil. Bir Linux sisteminde, sistemin bir komut dosyasını yürütmesi için dosyadaki yürütülebilir bayrağı onunla birlikte ayarlamanız gerekir.

Bu bayrak dosyanın kendisinde hiçbir şeyi değiştirmez, sisteme sadece bunun sadece bir metin dosyası olmadığını, bir program olduğunu ve yürütülmesi gerektiğini söyler, dosyayı açın, yorumlayıcıyı bulun ve çalıştırın. Herhangi bir yorumlayıcı belirtilmemişse, varsayılan olarak kullanıcının yorumlayıcısı kullanılacaktır. Ancak herkes bash kullanmadığı için bunu açıkça belirtmeniz gerekir.

Koşmak:

chmod ugo+x komut dosyası dosyası

Şimdi küçük ilk programımızı çalıştırıyoruz:

./Komut dosyaları

Her şey çalışıyor. Örneğin bir güncelleme için küçük bir komut dosyası yazmayı zaten biliyorsunuz. Gördüğünüz gibi, komut dosyaları terminalde yürütülen aynı komutları içeriyor, yazmaları çok kolay. Ama şimdi görevi biraz karmaşıklaştıracağız. Bir komut dosyası bir program olduğundan, bazı kararları kendi başına vermesi, komut yürütme sonuçlarını saklaması ve döngüleri yürütmesi gerekir. Bütün bunlar Bash kabuğu ile yapılabilir. Doğru, burada her şey çok daha karmaşık. Basitten başlayalım.

Komut dosyalarındaki değişkenler

Bash'de komut dosyaları yazmak, geçici verileri depolamadan nadiren tamamlanır, bu da değişkenler oluşturmak anlamına gelir. Değişkenler olmadan tek bir programlama dili yapılamaz ve bizim ilkel kabuk dilimiz de öyle.

Daha önce ortam değişkenleriyle karşılaşmış olabilirsiniz. Yani bunlar aynı değişkenlerdir ve aynı şekilde çalışırlar.

Örneğin, bir dize değişkeni bildirelim:

string="Merhaba dünya"

Dizemizin değeri tırnak içindedir. Ama aslında, alıntılara her zaman ihtiyaç duyulmaz. Bash'ın ana ilkesi burada korunur - boşluk özel bir karakterdir, ayırıcıdır, bu nedenle tırnak işaretleri kullanmazsanız, dünya zaten ayrı bir komut olarak kabul edilecektir, aynı nedenle eşitin önüne ve arkasına boşluk koymayız. işaret.

Bir değişkenin değerini göstermek için $ sembolü kullanılır. Örneğin:

Komut dosyamızı değiştirelim:

!/bin/bash
string1="merhaba"
string2=dünya
dizi=$dizi1$dizi2
yankı $dize

Ve kontrol ediyoruz:

Bash, C++ gibi üst düzey dillerin yaptığı gibi değişken türleri arasında ayrım yapmaz, bir değişkene hem sayı hem de dize atayabilirsiniz. Aynı şekilde, tüm bunlar bir dize olarak kabul edilecektir. Kabuk yalnızca dize birleştirmeyi destekler, bunu yapmak için değişken adlarını arka arkaya yazmanız yeterlidir:

!/bin/bash
string1="merhaba"
string2=dünya
string=$string1$string2\ ve\ ben
string3=$string1$string2" ve ben"
yankı $dize3

Kontrol ediyoruz:

Lütfen, dediğim gibi, dizede özel karakter yoksa tırnakların isteğe bağlı olduğunu unutmayın. Dizeleri birleştirmenin her iki yoluna da yakından bakın, tırnakların rolü burada da gösterilmiştir. Daha gelişmiş dize işleme veya aritmetik işlemlere ihtiyacınız varsa, bu, kabuğun yeteneklerine dahil değildir, bunun için sıradan yardımcı programlar kullanılır.

Değişkenler ve komut çıktısı

Değişkenler, yardımcı programların yürütülmesinin sonucunu depolayamazlarsa çok kullanışlı olmazlardı. Bunun için aşağıdaki sözdizimi kullanılır:

$(takım )

Bu yapı ile komutun çıktısı ekrana değil doğrudan çağrıldığı yere yönlendirilecektir. Örneğin, tarih yardımcı programı geçerli tarihi döndürür. Bu komutlar eşdeğerdir:

Anlıyor musunuz? Merhaba dünya ve tarihin görüntüleneceği bir script yazalım:

string1="merhaba dünya"
string2=$(tarih)

dizi=$dizi1$dizi2

Artık değişkenler hakkında yeterince bilginiz var ve bir bash betiği oluşturmaya hazırsınız, ancak daha fazlası var. Ardından, parametrelere ve kontrol yapılarına bakacağız. Bunların hepsinin normal bash komutları olduğunu ve bunları bir dosyaya kaydetmenize gerek olmadığını, hareket halindeyken hemen çalıştırabileceğinizi hatırlatmama izin verin.

komut dosyası parametreleri

Kullanıcı girdisine bağlı olmayan bir bash betiği oluşturmak her zaman mümkün değildir. Çoğu durumda, kullanıcıya hangi işlemi yapacağını veya hangi dosyayı kullanacağını sormanız gerekir. Bir betiği çağırırken, ona parametreler iletebiliriz. Bu parametrelerin tümü, sayı olarak adlandırılan değişkenler olarak mevcuttur.

1 adlı değişken, birinci parametrenin, değişken 2'nin, ikincinin vb. değerini içerir. Bu bash betiği, ilk parametrenin değerini verir:

!/bin/bash
yankı $1

Komut dosyalarındaki kontrol yapıları

Bir bash betiği oluşturmak, belirli faktörleri analiz etme ve bunlara yanıt olarak gerekli eylemleri gerçekleştirme yeteneği olmadan o kadar yararlı olmazdı. Bu oldukça karmaşık bir konudur, ancak bir bash betiği oluşturmak için çok önemlidir.

Bash'de koşulları kontrol etmek için bir komut vardır.Sözdizimi aşağıdaki gibidir:

if komut_koşulu
sonra
takım
Başka
takım
fi

Bu komut, koşul komutunun çıkış kodunu kontrol eder ve eğer 0 (başarılı) kelimeden sonra komutu veya birkaç komutu yürütürse, çıkış kodu 1 ise, else bloğu yürütülür, fi, bloğun tamamlanması anlamına gelir. komutlar.

Ancak çoğu zaman komutun dönüş koduyla değil, dizeleri ve sayıları karşılaştırmakla ilgilendiğimiz için, çeşitli karşılaştırmalar yapmanıza ve karşılaştırmanın sonucuna bağlı olarak bir dönüş kodu vermenize olanak tanıyan [[ komutu tanıtıldı. Sözdizimi:

[[ parametre1 operatör parametre2 ]]

Karşılaştırma için zaten tanıdık operatörleri kullanıyoruz<,>,=,!= vb. İfade doğruysa, komut 0, değilse - 1 döndürür. Davranışını terminalde biraz test edebilirsiniz. Son komutun dönüş kodu $?

Şimdi, tüm bunları birleştirerek, koşullu ifadeye sahip bir komut dosyası elde ederiz:

!/bin/bash
eğer [[ $1 > 2 ]]
sonra
echo $1", 2"den büyük
Başka
echo $1", 2 veya 2'den küçük
fi

Tabii ki, bu tasarımın daha güçlü özellikleri var, ancak bu makalede ele alınamayacak kadar karmaşık. Belki daha sonra bunun hakkında yazarım. Şimdilik döngülere geçelim.

Komut dosyalarındaki döngüler

Programların avantajı, birkaç satırda hangi eylemlerin birkaç kez gerçekleştirilmesi gerektiğini belirleyebilmemizdir. Örneğin, sadece birkaç satırdan oluşan ancak saatlerce çalışan, parametreleri ayrıştırıp gerekli işlemleri yapan bash betikleri yazmak mümkündür.

Önce for döngüsüne bakalım. İşte sözdizimi:

listedeki değişken için
yapmak
takım
tamamlamak

Tüm listeyi yineler ve listedeki değeri sırayla değişkene atar, her atamadan sonra do ve done arasında yer alan komutları yürütür.

Örneğin, beş basamaktan fazla yineleyelim:

1 2 3 4 5'teki dizin için
yapmak
yankı $ indeksi
tamamlamak

Veya geçerli dizindeki tüm dosyaları listeleyebilirsiniz:

$(ls -l) içindeki dosya için; echo "$file" yapın; tamamlamak

Anladığınız gibi, yalnızca adları görüntüleyemezsiniz, aynı zamanda gerekli işlemleri de gerçekleştirebilirsiniz, bu bir bash betiği oluştururken çok yararlıdır.

Bakacağımız ikinci döngü, koşul komutu 0, başarı kodunu döndürürken çalışan while döngüsüdür. Sözdizimini düşünün:

komut koşulu sırasında
yapmak
takım
tamamlamak

Bir örnek düşünün:

!/bin/bash
indeks=1
while [[ $dizin< 5 ]]
yapmak
yankı $ indeksi
"indeks=indeks+1" olsun
tamamlamak

Gördüğünüz gibi, her şey yapılır, let komutu belirtilen matematiksel işlemi gerçekleştirir, bizim durumumuzda değişkenin değerini bir artırır.

Bir şeyi daha not etmek isterim. while, for, if gibi yapılar birden çok satıra yazılacak şekilde tasarlanmışlardır ve bunları tek satıra yazmaya çalışırsanız hata alırsınız. Ancak yine de bunun için satır sonu olması gereken yere noktalı virgül ";" koymak mümkündür. Örneğin, önceki döngü tek bir satır olarak yürütülebilirdi:

indeks=1; while [[ $dizin< 5 ]]; do echo $index; let "index=index+1"; done;

Her şey çok basit, makaleyi ek bash terimleri ve özellikleri ile karmaşıklaştırmamaya çalıştım, sadece en temel olanı. Bazı durumlarda, bir bash betiği için bir gui yapmanız gerekebilir, daha sonra zenity veya kdialog gibi programları kullanabilirsiniz, bu sayede kullanıcıya mesaj görüntülemek ve hatta ondan bilgi istemek çok uygundur.

sonuçlar

Artık linux'ta komut dosyası oluşturmanın temellerini anlıyorsunuz ve örneğin yedekleme için ihtiyacınız olan komut dosyasını yazabilirsiniz. Bash betiklerine sıfırdan bakmaya çalıştım. Bu nedenle, tüm yönleri dikkate alınmamıştır. Belki bu konuya aşağıdaki makalelerden birinde döneceğiz.

Bash kabuğunun /bin veya /usr/bin klasörlerinde bulunmayan yerleşik komutlara sahip olduğunu herkes bilir. Kabukta yerleşik olarak bulunurlar ve işlevler olarak çalışırlar. Önceki makalelerden birinde düşündük. Orada hemen hemen her şeyi, betiklerin nasıl görünmesi gerektiğini, koşulların, döngülerin, değişkenlerin kullanımını tartıştık, ancak işlevlerde durmadık.

Bugünkü yazımızda bu eksikliği gidereceğiz. Herhangi bir programlama dilinde olduğu gibi, Bash'in de kullanımı çok yararlı olabilecek işlevleri vardır. Bash işlevlerinin kullanımına, bunların nasıl yazılacağına ve hatta bu işlevlerden nasıl kitaplık oluşturulacağına bakacağız.

Öncelikle, bağlamımızda bir fonksiyonun ne olduğunu anlamamız gerekir. İşlev, belirli bir görevi yerine getiren, tek bir adla birleştirilmiş bir dizi komuttur. İşlev adıyla çağrılır, parametreleri alabilir ve işin sonucunu döndürebilir. Kısacası, Bash işlevleri tıpkı diğer programlama dillerinde olduğu gibi çalışır.

Bir işlev oluşturmak için sözdizimi çok basittir:

function_name() ( komut listesi )

İşlev adı, mevcut komutların veya işlevlerin hiçbiriyle eşleşmemelidir ve işlev gövdesindeki tüm komutlar yeni bir satıra yazılır.

basit fonksiyon

Ekrana bir string yazdıracak küçük bir fonksiyon yazalım:

$ vi işlev.sh

#!/bin/bash
printstr()(
yankı "merhaba dünya"
}
printstr

Bash işlevini çağırmak, diğer komutlarda olduğu gibi adını belirterek yapılır. Komut dosyamızı yürütme için çalıştırın, bundan önce yürütme haklarını vermeniz gerektiğini unutmayın:

chmod u+x işlev.sh

Her şey çalışıyor, şimdi görevi karmaşıklaştıralım, fonksiyona argümanları iletmeye çalışalım.

Fonksiyon Argümanları

Çağırırken işlev argümanları iletilmelidir ve bunlar komut dosyası argümanlarıyla aynı şekilde okunur. Bash parametreleriyle bir işlevi çağırmanın sözdizimi şöyledir:

fonksiyon adı argüman1 argüman2 ... argümanN

Gördüğünüz gibi, her şey oldukça basit. Parametreler bir boşlukla ayrılır. Şimdi fonksiyonumuzu, belirttiğimiz dizgiyi çıkaracak şekilde geliştirelim:

!/bin/bash
printstr()(
yankı $1
}
printstr "Merhaba dünya"

Birden fazla seçeneğiniz olabilir:

!/bin/bash
printstr()(
yankı $1
yankı 2 $
yankı 3 $
yankı 5 $
}
printstr "arg1" "arg2" "arg3" "arg4" "arg5"

C'de olduğu gibi, yığını kullanarak argümanları çıkarmanın başka bir yolu daha vardır. İlk argümanı alırız, ardından argüman yığını işaretçisini birer birer ilerletiriz ve ilk argümanı tekrar getiririz. Vb:

!/bin/bash
printstr()(
yankı $1
vardiya
yankı $1
vardiya
yankı $1
vardiya
yankı $1
}
printstr "arg1" "arg2" "arg3" "arg4"

Bir fonksiyonun sonucunu döndürme

Fonksiyonları sadece bash parametreleriyle kullanmakla kalmaz, aynı zamanda ondan işin sonucunu da alabilirsiniz. Bunun için dönüş komutu kullanılır. İşlevi sonlandırır ve dönüş kodunun sayısal değerini döndürür. 0 ile 255 arasında olabilir:

!/bin/bash
printstr()(
dönüş 134;
}
printstr
yankı $?

Durum kodu yerine bir bash işlevinin dönüş değerini kullanmanız gerekiyorsa, yankı kullanın. Dize hemen uçbirime gönderilmez, ancak işlevin sonucu olarak döndürülür ve bir değişkene yazılabilir ve sonra kullanılabilir:

!/bin/bash
printstr()(
yankı "test"
}
VAR=$(printstr)
yankı $VAR

Dışa aktarma işlevleri

Beyan komutuyla bir işlevi bir betiğin dışında kullanılabilir hale getirebilirsiniz:

!/bin/bash
printstr()(
yankı "merhaba dünya"
}
-x -f printstr bildir

Ardından betiği kaynak komutla çalıştırın:

kaynak function.sh
$printstr

özyineleme

Özyinelemeyi yapmak için kendi içinden bir işlevi çağırabilirsiniz:

!/bin/bash
printstr()(
yankı "merhaba dünya"
printstr
}
printstr

Özyinelemeyi kullanmayı deneyebilirsiniz, birçok durumda faydalı olabilir, sadece ilk Bash işlev çağrısını yapmayı unutmayın.

Bir fonksiyondaki yerel değişkenler

Bir işlevde sıradan bir değişken bildirirseniz, bu komut dosyası boyunca kullanılabilir olacaktır, bu, işlevin değerini döndürmek için uygundur, ancak bazen onu yerel bir değişken yapmak gerekebilir. Bunun için yerel bir komut var:

!/bin/bash
printstr()(
yerel VAR=1$
yankı $(var)
}
printstr "Merhaba Dünya"

İşlev Kitaplıkları

Bazı bash fonksiyonlarını alıp tek bir kütüphanede birleştirebiliriz, böylece bu fonksiyonları tek bir komutla içeri aktarabiliriz. Bu, dışa aktarma işlevlerine benzer şekilde yapılır. İlk önce bir kütüphane dosyası oluşturalım:

test1()(
echo "1'den Merhaba Dünya";
}
test2()(
echo "2'den Merhaba Dünya";
}
test3()(
echo "3'ten Merhaba Dünya";
}

Şimdi fonksiyonlarımızı kullanacak bir script oluşturalım. Kaynak komutunu kullanarak veya yalnızca komut dosyası adını belirterek kitaplığı içe aktarabilirsiniz:

!/bin/bash
kaynak lib.sh
test1
test2
test3

sonuçlar

Bu yazıda bash fonksiyonlarına, bunların nasıl yazılacağına, uygulanacağına ve kütüphanelerde birleştirileceğine baktık. Bash'de sık sık komut dosyaları yazıyorsanız, bu bilgi sizin için yararlı olacaktır. Her komut dosyasında kullanmak üzere kendi işlev setinizi oluşturabilir ve böylece işinizi kolaylaştırabilirsiniz.