Betik Yazmayı Kolaylaştıran Eğer Koşul Betikleri

[mimiksiz]

Güncelleme : gereksiz yere fazla kod yazmışım. bc ve zsh yazılımı kurulu olmalı. Yeni içerik:

Kod Seç Genişlet


dosya adı : boş
#!/bin/zsh
[ ! -z $1 ] && false

dosya adı : boş-değil
#!/bin/zsh
[ -z $1 ] && exit 1

dosya adı : böl
#!/bin/zsh
girdi=$(xargs -0 printf %s) || exit 1
[ -z $1 ] && {echo "Nerden bölüneceğini girmediniz."; exit 1 }
[ $2 -eq 1 -o $2 -eq 2 ] 2>/dev/null || {echo "1. veya 2. kısmı istediğinizi belirtmediniz."; exit 1 }
echo -n $girdi|grep -F "$1" &>/dev/null || {echo $girdi; exit }
aranan=$1
girdi_karakter_adet=${#girdi}
aranan_karakter_adet=${#aranan}
for a in {0..$girdi_karakter_adet}
do
indis=${girdi:$a:$aranan_karakter_adet}
[ "$indis" = "$aranan" ] && {bulundu=$a; break }
done
a=$((bulundu+aranan_karakter_adet))
son_kısım=${girdi:$a}
[ $bulundu -eq 0 ] && {echo -n $son_kısım; exit }
for a in {1..$bulundu}
do
ilk_kısım=$(printf $ilk_kısım; printf ${girdi[$a]}) &>/dev/null
done
[ $2 -eq 1 ] && echo -n $ilk_kısım
[ $2 -eq 2 ] && echo -n $son_kısım

dosya adı : büyük
#!/bin/zsh
[ -z $1 -o -z $2 -o "$1" = "-0" -o "$2" = "-0" ] && exit 1
[[ $1 =~ ^-?[0-9]+([.][0-9]+)?$ ]] || exit 1
[[ $2 =~ ^-?[0-9]+([.][0-9]+)?$ ]] || exit 1
[ $(echo "${1} <= ${2}" | bc) -eq 1 ] 1>/dev/null && exit 1 || exit 0

dosya adı : büyük-değil
#!/bin/zsh
[ "$1" = "-0" -o "$2" = "-0" ] && exit 0
[[ $1 =~ ^-?[0-9]+([.][0-9]+)?$ ]] || exit 0
[[ $2 =~ ^-?[0-9]+([.][0-9]+)?$ ]] || exit 0
[ $(echo "${1} > ${2}" | bc) -eq 1 ] 1>/dev/null && exit 1 || exit 0

dosya adı : büyük-eşit
#!/bin/zsh
[ -z $1 -o -z $2 -o "$1" = "-0" -o "$2" = "-0" ] && exit 1
[[ $1 =~ ^-?[0-9]+([.][0-9]+)?$ ]] || exit 1
[[ $2 =~ ^-?[0-9]+([.][0-9]+)?$ ]] || exit 1
[ $(echo "${1} < ${2}" | bc) -eq 1 ] 1>/dev/null && exit 1 || exit 0

dosya adı : büyük-eşit-değil
#!/bin/zsh
[ "$1" = "-0" -o "$2" = "-0" ] && exit 0
[[ $1 =~ ^-?[0-9]+([.][0-9]+)?$ ]] || exit 0
[[ $2 =~ ^-?[0-9]+([.][0-9]+)?$ ]] || exit 0
[ $(echo "${1} >= ${2}" | bc) -eq 1 ] 1>/dev/null && exit 1 || exit 0

dosya adı : dizin
#!/bin/zsh
[ -z $1 -o ! -d $1 ] && exit 1 || exit 0

dosya adı : dizin-değil
#!/bin/zsh
[ ! -z $1 -a -d $1 ] && exit 1 || exit 0

dosya adı : doğal-sayı
#!/bin/zsh
[[ $1 =~ ^[0-9]+$ ]] || exit 1

dosya adı : doğal-sayı-değil
#!/bin/zsh
[[ $1 =~ ^[0-9]+$ ]] && exit 1 || exit 0

dosya adı : dosya
#!/bin/zsh
[ -z $1 -o ! -f $1 ] && exit 1 || exit 0

dosya adı : dosya-değil
#!/bin/zsh
[ ! -z $1 -a -f $1 ] && exit 1 || exit 0

dosya adı : eşit
#!/bin/zsh
[ "$1" != "$2" ] && exit 1 || exit 0

dosya adı : eşit-değil
#!/bin/zsh
[ "$1" = "$2" ] && exit 1 || exit 0

dosya adı : küçük
#!/bin/zsh
[ -z $1 -o -z $2 -o "$1" = "-0" -o "$2" = "-0" ] && exit 1
[[ $1 =~ ^-?[0-9]+([.][0-9]+)?$ ]] || exit 1
[[ $2 =~ ^-?[0-9]+([.][0-9]+)?$ ]] || exit 1
[ $(echo "${1} >= ${2}" | bc) -eq 1 ] 1>/dev/null && exit 1 || exit 0

dosya adı : küçük-değil
#!/bin/zsh
[ "$1" = "-0" -o "$2" = "-0" ] && exit 0
[[ $1 =~ ^-?[0-9]+([.][0-9]+)?$ ]] || exit 0
[[ $2 =~ ^-?[0-9]+([.][0-9]+)?$ ]] || exit 0
[ $(echo "${1} < ${2}" | bc) -eq 1 ] 1>/dev/null && exit 1 || exit 0

dosya adı : küçük-eşit
#!/bin/zsh
[ -z $1 -o -z $2 -o "$1" = "-0" -o "$2" = "-0" ] && exit 1
[[ $1 =~ ^-?[0-9]+([.][0-9]+)?$ ]] || exit 1
[[ $2 =~ ^-?[0-9]+([.][0-9]+)?$ ]] || exit 1
[ $(echo "${1} > ${2}" | bc) -eq 1 ] 1>/dev/null && exit 1 || exit 0

dosya adı : küçük-eşit-değil
#!/bin/zsh
[ "$1" = "-0" -o "$2" = "-0" ] && exit 0
[[ $1 =~ ^-?[0-9]+([.][0-9]+)?$ ]] || exit 0
[[ $2 =~ ^-?[0-9]+([.][0-9]+)?$ ]] || exit 0
[ $(echo "${1} <= ${2}" | bc) -eq 1 ] 1>/dev/null && exit 1 || exit 0

dosya adı : negatif-sayı
#!/bin/zsh
[ "$1" = "-0" ] && exit 1
[[ $1 =~ ^-[0-9]+([.][0-9]+)?$ ]] || exit 1

dosya adı : negatif-sayı-değil
#!/bin/zsh
[ "$1" = "-0" ] && exit 0
[[ $1 =~ ^-[0-9]+([.][0-9]+)?$ ]] && exit 1 || exit 0

dosya adı : negatif-tam-sayı
#!/bin/zsh
[ "$1" = "-0" ] && exit 1
[[ $1 =~ ^-[0-9]+$ ]] || exit 1

dosya adı : negatif-tam-sayı-değil
#!/bin/zsh
[ "$1" = "-0" ] && exit 0
[[ $1 =~ ^-[0-9]+$ ]] && exit 1 || exit 0

dosya adı : negatif-virgüllü-sayı
#!/bin/zsh
[[ $1 =~ ^-[0-9]+([.][0-9]+)$ ]] || exit 1

dosya adı : negatif-virgüllü-sayı-değil
#!/bin/zsh
[[ $1 =~ ^-[0-9]+([.][0-9]+)$ ]] && exit 1 || exit 0

dosya adı : pozitif-sayı
#!/bin/zsh
[ $1 -eq 0 ] 2>/dev/null && exit 1
[[ $1 =~ ^[0-9]+([.][0-9]+)?$ ]] && exit 0 || exit 1

dosya adı : pozitif-sayı-değil
#!/bin/zsh
[ $1 -eq 0 ] 2>/dev/null && exit 0
[[ $1 =~ ^[0-9]+([.][0-9]+)?$ ]] && exit 1 || exit 0

dosya adı : pozitif-tam-sayı
#!/bin/zsh
[ $1 -eq 0 ] 2>/dev/null && exit 1
[[ $1 =~ ^[0-9]+$ ]] && exit 0 || exit 1

dosya adı : pozitif-tam-sayı-değil
#!/bin/zsh
[ $1 -eq 0 ] 2>/dev/null && exit 0
[[ $1 =~ ^[0-9]+$ ]] && exit 1

dosya adı : pozitif-virgüllü-sayı
#!/bin/zsh
[[ $1 =~ ^[0-9]+([.][0-9]+)$ ]] || exit 1

dosya adı : pozitif-virgüllü-sayı-değil
#!/bin/zsh
[[ $1 =~ ^[0-9]+([.][0-9]+)$ ]] && exit 1 || exit 0

dosya adı : satır
#!/bin/zsh
[ $1 -eq $1 ] 2>/dev/null && {sed -n $1'p'; exit }
if [ "$(echo $1|grep -o -)" = "-" -a -z $(echo $1|tr -d "[0-9]"\-) ] &>/dev/null
then
sed -n $(echo $1|cut -d- -f1),$(echo $1|cut -d- -f2)'p'
else
echo "Geçersiz giriş yaptınız."
exit 1
fi

dosya adı : sayı
#!/bin/zsh
[ "$1" = "-0" ] && exit 1
[[ $1 =~ ^-?[0-9]+([.][0-9]+)?$ ]] || exit 1

dosya adı : sayı-değil
#!/bin/zsh
[ "$1" = "-0" ] && exit 0
[[ $1 =~ ^-?[0-9]+([.][0-9]+)?$ ]] && exit 1 || exit 0

dosya adı : tam-sayı
#!/bin/zsh
[ "$1" = "-0" ] && exit 1
[[ $1 =~ ^-?[0-9]+$ ]] || exit 1

dosya adı : tam-sayı-değil
#!/bin/zsh
[ "$1" = "-0" ] && exit 0
[[ $1 =~ ^-?[0-9]+$ ]] && exit 1 || exit 0

dosya adı : virgüllü-sayı
#!/bin/zsh
[[ $1 =~ ^-?[0-9]+([.][0-9]+)$ ]] || exit 1

dosya adı : virgüllü-sayı-değil
#!/bin/zsh
[[ $1 =~ ^-?[0-9]+([.][0-9]+)$ ]] && exit 1 || exit 0

yeni içerik indirme linki:https://yadi.sk/d/OiH0k1cAeNW0nA


eski içerik:
Kısa, sade ve filtrelemekle zaman kaybetmeden türkçe if koşullu programlama için 40 adet, alias tanımlı 1 adet betik yazdım.

Bu betikler sayesinde kod kalabalığından kurtularak filtreleme işine girmeden ve [ "' ] gibi karakterleri kullanmadan rahatlıkla betik yazılabilir.
çalışmaları için zsh nin kurulu olması gerekiyor.
Örnek kullanımlar:

Kod Seç Genişlet


#!/bin/zsh
source eğer.sh
girdi=$(xargs -0 printf %s)
eğer içinde-adet-var $girdi - 1; ise #girdi değişkeninde 1 adet tire varsa
  ...
değer printf $girdi|içinde-yok -; ise #girdi değişkeninde tire yoksa
...
değer sayı $girdi; ise #girdi değişkeni sayı ise
...
değer negatif-virgüllü-sayı $girdi; ise
...
değer pozitif-tam-sayı $girdi && büyük-eşit $girdi 1; ise
...
eson
Tüm betiklerin kullanım örnekleri

Kod Seç Genişlet


eğer boş $girdi; ise
eğer boş-değil $girdi; ise
eğer büyük $girdi 0; ise
eğer büyük-değil $girdi 1; ise
eğer büyük-eşit $girdi 1; ise
eğer büyük-eşit-değil $girdi 1; ise
eğer dizin $girdi; ise
eğer dizin-değil $girdi; ise
eğer dosya $girdi; ise
eğer dosya-değil $girdi; ise
eğer doğal-sayı $girdi; ise
eğer doğal-sayı-değil $girdi; ise
eğer eşit $girdi 1; ise
eğer eşit-değil $girdi i; ise
eğer içinde-adet-var $girdi w 3; ise #3adet w varsa
eğer içinde-adet-yok $girdi o 1; ise #o 1adet değilse
eğer printf $girdi|içinde-var w; ise
eğer printf $girdi|içinde-yok o; ise
eğer küçük $girdi 1; ise
eğer küçük-değil $girdi 2; ise
eğer küçük-eşit $girdi 1; ise
eğer küçük-eşit-değil $girdi 1; ise
eğer negatif-sayı $girdi; ise
eğer negatif-sayı-değil $girdi; ise
eğer negatif-tam-sayı $girdi; ise
eğer negatif-tam-sayı-değil $girdi; ise
eğer negatif-virgüllü-sayı $girdi; ise
eğer negatif-virgüllü-sayı-değil $girdi; ise
eğer pozitif-sayı $girdi; ise
eğer pozitif-sayı-değil $girdi; ise
eğer pozitif-tam-sayı $girdi; ise
eğer pozitif-tam-sayı-değil $girdi; ise
eğer pozitif-virgüllü-sayı $girdi; ise
eğer pozitif-virgüllü-sayı-değil $girdi; ise
eğer sayı $girdi; ise #negatif, pozitif, tam sayı, ondalıklı sayı ise
eğer sayı-değil $girdi; ise
eğer tam-sayı $girdi; ise
eğer tam-sayı-değil $girdi; ise
eğer virgüllü-sayı $girdi; ise
eğer virgüllü-sayı-değil $girdi; ise

içinde-var, içinde-yok ve eğer.sh betikleri hariç hepsi parametre alır. içinde-var ve içinde-yok betikleri boru karakteriyle çalışır. (echo deneme|içinde-var d >> doğru sonuç döndürür başına if yazıp sonuna ;then ekleyerek işleme girilebilir) Sonuç doğru çıkarsa işlem yapmaz yani true döner if koşulu çalışır, sonuç yanlış çıkarsa exit 1 komutuyla yanlış çıkar ve if koşulu çalışmaz.
eğer.sh if koşuluna alias tanımlayarak if koşulunu türkçe kullanmak içindir. Diğer betiklerin çalışması için betiklerin bulunduğu dizinde olması gerekir. $HOME/bin klasörüne atıp $HOME/bin dizinini path değişkenine eklemenizi öneririm.

Kod Seç Genişlet


eğer.sh
#!/bin/zsh
alias eğer='if'
alias ise='then'
alias değer='elif'
alias değilse='else'
alias eson='fi'

boş
#!/bin/zsh
source eğer.sh
eğer [ "$1" != "" ]; ise
exit 1
eson

boş-değil
#!/bin/zsh
source eğer.sh
eğer boş $1; ise
exit 1
eson

büyük
#!/bin/zsh
source eğer.sh
eğer küçük $1 $2 || eşit $1 $2; ise
exit 1
eson

büyük-değil
#!/bin/zsh
source eğer.sh
eğer büyük $1 $2; ise
exit 1
eson

büyük-eşit
#!/bin/zsh
source eğer.sh
eğer küçük $1 $2; ise
exit 1
eson

büyük-eşit-değil
#!/bin/zsh
source eğer.sh
eğer büyük-eşit $1 $2; ise
exit 1
eson

dizin
#!/bin/zsh
source eğer.sh
eğer [ ! -d "$1" ]; ise
exit 1
eson

dizin-değil
#!/bin/zsh
source eğer.sh
eğer dizin $1; ise
exit 1
eson

dosya
#!/bin/zsh
source eğer.sh
eğer eşit $1 ""||[ ! -f $1 ]; ise
exit 1
eson

dosya-değil
#!/bin/zsh
source eğer.sh
eğer dosya $1; ise
exit 1
eson

doğal-sayı
#!/bin/zsh
source eğer.sh
eğer boş-değil $(printf $1|çıkar '[0-9]'); ise
exit 1
eson

doğal-sayı-değil
#!/bin/zsh
source eğer.sh
eğer doğal-sayı $1; ise
exit 1
eson

eşit
#!/bin/zsh
source eğer.sh
eğer doğal-sayı $1; ise
exit 1
eson

eşit-değil
#!/bin/zsh
source eğer.sh
eğer eşit $1 $2; ise
exit 1
eson

içinde-adet-var
#!/bin/zsh
source eğer.sh
eğer boş $1||boş $2||boş $3; ise
echo "Boş değer girdiniz."
exit 1
değer eşit-değil $(printf $1|tr -cd $2|wc -m) $3; ise
exit 1
eson

içinde-adet-yok
#!/bin/zsh
source eğer.sh
eğer içinde-adet-var $1 $2 $3; ise
exit 1
eson

küçük
#!/bin/zsh
source eğer.sh
bir=$1
iki=$2
küçük(){
eğer eşit $durum_bir pozitif; ise
eğer eşit $durum_iki negatif || [ ! "$bir" -lt "$iki" ]; ise
exit 1
eson
değer eşit $durum_iki negatif && [ ! "$iki" -lt "$bir" ]; ise
exit 1
eson
}
virgüllü_küçük(){
eğer eşit $virgüllü_bir evet; ise
virgülden_önce_bir=$(printf $bir|awk -F . '{print $1}')
değilse
virgülden_önce_bir=$bir
bir=$bir.0
eson
eğer eşit $virgüllü_iki evet; ise
virgülden_önce_iki=$(printf $iki|awk -F . '{print $1}')
değilse
virgülden_önce_iki=$iki
iki=$iki.0
eson

eğer [ "$virgülden_önce_bir" -lt "$virgülden_önce_iki" ]; ise
eğer eşit $durum_iki negatif; ise
exit 1
eson
değer [ "$virgülden_önce_iki" -lt "$virgülden_önce_bir" ]; ise
eğer eşit $durum_iki negatif && eşit $durum_bir pozitif; ise
exit 1
değer eşit $durum_bir pozitif && eşit $durum_iki pozitif; ise
false
eson
değilse #virgülden öncesi eşitse
virgülden_sonra_bir=$(printf $bir|awk -F . '{print $2}')
virgülden_sonra_iki=$(printf $iki|awk -F . '{print $2}')
virgülden_sonra_bir_adet=$(printf $virgülden_sonra_bir|wc -m)
virgülden_sonra_iki_adet=$(printf $virgülden_sonra_iki|wc -m)
eğer eşit $virgülden_sonra_bir_adet $virgülden_sonra_iki_adet; ise
eğer [ "$virgülden_sonra_iki" -lt "$virgülden_sonra_bir" ]; ise
eğer eşit $durum_iki negatif && eşit $durum_bir pozitif; ise
exit 1
eson
değer [ "$virgülden_sonra_bir" -lt "$virgülden_sonra_iki" ]; ise
eğer eşit $durum_bir pozitif && eşit $durum_iki negatif; ise
exit 1
değer eşit $durum_iki negatif && eşit $durum_bir negatif ]; ise
exit 1
eson
değer eşit $virgülden_sonra_bir $virgülden_sonra_iki; ise
exit 1
eson
değer [ "$virgülden_sonra_bir_adet" -lt "$virgülden_sonra_iki_adet" ]; ise
döngü_kontrol_küçük $virgülden_sonra_iki_adet
değilse
döngü_kontrol_küçük $virgülden_sonra_bir_adet
eson
eson
}
döngü_kontrol_küçük(){
for (( a=1; a<=$@; a++ )); do
virgülden_sonra_bir_a=$(printf ${virgülden_sonra_bir: 0: $a})
virgülden_sonra_iki_a=$(printf ${virgülden_sonra_iki: 0: $a})
eğer eşit-değil $virgülden_sonra_bir_a $virgülden_sonra_iki_a; ise
break
eson
done
eğer [ "$virgülden_sonra_bir_a" -lt "$virgülden_sonra_iki_a" ]; ise
eğer eşit $durum_bir negatif && eşit $durum_iki negatif; ise
exit 1
değer eşit $durum_iki negatif && eşit $durum_bir pozitif; ise
exit 1
eson
değer [ "$virgülden_sonra_iki_a" -lt "$virgülden_sonra_bir_a" ]; ise
eğer eşit $durum_iki pozitif && eşit $durum_bir pozitif; ise
exit 1
değer eşit $durum_iki negatif && eşit $durum_bir pozitif; ise
exit 1
eson
eson
}
kontrol(){
eğer boş $iki||boş $bir; ise
echo "2 adet sayı girmelisiniz."
exit 1
değer sayı-değil $bir || sayı-değil $iki; ise
echo "Sayı girmelisiniz."
exit 1
eson
eğer negatif-sayı $bir; ise
tireden_sonraki_karakter_adeti_bir=$(echo $(( $(printf ${#bir})-1 )))
bir=$(printf ${bir: -$tireden_sonraki_karakter_adeti_bir})
durum_bir=negatif
değilse
durum_bir=pozitif
eson
eğer negatif-sayı $iki; ise
tireden_sonraki_karakter_adeti_iki=$(echo $(( $(printf ${#iki})-1 )))
iki=$(printf ${iki: -$tireden_sonraki_karakter_adeti_iki})
durum_iki=negatif
değilse
durum_iki=pozitif
eson
eğer virgüllü-sayı $bir; ise
virgüllü_bir=evet
eson
eğer virgüllü-sayı $iki; ise
virgüllü_iki=evet
eson
eğer eşit $virgüllü_iki evet || eşit $virgüllü_bir evet; ise
virgüllü_küçük
değilse
küçük
eson
}
kontrol

küçük-değil
#!/bin/zsh
source eğer.sh
eğer küçük $1 $2; ise
exit 1
eson

küçük-eşit
#!/bin/zsh
source eğer.sh
eğer büyük $1 $2; ise
exit 1
eson

küçük-eşit-değil
#!/bin/zsh
source eğer.sh
eğer küçük-eşit $1 $2; ise
exit 1
eson

negatif-sayı
#!/bin/zsh
source eğer.sh
bir=$1
eğer sayı-değil $bir||! printf $bir|grep - &>/dev/null; ise
exit 1
eson

negatif-sayı-değil
#!/bin/zsh
source eğer.sh
eğer negatif-sayı $1; ise
exit 1
eson

negatif-tam-sayı
#!/bin/zsh
source eğer.sh
eğer tam-sayı-değil $1 || negatif-sayı-değil $1; ise
exit 1
eson

negatif-tam-sayı-değil
#!/bin/zsh
source eğer.sh
eğer negatif-tam-sayı $1; ise
exit 1
eson

negatif-virgüllü-sayı
#!/bin/zsh
source eğer.sh
eğer ! virgüllü-sayı $1||negatif-sayı-değil $1; ise
exit 1
eson

negatif-virgüllü-sayı-değil
#!/bin/zsh
source eğer.sh
eğer negatif-virgüllü-sayı $1; ise
exit 1
eson

pozitif-sayı
#!/bin/zsh
source eğer.sh
eğer sayı-değil $1||eşit $1 0||printf $1|içinde-var -; ise
exit 1
eson

pozitif-sayı-değil
#!/bin/zsh
source eğer.sh
eğer pozitif-sayı $1; ise
exit 1
eson

pozitif-tam-sayı
#!/bin/zsh
source eğer.sh
eğer doğal-sayı-değil $1||eşit $1 0; ise
exit 1
eson

pozitif-tam-sayı-değil
#!/bin/zsh
source eğer.sh
eğer pozitif-tam-sayı $1; ise
exit 1
eson

pozitif-virgüllü-sayı
#!/bin/zsh
source eğer.sh
eğer virgüllü-sayı-değil $1||pozitif-sayı-değil $bir; ise
exit 1
eson

pozitif-virgüllü-sayı-değil
#!/bin/zsh
source eğer.sh
eğer pozitif-virgüllü-sayı $1; ise
exit 1
eson

sayı
#!/bin/zsh
source eğer.sh
bir=$1
eğer boş $bir; ise
exit 1
eson
ilk_karakter=$(printf ${bir: 0: 1})
ilk_iki_karakter=$(printf ${bir: 0: 2})
son_karakter=$(printf "${bir[-1]}")
eğer ! printf $bir|grep "[0-9]" &>/dev/null; ise
exit 1
değer eşit $bir -0; ise
exit 1
değer [ ! "$(printf $bir|tr -cd -|wc -m)" -lt "2" ]; ise
exit 1
değer [ ! "$(printf $bir|tr -cd '.'|wc -m)" -lt "2" ]; ise
exit 1
değer eşit $ilk_iki_karakter "-."; ise
exit 1
değer [ "$(printf $bir|tr -d .-|tr -d '[0-9]')" != "" ]; ise
exit 1
değer [ "$(printf $bir|tr -cd .)" != "" ]; ise
eğer eşit $son_karakter .||eşit $ilk_karakter .; ise
exit 1
eson
değer printf $bir|grep - &>/dev/null; ise
eğer eşit-değil $ilk_karakter "-"; ise
exit 1
eson
eson

sayı-değil
#!/bin/zsh
source eğer.sh
eğer sayı $1; ise
exit 1
eson

tam-sayı
#!/bin/zsh
source eğer.sh
eğer sayı-değil $1||virgüllü-sayı $1; ise
exit 1
eson

tam-sayı-değil
#!/bin/zsh
source eğer.sh
eğer tam-sayı $1; ise
exit 1
eson

virgüllü-sayı
#!/bin/zsh
source eğer.sh
eğer sayı-değil $1||içinde-adet-yok $1 . 1; ise
exit 1
eson

virgüllü-sayı-değil
#!/bin/zsh
source eğer.sh
eğer virgüllü-sayı $1; ise
exit 1
eson