Bash – why is an array variable not considered set if it is assigned `()`

arraybashvariable

bash manual says:

A parameter is an entity that stores values

A variable is a parameter denoted by a name.

A parameter is set if it has been assigned a value.

An array variable is considered set if a subscript has been assigned a value.

Is an array variable a variable and a parameter?

If yes, why is an array variable not considered set if it is assigned ()?

$ ar=()
$ echo ${ar-This is a new value}
This is a new value

Thanks.

Best Answer

In bash, like in ksh, where $var is an array, $var is actually short for ${var[0]}.

So in:

var=([1]=whatever [2]=blah)

${var+set} would not expand to set, and [[ -v var ]] would return false, because $var has no element of indice 0 (note that in bash, like in ksh, but contrary to most other shells and languages, arrays are sparse arrays, or associative arrays with keys limited to positive integers).

In bash (at least since 4.3), when you declare a variable as array with:

typeset -a var

var is initially unset. It's not even set to an empty list. In 4.3, typeset -p var would return an error. In 4.2 and before it would output:

declare -a a='()'

(as if declaring the array assigned an empty list like it does in zsh)

In 4.4, it outputs:

declare -a var

So, since 4.3, an unset (but declared) array is different from an array that is assigned an empty list.

Still, it's difficult programmatically to differentiate between both. But in practice, the distinction is not very useful. Most likely, what you want to know is how many elements are in the array:

((${#array[@]})) || echo array has no element

See zsh, rc, fish and yash for shells with better array designs.

Related Solutions

Bash Arrays – Using Variables in Array Names

Some ideas:

A "parameter expansion" of a variable value (the ${...} part):
```
echo "arr$COUNTER[0] = ${arr$COUNTER[0]}"
```
will not work. You may get around by using eval (but I do not recommend it):
```
eval echo "arr$COUNTER[0] = \${arr$COUNTER[0]}"
```
That line could be written as this:
```
i="arr$COUNTER[0]"; echo "$i = ${!i}"
```
That is called indirection (the !) in Bash.
A similar issue happens with this line:
```
declare -a "arr$COUNTER=($field)"
```
Which should be split into two lines, and eval used:
```
declare -a "arr$COUNTER"
eval arr$COUNTER\=$ \$field $
```
Again, I do not recommend using eval (in this case).
As you are reading the whole file into the memory of the shell, we may as well use a simpler method to get all lines into an array:
```
readarray -t lines <"VALUES_FILE.txt"
```
That should be faster than calling awk for each line.

An script with all the above could be:

#!/bin/bash
valfile="VALUES_FILE.txt"

readarray -t lines <"$valfile"             ### read all lines in.

line_count="${#lines[@]}"
echo "Total number of lines $line_count"

for ((l=0;l<$line_count;l++)); do
    echo "Counter value is $l"             ### In which line are we?
    echo "Field = ${lines[l]}"             ### kepth only to help understanding.
    k="arr$l"                              ### Build the variable arr$COUNTER
    IFS=" " read -ra $k <<<"${lines[l]}"   ### Split into an array a line.
    eval max=\${#$k[@]}                    ### How many elements arr$COUNTER has?
    #echo "field $field and k=$k max=$max" ### Un-quote to "see" inside.
    for ((j=0;j<$max;j++)); do             ### for each element in the line.
        i="$k[$j]"; echo "$i = ${!i}"      ### echo it's value.
    done
done
echo "The End"
echo

However, still, AWK may be faster, if we could execute what you need in AWK.

A similar processing could be done in awk. Assuming the 6 values will be used as an IP (4 of them) and the other two are a number and an epoch time.

Just a very simple sample of an AWK script:

#!/bin/sh
valfile="VALUES_FILE.txt"
awk '
NF==6 { printf ( "IP: %s.%s.%s.%s\t",$1,$2,$3,$4)
        printf ( "number: %s\t",$5+2)
        printf ( "epoch: %s\t",$6)
        printf ( "\n" )
    }
' "$valfile"

Just make a new question with the details.

bash – Are the Null String and “” the Same String?

Yes. Using the test from this answer:

$ [ -n "${a+1}" ] && echo "defined" || echo "not defined"
not defined
$ a=""
$ [ -n "${a+1}" ] && echo "defined" || echo "not defined"
defined
$ b=
$ [ -n "${b+1}" ] && echo "defined" || echo "not defined"
defined

So setting the variable to "" is the same as setting it to empty value. Therefore, empty value and "" are the same.

Best Answer

Related Solutions

Bash Arrays – Using Variables in Array Names

bash – Are the Null String and “” the Same String?

Related Question