Bagaimana untuk menentukan apakah sebuah bash variabel kosong?

Ini akan mengembalikan true jika variabel disetel atau disetel ke string kosong ("").

if [ -z "$VAR" ];

Di Bash, bila anda're tidak peduli dengan portabilitas untuk kerang yang don't dukungan itu, anda harus selalu menggunakan double-sintaks braket:

Salah satu dari berikut:

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

Di Bash, dengan menggunakan dua tanda kurung, tanda kutip tidak't perlu. Anda dapat menyederhanakan tes untuk variabel yang tidak mengandung nilai ke:

if [[ $variable ]]

Sintaks ini kompatibel dengan ksh (setidaknya ksh93, sih). Tidak bekerja di murni POSIX atau lebih tua Bourne seperti sh atau dasbor.

Lihat jawaban saya di sini dan BashFAQ/031 untuk informasi lebih lanjut tentang perbedaan antara single dan double kurung.

Anda dapat menguji untuk melihat apakah variabel ini secara khusus unset (sebagai berbeda dari string kosong):

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

mana "x" adalah sewenang-wenang.

Jika anda ingin mengetahui apakah variabel adalah null tetapi tidak diset:

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

Variabel dalam bash (dan setiap POSIX-kompatibel shell) dapat berupa salah satu dari tiga negara:

• unset
• ditetapkan ke string kosong
• set untuk non-string kosong

Sebagian besar waktu anda hanya perlu tahu jika sebuah variabel set untuk non-string kosong, tapi kadang-kadang itu's penting untuk membedakan antara unset dan ditetapkan ke string kosong.

Berikut adalah contoh bagaimana anda dapat menguji berbagai kemungkinan, dan bekerja di bash atau POSIX-kompatibel shell:

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

Berikut ini adalah hal yang sama tetapi berguna dalam bentuk tabel:

                        +-------+-------+-----------+
                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      |
+-----------------------+-------+-------+-----------+

The ${VAR+foo} membangun memperluas ke string kosong jika VAR adalah unset atau foo jika VAR diatur untuk apa-apa (termasuk string kosong).

The ${VAR-foo} membangun mengembang untuk nilai VAR jika set (termasuk set ke string kosong) dan foo jika diset. Hal ini berguna untuk memberikan user-overridable default (misalnya, ${COLOR-red} mengatakan untuk menggunakan merah kecuali variabel WARNA yang telah ditetapkan untuk sesuatu).

Alasan mengapa [ x"${VAR" = x ] sering dianjurkan untuk menguji apakah sebuah variabel adalah baik disetel atau disetel ke string kosong adalah karena beberapa implementasi dari [ perintah (juga dikenal sebagai test) adalah kereta. Jika VAR diatur untuk sesuatu seperti -n, maka beberapa implementasi akan melakukan hal yang salah ketika diberi [ "${VAR" = "" ] karena argumen pertama untuk [ adalah keliru ditafsirkan sebagai -n operator, bukan string.

-z adalah cara terbaik.

Opsi lain I've yang digunakan untuk mengatur sebuah variabel, tetapi dapat diganti dengan variabel lain misalnya

export PORT=${MY_PORT:-5432}

Jika $MY_PORT variabel kosong, kemudian di PORT akan diatur ke 5432, jika PORT diset ke nilai MY_PORT. Perhatikan sintaks seperti usus besar dan dash.

Jika anda're tertarik dalam membedakan kasus set-kosong terhadap unset status, melihat pilihan-u untuk bash:

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

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

Alternatif I've terlihat [ -z "$foo" ] adalah sebagai berikut, namun saya'm tidak yakin mengapa orang-orang menggunakan metode ini, ada yang tahu?

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

Pokoknya jika anda're pelarangan unset variabel (baik oleh set-u atau set-o nounset), maka anda'll mengalami kesulitan dengan kedua metode tersebut. Ada's sederhana memperbaiki ini:

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

Catatan: ini akan meninggalkan anda dengan variabel undef.

The pertanyaan bertanya bagaimana untuk memeriksa apakah sebuah variabel string kosong dan jawaban terbaik yang sudah diberikan untuk itu.
Tapi aku mendarat di sini setelah masa berlalu pemrograman php dan apa yang saya benar-benar mencari sebuah cek suka kosong fungsi di php bekerja pada bash shell.
Setelah membaca jawaban saya menyadari bahwa saya tidak berpikir dengan benar di bash, tapi bagaimanapun pada saat itu fungsi seperti kosong di php akan menjadi soooo berguna dalam bash kode.
Karena saya pikir ini bisa terjadi kepada orang lain, saya memutuskan untuk mengkonversi php kosong fungsi di bash

Menurut [php manual][1]:
variabel dianggap kosong jika itu doesn't ada atau jika nilainya adalah salah satu dari yang berikut:

• "" (string kosong)
• 0 (0 sebagai integer)
• 0.0 (0 sebagai pelampung)
• "0" (0 sebagai string)
• array kosong
• sebuah variabel dideklarasikan, tapi tanpa nilai

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 "" ) ]]
}

Contoh penggunaan:

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

Demo:
cuplikan berikut:

#!/bin/bash

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

for (( i=0; i

seluruh if-then dan -z yang tidak perlu.

[ "$foo" ] && echo "foo tidak kosong"
[ "$foo" ] || echo "foo memang kosong"

Saya 5 sen: ada juga yang lebih pendek sintaks dari jika ..., yang satu ini:

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

Baris ini akan menetapkan NILAI jika argumen yang telah disediakan dan akan mencetak pesan kesalahan didahului dengan script baris nomor dalam kasus kesalahan (dan akan menghentikan eksekusi script).

Contoh lain dapat ditemukan di abs-panduan (cari «Contoh 10-7»).

Secara pribadi lebih suka cara yang jelas untuk memeriksa :

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

Ini benar persis ketika $FOO adalah mengatur dan kosong:

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

oneliner perpanjangan duffbeer703's solusi:

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

Bukan jawaban yang tepat, tetapi berlari ke trik ini. Jika string anda're looking for berasal dari "perintah" maka anda benar-benar dapat menyimpan perintah di env. variabel dan kemudian mengeksekusi setiap kali jika pernyataan, maka tidak ada tanda kurung yang diperlukan!

Misalnya perintah ini, yang menentukan jika anda're di debian:

grep debian /proc/version

lengkap contoh:

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

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

Jadi ini adalah cara yang tidak langsung (siarang itu setiap waktu) untuk memeriksa string kosong (itu terjadi akan memeriksa untuk kesalahan respon dari perintah, tetapi juga terjadi untuk mengembalikan string kosong).