Boolean ve bash while döngüsünde. For döngüsü neden bir dizinde çalışmıyor? Örnek: Yürütülebilir dosyaları arayın

6. for döngüsünde Continue ve Break'i uygulamak

Örnek (i=6 olduğunda sonlandır ve i=3 ve i=5 olduğunda yürütme): için(1..8)'de i; Yapmak eğer[ $i -eq 6 ]; Daha sonra kırmak; fi eğer[ $i -eq 3 ] || [ $i -eq 5 ]; Daha sonra devam etmek; fi yankı $i Tamamlandı Yürütme sonucu: $ $ i için (1..8); do \ > if [ $i -eq 6 ]; sonra kır; fi; \ > if [ $i -eq 3 ] || [ $i -eq 5 ]; sonra devam edin; fi; \ > echo $i; \ > tamamlandı 1 2 4

Dikkat: Gönderide gizli faydalar var!

döngüler için

Bash kabuğu, değer dizileri üzerinde yineleme yapmanızı sağlayan for döngülerini destekler. Bu tür döngülerin temel yapısı şöyledir:

Listedeki var için komut tamamlandı

Döngünün her yinelemesinde listedeki bir sonraki değer var değişkenine yazılacaktır. Bu nedenle döngünün ilk geçişi listedeki ilk değeri kullanacaktır. İkincisinde - ikincisinde vb. - döngü son öğeye ulaşana kadar.

Basit değerler üzerinde yineleme

Belki de bash betiklerindeki for döngüsünün en basit örneği, basit değerler listesinin yinelenmesidir:

#!/bin/bash birinci ikinci üçüncü dördüncü beşincide var için echo do echo $var öğesi tamamlandı

Bu betiğin sonuçları aşağıda gösterilmiştir. $var değişkeninin listedeki öğeleri sıralı olarak içerdiğini açıkça görebilirsiniz. Bu, döngü sonuncusuna ulaşana kadar gerçekleşir.

Döngü için basit

$var değişkeninin döngüden çıkarken değerini koruduğunu, içeriğinin değiştirilebileceğini ve genel olarak onunla diğer değişkenler gibi çalışabileceğinizi lütfen unutmayın.

Karmaşık değerler üzerinde yineleme

For döngüsünü başlatmak için kullanılan liste, yalnızca tek bir kelimeden oluşan basit dizeleri değil, aynı zamanda birden fazla kelime ve noktalama işareti içeren tüm ifadeleri de içerebilir. Örneğin, şöyle görünebilir:

#!/bin/bash for var in birinci "ikinci" "üçüncü" "Ben yapacağım" do echo "Bu: $var" bitti

Bu döngü listeden geçtikten sonra olan şey budur. Gördüğünüz gibi sonuç oldukça bekleniyor.

Karmaşık değerler üzerinde yineleme
TNW-CUS-FMP - hizmetlerimizde %10 indirim için promosyon kodu, 7 gün içinde etkinleştirilebilir"

Komutun sonuçlarından elde edilen bir listeyle döngünün başlatılması

For döngüsünü başlatmanın başka bir yolu da ona bir komutun sonucu olan bir liste iletmektir. Burada komut ikamesi bunları yürütmek ve çalışmalarının sonuçlarını elde etmek için kullanılır.

#!/bin/bash file="dosyam" for var in $(cat $file) do echo " $var" bitti

Bu örnek, bir dosyanın içeriğini okuyan cat komutunu kullanır. Ortaya çıkan değer listesi döngüye aktarılır ve ekranda görüntülenir. Erişmekte olduğumuz dosyanın yeni satırlarla ayrılmış bir sözcük listesi içerdiğini, boşluk kullanılmadığını lütfen unutmayın.

Bir dosyanın içeriği arasında dolaşan bir döngü

Burada, eğer satır satır veri işleme bekleniyorsa, satırları boşluklarla ayrılmış birkaç kelime içerebilen daha karmaşık yapıya sahip bir dosya için böyle bir yaklaşımın işe yaramayacağını dikkate almalıyız. Döngü satırları değil tek kelimeleri işleyecektir.

Peki ya hiç istediğin bu değilse?

Alan ayırıcılar

Yukarıdaki özelliğin nedeni, alan ayırıcılarını belirtmenize olanak tanıyan IFS (Dahili Alan Ayırıcı) adı verilen özel bir ortam değişkenidir. Varsayılan olarak bash kabuğu aşağıdaki karakterleri alan ayırıcıları olarak ele alır:

• Uzay
• Sekme karakteri
• Satır besleme karakteri

Bash veride bu karakterlerden herhangi biriyle karşılaşırsa listedeki bir sonraki bağımsız değerin ondan önce geldiğini varsayar.

Sorunu çözmek için IFS ortam değişkenini geçici olarak değiştirebilirsiniz. Alan ayırıcı olarak yalnızca yeni satıra ihtiyacınız olduğunu varsayarak bunu bir bash betiğinde nasıl yapacağınız aşağıda açıklanmıştır:

IFS=$"n"

Bu komutu bash betiğinize eklediğinizde, beklendiği gibi çalışacak, boşlukları ve sekmeleri yok sayacak ve yalnızca yeni satır karakterlerini alan ayırıcı olarak değerlendirecektir.

#!/bin/bash file="/etc/passwd" IFS=$"n" for var in $(cat $file) do echo " $var" bitti

Bu betik çalıştırılırsa, döngünün her yinelemesinde dosyaya yazılan bir sonraki satıra erişim sağlayarak kendisinden tam olarak ne isteniyorsa çıktısını verecektir.

For döngüsündeki bir dosyanın içeriğinin satır satır geçişi

Diğer karakterler sınırlayıcı olabilir. Örneğin yukarıda /etc/passwd dosyasının içeriğini görüntüledik. Satırlardaki kullanıcı verileri iki nokta üst üste ile ayrılır. Bu tür dizeleri bir döngüde işlemeniz gerekiyorsa, IFS şu şekilde yapılandırılabilir:

Bir dizinde bulunan dosyalar arasında geçiş yapma

Bash betiklerinde for döngülerinin en yaygın kullanımlarından biri, bir dizinde bulunan dosyaların arasında geçiş yapmak ve bu dosyaları işlemektir.

Örneğin, dosya ve klasörlerin nasıl listeleneceği aşağıda açıklanmıştır:

/home/likegeeks/* içindeki dosya için #!/bin/bash do if [ -d "$file" ] ardından echo "$file bir dizindir" elif [ -f "$file" ] ardından echo "$file bir dizindir dosya" fi bitti

Listedeki var için komut tamamlandı
Döngünün her yinelemesinde listedeki bir sonraki değer var değişkenine yazılacaktır. Bu nedenle döngünün ilk geçişi listedeki ilk değeri kullanacaktır. İkincisinde - ikincisinde vb. - döngü son öğeye ulaşana kadar.

Basit değerler üzerinde yineleme

#!/bin/bash birinci ikinci üçüncü dördüncü beşincide var için echo do echo $var öğesi tamamlandı
Bu betiğin sonuçları aşağıda gösterilmiştir. $var değişkeninin listedeki öğeleri sıralı olarak içerdiğini açıkça görebilirsiniz. Bu, döngü sonuncusuna ulaşana kadar gerçekleşir.

Döngü için basit

$var değişkeninin döngüden çıkarken değerini koruduğunu, içeriğinin değiştirilebileceğini ve genel olarak onunla diğer değişkenler gibi çalışabileceğinizi lütfen unutmayın.

Karmaşık değerler üzerinde yineleme

#!/bin/bash for var in birinci "ikinci" "üçüncü" "Ben yapacağım" do echo "Bu: $var" bitti
Bu döngü listeden geçtikten sonra olan şey budur. Gördüğünüz gibi sonuç oldukça bekleniyor.

Karmaşık değerler üzerinde yineleme
TNW-CUS-FMP - hizmetlerimizde %10 indirim için promosyon kodu, 7 gün içinde etkinleştirilebilir"

Komutun sonuçlarından elde edilen bir listeyle döngünün başlatılması

#!/bin/bash file="dosyam" for var in $(cat $file) do echo " $var" bitti
Bu örnek, bir dosyanın içeriğini okuyan cat komutunu kullanır. Ortaya çıkan değer listesi döngüye aktarılır ve ekranda görüntülenir. Erişmekte olduğumuz dosyanın yeni satırlarla ayrılmış bir sözcük listesi içerdiğini, boşluk kullanılmadığını lütfen unutmayın.

Bir dosyanın içeriği arasında dolaşan bir döngü

Burada, eğer satır satır veri işleme bekleniyorsa, satırları boşluklarla ayrılmış birkaç kelime içerebilen daha karmaşık yapıya sahip bir dosya için böyle bir yaklaşımın işe yaramayacağını dikkate almalıyız. Döngü satırları değil tek tek kelimeleri işleyecektir.

Peki ya hiç istediğin bu değilse?

Alan ayırıcılar

• Uzay
• Sekme karakteri
• Satır besleme karakteri

Sorunu çözmek için IFS ortam değişkenini geçici olarak değiştirebilirsiniz. Alan ayırıcı olarak yalnızca yeni satıra ihtiyacınız olduğunu varsayarak bunu bir bash betiğinde nasıl yapacağınız aşağıda açıklanmıştır:

IFS=$"\n"
Bu komutu bash betiğinize eklediğinizde, beklendiği gibi çalışacak, boşlukları ve sekmeleri yok sayacak ve yalnızca yeni satır karakterlerini alan ayırıcı olarak değerlendirecektir.

#!/bin/bash file="/etc/passwd" IFS=$"\n" for var in $(cat $file) do echo " $var" bitti
Bu betik çalıştırılırsa, döngünün her yinelemesinde dosyaya yazılan bir sonraki satıra erişim sağlayarak kendisinden tam olarak ne isteniyorsa çıktısını verecektir.

For döngüsündeki bir dosyanın içeriğinin satır satır geçişi

Diğer karakterler sınırlayıcı olabilir. Örneğin yukarıda /etc/passwd dosyasının içeriğini görüntüledik. Satırlardaki kullanıcı verileri iki nokta üst üste ile ayrılır. Bu tür dizeleri bir döngüde işlemeniz gerekiyorsa, IFS şu şekilde yapılandırılabilir:

Bir dizinde bulunan dosyalar arasında geçiş yapma

Örneğin, dosya ve klasörlerin nasıl listeleneceği aşağıda açıklanmıştır:

/home/likegeeks/* içindeki dosya için #!/bin/bash do if [ -d "$file" ] ardından echo "$file bir dizindir" elif [ -f "$file" ] ardından echo "$file bir dizindir dosya" fi bitti
Bu makale serisindeki önceki materyali anladıysanız, if-then yapısının yapısının yanı sıra bir dosyayı bir klasörden nasıl ayırt edeceğinizi de anlamalısınız. Yukarıdaki kodu anlamakta zorlanıyorsanız bu materyali yeniden okuyun.

Komut dosyasının çıktısı budur.

Bir klasörün içeriğini görüntüleme

Döngüyü nasıl başlattığımıza, yani klasör adresinin sonundaki "*" joker karakterine dikkat edin. Bu sembol, "herhangi bir addaki tüm dosyalar" anlamına gelen bir joker karakter olarak düşünülebilir. desenle eşleşen dosya adlarının otomatik olarak değiştirilmesini düzenlemenize olanak tanır.

Bir if ifadesinde bir koşulu test ederken, değişken adını tırnak içine alırız. Bunun nedeni, dosya veya klasör adının boşluk içerebilmesidir.

Döngüler için C tarzı

(i = 0; ben için)< 10; i++) { printf("number is %d\n", i); }
Bash komut dosyalarında, bazı farklılıklar olmasına rağmen açıklaması C tarzı döngülere çok benzeyen for döngülerini kullanabilirsiniz. Bu yaklaşıma sahip döngü şeması şuna benzer:

For ((değişkenin başlangıç ​​değeri; döngünün bitiş koşulu; değişkenin değişimi))
Bash'ta şu şekilde yazılabilir:

İçin ((a = 1; a< 10; a++))
İşte çalışan bir örnek:

#!/bin/bash for ((i=1; i<= 10; i++)) do echo "number is $i" done
Bu kod 1'den 10'a kadar sayıların bir listesini verecektir.

C tarzında döngü

döngü sırasında

İşte while döngülerinin organizasyonunun bir diyagramı
durum kontrol komutu sırasında
Yapmak
diğer takımlar
Tamamlandı

Bunun gibi bir döngüye sahip örnek bir komut dosyasına bakalım:

#!/bin/bash var1=5 while [ $var1 -gt 0 ] do echo $var1 var1=$[ $var1 - 1 ] bitti
Döngü girişinde $var1 değişkeninin sıfırdan büyük olup olmadığı kontrol edilir. Eğer öyleyse, döngünün gövdesi yürütülür ve burada değişkenin değerinden bir çıkarılır. Bu her yinelemede gerçekleşir ve değişkenin değerini değiştirilmeden önce konsola yazdırırız. $var1 0 değerine ulaştığında döngü durur.

while döngüsünün sonucu

$var1 değişkenini değiştirmezseniz bu, betiğin sonsuz bir döngüye girmesine neden olur.

İç içe geçmiş döngüler

#!/bin/bash for ((a = 1; a<= 3; a++)) do echo "Start $a:" for ((b = 1; b <= 3; b++)) do echo " Inner loop: $b" done done
Bu betiğin çıktısını aşağıda bulabilirsiniz. Gördüğünüz gibi, önce dış döngünün ilk yinelemesi gerçekleştirilir, ardından iç döngünün üç yinelemesi gerçekleştirilir, tamamlandıktan sonra dış döngü tekrar devreye girer, ardından tekrar iç döngü devreye girer.

İç içe geçmiş döngüler

Dosya İçeriklerinin İşlenmesi

#!/bin/bash IFS=$"\n" $(cat /etc/passwd) içindeki giriş için do echo "$entry içindeki değerler –" IFS=: $entry içindeki değer için do echo " $value" bitti Tamamlandı
Bu scriptte iki döngü var. İlki, sınırlayıcı olarak yeni satır karakterini kullanarak satırları geçer. Dahili olan, alanları iki nokta üst üste ile ayrılmış dizeleri ayrıştırmakla meşgul.

Dosya Veri İşleme

Bu yaklaşım, CSV dosyalarını veya benzer dosyaları işlerken, sınırlayıcı karakteri gerektiği gibi IFS ortam değişkenine yazarak kullanılabilir.

Döngü yönetimi

• kırmak
• devam etmek

mola komutu

var1 için #!/bin/bash 1 2 3 4 5 6 7 8 9 10 yapın if [ $var1 -eq 5 ] sonra fi echo "Numara: $var1" bitti
Normal koşullar altında böyle bir döngü, listedeki tüm değerler listesinin üzerinden geçecektir. Ancak bizim durumumuzda $var1 değişkeni 5'e eşit olduğunda yürütmesi kesintiye uğrayacaktır.

For döngüsünden erken çıkmak

İşte aynı şey, ancak while döngüsü için:

#!/bin/bash var1=1 while [ $var1 -lt 10 ] do if [ $var1 -eq 5 ] ardından break fi echo "Yineleme: $var1" var1=$(($var1 + 1)) bitti
$var1 5'e ulaştığında çalıştırılan break komutu döngüyü keser. Konsol önceki örnektekiyle aynı şeyi gösterecektir.

devam komutu

#!/bin/bash for ((var1 = 1; var1< 15; var1++)) do if [ $var1 -gt 5 ] && [ $var1 -lt 10 ] then continue fi echo "Iteration number: $var1" done
Döngü içindeki koşul sağlandığında, yani $var1 5'ten büyük ve 10'dan küçük olduğunda, kabuk devam komutunu yürütür. Bu, döngünün gövdesinde kalan komutların atlanması ve bir sonraki yinelemeye geçilmesiyle sonuçlanır.

For döngüsünde devam komutu

Çıkışın Döngüde Çalıştırılması İşleme

Örneğin, çıktıyı bir döngüde ekranda göstermek yerine, hepsini bir dosyaya yazabilir veya başka bir yere iletebilirsiniz:

#!/bin/bash for ((a = 1; a< 10; a++)) do echo "Number is $a" done >dosyam.txt echo "tamamlandı."
Kabuk myfile.txt dosyasını oluşturacak ve for ifadesinin çıktısını bu dosyaya yönlendirecektir. Dosyayı açalım ve tam olarak beklediğimizi içerdiğinden emin olalım.

Döngü çıktısını dosyaya yönlendir

Örnek: Yürütülebilir dosyaları arayın

#!/bin/bash IFS=: $PATH içindeki klasör için echo "$klasör:" yapın $klasör/* içindeki dosya için yapın if [ -x $dosya ] ardından echo " $dosya" fi bitti
Küçük ve basit olan bu komut dosyası, PATH'den klasörlerde saklanan yürütülebilir dosyaların bir listesini almamıza olanak sağladı.

PATH değişkeninden klasörlerdeki yürütülebilir dosyaları arama

Sonuçlar

Bash betiklerinin geliştiricisi olduğunuzu ve onlar hakkında yalnızca bu makale serisinin ilk bölümünde ve bu ikincisinde belirtilenleri bilen bir geliştirici olduğunuzu varsayarsak, o zaman zaten yararlı bir şeyler yazabilirsiniz. Önümüzde, parametreleri ve komut satırı anahtarlarını bash betiklerine nasıl aktaracağınızı ve bunlarla ne yapacağınızı öğreneceğiniz üçüncü bölüm var.

Sistem yönetiminin temel kurallarından biri şu şekilde ifade edilebilir: Eğer aynı şeyi tekrar tekrar yapmanız gerekiyorsa bir script yazın ve bırakın o işi sizin yerinize yapsın. Bir komut dosyasında birkaç kez bir eylem gerçekleştirmeniz gerekiyorsa, o zaman şunu kullanmalısınız: döngüler. İÇİNDE GNU Bash'i yapıları kullanarak döngüler oluşturabilirsiniz için, sırasında Ve değin.

Eğer programlamayla ilgileniyorsanız, büyük olasılıkla bu yapılara zaten aşinasınızdır. Eğer benim gibi ders çalışıyorsan Bash Herhangi bir programlama deneyimi olmadan döngülerin kullanımı anlaşılacak kadar açık olmayabilir. Farklı döngü türleri arasındaki farkları tanımlayarak başlayalım ve ardından örneklere geçelim.

Döngü için eylemlerin tümü tamamlanıncaya kadar tekrarlanacak şekilde tasarlanmıştır. Örneğin, bir görsel kataloğunuz olduğunu ve bunları bir formattan diğerine dönüştürmeniz gerektiğini düşünün. Bir döngü kullanabilirsiniz için programla birlikte dönüştürmek paketten ImageMagick(veya başka bir program), örneğin görüntüleri JPEG formatından PNG formatına dönüştürmek için. Veya örneğin birçok ses dosyasını dönüştürmeniz gerekebilir. MP3 V OGG Vorbis.

Döngü sırasında eylemleri tekrarlamak için kullanılır Hoşçakal yürütülür (bu doğru) bazı koşullar. Döngü değin biraz farklı çalışır: bir eylem gerçekleştirir değin koşul sağlanana kadar. Örneğin, bir sayacınız olabilir ve bir işlem gerçekleştirebilirsiniz. değin değeri 10'a ulaşana kadar. Örnekler kullanarak buna daha detaylı bakalım.

Döngüyle başlayalım için. Formatı şöyledir:

$(komut) içindeki i için; $i komutunu yap; Tamamlandı

Döngü kullanıyorsanız için komut dosyasında şu şekilde biçimlendirmek daha iyidir:

$(command) içindeki i için #!/bin/bash; komutu yap $i yaptım

Örneğin, bir dizinde bulunan tüm HTML dosyalarının yedek kopyalarını almanız gerekiyorsa aşağıdaki komutu kullanabilirsiniz:

$(ls *html); içindeki i için; do cp $i $i.bak; Tamamlandı

Burada yerel bir değişken yaratıldı $i, komut yürütülür ls *html sonuçları değişkenin değerini başlatan veriler olacaktır. $i döngünün her yinelemesinde (örneğimizde bu, komut tarafından döndürülen dosyaların listesi olacaktır) ls, her yineleme için bir tane). Daha sonra komut yürütülür cp parametreler arasında bir değişkenin iletildiği yer $i.

Bazıları mektubu kullanmanın gerekli olup olmadığını sorabilir "Ben" değişken adı olarak mı? HAYIR. Herhangi bir doğru kullanabilirsiniz Bash değişken ismi. Elbette komut dosyalarınızda daha anlamlı değişken adları kullanmak daha iyidir, örneğin $giriş veya $html.

Döngü kullanmanın çok kısa ve basit bir örneğini verdim için. Bir blokta yürütülen bir komut yerine Yapmak,kullanmak Eko kendisine iletilen parametreleri görmek için. Bu, komut dosyalarının test aşamasında çok yararlı bir uygulamadır ve aynı zamanda çalışmayı daha ayrıntılı olarak anlamanıza yardımcı olmanın iyi bir yoludur. için.

süre ve zamana kadar

Şimdi inşaatlara bakalım sırasında Ve değin. Ayrıca bash şartlarını da biraz kullanacağız. Örneğimizde bunları örneğin bir değişkenin değerinin X sayısından büyük veya küçük olduğunu belirlemek için kullanacağız; dosyanın var olup olmadığı ve bir dizin olup olmadığı. Örneğin bir dosyanın okunabilir olup olmadığını veya dosyanın izinlerinde GID biti olup olmadığını belirlemek için koşullu ifadeleri de kullanabilirsiniz.

Boş dosyalar oluşturmak gibi basit bir şey deneyelim. Bunun hayatta işinize yaraması pek mümkün değil, ancak örnek olarak bu kadar.

#!/bin/bash i=0 iken [ $i -lt 22 ] dokunurken $i i=$[$i+1] tamamlandı

Bu komut dosyası, 0'dan 21'e kadar adlara sahip 22 dosya oluşturacaktır. Döngü, şu ana kadar çalışacaktır: Hoşçakal değişken değer $i az ( -lt) 22.

Şimdi bir döngü kullanarak oluşturulan dosyalardan kurtulalım değin:

#!/bin/bash i=0 ta ki [ $i -eq 22 ] do rm $i i=$[$i+1] bitene kadar

Burada değiştirdik sırasında Açık değin ve koşullu ifadede yerini aldılar "az" (-lt) Açık "eşittir" (-eşit). Böylece scriptimiz değer olduğu sürece çalışacaktır. $i 22'ye ulaşmayacak. Ve bunun yerine dokunmak Kullandığımız rm Dosyaları oluşturmak yerine silmek için. Basit, değil mi?

Bu dersimizde tanımaya devam ediyoruz. darbe. Bu unsurları dikkate aldığımızı hatırlatmak isterim. darbe Bu, işletim sistemi komut dosyalarını anlamamıza yardımcı olacaktır. Bu tür unsurlar kesinlikle döngüler ve işlevlerdir. Birisi programlama okuduysa bu soruları anlamakta hiçbir zorluk yaşanmayacaktır.

döngü için

Döngü için V darbe iki türü vardır. Önce klasik versiyona bakalım için. Genel görünüm şu şekildedir:

Elemanlar arasında için Ve içinde arasında belirtilen değerler dizisinden bir değer alan bir değişken ayarlanır. içinde Ve Yapmak. Arasında Yapmak Ve Tamamlandı Bir değişkenin değeri her değiştiğinde yürütülen komutlar vardır. Değişken diziden son değeri aldığında döngü durur. Sıradaki değerler boşluklarla ayrılmıştır.

İşte pratik bir örnek:

Değerlerin sırası farklı şekillerde belirtilebilir. Açıkça - yukarıdaki örnekte olduğu gibi veya diğer değişkenleri kullanarak veya özel komutları kullanarak. Bazı örneklere bakalım. Değerler boşluklarla ayrılmış olarak belirtildiğinden, bu tür değerler boşluk içeren bir dize içeren herhangi bir değişken olabilir:

Sonuç ilk örnekteki ile aynı olacaktır.

Bir sayı dizisi belirtmeniz gerekiyorsa bu komutu kullanabilirsiniz. sıra ve bir ikame mekanizması. Takım sıra ekrana bir dizi sayısal değer döndürür. Sözdizimi basittir ve aşağıdaki örnekte açıkça anlaşılacaktır:

Sonuç:

İkinci türe dönelim için. Çoğu zaman komut dosyalarında C benzeri varyantı bulabilirsiniz. için sayıya dayalı döngüler için kullanılır. Bir örneğe bakalım:

Döngü, ifadede test edilen koşul doğru olduğu sürece çalışır. İfade false değerini döndürdüğü anda döngünün yürütülmesi durdurulur.

Pratik örnek:

#!/bin/bash
ben=1
while [ $i -lt 7 ]
Yapmak
yankı $i
i=i+1 olsun
Tamamlandı

Örneğimizde değişkenin Ben 7 sayısından (-lt) küçüktür ve eğer öyleyse değişkenin değeri ekranda görüntülenir. İfade i=i+1 olsun, değişkeni birer birer artırır, tekrar kontrol eder, vb. Let yorumlayıcıya argümanların sayısal değerler olarak tanınması gerektiğini söyler. Bu satır şu şekilde yazılabilir: izin ver ++(c benzeri varyant). Bir sayı birden fazla arttığında şu şekilde yazılabilir: i+=2 olsun- bu durumda Ben 2'lik artışlarla artacaktır. Bir değişkeni artırmak için başka bir seçenek de yerleşik hesap makinesini kullanmaktır (yalnızca tam sayılarla çalışır). Hesap makinesine çift parantez aracılığıyla erişilebilir: i=$(($i+1)) veya kare olanlardan: i=$[$i+1] Hesap makinesini komut satırında da kullanabilirsiniz:

Sonsuz bir döngüyle karşılaşmamak için döngülere dikkat etmeniz gerekiyor. Bu arada, hata ayıklama için darbe komut dosyalarında ilk satırı değiştirebilirsiniz #!/bin/bash -x veya komut dosyasını komutla çalıştırın bash-x:

igor@ubuntu:~/linux$ bash -x ./testfor.sh
+ ben=1
+ '[' 1 -gt 5 ']'
+ yankı i=1
ben=1
+ i=i+1 olsun
+ '[' 2 -gt 5 ']'
+ yankı i=2
ben=2
+ i=i+1 olsun
+ '[' 3 -gt 5 ']'
+ yankı i=3
ben=3
+ i=i+1 olsun
+ '[' 4 -gt 5 ']'
+ yankı i=4
ben=4
+ i=i+1 olsun
+ '[' 5 -gt 5 ']'
+ yankı i=5
ben=5
+ i=i+1 olsun
+ '[' 6 -gt 5 ']'

Döngülerin nasıl çalıştığına dair anlayışınızı güçlendirmek için küçük komut dosyaları yazma alıştırması yaptığınızdan emin olun. darbe.

Bash'taki işlevler

Fonksiyonlar şuralarda kullanılır: darbeçok geniş. İşlevler iki şekilde açıklanır: bir anahtar sözcükle işlev ve onsuz.

İlk yol:

işlev işlev_adı
{
fonksiyon gövdesi
}

İkinci yol:

fonksiyon adı()
{
fonksiyon gövdesi
}

Bir işlev, kodun herhangi bir yerinde adıyla çağrılır, ancak yalnızca işlevin kendisi tanımlandıktan sonra. Fonksiyonlara, fonksiyon çağrısından (isim) sonra bir boşlukla ayrılmış olarak belirtilen parametreler de iletilebilir. Örnek bir komut dosyasına bakalım darbe:

#!/bin/bash
fonksiyon astarı
{
eğer [ $# -ne 0 ]
Daha sonra
yerel a=1
echo "Geçilen parametre sayısı - $#"
benim için $@ cinsinden
Yapmak
echo "$a-th parametresi $i"
hadi a++
Tamamlandı
0'a dön
başka
echo "Parametreler aktarılmadı"
dönüş 1
fi
}
echo "Parametrelerle bir işlevi çağırın:"
astar a b c
yankı $?
echo "Parametresiz bir işlevi çağırın:"
astar
yankı $?

Bu örnekte, adlı bir işlev astar. Parametrelerle bir işlevi çağırmak: astar a b c ve parametreler olmadan: astar. Fonksiyonun gövdesinde, aşağıdakiler hariç tüm yapılar size tanıdık gelmelidir. $# , $i Ve $@ .$# — işleve iletilen parametrelerin sayısını döndürür. Örneğimizde bu bir sayı olacak 3 .$@ tüm parametreleri tek satırda döndürür. Örnekte şöyle olurdu a b c. Ve aracılığıyla $1 , $2 , $3 vesaire. Her parametreye ayrı ayrı erişebilirsiniz. $? — son komutun yürütme kodunu içerir. Örneğimizde fonksiyon yürütme kodu.

İşlev ayrıca bir anahtar kelime aracılığıyla sayısal bir değer de döndürebilir. geri dönmek. İşlev hatasız yürütülürse genellikle 0 değerini veya bir şeyler ters giderse sıfırdan farklı bir değer döndürürler. Örnekte, bir fonksiyon parametrelerle çağrılırsa 0 değeri, eğer fonksiyon parametresiz çağrılırsa 1 kodu döndürülür.

Parametrelerin bir fonksiyona aktarılmasıyla ilgili her şey bir komut dosyası için tamamen aynı şekilde çalışır. Ayrıca komut dosyasına parametreleri iletebilir ve bunları aynı şekilde kullanarak değiştirebilirsiniz. $#, $@, $N. Aynı kategoriden seçenek - $0 - betiği başlatan komutun adını döndürür. Komut dosyası komut tarafından çalıştırıldıysa ./script.sh, sonra yankı $0 değeri döndürecek ./script.sh ve eğer komut verilmişse /home/igor/linux/script.sh sonra değer döndürülür /home/igor/linux/script.sh.