Bir bash değişkeninin boş olup olmadığı nasıl belirlenir?

Bash'te, onu desteklemeyen mermilere taşınabilirlikle ilgilenmediğinizde, her zaman çift köşeli parantez sözdizimini kullanmalısınız:

Aşağıdakilerden herhangi biri:

if [[ -z $variable ]]
if [[ -z "$variable" ]]
if [[ ! $variable ]]
if [[ ! "$variable" ]]

Bash'te çift köşeli parantez kullanarak tırnak işaretleri gerekmez. için bir değer içeren bir değişken için testi basitleştirebilirsiniz:

if [[ $variable ]]

Bu sözdizimi ksh ile uyumludur (en azından ksh93). Saf POSIX veya sh veya tire gibi eski Bourne mermilerinde çalışmaz.

Çift ve tek köşeli parantezler arasındaki farklar hakkında daha fazla bilgi için buradaki cevabım ve BashFAQ/031 konusuna bakın.

Bir değişkenin özel olarak ayarlanıp ayarlanmadığını (boş bir dizeden farklı olarak) test edebilirsiniz:

if [[ -z ${variable+x} ]]

burada "x" isteğe bağlıdır.

Bir değişkenin null olup olmadığını ancak unset olmadığını bilmek istiyorsanız:

if [[ -z $variable && ${variable+x} ]]

Bash (ve POSIX uyumlu herhangi bir Kabuk) içindeki bir değişken üç durumdan birinde olabilir:

• ayarlanmazsa
• boş dizeye ayarla
• boş olmayan bir dizeye ayarla

Çoğu zaman, yalnızca bir değişkenin boş olmayan bir dizeye ayarlanıp ayarlanmadığını bilmeniz gerekir, ancak bazen unset ile boş dizeye ayarlamak arasında ayrım yapmak önemlidir.

Aşağıdakiler, çeşitli olasılıkları nasıl test edebileceğinizin örnekleridir ve bash veya herhangi bir POSIX uyumlu Kabukta çalışır:

if [ -z "${VAR}" ]; then
    echo "VAR is unset or set to the empty string"
fi
if [ -z "${VAR+set}" ]; then
    echo "VAR is unset"
fi
if [ -z "${VAR-unset}" ]; then
    echo "VAR is set to the empty string"
fi
if [ -n "${VAR}" ]; then
    echo "VAR is set to a non-empty string"
fi
if [ -n "${VAR+set}" ]; then
    echo "VAR is set, possibly to the empty string"
fi
if [ -n "${VAR-unset}" ]; then
    echo "VAR is either unset or set to a non-empty string"
fi

İşte aynı şey ama kullanışlı tablo formunda:

                        +-------+-------+-----------+
                VAR is: | unset | empty | non-empty |
+-----------------------+-------+-------+-----------+
| [ -z "${VAR}" ]       | true  | true  | false     |
| [ -z "${VAR+set}" ]   | true  | false | false     |
| [ -z "${VAR-unset}" ] | false | true  | false     |
| [ -n "${VAR}" ]       | false | false | true      |
| [ -n "${VAR+set}" ]   | false | true  | true      |
| [ -n "${VAR-unset}" ] | true  | false | true      |
+-----------------------+-------+-------+-----------+

${VAR+foo} construct, VAR ayarlanmamışsa boş dizeye veya foo herhangi bir şeye (boş dize dahil) ayarlanmışsa VAR öğesine genişler.

${VAR-foo} construct, ayarlanmışsa VAR değerine (boş dizeye ayarlananlar dahil) ve ayarlanmadıysa foo değerine genişler. Bu, kullanıcı tarafından geçersiz kılınabilen varsayılanları sağlamak için kullanışlıdır (ör. ${COLOR-red}, red değişkeni bir şeye ayarlanmadığı sürece COLOR kullandığını söylüyor).

Sebebi ise [ x"${VAR}" = x ] genellikle, bir değişkenin ayarlanmamış veya boş dizeye ayarlanıp ayarlanmadığını test etmek için önerilir, çünkü [ komutu (test olarak da bilinir) hatalıdır. VAR, -n, bazı uygulamalar _ verildiğinde yanlış bir şey yapar [ "${VAR}" = "" ] çünkü [ yanlışlıkla -n operatörü, bir dize değil.

-z en iyi yoldur.

Kullandığım başka bir seçenek de bir değişken ayarlamaktır, ancak başka bir değişken tarafından geçersiz kılınabilir.

export PORT=${MY_PORT:-5432}

Eğer $MY_PORT değişkeni boş, sonra PORT 5432 olarak ayarlanır, aksi takdirde PORT MY_PORT. Sözdiziminin iki nokta üst üste ve kısa çizgi içerdiğini unutmayın.

Set-empty ve unset durumlarını ayırt etmekle ilgileniyorsanız, bash için -u seçeneğine bakın:

$ set -u
$ echo $BAR
bash: BAR: unbound variable
$ [ -z "$BAR" ] && echo true
bash: BAR: unbound variable
$ BAR=""
$ echo $BAR

$ [ -z "$BAR" ] && echo true
true

Gördüğüm bir alternatif [ -z "$foo" ] aşağıdaki, ancak insanların neden bu yöntemi kullandığından emin değilim, kimse biliyor mu?

[ "x${foo}" = "x" ]

Her neyse, ayarlanmamış değişkenlere izin vermiyorsanız (set -u veya set -o nounset), bu yöntemlerin ikisinde de sorun yaşarsınız. Bunun basit bir çözümü var:

[ -z "${foo:-}" ]

Not: bu değişkeninizi undef olarak bırakacaktır.

sorusu bir değişkenin boş bir dize olup olmadığını nasıl kontrol edeceğini sorar ve bunun için en iyi cevaplar zaten verilmiştir.
Ama php programlama geçtikten sonra buraya indi ve ben aslında aradığım şey php boş fonksiyonu bir bash Shell çalışma gibi bir kontrol oldu.
Cevapları okuduktan sonra bash'da düzgün düşünmediğimi fark ettim, ama o anda php'deki boş gibi bir işlev bash kodumda çok kullanışlı olurdu.
Bunun başkalarına da olabileceğini düşündüğüm için, basp'ta php boş işlevini dönüştürmeye karar verdim

php kılavuz göre:
bir değişken, yoksa veya değeri aşağıdakilerden biri ise boş kabul edilir:

• "" (boş bir dize)
• 0 (0 as an integer)
• 0.0 (şamandıra olarak 0)
• "0" (dize olarak 0)
• boş bir dizi
• bildirilen ancak değeri olmayan bir değişken

Elbette null ve false durumlar bash biçimine dönüştürülemez, bu nedenle atlanırlar.

function empty
{
    local var="$1"

    # Return true if:
    # 1.    var is a null string ("" as empty string)
    # 2.    a non set variable is passed
    # 3.    a declared variable or array but without a value is passed
    # 4.    an empty array is passed
    if test -z "$var"
    then
        [[ $( echo "1" ) ]]
        return

    # Return true if var is zero (0 as an integer or "0" as a string)
    Elif [ "$var" == 0 2> /dev/null ]
    then
        [[ $( echo "1" ) ]]
        return

    # Return true if var is 0.0 (0 as a float)
    Elif [ "$var" == 0.0 2> /dev/null ]
    then
        [[ $( echo "1" ) ]]
        return
    fi

    [[ $( echo "" ) ]]
}

Kullanım örneği:

if empty "${var}"
    then
        echo "empty"
    else
        echo "not empty"
fi

Deneme:
aşağıdaki pasaj:

#!/bin/bash

vars=(
    ""
    0
    0.0
    "0"
    1
    "string"
    " "
)

for (( i=0; i<${#vars[@]}; i++ ))
do
    var="${vars[$i]}"

    if empty "${var}"
        then
            what="empty"
        else
            what="not empty"
    fi
    echo "VAR \"$var\" is $what"
done

exit

çıktılar:

VAR "" is empty
VAR "0" is empty
VAR "0.0" is empty
VAR "0" is empty
VAR "1" is not empty
VAR "string" is not empty
VAR " " is not empty

Bir bash mantığında bu işlevde sıfırdaki kontrollerin yan sorunlara neden olabileceğini söyledikten sonra, bu işlevi kullanan herkes bu riski değerlendirmeli ve belki de bu kontrolleri sadece birincisini bırakarak kesmeye karar vermelidir .

5 sentim: if ... İfadesinden daha kısa bir sözdizimi de var:

VALUE="${1?"Usage: $0 value"}"

Bu satır, bir bağımsız değişken sağlandıysa VALUE değerini ayarlar ve bir hata olması durumunda komut dosyası satır numarasının önüne bir hata mesajı yazdırır (ve komut dosyasının yürütülmesini sonlandırır).

Başka bir örnek abs-guide ("Örnek 10-7" için arama) bölümünde bulunabilir.

if-then ve -z öğelerinin tümü gereksizdir.

 ["$ foo"] && echo "foo boş değil" 
 ["$ foo"] || echo "foo gerçekten boş" 

Bu, $ FOO ayarlandığında ve boş olduğunda geçerlidir:

[ "${FOO+x}" = x ] && [ -z "$FOO" ]

oneliner uzantısı duffbeer7 'ın çözümü:

#! /bin/bash
[ -z "$1" ] || some_command_that_needs_$1_parameter

Şahsen kontrol etmenin daha net bir yolunu tercih edin:

if [ "${VARIABLE}" == "" ]; then
  echo VARIABLE is empty
else
  echo VARIABLE is not empty
fi

Tam bir cevap değil, ama bu hile ile karşılaştı. Aradığınız dize "bir komuttan" geliyorsa, komutu env'de saklayabilirsiniz. değişkenini seçin ve if ifadesi için her seferinde çalıştırın, ardından parantez gerekmez!

Örneğin, debian'da olup olmadığınızı belirleyen bu komut:

grep debian /proc/version

tam örnek:

IS_DEBIAN="grep -i debian /proc/version"

if $IS_DEBIAN; then
  echo 'yes debian'
else
  echo 'non debian'
fi

Bu, boş bir dizeyi kontrol etmek için dolaylı bir yol (her seferinde yeniden çalıştırma) gibidir (komuttan gelen hata yanıtını kontrol ediyor, ancak boş bir dize döndürüyor).