Bash'te komut dosyaları yazmak. Linux'ta Komut Dosyası Yazma (Örneklerle Öğrenme) En başından bilmeniz gerekenler

Linux'ta komut dosyaları yazmak (örneklerle öğrenme)

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

1. Giriş

Senaryo yazmak için gerekenler
Araç sahipliği Komut satırı ve gerekli seçenekleri.
Temel bilgi İngilizce ilkokul düzeyine 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 gelir. Üstelik bu komutların bir kişi tarafından yerine getirilmesi gerekli değildir. Bir makine tarafından çalıştırılmak üzere programlanabilirler.
İkincisi, (aniden) 20-1000'e varan normal bir görev yapmak bile ... tekrarlayan işlemleri bir komut dosyasında uygulamak ÇOK daha kolaydır.

komut dosyası nedir
Komut dosyası, belirli bir sırada ve sırayla olması gereken bir dizi talimattır. kesin zaman bilgisayarı çalıştırın. Talimatlar olabilir dahili komutlar kabuklar (döngüler, koşullar, işleme metin bilgisi, birlikte çalışmak Ortam Değişkenleri vb.), gerekli parametrelerle konsolda çalıştırdığımız herhangi bir programın yanı sıra.

Senaryo nasıl yazılır
Bizim durumumuzda, komut dosyası şöyle olacaktır: Metin dosyası yürütme nitelikleri ile. UNIX dünyasında sha-bang olarak adlandırılan bir betik dosyası #! ile başlıyorsa, bu sisteme betiği çalıştırmak için hangi yorumlayıcıyı kullanacağını söyler. Bunu anlamak zorsa, o zaman 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 bunlara gideceğini unutmayın.

ayrılık sözü
Komut dosyasındaki hemen hemen her satıra olabildiğince çok yorum yazmanızı içtenlikle tavsiye ederim. Zaman geçecek ve bir kez yazılan senaryoyu değiştirmeniz veya modernize etmeniz gerekecek. Senaryoda yazılanları hatırlamıyorsanız veya anlamıyorsanız, onu değiştirmek zorlaşır, sıfırdan yazmak daha kolay olur.

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

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

ayarların ve verilerin yedeklenmesi.

ekleme posta kutuları v posta sunucusu(daha doğrusu mysql veritabanında)

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

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

Komut dosyası oluşturma tekniği hakkında
Bir metin dosyası oluşturuyoruz, düzenliyoruz, yürütme haklarını belirliyoruz, çalıştırıyoruz, hataları kontrol ediyoruz, düzeltiyoruz, çalıştırıyoruz, hataları kontrol ediyoruz ...
Her şey yalandığında ve düzgün çalıştığında, onu 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 kılavuz, kullanarak komut dosyalarının (bundan sonra komut dosyaları olarak anılacaktır) nasıl yazılacağına dair önceden bilgi sahibi olmadığını varsayar. iç dil bash. Bu kılavuzun yardımıyla, kısa sürede komut dosyası oluşturmanın çok önemli olduğunu keşfedeceksiniz. Basit görev. 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 çalıştırılabilir yapın:

Kod: Hepsini seç $ chmod +x hello_world.sh

Yürütme için betiği çalıştırın

Kod: Hepsini seç $ ./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österdik.

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

Kod: Hepsini seç $ ./hello_world.sh
SELAM DÜNYA!!!

Değişkenli arşivleme komut dosyamız:

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

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

3.1 Genel ve yerel değişkenler

#!/bin/bash
# Genel bir değişken bildirin
# Bu değişken, bu betiğin herhangi bir yerinde kullanılabilir
VAR="genel değişken"
fonksiyon bash(
# Yerel bir değişken bildirin
# Böyle bir değişken sadece tanımlandığı fonksiyon için geçerlidir.
yerel VAR="yerel değişkenler"
yankı $VAR
}
yankı $VAR
darbe
# Global değişkenin değişmediğini unutmayın
yankı $VAR

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

4. Argümanları Komut Dosyasına Aktarma

#!/bin/bash
# Bağımsız değişkenlere erişmek için önceden tanımlanmış değişkenleri kullanın
# Argümanları ekrana yazdır
yankı $1 $2 $3 ' -> yankı $1 $2 $3'

#Argümanlara özel bir dizi aracılığıyla da erişebiliriz args=("$@")
# Argümanları ekrana yazdır
echo $(args) $(args) $(args) ' -> args=("$@"); echo $(args) $(args) $(args)'

# Tüm bağımsız değişkenleri aynı anda görüntülemek için $@ değişkenini kullanın
yankı $@ ' -> yankı $@'

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

Kod: Tüm $ ./arguments.sh Bash Komut Dosyası Eğitimi'ni seçin
Bash Komut Dosyası Eğitimi -> echo $1 $2 $3
Bash Komut Dosyası Eğitimi -> args=("$@"); yankı $(args) $(args) $(args)
Bash Komut Dosyası Eğitimi -> echo $@
Geçirilen bağımsız değişken sayısı: 3 -> yankı Geçirilen bağımsız değişken sayısı: $#

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

#!/bin/bash
# kullanmak geri alıntılar» ` » bir kabuk komutunu yürütmek için
yankı "uname -o"
# şimdi tırnak işaretleri olmadan deneyelim
yankı uname -o

Kod: Hepsini seç $ 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 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 betiği hakkında ne düşünüyorsun? »
# read komutu artık bir yanıtı varsayılan yerleşik değişken $REPLY'de saklıyor
Okumak
echo "$REPLY dedin, bunu duyduğuma sevindim! »
echo -e "En sevdiğiniz renkler nelerdir? »
# -a, okuma komutunu bir diziye okumak için yapar
renkleri oku
echo "En sevdiğim renkler ayrıca $(renkler), $(renkler) ve $(renkler):-)"

Kod: Hepsini seç $ ./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ğı kullanmak

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

Kod: Hepsini seç $ ./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
Çıkış Bash Tuzağı Örneği!!!

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 bildirmek

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

# dizinin her öğesinde döngü
için ((i=0;i<$ELEMENTS;i++)); do
yankı $(DİZİ[$(i)])
Tamamlandı

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 bildirin
-a DİZİSİ ilan et
# yürütme 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önetici 10 izin sayısı=0

HAT okunurken<&10; do

DİZİ[$sayım]=$SATIR
((sayı++))
Tamamlandı

yankı Eleman sayısı: $(#ARRAY[@])
# Dizi değerlerini göster
yankı $(DİZİ[@])
# dosyayı kapat
yürütme 10>&-

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

9. Eğer-o zaman-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 ]; Daha sonra
echo "Dizin var"
başka
echo "Klasör mevcut değil"
fi

Kod: Hepsini seç $ ./if_else.sh
Dizin mevcut değil
$ mkdir BashScripting
$ ./if_else.sh
Dizin var

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

#!/bin/bash
# 4 değeri ile bir değişken bildirin
seçim=4
# Görüntülemek
yankı "1. bash"
yankı "2. Komut Dosyası»
yankı "3. Öğretici»

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

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

echo "Kelime seçtiniz: Bash"

if [ $seçim -eq 2 ] ; Daha sonra
echo "Kelime seçtiniz: Scripting"
başka

if [ $seçim -eq 3 ] ; Daha sonra
echo "Kelime seçtiniz: Öğretici"
başka
yankı "Lütfen 1-3 arasında bir seçim yapın!"
yankı "1. bash"
yankı "2. Komut Dosyası»
yankı "3. Öğretici»
echo -n "Lütfen bir kelime seçin ? »
seçim=4
fi
fi
fi
Tamamlandı

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

5

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

Böylece, önce "while" döngüsünün gövdesi yürütülür, çünkü seçim değişkeni başlangıçta dört olarak ayarlanır. Daha sonra içine kullanıcı girişini okuruz ve giriş 1.2 veya 3'e eşit değilse, 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

Teğmen<
-gt>
-le<=
-ge >=
-eq ==
-ne !=

#!/bin/bash

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

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

#!/bin/bash
# Değişkenleri tamsayı değerlerle bildirin
SAYI1=2
SAYI2=3
if [ $NUM1 -eq $NUM2 ]; Daha sonra
echo "İki Değer de Eşittir"
başka
yankı "Değerler eşit DEĞİLDİR"
fi

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

#!/bin/bash
# Değişkenleri tamsayı değerlerle bildirin
SAYI1=2
SAYI2=1
if [ $NUM1 -eq $NUM2 ]; Daha sonra
echo "İki Değer de Eşittir"
elif [ $NUM1 -gt $NUM2 ]; Daha sonra
yankı "$NUM1, $NUM2'den büyüktür"
başka
yankı "$NUM2, $NUM1'den büyüktür"
fi

Kod: Tüm $ ./equals.sh'yi seçin
2 1'den büyüktür

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

Aynısı
!= aynı değil
< меньще чем
> 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 ]; Daha 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'i bildirin
S1="Bas"
# Sembolik değişken S2'yi bildirin
S2="Bas"
eğer [ $S1 = $S2 ]; Daha sonra
echo "Her iki String de eşittir"
başka
echo "Dizeler eşit DEĞİLDİR"
fi

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

11. Dosyaları kontrol etme

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

#!/bin/bash
dosya="./dosya"
if [ -e $dosya ]; Daha sonra
yankı "Dosya var"
başka
yankı "Dosya mevcut değil"
fi

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

Benzer şekilde örnek için, dosyanın var olup olmadığını kontrol etmek için "while" döngülerini kullanabiliriz. Bu komut dosyası, dosya mevcut olana kadar uyuyacaktır. Bash negatifine dikkat edin "!" -e seçeneğini olumsuzlar (tersine çevirir).

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

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

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

Kod: $(ls /var/); içinde f için tüm $'ları seçin; yankı yap $f; yapılan Kod: $(ls /var/); içinde f için tüm $'ları seçin; yankı yap $f; Tamamlandı
yedekler
önbellek
kaza
oyunlar
lib
yerel
kilit
kayıt
posta
seç
koşmak
makara
tmp
www

12.2. döngü sırasında

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

COUNT=COUNT-1 olsun
Tamamlandı

Kod: Hepsini seç $ ./while_loop.sh
Count değeri: 6
Count değeri: 5
Count değeri: 4
Count değeri: 3
Count değeri: 2
Count değeri: 1

12.3. döngüye kadar

#!/bin/bash
SAYI=0
#döngüye kadar
[ $COUNT -gt 5 ] tarihine kadar; Yapmak
sayımın yankı değeri: $COUNT
COUNT=COUNT+1 olsun
Tamamlandı

Kod: Hepsini seç $ ./until_loop.sh
Count değeri: 0
Count değeri: 1
Count değeri: 2
Count değeri: 3
Count değeri: 4
Count değeri: 5

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

#!/bin/bash
# Bu komut dosyası boşlukları bulur ve kaldırır
# dosyalarda, bunları alt çizgi ile değiştirmek
YÖN="."
Döngüdeki çıktıyı yeniden yönlendirerek read komutu ile döngüyü kontrol etme.
$DIR -türünü bul f | dosya okunurken; Yapmak
# dosya adlarında boşluk bulmak için POSIX sınıfını [:space:] kullanın
if [[ "$file" = *[[:space:]]* ]]; Daha sonra
# boşlukları alt çizgi ile değiştir
mv "$dosya" `echo $dosya | tr '' '_''
fi;
Tamamlandı

Kod: Hepsini seç $ ls -1
komut dosyası.sh
$ touch "boşluklu dosya"
$ ls -1
boşluklu dosya
komut dosyası.sh
$ ./script.sh
$ ls -1
dosya_ile_boşluklar
komut dosyası.sh

13. Fonksiyonlar

#!/bin/bash
# Fonksiyonlar herhangi bir sırayla 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 geçir
function_A "İşlev A."
fonksiyon_B
# parametreyi C işlevi işlevine geçir
function_C "İşlev C."
işlev_D

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

14. Operatör seçin - Seçin

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

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

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!"
durumu oku;
# basit bir vaka seçimi yapısı
# bu örnekte $case'in sadece bir değişken olduğunu unutmayın
# ve böyle adlandırılması gerekmez. bu sadece bir örnek
$ kasa
1) echo "Bash'ı 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 / komut dosyası dili nedir?
1) darbe
2) perl
3) fiton
4) c++
5) Bilmiyorum!
4
c++'ı seçtiniz

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

Daha detaylı 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-Giriş/
https://bug.cf1.ru/2005-03-17/programmin … -book.html

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

İçin basit bir bash betiği yazmak aşağıdaki basit adımları uygulamamı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 testdir dizinine geçmenizi sağlar

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

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

Gördüğümüz gibi, bizim 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 aynı komutlardan (sabit parametrelerle) oluşan bir zincir çalıştırıyorsanız, aynı komutları yazmanız mantıklı olabilir. basit bash betiği, bu da zamandan tasarruf etmenizi ve işinizi otomatikleştirmenizi sağlar.

Bugün bash betiklerinden bahsedeceğiz. Bunlar, bash kabuğu için yazılmış komut satırı betikleridir. Zsh, tcsh, ksh gibi başka kabuklar da var ama biz bash'a odaklanacağız. Bu materyal herkese yöneliktir, tek koşul Linux komut satırında çalışabilme 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 bir 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, birkaç komutu aynı anda yürütmenize ve bunları noktalı virgülle girmenize olanak tanır:

ş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 geçerli çalışma dizini hakkında bilgi görüntüler, ardından whoami komutu oturum açtığınız kullanıcı hakkında bilgi görüntüler.

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

ARG_MAX yapılandırmasını alın
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 basitçe o dosyayı çağırırsak ne olur? Aslında bahsettiğimiz dosyanın adı komut satırı scriptidir.

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

touch 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 olacaktır:

#!/bin/bash
Bu dosyanın başka yerlerinde, kabuğun işlemediği yorumları belirtmek için hash sembolü kullanılır. Ancak, ilk satır özel bir durumdur, burada bir hash işareti ve ardından bir ünlem işareti (shebang denir) ve bash yolu sisteme betiğin özellikle bash için yazıldığını söyler.

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

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

Bir Komut Dosyasında İzinleri Ayarlama

Dosyayı myscript olarak adlandırarak kaydedin ve bash betiğini neredeyse bitirdiniz. Artık geriye kalan tek şey bu dosyayı çalıştırılabilir hale getirmek, aksi halde çalıştırmayı denediğinizde Permission request (İzin reddedildi) hatasıyla karşılaşırsınız.

Yanlış yapılandırılmış izinlere sahip bir betik dosyası çalıştırmaya çalışılıyor

Dosyayı çalıştırılabilir yapalım:

Chmod +x ./komutlarım
Şimdi çalıştırmayı deneyelim:

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

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

Mesaj çıkışı

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

#!/bin/bash # yorumumuz burada echo "Geçerli dizin:" pwd echo "Giriş yapan kullanıcı:" whoami
Güncellenen betiği çalıştırdıktan sonra ne olacağı aşağıda açıklanmıştır.

Bir komut dosyasından mesajların çıktısını alma

Artık echo 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 Kullanmak

Değişkenler, diğer komutlar tarafından kullanılmak üzere komutların sonuçları gibi bilgileri komut dosyasında saklamanıza olanak tanır.

Çalışmalarının sonuçlarını saklamadan bireysel 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 giriş dizinini şu şekilde görüntüleyebilirsiniz:

#!/bin/bash # kullanıcı evini göster yankı "Geçerli kullanıcının evi: $HOME"
Lütfen $HOME sistem değişkenini çift tırnak içinde kullanabileceğimizi unutmayın, bu sistemin onu tanımasını engellemeyecektir. Yukarıdaki komut dosyasını çalıştırırsanız ne olacağı aşağıda açıklanmıştır.

Komut Dosyasında Ortam Değişkeni Kullanma

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

Yankı "Cebimde 1 dolarım var"
Sistem, tırnak işaretleri ile ayrılmış bir dizede bir dolar işareti algılayacak ve bir değişkene başvurduğumuzu varsayacaktır. Betik, $1 tanımsız değişkeninin değerini görüntülemeye çalışacak. İhtiyacımız olan bu değil. Ne yapalım?

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

Yankı "Cebimde \$1 var"
Betik şimdi tam olarak beklenen çıktıyı verecektir.

Bir Dolar İşareti Çıkarmak İçin Bir Kaçış Dizisi Kullanma

Kullanıcı değişkenleri

Ortam değişkenlerine ek olarak bash betikleri, betikte 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ştirilebilir
#!/bin/bash # test değişkenleri grade=5 kişi="Adam" echo "$person iyi bir çocuk, $grade sınıfında"
İşte böyle bir betiği çalıştırdıktan sonra olan şey.

Komut Dosyasındaki Özel Değişkenler

Komut ikamesi

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

Bu iki şekilde yapılabilir.

• "`" ters tik karakteri ile
• $() yapısı ile

İlk yaklaşımı kullanırken, ters tırnak yerine tek bir alıntı kullanmamaya dikkat edin. Komut, bu tür iki simge içine alınmalıdır:

mydir=`pwd`
İkinci yaklaşımda, aynısı şu şekilde 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 komutu kullanılarak 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 betik dosyasında matematiksel işlemler gerçekleştirmek için $((a+b)) gibi bir yapı kullanabilirsiniz:

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

Bir betikte 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 işlem, aksi takdirde başka bir işlem yapılmalıdır. Bu birçok durumda uygulanabilir ve eğer-o zaman kontrol yapısı burada bize yardımcı olacaktır. En basit haliyle şöyle görünür:

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

#!/bin/bash eğer pwd ise "Çalışıyor" fi'yi yankılayın
Bu durumda pwd komutu başarıyla tamamlanırsa konsola "çalışıyor" yazısı yazdırılacaktır.

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

#!/bin/bash user=likegeeks eğer grep $user /etc/passwd ise "$user Var" fi'yi yankılayın
Bu betiği çalıştırdıktan sonra olan budur.

kullanıcı arama

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

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

if-then-else kontrol yapısı

Programın hem başarılı bir aramanın hem de başarısızlığın sonuçlarını rapor edebilmesi için if-then-else yapısını kullanacağız. Nasıl ayarlandığı aşağıda açıklanmıştır:

if komut o zaman komutlar else komutlar fi
İlk komut, başarılı olduğu anlamına gelen sıfır döndürürse, koşul doğru olur ve yürütme else dalından aşağı inmez. Aksi takdirde, sıfırdan farklı bir sonuç döndürülürse, yani başarısızlık veya yanlış bir sonuç döndürülürse, 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 "$user Var" ifadesini yankılayın, aksi halde "$user kullanıcısı mevcut değil" yankısını yapın
Yürütülmesi else şubesi boyunca devam etti.

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

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

Eğer komut1 o zaman elif komutu2'ye komut verirse fi komutu verir
İlk komut sıfır döndürürse, bu başarıyı gösterir, birinci sonra bloktaki komutlar yürütülür, aksi takdirde birinci koşul yanlışsa ve ikinci komut sıfır döndürürse, ikinci kod bloğu yürütülür.

#!/bin/bash user=anotherUser if grep $user /etc/passwd sonra echo "$user 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ç döndürmezse useradd komutunu kullanarak yeni bir kullanıcı oluşturabilir veya yararlı başka bir şey yapabilirsiniz.

Sayı Karşılaştırması

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 değerini 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 değerini döndürür.
n1 -le n2 n1, n2'den küçük veya ona eşitse true değerini döndürür.
n1 -lt n2 n1, n2'den küçükse true değerini döndürür.
n1 -ne n2 n1, n2'ye eşit değilse true değerini döndürür.

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

#!/bin/bash val1=6 eğer [ $val1 -gt 5 ] ise echo "$val1 test değeri 5'ten büyüktür" aksi takdirde echo "$val1 test değeri 5'ten büyük değildir" fi
İşte bu komutun çıktısı ne olacak.

Kodlardaki 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ı çalıştırılır ve ilgili mesaj konsolda görüntülenir.

Dize karşılaştırması

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

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

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

#!/bin/bash user = "likegeeks", eğer [$user = $USER] ise, "$user kullanıcısı şu an oturum açmış kullanıcıdır" fi'yi yankılayın
Komut dosyasının yürütülmesi sonucunda aşağıdakileri elde ederiz.

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

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

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

#!/bin/bash val1=text val2="başka bir metin" if [ $val1 \>
İşte betiğin sonuçları.

Dize karşılaştırması, 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
Bu uyarıdan kurtulmak için $val2'yi içine alın ikili alıntı:

#!/bin/bash val1=metin val2="başka bir metin" if [ $val1 \> "$val2" ] ise "$val1, $val2'den büyüktür" şeklinde yankı yapın, aksi takdirde "$val1, $val2'den küçüktür" şeklinde yankı yapın
Şimdi her şey olması gerektiği gibi çalışıyor.

Dize karşılaştırması

">" ve " nin başka bir ö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ıralar:

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

#!/bin/bash val1=Likegeeks val2=likegeeks if [ $val1 \> $val2 ] o zaman "$val1, $val2'den büyüktür" diye yankı yapın, aksi halde "$val1, $val2'den küçük" yankısını yapın
Ç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. Buradaki dize karşılaştırması, ASCII karakter kodlarını karşılaştırarak yapılır, dolayısıyla sıralama düzeni karakter kodlarına bağlıdır.

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

Dosya kontrolleri

Belki de aşağıdaki komutlar en çok bash betiklerinde kullanılır. kontrol etmenize izin veriyorlar çeşitli koşullar ilgili dosyalar. İşte bu komutların bir listesi.

-d dosya Dosyanın var olup olmadığını ve bir dizin olup olmadığını kontrol eder.
-e dosya Bir dosya olup olmadığını kontrol eder.
-f dosya Bir dosyanın var olup olmadığını ve bir dosya olup olmadığını kontrol eder.
-r dosya Dosyanın var olup olmadığını ve okunabilir olup olmadığını kontrol eder.
-s dosya Dosyanın var olup olmadığını ve boş olup olmadığını kontrol eder.
-w dosya Dosyanın var olup olmadığını ve yazılabilir olup olmadığını kontrol eder.
-x dosya Dosyanın var olup olmadığını ve yürütülebilir olup olmadığını kontrol eder.
file1 -nt file2 file1'in file2'den daha yeni olup olmadığını kontrol eder.
dosya1 -ot dosya2 Dosya1'in dosya2'den eski olup olmadığını kontrol eder.
-O dosya Dosyanın var 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 geçerli 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 pek çok komutun hatırlanması kolaydır. Çeşitli kelimelerin kısaltması olan adları, yaptıkları kontrolleri doğrudan gösterir.

Komutlardan birini pratikte deneyelim:

#!/bin/bash mydir=/home/likegeeks if [ -d $mydir ] sonra echo "$mydir dizini var" cd $ mydir ls else echo "$mydir dizini yok" fi
Mevcut bir dizin için olan bu betik içeriğini gösterecektir.

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ız hakkında konuştuk ve bazı temel konuları ele aldık. Aslında, bash programlamanın konusu çok büyük. Bu makale, 11 materyalden oluşan geniş bir dizinin ilk bölümünün çevirisidir. Hemen devam etmek istiyorsanız - işte bu malzemelerin orijinallerinin bir listesi. Kolaylık olması için, çevirisini az önce okuduğunuz kişi buraya dahil edilmiştir.

Tabii ki, Linux işletim sistemi ile en az bir kez iletişim kuran herkes BASH komut kabuğuyla uğraşmıştır (en azından kesin olarak duymuşlardır). Ancak BASH yalnızca bir komut kabuğu değil, aynı zamanda mükemmel bir betik programlama dilidir.
Bu makalenin amacı, kullanıcıları bash'a daha yakın tanıtmak, dilin sözdizimi, temel teknikleri ve özellikleri hakkında konuşmak, hatta sıradan kullanıcı Günlük (-haftalık, -aylık) rutin işleri gerçekleştirmek için hızlı bir şekilde basit bir komut dosyası yazabildim veya dizin yedekleme için bir komut dosyası oluşturmak için "dizimde" diyelim.

giriiş

BASH - Bourne-Again SHell ("yeniden doğmuş kabuk" veya "Bourne-Again SHell yeniden" olarak çevrilebilir), Unix benzeri sistemlerde, özellikle GNU/Linux'ta en popüler komut yorumlayıcısıdır. Aşağıda, betiklerimizi oluşturmak için kullanacağımız bir dizi yerleşik komut bulunmaktadır.

Çıkış yolunu kır döngü için, iken veya kadar
devam, for, while veya till döngüsünün bir sonraki yinelemesini yürütür
yankı, boşlukla ayrılmış bağımsız değişkenleri standart çıktıya yazdırır
çıkış kabuktan çıkış
export, argümanları ortamdaki alt süreçlere iletilecek değişkenler olarak işaretler
hash, argüman olarak verilen komutların tam yol adlarını hatırlar, böylece bir sonraki çağrıldıklarında aranmazlar.
kill bir işleme bir sonlandırma sinyali gönderir
pwd geçerli çalışma dizinini görüntüler
read, kabuk girdisinden bir satır okur ve bunu belirtilen değişkenlere değer atamak için kullanır.\
dönüş, kabuk işlevinin belirtilen değerle çıkmasına neden olur
kaydırma, konumsal parametreleri sola taşır
test koşullu ifadeyi değerlendirir
times, kabuk ve soyundan gelenler tarafından kullanılan kullanıcı adını ve sistem saatini yazdırır
trap, kabuk bir sinyal aldığında yürütülecek komutları belirtir
unset, kabuk değişkenlerinin yok edilmesine neden olur
wait, alt sürecin çıkmasını bekler ve çıkış durumunu bildirir.

Ve tabii ki, yerleşik komutlara ek olarak, süreçte zaten tanıyacağımız bir dizi harici, ayrı program komutu kullanacağız.

Baştan beri bilmeniz gerekenler

1. Herhangi bir bash betiği şu satırla başlamalıdır:

#!/bin/bash
bu satırda #! bash yorumlayıcısının yolu belirtilir, bu nedenle başka bir yere yüklediyseniz (nerede, bash bash yazarak öğrenebilirsiniz) onu kendi yolunuzla değiştirin.
2. Yorumlar # simgesiyle başlar (ilk satır hariç).
3. Bash'ta değişkenlerin bir türü yoktur (bunlar aşağıda ele alınacaktır)

Komut Dosyası Değişkenleri ve Parametreleri

Size analiz edeceğimiz küçük bir örnek vereyim:

#!/bin/bash
# bash yorumlayıcısını nerede saklayacağımızı belirtin
parametre1=$1 #parametr1 değişkenini betiğin ilk parametresinin değerine ayarla
script_name=$0 #script_name değişkenini script adının değerine ayarla
echo "$script_name adında ve $parametr1 parametresinde bir betik çalıştırdınız" # echo komutu belirli bir dizi verir, değişkenlere $variable_name aracılığıyla erişilir.
echo "$parametr1 parametresiyle $script_name adlı bir betik çalıştırdınız" #burada başka tırnak işaretleri görüyoruz, aradaki fark, tek tırnak içinde değişken ikamesi olmaması.
exit 0 #0 koduyla çıkın (komut dosyasının başarıyla tamamlanması)

[e-posta korumalı]:~$ ./test.sh qwerty
qwerty parametresiyle ./test.sh adlı bir komut dosyası çalıştırdınız
$script_name isimli ve $parametr1 parametreli bir script çalıştırdınız.

Artık değişkenleri nasıl kullanacağımızı ve parametreleri bir betiğe nasıl ileteceğimizi gördüğümüze göre, ayrılmış değişkenlere aşina olmanın zamanı geldi:

$DIRSTACK - dizin yığınının en üstündeki içerik
$EDİTÖR- Metin düzeltici varsayılan
$EUID - Etkili UID. Komutları başka bir kullanıcı olarak yürütmek için su programını kullandıysanız, bu değişken o kullanıcının UID'sini içerirken...
$UID - ...içerir gerçek kimlik, yalnızca oturum açma sırasında ayarlanır.
$FUNCNAME - komut dosyasındaki geçerli işlevin adı.
$GROUPS - geçerli kullanıcının ait olduğu grup dizisi
$HOME - kullanıcının ev dizini
$HOSTNAME - ana bilgisayar adınız
$HOSTTYPE - konak mimarisi.
$LC_CTYPE - karakter kodlamasını belirleyen dahili değişken
$OLDPWD - eski çalışma dizini
$OSTYPE - İşletim sistemi türü
$PATH - program arama yolu
$PPID - üst işlem kimliği
$SECONDS - betik çalışma süresi (saniye olarak)
$# - betiğe iletilen toplam parametre sayısı
$* - betiğe aktarılan tüm argümanlar (bir dizgede görüntülenir)
$@ - öncekiyle aynı, ancak parametreler bir sütunda gösteriliyor
$! - Arka planda çalışan son işlemin PID'si
$$ - Komut dosyasının kendisinin PID'si

Koşullar

Koşullu işleçler, bence, bir şey üzerine program yazmayı deneyen hemen hemen herkese aşinadır. Bash'ta koşullar aşağıdaki gibi yazılır. yol (örnekte her zamanki gibi):
#!/bin/bash
source=$1 # betiğin ilk parametresini kaynak değişkene koy
dest=$2 # betiğin ikinci parametresini dest değişkenine koyun

If [[ "$source" -eq "$dest" ]] # karşılaştırmak için değişken adlarını alıntılayın. -eq - "eşit" anlamına gelen mantıksal karşılaştırma
o zaman # eğer gerçekten eşitlerse, o zaman
echo "Hedef $hedef ve kaynak $kaynak aynı dosyadır!" #bir hata mesajı göster, çünkü $source ve $dest eşittir
çıkış 1 # bir hatayla çık (1 - hata kodu)
else # eşit değillerse
cp $source $dest # ardından cp komutunu çalıştırın: kaynağı hedefe kopyalayın
echo "Kopyalama başarılı!"
fi #koşulun sonunu belirtir.

Komut dosyasının yürütülmesinin sonucu:
[e-posta korumalı]:~$ ./primer2.sh 1 1
Başvuran 1 ve kaynak 1 aynı dosyadır!
[e-posta korumalı]:~$ ./primer2.sh 1 2
Mutlu kopyalama!

if-then-else yapısı şu şekilde kullanılır:
eğer<команда или набор команд возвращающих код возврата(0 или 1)>
Daha sonra
<если выражение после if истино, то выполняется этот блок>
başka
<если выражение после if ложно, тот этот>
Yapılar [[ , [ , test, (()) veya başka herhangi bir (veya birkaç) linux komutu, bir dönüş kodu döndüren komutlar olarak işlev görebilir.
test - mantıksal karşılaştırma için kullanılır. ifadeden sonra, bir kapatma parantezi "]" gereklidir
[, test komutunun eş anlamlısıdır
[[ - genişletilmiş "[" sürümü (sürüm 2.02'den beri) (örnekte olduğu gibi), içinde || (veya), & (ve). "]]" kapanış parantezine sahip olmalıdır
(()) - matematiksel karşılaştırma.
formun çok düzeyli koşullarını oluşturmak için:
eğer...
Daha sonra ....
başka
eğer ....
Daha sonra....
başka ....

Kodun kısalığı ve okunabilirliği için yapıyı kullanabilirsiniz:
eğer..
Daha sonra ...
elif...
Daha sonra ...
elif...

Koşullar. Çoktan seçmeli

Herhangi bir değişkeni karşılaştırmanız gerekirse büyük miktar parametreler, case ifadesini kullanmak daha uygundur.
#!/bin/bash
echo "Çalıştırılacak düzenleyiciyi seçin:"
yankı "1 Çalışan nano"
yankı "2 Vi programını çalıştır"
yankı "3 Emacs programını başlat"
yankı "4 Çıkış"
#burada yapmayı oku standart girdiden $doing değişkenini okuruz

$doing in vakası
1)
/usr/bin/nano # $doing 1 ise nano'yu çalıştırın
;;
2)
/usr/bin/vi # $doing 2 içeriyorsa vi'yi başlat
;;
3)
/usr/bin/emacs # eğer $doing 3 içeriyorsa emacs'ı başlat
;;
4)
çıkış 0
;;
*) #Klavyeden bu durumda açıklanmayan bir şey girilirse, aşağıdakileri yapın:
yankı "Geçersiz işlem girildi"

Esac #end case bildirimi.

İşin sonucu:
[e-posta korumalı]:~$ ./menu2.sh
Başlatmak için bir düzenleyici seçin:
1 nano'yu başlatma
2 vi'yi başlatmak
3 emacs'ı başlatın
4 Çıkış

Bir sayı seçtikten ve Enter'a bastıktan sonra, seçtiğiniz düzenleyici başlayacaktır (tabii ki tüm yollar doğru değilse ve bu düzenleyiciler kurulu değilse :))
if-then-else-fi yapısı için kullanılan mantıksal işleçlerin listesi aşağıdadır:
-z # satırı boş
-n # dizi boş değil
=, (==) # dizi eşittir
!= # dizi eşit değil
-eq # eşittir
-ne # eşit değil
-lt,(<) # меньше
-le,(<=) # меньше или равно
-gt,(>) #daha fazla
-ge,(>=) #büyük veya eşittir
! # boole ifadesinin olumsuzlanması
-a,(&&) #mantıksal VE
-o,(||) # mantıksal "VEYA"

Makaleyi aşırı yüklememek için dilin temellerini ve koşullarını anladık, onu birkaç parçaya ayıracağım (3 diyelim). İkinci bölümde ise döngü operatörlerini ve matematiksel işlemlerin performansını inceleyeceğiz.

güncelleme: Bazı hatalar düzeltildi
güncelleme: if-then-else koşullarıyla ilgili bölüm güncellendi

Bash kabuğunun /bin veya /usr/bin klasörlerinde bulunmayan yerleşik komutlara sahip olduğunu herkes bilir. Kabuğun içine yerleştirilmiştir ve işlevler olarak çalışırlar. Önceki makalelerden birinde düşündük. Orada neredeyse her şeyi tartıştık, betiklerin nasıl görünmesi gerektiğini, koşulların, döngülerin, değişkenlerin kullanımı, 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 nasıl kullanılacağına, 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 işlevin 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 çalışmanın sonucunu döndürebilir. Kısacası, Bash işlevleri tıpkı diğer programlama dillerindeki 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 dizi yazdıracak küçük bir fonksiyon yazalım:

$ vi işlevi.sh

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

Arama bash işlevleri diğer herhangi bir komutta olduğu gibi, adı belirtilerek yapılır. Yürütme için komut dosyamızı çalıştırın, bundan önce ona yürütme hakları vermeniz gerektiğini unutmayın:

chmod u+x işlevi.sh

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

İşlev Argümanları

İşlev bağımsız değişkenleri çağrılırken iletilmelidir ve bunlar kod bağımsız değişkenleriyle aynı şekilde okunur. Bash parametreleriyle bir işlevi çağırmak için 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 dizgeyi verecek ş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 bağımsız değişkenleri çıkarmanın başka bir yolu vardır. İlk bağımsız değişkeni getiriyoruz, ardından bağımsız değişken yığını işaretçisini bir adım ilerletiyoruz ve ilk bağımsız değişkeni tekrar getiriyoruz. Ve benzeri:

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

Bir fonksiyonun sonucunu döndürmek

Yalnızca bash parametreleriyle işlevleri kullanamazsınız, aynı zamanda çalışmanın sonucunu da ondan alabilirsiniz. Bunun için return 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;
}
yazdır
yankı $?

Durum kodu yerine bir bash işlevinin dönüş değerini kullanmanız gerekiyorsa, echo kullanın. Dize hemen terminale 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ı "testi"
}
VAR=$(yazdır.str)
yankı $VAR

Dışa aktarma işlevleri

Bir işlevi betiğin dışında kullanılabilir hale getirmek için şu komutu kullanabilirsiniz:

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

Ardından betiği source komutuyla çalıştırın:

kaynak işlevi.sh
$printstr

özyineleme

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

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

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

Bir işlevdeki yerel değişkenler

Bir işlevde sıradan bir değişken bildirirseniz, 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çe aktarabiliriz. Bu, işlevleri dışa aktarmaya benzer bir şekilde yapılır. Öncelikle 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 betik oluşturalım. Kaynak komutunu kullanarak veya yalnızca betik adını belirterek kitaplığı içe aktarabilirsiniz:

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

sonuçlar

Bu yazıda bash işlevlerine, bunların nasıl yazılacağına, uygulanacağına ve kitaplıklarda birleştirileceğine baktık. Bash'te sık sık komut dosyaları yazarsanız, bu bilgiler 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.