Bir değişkenin boş veya sadece boşluk içerip içermediğini nasıl test edebilirim?

Aşağıdaki bash sözdizimi paramboş olmadığını doğrular :

 [[ !  -z  $param  ]]

Örneğin:

param=""
[[ !  -z  $param  ]] && echo "I am not zero"

Çıktı yok ve para cezası.

Ancak, parambir (veya daha fazla) boşluk karakteri dışında boş olduğunda , durum farklıdır:

param=" " # one space
[[ !  -z  $param  ]] && echo "I am not zero"

"Sıfır değilim" çıktı.

Testi yalnızca boşluk karakterleri içeren değişkenleri boş olarak değerlendirecek şekilde nasıl değiştirebilirim?

Öncelikle, -ztestin açıkça şunlar için olduğunu unutmayın :

dizenin uzunluğu sıfır

Yani, sadece boşluk içeren bir dize olmalıdır edilir değil altında doğru olması -zbunun sıfır olmayan bir uzunluğa sahiptir çünkü.

İstediğiniz şey, kalıp değiştirme parametresi genişletmesini kullanarak değişkenden boşlukları kaldırmaktır :

[[ -z "${param// }" ]]

Bu, paramdeğişkeni genişletir ve desenin tüm eşleşmelerini (tek bir boşluk) hiçbir şeyle değiştirir, bu nedenle yalnızca içinde boşluk olan bir dize boş bir dizeye genişler.

Nasıl çalıştığını asıl mesele yani ${var/pattern/string}ilk en uzun maç değiştirir patternile string. Ne zaman patternbaşlar /(yukarıdaki gibi) o zaman değiştirir tüm maçları. Değişim boş olduğundan, finali /ve stringdeğeri atlayabiliriz :

$ {Parametre / kalıp / dizge}

Desen sadece Dosyaismi gibi bir kalıp üretmek için genişletilir. Parametre genişletilir ve değere karşı en uzun örüntü eşleşmesi dizeyle değiştirilir . Eğer desen '/' ile başlar, tüm maçları deseni ile değiştirilir dize . Normalde sadece ilk eşleşme değiştirilir. ... Dize boş ise, kalıp eşleşmeleri silinir ve / sonraki kalıp ihmal edilebilir.

Bütün bunlardan sonra, ${param// }tüm boşlukları silmek için son buluruz .

_{kshİçinde bulunduğu ( mevcut olduğu yerde) zshve bashsözdiziminin POSIX olmadığını ve shkomut dosyalarında kullanılmaması gerektiğini unutmayın .}

Bir dizginin yalnızca yetkili bir kümedeki karakterleri içerdiğini kontrol etmenin kolay yolu yetkisiz karakterlerin varlığını test etmektir. Bu nedenle, dizenin yalnızca boşluk içerip içermediğini test etmek yerine, dizenin boşluktan başka bir karakter içerip içermediğini test edin. Bash, ksh veya zsh:

if [[ $param = *[!\ ]* ]]; then
  echo "\$param contains characters other than space"
else
  echo "\$param consists of spaces only"
fi

“Yalnızca boşluklardan oluşur”, boş (veya ayarlanmamış) bir değişkenin durumunu içerir.

Herhangi bir boşluk karakteri için test yapmak isteyebilirsiniz. Kullanım [[ $param = *[^[:space:]]* ]]açık ne olursa olsun, örneğin test etmek istediğiniz boşluk karakterlerinin listesi yerel ayarları veya kullanmayı [[ $param = *[$' \t\n']* ]]uzay, sekme veya Yenisatır için test etmek.

İpin =içini bir desene göre eşleştirmek [[ … ]], bir ksh uzantısıdır (bash ve zsh da bulunur). Herhangi bir Bourne / POSIX tarzında, caseyapıyı dizeyle kalıpla eşleştirmek için kullanabilirsiniz . Standart kabuk desenlerinin , çoğu normal ifade sözdizimindeki gibi !değil, karakter kümesini olumsuzlamak için kullandığını unutmayın ^.

case "$param" in
  *[!\ ]*) echo "\$param contains characters other than space";;
  *) echo "\$param consists of spaces only";;
esac

Boşluk karakterlerini test etmek için, $'…'sözdizimi ksh / bash / zsh; Bu karakterleri tam anlamıyla betiğinize ekleyebilirsiniz (bir yeni satırın ters eğik çizgi + newline hiçbir şeye genişlemediğinden, tırnak içinde olması gerekeceğini unutmayın) veya

whitespace=$(printf '\n\t ')
case "$param" in
  *[!$whitespace]*) echo "\$param contains non-whitespace characters";;
  *) echo "\$param consists of whitespace only";;
esac

POSIXly:

case $var in
  (*[![:blank:]]*) echo '$var contains non blank';;
  (*) echo '$var contains only blanks or is empty or unset'
esac

Ayırt etmek boş , dışı boş , boş , unset :

case ${var+x$var} in
  (x) echo empty;;
  ("") echo unset;;
  (x*[![:blank:]]*) echo non-blank;;
  (*) echo blank
esac

[:blank:]yatay boşluk karakterleri içindir (ASCII'de boşluk ve sekme, ancak yerel ayarlarınızda muhtemelen birkaç tane daha vardır; bazı sistemler ayrılmaz alanı içerecektir (mümkün olduğunda), bazıları olmaz). Siz de (yeni satır veya form-besleme gibi) dikey boşluk karakterleri istiyorsanız, yerini [:blank:]ile [:space:].

İyi bir betik dilinde bir betik yerine bir kabuk betiği yazmak için geriye kalan tek neden , aşırı taşınabilirliğin önemli bir endişe kaynağı olmasıdır. Miras /bin/sh, sahip olacağınızdan emin olabileceğiniz tek şey, ancak örneğin Perl, örneğin, platformlar arası Bash'ten daha olası. Bu nedenle, gerçekten evrensel olmayan özellikleri kullanan kabuk komut dosyalarını asla yazmayın - ve bazı özel Unix satıcılarının POSIX.1-2001'den önce kabuk ortamlarını donduğunu unutmayın .

Bu testi yapmanın taşınabilir bir yolu var, ancak kullanmanız gerekiyor tr:

[ "x`printf '%s' "$var" | tr -d "$IFS"`" = x ]

(Varsayılan değer $IFS, uygun bir şekilde boşluk, sekme ve yeni satırdır.)

( printfYerleşik, kendiliğinden taşınabilirdir, ancak ona güvenmek, sizin hangi türünün bulunduğuna karar echovermekten çok daha az güçtür .)

if [[ -n "${variable_name/[ ]*\n/}" ]]
then
    #execute if the the variable is not empty and contains non space characters
else
    #execute if the variable is empty or contains only spaces
fi

Değişkenin boş olup olmadığını veya boşluk içerdiğini test etmek için bu kodu da kullanabilirsiniz:

${name:?variable is empty}

Bir değişkenin ayarlanmamış olup olmadığını test etmek için, boş (boş değere sahip) veya yalnızca boşluk içeriyor:

 [ -z "${param#"${param%%[! ]*}"}" ] && echo "empty"

Açıklama:

• ${param%%[! ]*}Kaldırılan alanın ilkinden boşluk olmayana kadar genişler .
• Bu sadece baştaki boşlukları bırakıyor.
• Bir sonraki genişleme, öndeki boşlukları değişkenden kaldırır.
• Sonuç boşsa, değişken başlamak için boştu.
• Veya değişken boş değilse, öndeki boşlukları çıkarmak onu boş bıraktı.
• Sonuç boşsa -z, eko empty.

Yukarıdaki POSIX uyumludur ve herhangi bir Bourne soyundan çalışır.

Bunu da sekmelere genişletmek istiyorsanız, açık bir sekme ekleyin:

 [ -z "${param#"${param%%[!     ]*}"}" ] && echo "empty"

veya kaldırmanız gereken karakterleri içeren bir değişken kullanın:

 var=$' \t'   # in ksh, bash, zsh
 [ -z "${param#"${param%%[!$var]*}"}" ] && echo "empty"

veya bazı POSIX "karakter sınıfı ifadeleri" kullanabilirsiniz (boşluk, boşluk ve sekme anlamına gelir):

 [ -z "${param#"${param%%[![:blank:]]*}"}" ] && echo "empty"

Fakat bu mksh, lksh ve posh'de başarısız olacaktır.

Bunu dene:

$ [[ -z \`echo $n\` ]] && echo zero

zero