Girişbash argümanları. betiklerde bash işlevleri
Bu materyal serisinin önceki bölümlerinde uzmanlaştıktan sonra, bash betiklerinin ne olduğunu, nasıl yazılacağını, program yürütme akışının nasıl kontrol edileceğini, dosyalarla nasıl çalışılacağını öğrendiniz. Bugün komut dosyalarına kullanıcıdan veri alma ve bu verileri işleme yeteneği ile donatarak nasıl etkileşim ekleyeceğimizden bahsedeceğiz.
Komut dosyalarına veri aktarmanın en yaygın yolu parametreleri kullanmaktır. Komut satırı. Komut dosyasını parametrelerle çağırarak, ona çalışabileceği bazı bilgiler aktarıyoruz. Şuna benziyor:
$ ./komut dosyam 10 20
Bu örnekte, betiğe iki parametre iletilir - "10" ve "20". Bütün bunlar iyi, ancak komut dosyasındaki veriler nasıl okunur?
Komut satırı seçeneklerini okuma
Bash kabuğu, komut dosyası çalıştırıldığında girilen komut satırı parametrelerine konumsal parametreler adı verilen özel değişkenler atar:- $0 - komut dosyası adı.
- $1 ilk parametredir.
- $2 ikinci parametredir ve dokuzuncu parametre olan $9'a kadar devam eder.
#!/bin/bash yankı $0 yankı $1 yankı $2 yankı $3
Komut dosyasını parametrelerle çalıştıralım:
./komutum 5 10 15
Konsola çıktı olarak vereceği şey bu.
Komut dosyasının başlatıldığı parametrelerin görüntülenmesi
Komut satırı seçeneklerinin boşluklarla ayrıldığını unutmayın.
Parametre kullanmanın başka bir örneğine bakalım. Burada betiğe iletilen sayıların toplamını buluyoruz:
#!/bin/bash toplam=$[ $1 + $2 ] yankı İlk parametre $1'dir. yankı İkinci parametre $2'dir. yankı Toplam $toplamdır.
Komut dosyasını çalıştıralım ve hesaplama sonucunu kontrol edelim.
Kendisine iletilen sayıların toplamını bulan komut dosyası
Komut satırı seçeneklerinin sayı olması gerekmez. Dizeleri komut dosyalarına da iletebilirsiniz. Örneğin, burada bir dizeyle çalışan bir komut dosyası var:
#!/bin/bash echo Merhaba $1, nasılsınız?
Çalıştıralım:
./myscript Adam
Ondan ne beklediğimizi gösterecek.
Bir dize parametresiyle çalışan komut dosyası
Ya parametre boşluk içeriyorsa ve onu bağımsız bir veri parçası olarak işlememiz gerekiyorsa? Bu kılavuzun önceki bölümlerinde uzmanlaştıysanız, yanıtı zaten bildiğinize inanıyoruz. Tırnak kullanımından oluşur.
Komut dosyasının dokuzdan fazla parametreye ihtiyacı varsa, bunlara erişirken, değişken adındaki sayı, aşağıdaki gibi süslü parantez içine alınmalıdır:
Parametre Kontrolü
Komut dosyası parametreler olmadan çağrılırsa, ancak kodun normal çalışması için bunların varlığı bekleniyorsa, bir hata oluşur. Bu nedenle, çağrıldığında komut dosyasına iletilen parametrelerin varlığının her zaman kontrol edilmesi önerilir. Örneğin, şu şekilde organize edilebilir:#!/bin/bash eğer [ -n "$1" ] ise Hello $1'i yankılayın. başka yankı "Parametre bulunamadı." fi
Betiği önce bir parametre ile sonra da parametresiz olarak çağıralım.
Komut satırı seçeneklerini kontrol eden bir komut dosyasını çağırma
Parametre sayısı
Bir betikte kendisine iletilen parametrelerin sayısını sayabilirsiniz. Bash kabuğu bunun için özel bir değişken sağlar. Yani, $# değişkeni çağrıldığında komut dosyasına iletilen parametrelerin sayısını içerir.Hadi deneyelim:
#!/bin/bash echo Geçirilen $# parametresi vardı.
Senaryoyu arayalım.
./komut dizim 1 2 3 4 5
Sonuç olarak, komut dosyası kendisine 5 parametrenin iletildiğini bildirecektir.
Bir komut dosyasındaki parametre sayısını sayma
Bu değişken verir sıradışı bir yol komut dosyasına iletilen ve sayıları hakkında bilgi gerektirmeyen son parametrelerin elde edilmesi. İşte göründüğü gibi:
#!/bin/bash echo Son parametre $(!#) idi
Komut dosyasını çağıralım ve ne çıktısına bakalım.
Son parametreye erişim
Tüm komut satırı seçeneklerini yakalama
Bazı durumlarda, betiğe iletilen tüm parametreleri yakalamanız gerekir. Bunu yapmak için $* ve $@ değişkenlerini kullanabilirsiniz. Her ikisi de, komut dosyasına iletilenlere konumsal parametreler kullanmadan erişmeyi mümkün kılan tüm komut satırı seçeneklerini içerir.$* değişkeni, komut satırına girilen tüm seçenekleri tek bir "kelime" olarak içerir.
$@ değişkeninde, parametreler ayrı "kelimelere" bölünür. Bu parametreler döngüler halinde yinelenebilir.
Bu değişkenler arasındaki farkı örneklerle görelim. Önce içeriklerine bir göz atalım:
#!/bin/bash echo "\$* yöntemini kullanarak: $*" echo "----------" echo "\$@ yöntemini kullanarak: $@"
İşte betiğin çıktısı.
Değişkenler $* ve $@
Gördüğünüz gibi, her iki değişkenin çıktısı da aynı sonucu veriyor. Şimdi aralarındaki farkı görmek için bu değişkenlerin içerikleri arasında dolaşmayı deneyelim:
#!/bin/bash sayısı=1 "$*" içindeki parametre için do echo "\$* Parametre #$count = $param" count=$(($count + 1)) yapılan sayı="$ içindeki parametre için 1 @" do echo "\$@ Parametre #$count = $param" count=$(($count + 1)) yapıldı
Komut dosyasının konsola ne yazdırdığına bir bakın. Değişkenler arasındaki fark oldukça açıktır.
Bir döngüde $* ve $@ değişkenlerini ayrıştırma
$* değişkeni, komut dosyasına tek bir veri parçası olarak iletilen tüm parametreleri içerirken, $@ değişkeninde bunlar bağımsız değerlerle temsil edilir. Hangi değişkenin kullanılacağı, belirli bir senaryoda tam olarak neyin gerekli olduğuna bağlıdır.
vardiya komutu
Shift komutu, konumsal parametrelerin değerlerini tam anlamıyla kaydırdığı için bash betiklerinde dikkatli kullanılmalıdır.Bu komutu kullandığınızda, konumsal parametre değerlerini sola kaydırmak varsayılandır. Örneğin, $3 değişkeninin değeri $2 değişkeninin değeri olur, $2'nin değeri $1 olur ve daha önce $1'de olan şey kaybolur. Bunun, betik adını içeren $0 değişkeninin değerini değiştirmediğini unutmayın.
Shift komutunu kullanarak, betiğe iletilen parametreleri yinelemenin başka bir yolunu düşünelim:
#!/bin/bash count=1 iken [ -n "$1" ] yankı yapar "Parameter #$count = $1" count=$(($count + 1)) vardiya tamamlandı
Betik, ilk parametrenin değerinin uzunluğunu kontrol eden bir while döngüsü kullanır. Uzunluk sıfır olduğunda döngüden çıkılır. İlk parametreyi kontrol edip ekranda görüntüledikten sonra, parametre değerlerini bir konum kaydıran shift komutu çağrılır.
Seçenekler arasında yineleme yapmak için shift komutunu kullanma
Shift komutunu kullanırken, her çağrıldığında $1 değerinin geri alınamayacak şekilde kaybolduğunu unutmayın.
Komut satırı anahtarları
Komut satırı anahtarları genellikle önünde kısa çizgi olan harfler gibi görünür. Senaryoları yönetmeye hizmet ederler. Bu örneği göz önünde bulundurun:#!/bin/bash yankı yaparken [ -n "$1" ] -a)'da "$1" büyüklüğünü yapar yankı "-a seçeneği bulundu" ;; -b) echo "-b seçeneği bulundu" ;; -c) echo "-c seçeneği bulundu" ;; *) echo "$1 bir seçenek değildir" ;; esac vardiyası tamamlandı
Senaryoyu çalıştıralım:
$ ./komut dizim -a -b -c -d
Ve terminale ne yazacağını analiz edelim.
Anahtarları bir komut dosyasında işleme
Bu kod, kendisine iletilen anahtarı komut dosyası tarafından işlenen anahtarlar listesine göre kontrol eden case yapısını kullanır. Geçilen değer bu listede bulunursa, karşılık gelen kod dalı yürütülür. İşleme sağlanmayan komut dosyası çağrılırken herhangi bir anahtar kullanılırsa, "*" dalı yürütülür.
Anahtarlar ve parametreler arasında nasıl ayrım yapılır?
Genellikle bash betikleri yazarken, hem komut satırı seçeneklerini hem de anahtarları kullanmanız gereken bir durum ortaya çıkar. standart yol bunu yapmak için, komut dosyasına tuşların ne zaman bittiğini ve olağan parametrelerin ne zaman başladığını söyleyen özel bir karakter dizisi kullanmaktır.Bu sıra bir çift çizgidir (--). Kabuk, anahtar listesinin bittiği konumu belirtmek için kullanır. Komut dosyası, tuşların sonunun işaretini algıladıktan sonra, geriye kalanlar, hata korkusu olmadan anahtarlar olarak değil, parametreler olarak işlenebilir. Bir örnek düşünün:
#!/bin/bash while [ -n "$1" ] -a)'da "$1" büyüklüğünü gerçekleştirirken echo "-a seçeneği bulundu" ;; -b) echo "-b seçeneği bulundu";; -c) echo "-c seçeneği bulundu" ;; --) mesai molası ;; *) echo "$1 bir seçenek değildir";; esac shift done count=1 $@ içindeki param için do echo "Parameter #$count: $param" count=$(($count + 1)) yapıldı
Bu betik, kırmak için break komutunu kullanır. döngü sırasında bir dizede çift tire bulunduğunda.
İşte onu aradıktan sonra olan şey.
Anahtarları ve komut satırı seçeneklerini kullanma
Gördüğünüz gibi, kendisine iletilen verileri ayrıştıran komut dosyası çift çizgi bulduğunda, anahtarların işlenmesini tamamlar ve henüz işlenmemiş her şeyi parametre olarak kabul eder.
Anahtarları Değerlerle İşleme
Komut dosyalarınız karmaşıklaştıkça, normal tuşların artık yeterli olmadığı durumlarla karşılaşacaksınız, bu da bazı değerlere sahip anahtarlar kullanmanız gerektiği anlamına gelir. Örneğin, bu özelliği kullanan bir betik çağrısı şöyle görünür:./myscript -a test1 -b -c test2
Betik, komut satırı anahtarlarıyla birlikte ek seçeneklerin ne zaman kullanıldığını algılayabilmelidir:
#!/bin/bash while [ -n "$1" ], -a'da "$1" büyüklüğünü gerçekleştirirken echo "-a seçeneği bulundu";; -b) param="$2" echo "$param parametre değeriyle -b seçeneği bulundu shift ;; -c) echo "-c seçeneği bulundu";; --) mesai molası ;; *) echo "$1 bir seçenek değildir";; esac shift done "$@" içindeki param için count=1 do echo "Parameter #$count: $param" count=$(($count + 1)) yapıldı
Bu betiği şöyle adlandıralım:
./myscript -a -b test1 -d
Çalışmalarının sonuçlarına bakalım.
Anahtar Parametreleri İşleme
Bu örnekte, case yapısında üç anahtar işlenmektedir. -b anahtarı gerektirir ek parametre. İşlenmekte olan anahtar $1 değişkeninde olduğu için karşılık gelen parametresi $2 olacaktır (burada shift komutu kullanılır, yani işlendikçe betiğe ne geçilirse sola kaydırılır). Bunu hallettiğimizde geriye sadece $2 değişkeninin değerini çıkartmak kalıyor ve istediğimiz anahtarın parametresini almış oluyoruz. Elbette burada bir shift komutuna daha ihtiyaç duyulmaktadır. sonraki anahtar 1 doları vurdu.
Standart Anahtarları Kullanma
Bash betikleri yazarken, komut satırı anahtarları için herhangi bir harfi seçebilir ve betiğin bu anahtarlara tepkisini keyfi olarak ayarlayabilirsiniz. Bununla birlikte, Linux dünyasında, bazı anahtarların değerleri, uyulması yararlı olan bir standart haline geldi. İşte bu anahtarların bir listesi:-a Tüm nesneleri görüntüleyin.
-c Bir sayım gerçekleştirin.
-d Bir dizin belirtin.
-e Nesneyi genişlet.
-f Verilerin okunacağı dosyayı belirtin.
-h Komut için yardımı görüntüler.
-i Büyük/küçük harf yoksay.
-l Tam formatlı çıktı gerçekleştirin.
-n Etkileşimsiz (toplu) modu kullan.
-o Çıktıyı yeniden yönlendirmek istediğiniz dosyayı belirtmenizi sağlar.
-q Komut dosyasını sessiz modda yürütün.
-r Klasörleri ve dosyaları yinelemeli olarak işleyin.
-s Komut dosyasını sessiz modda yürütün.
-v Ayrıntılı çıktı gerçekleştir.
-x Nesneyi hariç tut.
-y Tüm sorulara "evet" yanıtı verin.
Linux kullanıyorsanız, muhtemelen bu anahtarların çoğuna aşinasınızdır. Komut dosyalarınızda bunları geleneksel anlamlarında kullanarak, kullanıcıların belgeleri okuma endişesi duymadan onlarla etkileşime girmesine yardımcı olacaksınız.
Kullanıcıdan veri alma
Komut satırı anahtarları ve seçenekleri, komut dosyasının kullanıcısından girdi almanın harika bir yoludur, ancak bazı durumlarda daha fazla etkileşim gerekir.Bazen betikler, program çalışırken kullanıcının girmesi gereken verilere ihtiyaç duyar. Bash kabuğu, tam da bu amaç için okuma komutunu sağlar.
Bu komut, standart girişten (klavyeden) veya diğer dosya tanıtıcıları kullanarak girişi kabul etmenizi sağlar. Verileri aldıktan sonra, bu komut onu bir değişkene yerleştirir:
#!/bin/bash echo -n "Adınızı girin: " name echo "Merhaba $ad, programıma hoş geldiniz."
Bilgi istemini yazdıran echo komutunun -n seçeneğiyle çağrıldığına dikkat edin. Bu, bilgi isteminin sonunda satır beslemesi olmamasıyla sonuçlanır ve komut dosyası kullanıcısının verileri bir sonraki satır yerine bilgi istemiyle aynı konuma girmesine izin verir.
Kullanıcı girişinin işlenmesi
Okumayı çağırırken birkaç değişken belirleyebilirsiniz:
#!/bin/bash read -p "Adınızı girin: " ilk son yankı "$son, $ilk için verileriniz..."
Komut dosyasının çalıştırıldığında vereceği çıktı budur.
Okuma komutunda birden çok değişken
read çağrılırken herhangi bir değişken belirtilmezse, kullanıcı tarafından girilen veriler özel REPLY ortam değişkenine yerleştirilecektir:
#!/bin/bash read -p "Adınızı girin: " echo Merhaba $REPLY, programıma hoş geldiniz.
Kullanım Çevre değişkeni CEVAP VERMEK
Kullanıcı bazı verileri girse de girmese de komut dosyası çalışmaya devam edecekse, read komutunu çağırırken -t anahtarını kullanabilirsiniz. Yani, key parametresi giriş bekleme süresini saniye cinsinden ayarlar:
#!/bin/bash if read -t 5 -p "Adınızı girin: " name sonra echo "Merhaba $name, betiğime hoşgeldiniz" else echo "Üzgünüm, çok yavaş!" fi
Veriler 5 saniye içinde girilmezse, komut dosyası koşullu ifadenin else dalını çalıştırarak bir özür yazdırır.
Veri girişi zaman sınırı
şifre girme
Bazen kullanıcının betiğin sorusuna yanıt olarak girdiği şeyin ekranda gösterilmemesi daha iyidir. Örneğin, bu genellikle parola isterken yapılır. Read komutunun -s seçeneği, klavye girişinin ekranda görüntülenmesini engeller. Aslında veriler çıktıdır, ancak read komutu metin rengini arka plan rengiyle aynı yapar.#!/bin/bash read -s -p "Parolanızı girin: " pass echo "Parolanız gerçekten $pass mı?"
İşte bu betiğin nasıl çalışacağı.
Hassas verileri girme
Bir dosyadan veri okuma
Read komutu, her çağrıda bir dosyadan bir satır metin okuyabilir. Dosyada okunmamış satır kalmadığında, basitçe duracaktır. Bir dosyanın tüm içeriğini bir komut dosyasında almanız gerekiyorsa, dosyadaki cat komutunu çağırmanın sonuçlarını, read komutunu içeren while yapısına aktarabilirsiniz (tabii ki, cat komutunu kullanmak ilkel görünür, ancak Amacımız, yeni başlayanlara odaklanarak her şeyi olabildiğince basit göstermek; Ileri düzey kullanıcılar Eminim anlayacaklardır).Dosyaları okumak için az önce açıklanan yaklaşımı kullanan bir komut dosyası yazalım.
#!/bin/bash sayısı=1 kedi dosyam | satır okunurken "Line $count: $line" count=$(($count + 1)) yankı yapın "Bitti" yankısını yapın
Onu iş başında görelim.
Bir dosyadan veri okuma
Burada dosyanın içeriğini while döngüsüne aktardık ve bu dosyanın tüm satırlarını dolaşarak her birinin numarasını ve içeriğini görüntüledik.
Sonuçlar
Bugün anahtarlar ve komut satırı parametreleri ile çalışmayı analiz ettik. Bu araçlar olmadan, betiklerin kullanım alanı son derece dardır. Senaryo dedikleri gibi "kendim için" yazılmış olsa bile. Tam burada, programın yürütülmesi sırasında kullanıcıdan veri almaya yönelik yaklaşımları ele aldık - bu, komut dosyalarını etkileşimli hale getirir.Bir dahaki sefere giriş ve çıkış işlemleri hakkında konuşacağız.
Sevgili okuyucular! Bu malzeme serisinin önceki bölümlerindeki yorumlarda deneyimlerinizi paylaştığınız için teşekkür ederiz. Başlangıçta veya çalışırken bir komut dosyasına aktarılabilecek her şeyi işlemekle ilgili söyleyecek bir şeyiniz varsa, birçok kişinin bu konuda okumakla ilgileneceğinden eminiz.
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
Bir bash işlevini çağırmak, diğer tüm komutlarda olduğu gibi, adını belirterek 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 parametreleri olan 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.
Standart getopt büyüsüne sahip bir komut dosyası oluşturdum, böylece komut dosyasını şu şekilde arayabilirsiniz:
Batman-connect -c ffki
Bu betiği kısa çizgi olmadan tek bir parametreyle çağırmak için nasıl parametre eklenir?
batman ffki'yi bağlayınyani bu tek seçeneği -c'nin ikinci argümanı olarak yorumlayacaktır?
Bu cevaba göre denedim:
If[$@="ffki"]; sonra -- "-c $@" fi'yi ayarlayın
Ancak bu bir hatayla sonuçlanıyor, çünkü betiğimdeki bu satır onu değiştirecek:
# $@ PARSED_OPTIONS=$(getopt -n "$0" -o hsrvVi:c: --long "help,start,restart,stop,verbose,vv, sürüm, arayüz:, topluluk:" -- "$@")
Komut dosyamın tamamını yeniden yüklemek zorunda kalmaktan hoşlanmıyorum, bu yüzden ilk bağımsız değişkeni '-c' ve ikincisini 'ffki' olarak ayarlamak için basit bir satır var mı?
4 Çözüm, "Sadece bir bağımsız değişken verilirse bash bağımsız değişkenlerini değiştirin" için form web'i toplar
gibi bir şey yapabilirsin
[ $# = 1 ] ise; o zaman # başka tek bir argüman olduğunda ne yapıyorsan onu yap # getopt bitlerini yap # her iki durumda da ne yapacaksan onu yap
Desteklemek istediğiniz tek anahtar -c ise, getopt'a ihtiyacınız yoktur ve bunun yerine şöyle bir şey yapabilirsiniz:
#!/bin/bash kullanımı() ( echo "Kullanım: $0 [ -c ] arg" >&2 çıkış 1 ) if [ $# = 2 ]; o zaman eğer [ $1 = "-c" ]; sonra shift c_switch_value="$1" başka kullanım fi elif [ $# = 1 ]; sonra c_switch_value="$1" başka kullanım fi
Yine de bunun daha okunaklı olup olmadığı tartışmalıdır.
[ $# = 1 ] ise; sonra # Yalnızca bir bağımsız değişken varsa, geçerli işlemi şununla değiştirin: yeni betiğin çağrılması # tek seçenek -c seçenek exec "$0" -c "$@" fi olarak kullanılacaktır
Bu, asıl soruyu yanıtlamıyor, ancak benim özel durumumda işe yarayan bir geçici çözüm.
if yan tümcesindeki komut [ ardından = ffki ] sözcükleriyle Followeb konumsal parametrelerini oluşturan sözcük değiştirme açılımlarının bir listesine genişler . Genel olarak $VAR, dışarıdayken "VAR değeri" anlamına gelmez. ikili alıntı, yani "VAR değerini şuna bölün: tekil kelimeler ve onları küreler olarak yorumlayın." Bkz. Kabuk komut dosyam neden boşluklara veya diğer özel karakterlere takılıyor?
Ayrıca, "$@" özel bir durumdur: tek bir kelimeye (tırnaklara rağmen) değil, konumsal parametreler listesine (daha fazla genişletme yok) genişler. Boşlukla ayrılmış konumsal parametrelerden (daha doğrusu, IFS değerinin ilk karakteri) oluşan tek bir kelimeye genişleyen "$*" kullanabilirsiniz. Bu nedenle, değeri ffki olan tek bir konum parametresi olup olmadığını kontrol etmek için şunu kullanabilirsiniz:
[ "$*" = "ffki" ] ise; Daha sonra
[ $# -eq 1 ] && [ "$1" = "ffki" ] ise; Daha sonra
Konumsal parametreleri değiştirmek için yakındınız: set yerleşkesini kullanın ve yeni konumsal parametre setini ayrı bağımsız değişkenler olarak iletin. İlk parametrenin a - ile başlama riski varsa, bir seçenek olarak yorumlanmaması için set -- ... kullanın.
[ "$*" = "ffki" ] ise; sonra -- -c "ffki" fi'yi ayarlayın
Bu materyal serisinin önceki bölümlerinde uzmanlaştıktan sonra, bash betiklerinin ne olduğunu, nasıl yazılacağını, program yürütme akışının nasıl kontrol edileceğini, dosyalarla nasıl çalışılacağını öğrendiniz. Bugün komut dosyalarına kullanıcıdan veri alma ve bu verileri işleme yeteneği ile donatarak nasıl etkileşim ekleyeceğimizden bahsedeceğiz.
Komut dosyalarına veri aktarmanın en yaygın yolu, komut satırı seçeneklerini kullanmaktır. Komut dosyasını parametrelerle çağırarak, ona çalışabileceği bazı bilgiler aktarıyoruz. Şuna benziyor:
$ ./komut dosyam 10 20
Bu örnekte, betiğe iki parametre iletilir - "10" ve "20". Bütün bunlar iyi, ancak komut dosyasındaki veriler nasıl okunur?
Komut satırı seçeneklerini okuma
Bash kabuğu, komut dosyası çalıştırıldığında girilen komut satırı parametrelerine konumsal parametreler adı verilen özel değişkenler atar:- $0 - komut dosyası adı.
- $1 ilk parametredir.
- $2 ikinci parametredir ve dokuzuncu parametre olan $9'a kadar devam eder.
#!/bin/bash yankı $0 yankı $1 yankı $2 yankı $3
Komut dosyasını parametrelerle çalıştıralım:
./komutum 5 10 15
Konsola çıktı olarak vereceği şey bu.
Komut dosyasının başlatıldığı parametrelerin görüntülenmesi
Komut satırı seçeneklerinin boşluklarla ayrıldığını unutmayın.
Parametre kullanmanın başka bir örneğine bakalım. Burada betiğe iletilen sayıların toplamını buluyoruz:
#!/bin/bash toplam=$[ $1 + $2 ] yankı İlk parametre $1'dir. yankı İkinci parametre $2'dir. yankı Toplam $toplamdır.
Komut dosyasını çalıştıralım ve hesaplama sonucunu kontrol edelim.
Kendisine iletilen sayıların toplamını bulan komut dosyası
Komut satırı seçeneklerinin sayı olması gerekmez. Dizeleri komut dosyalarına da iletebilirsiniz. Örneğin, burada bir dizeyle çalışan bir komut dosyası var:
#!/bin/bash echo Merhaba $1, nasılsınız?
Çalıştıralım:
./myscript Adam
Ondan ne beklediğimizi gösterecek.
Bir dize parametresiyle çalışan komut dosyası
Ya parametre boşluk içeriyorsa ve onu bağımsız bir veri parçası olarak işlememiz gerekiyorsa? Bu kılavuzun önceki bölümlerinde uzmanlaştıysanız, yanıtı zaten bildiğinize inanıyoruz. Tırnak kullanımından oluşur.
Komut dosyasının dokuzdan fazla parametreye ihtiyacı varsa, bunlara erişirken, değişken adındaki sayı, aşağıdaki gibi süslü parantez içine alınmalıdır:
Parametre Kontrolü
Komut dosyası parametreler olmadan çağrılırsa, ancak kodun normal çalışması için bunların varlığı bekleniyorsa, bir hata oluşur. Bu nedenle, çağrıldığında komut dosyasına iletilen parametrelerin varlığının her zaman kontrol edilmesi önerilir. Örneğin, şu şekilde organize edilebilir:#!/bin/bash eğer [ -n "$1" ] ise Hello $1'i yankılayın. başka yankı "Parametre bulunamadı." fi
Betiği önce bir parametre ile sonra da parametresiz olarak çağıralım.
Komut satırı seçeneklerini kontrol eden bir komut dosyasını çağırma
Parametre sayısı
Bir betikte kendisine iletilen parametrelerin sayısını sayabilirsiniz. Bash kabuğu bunun için özel bir değişken sağlar. Yani, $# değişkeni çağrıldığında komut dosyasına iletilen parametrelerin sayısını içerir.Hadi deneyelim:
#!/bin/bash echo Geçirilen $# parametresi vardı.
Senaryoyu arayalım.
./komut dizim 1 2 3 4 5
Sonuç olarak, komut dosyası kendisine 5 parametrenin iletildiğini bildirecektir.
Bir komut dosyasındaki parametre sayısını sayma
Bu değişken, sayıları hakkında bilgi gerektirmeden, betiğe iletilen parametrelerin sonuncusunu almanın alışılmadık bir yolunu sağlar. İşte göründüğü gibi:
#!/bin/bash echo Son parametre $(!#) idi
Komut dosyasını çağıralım ve ne çıktısına bakalım.
Son parametreye erişim
Tüm komut satırı seçeneklerini yakalama
Bazı durumlarda, betiğe iletilen tüm parametreleri yakalamanız gerekir. Bunu yapmak için $* ve $@ değişkenlerini kullanabilirsiniz. Her ikisi de, komut dosyasına iletilenlere konumsal parametreler kullanmadan erişmeyi mümkün kılan tüm komut satırı seçeneklerini içerir.$* değişkeni, komut satırına girilen tüm seçenekleri tek bir "kelime" olarak içerir.
$@ değişkeninde, parametreler ayrı "kelimelere" bölünür. Bu parametreler döngüler halinde yinelenebilir.
Bu değişkenler arasındaki farkı örneklerle görelim. Önce içeriklerine bir göz atalım:
#!/bin/bash echo "\$* yöntemini kullanarak: $*" echo "----------" echo "\$@ yöntemini kullanarak: $@"
İşte betiğin çıktısı.
Değişkenler $* ve $@
Gördüğünüz gibi, her iki değişkenin çıktısı da aynı sonucu veriyor. Şimdi aralarındaki farkı görmek için bu değişkenlerin içerikleri arasında dolaşmayı deneyelim:
#!/bin/bash sayısı=1 "$*" içindeki parametre için do echo "\$* Parametre #$count = $param" count=$(($count + 1)) yapılan sayı="$ içindeki parametre için 1 @" do echo "\$@ Parametre #$count = $param" count=$(($count + 1)) yapıldı
Komut dosyasının konsola ne yazdırdığına bir bakın. Değişkenler arasındaki fark oldukça açıktır.
Bir döngüde $* ve $@ değişkenlerini ayrıştırma
$* değişkeni, komut dosyasına tek bir veri parçası olarak iletilen tüm parametreleri içerirken, $@ değişkeninde bunlar bağımsız değerlerle temsil edilir. Hangi değişkenin kullanılacağı, belirli bir senaryoda tam olarak neyin gerekli olduğuna bağlıdır.
vardiya komutu
Shift komutu, konumsal parametrelerin değerlerini tam anlamıyla kaydırdığı için bash betiklerinde dikkatli kullanılmalıdır.Bu komutu kullandığınızda, konumsal parametre değerlerini sola kaydırmak varsayılandır. Örneğin, $3 değişkeninin değeri $2 değişkeninin değeri olur, $2'nin değeri $1 olur ve daha önce $1'de olan şey kaybolur. Bunun, betik adını içeren $0 değişkeninin değerini değiştirmediğini unutmayın.
Shift komutunu kullanarak, betiğe iletilen parametreleri yinelemenin başka bir yolunu düşünelim:
#!/bin/bash count=1 iken [ -n "$1" ] yankı yapar "Parameter #$count = $1" count=$(($count + 1)) vardiya tamamlandı
Betik, ilk parametrenin değerinin uzunluğunu kontrol eden bir while döngüsü kullanır. Uzunluk sıfır olduğunda döngüden çıkılır. İlk parametreyi kontrol edip ekranda görüntüledikten sonra, parametre değerlerini bir konum kaydıran shift komutu çağrılır.
Seçenekler arasında yineleme yapmak için shift komutunu kullanma
Shift komutunu kullanırken, her çağrıldığında $1 değerinin geri alınamayacak şekilde kaybolduğunu unutmayın.
Komut satırı anahtarları
Komut satırı anahtarları genellikle önünde kısa çizgi olan harfler gibi görünür. Senaryoları yönetmeye hizmet ederler. Bu örneği göz önünde bulundurun:#!/bin/bash yankı yaparken [ -n "$1" ] -a)'da "$1" büyüklüğünü yapar yankı "-a seçeneği bulundu" ;; -b) echo "-b seçeneği bulundu" ;; -c) echo "-c seçeneği bulundu" ;; *) echo "$1 bir seçenek değildir" ;; esac vardiyası tamamlandı
Senaryoyu çalıştıralım:
$ ./komut dizim -a -b -c -d
Ve terminale ne yazacağını analiz edelim.
Anahtarları bir komut dosyasında işleme
Bu kod, kendisine iletilen anahtarı komut dosyası tarafından işlenen anahtarlar listesine göre kontrol eden case yapısını kullanır. Geçilen değer bu listede bulunursa, karşılık gelen kod dalı yürütülür. İşleme sağlanmayan komut dosyası çağrılırken herhangi bir anahtar kullanılırsa, "*" dalı yürütülür.
Anahtarlar ve parametreler arasında nasıl ayrım yapılır?
Genellikle bash betikleri yazarken, hem komut satırı seçeneklerini hem de anahtarları kullanmanız gereken bir durum ortaya çıkar. Bunu yapmanın standart yolu, komut dosyasına tuşların ne zaman bittiğini ve normal seçeneklerin ne zaman başladığını söyleyen özel bir karakter dizisi kullanmaktır.Bu sıra bir çift çizgidir (--). Kabuk, anahtar listesinin bittiği konumu belirtmek için kullanır. Komut dosyası, tuşların sonunun işaretini algıladıktan sonra, geriye kalanlar, hata korkusu olmadan anahtarlar olarak değil, parametreler olarak işlenebilir. Bir örnek düşünün:
#!/bin/bash while [ -n "$1" ] -a)'da "$1" büyüklüğünü gerçekleştirirken echo "-a seçeneği bulundu" ;; -b) echo "-b seçeneği bulundu";; -c) echo "-c seçeneği bulundu" ;; --) mesai molası ;; *) echo "$1 bir seçenek değildir";; esac shift done count=1 $@ içindeki param için do echo "Parameter #$count: $param" count=$(($count + 1)) yapıldı
Bu betik, bir dizgede çift tire ile karşılaştığında while döngüsünü kırmak için break komutunu kullanır.
İşte onu aradıktan sonra olan şey.
Anahtarları ve komut satırı seçeneklerini kullanma
Gördüğünüz gibi, kendisine iletilen verileri ayrıştıran komut dosyası çift çizgi bulduğunda, anahtarların işlenmesini tamamlar ve henüz işlenmemiş her şeyi parametre olarak kabul eder.
Anahtarları Değerlerle İşleme
Komut dosyalarınız karmaşıklaştıkça, normal tuşların artık yeterli olmadığı durumlarla karşılaşacaksınız, bu da bazı değerlere sahip anahtarlar kullanmanız gerektiği anlamına gelir. Örneğin, bu özelliği kullanan bir betik çağrısı şöyle görünür:./myscript -a test1 -b -c test2
Betik, komut satırı anahtarlarıyla birlikte ek seçeneklerin ne zaman kullanıldığını algılayabilmelidir:
#!/bin/bash while [ -n "$1" ], -a'da "$1" büyüklüğünü gerçekleştirirken echo "-a seçeneği bulundu";; -b) param="$2" echo "$param parametre değeriyle -b seçeneği bulundu shift ;; -c) echo "-c seçeneği bulundu";; --) mesai molası ;; *) echo "$1 bir seçenek değildir";; esac shift done "$@" içindeki param için count=1 do echo "Parameter #$count: $param" count=$(($count + 1)) yapıldı
Bu betiği şöyle adlandıralım:
./myscript -a -b test1 -d
Çalışmalarının sonuçlarına bakalım.
Anahtar Parametreleri İşleme
Bu örnekte, case yapısında üç anahtar işlenmektedir. -b anahtarı ek bir parametre gerektirir. İşlenmekte olan anahtar $1 değişkeninde olduğu için karşılık gelen parametresi $2 olacaktır (burada shift komutu kullanılır, yani işlendikçe betiğe ne geçilirse sola kaydırılır). Bunu hallettiğimizde geriye sadece $2 değişkeninin değerini çıkartmak kalıyor ve istediğimiz anahtarın parametresini almış oluyoruz. Elbette, bir sonraki anahtarın $1 içine girmesi için burada bir shift komutuna daha ihtiyaç vardır.
Standart Anahtarları Kullanma
Bash betikleri yazarken, komut satırı anahtarları için herhangi bir harfi seçebilir ve betiğin bu anahtarlara tepkisini keyfi olarak ayarlayabilirsiniz. Bununla birlikte, Linux dünyasında, bazı anahtarların değerleri, uyulması yararlı olan bir standart haline geldi. İşte bu anahtarların bir listesi:-a Tüm nesneleri görüntüleyin.
-c Bir sayım gerçekleştirin.
-d Bir dizin belirtin.
-e Nesneyi genişlet.
-f Verilerin okunacağı dosyayı belirtin.
-h Komut için yardımı görüntüler.
-i Büyük/küçük harf yoksay.
-l Tam formatlı çıktı gerçekleştirin.
-n Etkileşimsiz (toplu) modu kullan.
-o Çıktıyı yeniden yönlendirmek istediğiniz dosyayı belirtmenizi sağlar.
-q Komut dosyasını sessiz modda yürütün.
-r Klasörleri ve dosyaları yinelemeli olarak işleyin.
-s Komut dosyasını sessiz modda yürütün.
-v Ayrıntılı çıktı gerçekleştir.
-x Nesneyi hariç tut.
-y Tüm sorulara "evet" yanıtı verin.
Linux kullanıyorsanız, muhtemelen bu anahtarların çoğuna aşinasınızdır. Komut dosyalarınızda bunları geleneksel anlamlarında kullanarak, kullanıcıların belgeleri okuma endişesi duymadan onlarla etkileşime girmesine yardımcı olacaksınız.
Kullanıcıdan veri alma
Komut satırı anahtarları ve seçenekleri, komut dosyasının kullanıcısından girdi almanın harika bir yoludur, ancak bazı durumlarda daha fazla etkileşim gerekir.Bazen betikler, program çalışırken kullanıcının girmesi gereken verilere ihtiyaç duyar. Bash kabuğu, tam da bu amaç için okuma komutunu sağlar.
Bu komut, standart girişten (klavyeden) veya diğer dosya tanıtıcıları kullanarak girişi kabul etmenizi sağlar. Verileri aldıktan sonra, bu komut onu bir değişkene yerleştirir:
#!/bin/bash echo -n "Adınızı girin: " name echo "Merhaba $ad, programıma hoş geldiniz."
Bilgi istemini yazdıran echo komutunun -n seçeneğiyle çağrıldığına dikkat edin. Bu, bilgi isteminin sonunda satır beslemesi olmamasıyla sonuçlanır ve komut dosyası kullanıcısının verileri bir sonraki satır yerine bilgi istemiyle aynı konuma girmesine izin verir.
Kullanıcı girişinin işlenmesi
Okumayı çağırırken birkaç değişken belirleyebilirsiniz:
#!/bin/bash read -p "Adınızı girin: " ilk son yankı "$son, $ilk için verileriniz..."
Komut dosyasının çalıştırıldığında vereceği çıktı budur.
Okuma komutunda birden çok değişken
read çağrılırken herhangi bir değişken belirtilmezse, kullanıcı tarafından girilen veriler özel REPLY ortam değişkenine yerleştirilecektir:
#!/bin/bash read -p "Adınızı girin: " echo Merhaba $REPLY, programıma hoş geldiniz.
REPLY ortam değişkenini kullanma
Kullanıcı bazı verileri girse de girmese de komut dosyası çalışmaya devam edecekse, read komutunu çağırırken -t anahtarını kullanabilirsiniz. Yani, key parametresi giriş bekleme süresini saniye cinsinden ayarlar:
#!/bin/bash if read -t 5 -p "Adınızı girin: " name sonra echo "Merhaba $name, betiğime hoşgeldiniz" else echo "Üzgünüm, çok yavaş!" fi
Veriler 5 saniye içinde girilmezse, komut dosyası koşullu ifadenin else dalını çalıştırarak bir özür yazdırır.
Veri girişi zaman sınırı
şifre girme
Bazen kullanıcının betiğin sorusuna yanıt olarak girdiği şeyin ekranda gösterilmemesi daha iyidir. Örneğin, bu genellikle parola isterken yapılır. Read komutunun -s seçeneği, klavye girişinin ekranda görüntülenmesini engeller. Aslında veriler çıktıdır, ancak read komutu metin rengini arka plan rengiyle aynı yapar.#!/bin/bash read -s -p "Parolanızı girin: " pass echo "Parolanız gerçekten $pass mı?"
İşte bu betiğin nasıl çalışacağı.
Hassas verileri girme
Bir dosyadan veri okuma
Read komutu, her çağrıda bir dosyadan bir satır metin okuyabilir. Dosyada okunmamış satır kalmadığında, basitçe duracaktır. Bir dosyanın tüm içeriğini bir komut dosyasında almanız gerekiyorsa, dosyadaki cat komutunu çağırmanın sonuçlarını, read komutunu içeren while yapısına aktarabilirsiniz (tabii ki, cat komutunu kullanmak ilkel görünür, ancak Amacımız, yeni başlayanlara odaklanarak her şeyi olabildiğince basit göstermektir; deneyimli kullanıcılar bunu kesinlikle anlayacaktır).Dosyaları okumak için az önce açıklanan yaklaşımı kullanan bir komut dosyası yazalım.
#!/bin/bash sayısı=1 kedi dosyam | satır okunurken "Line $count: $line" count=$(($count + 1)) yankı yapın "Bitti" yankısını yapın
Onu iş başında görelim.
Bir dosyadan veri okuma
Burada dosyanın içeriğini while döngüsüne aktardık ve bu dosyanın tüm satırlarını dolaşarak her birinin numarasını ve içeriğini görüntüledik.
Sonuçlar
Bugün anahtarlar ve komut satırı parametreleri ile çalışmayı analiz ettik. Bu araçlar olmadan, betiklerin kullanım alanı son derece dardır. Senaryo dedikleri gibi "kendim için" yazılmış olsa bile. Tam burada, programın yürütülmesi sırasında kullanıcıdan veri almaya yönelik yaklaşımları ele aldık - bu, komut dosyalarını etkileşimli hale getirir.Bir dahaki sefere giriş ve çıkış işlemleri hakkında konuşacağız.
Sevgili okuyucular! Bu malzeme serisinin önceki bölümlerindeki yorumlarda deneyimlerinizi paylaştığınız için teşekkür ederiz. Başlangıçta veya çalışırken bir komut dosyasına aktarılabilecek her şeyi işlemekle ilgili söyleyecek bir şeyiniz varsa, birçok kişinin bu konuda okumakla ilgileneceğinden eminiz.
getopts, komut satırından bir betiğe iletilen bağımsız değişkenleri ayrıştırmak için kullanılan yerleşik bir Bash komutudur. Tek bir argümanda birleştirilmiş bir dizi seçeneği ve seçenek tarafından iletilen ek argümanları işlemenize olanak tanır.
# script_name -abc -d /ev/kullanıcı
getopts komutuyla kullanılan gizli değişkenler $OPTIND ve $OPTARG'dır.
Seçenek adının ardından gelen iki nokta üst üste karakteri, isteğe bağlı bir bağımsız değişkene sahip olduğunu gösterir.
getopts ":abcde:fg" Seçeneğini kullanırken
Tipik olarak, getopts bir while döngüsüne sarılır, döngünün her yinelemesi bir sonraki seçeneği ve onun argümanını (varsa) getirir, onu işler, ardından $OPTIND gizli değişkenini 1 azaltır ve yeni bir yinelemenin başlangıcına atlar.
Komut satırından bir betiğe iletilen seçeneklerin önünde bir eksi işareti (-) veya bir artı işareti (+) bulunmalıdır. Bu önek (- veya +), getopts'un seçenekleri diğer bağımsız değişkenlerden ayırmasını sağlar. Aslında getopts, önünde - veya + olmadıkça bağımsız değişkenleri işlemez ve ilk bağımsız değişkenle karşılaşılır karşılaşmaz seçenek çıkarma işlemi durur.
Bir while döngüsünün getopts ile tipik yapısı, döngüye devam etme koşulunu kontrol eden köşeli parantezlerin olmaması nedeniyle standart olandan biraz farklıdır.
Aşağıdaki betik ile getopts'un nasıl çalıştığını görebilirsiniz.
| test-getopts |
kullanım()( while getopts "abc:d:ef" Seçeneği |
Bu şekilde çalıştırmayı deneyin:
-opt ile test-getopts -abc
test-getopts -abefd d-opt
Ve şimdi şöyle:
Test-getopts -abcdef
test-getopts -cd d-opt
Getopts'un bu davranışı, -c seçeneğinin ek bir argüman beklemesinden kaynaklanmaktadır.