"bash: [: : integer expression expected"

Question

I want this function to return one random word if there aren't any command-line arguments.

I am modifying linuxconfig.org's random-word generator to run even when #$ -ne 1.

function random-word {
    if [ $# -eq 0 ] ;
    then 
        echo "I only take one argument, dummy"
        # previously was exit 0
    fi

    # Constants 
    X=0
    ALL_NON_RANDOM_WORDS=/usr/share/dict/words

    # total number of non-random words available 
    non_random_words=`cat $ALL_NON_RANDOM_WORDS | wc -l` 

    # while loop to generate random words  
    # number of random generated words depends on supplied argument 
    while [ $X -lt "$1" ] 
    do 
    random_number=`od -N3 -An -i /dev/urandom | 
    awk -v f=0 -v r="$non_random_words" '{printf "%i\n", f + r * $1 / 16777216}'` 
    sed `echo $random_number`"q;d" $ALL_NON_RANDOM_WORDS 
      let "X = X + 1" 
    done

The statement executes, but there's a bash error:

$ bob
I only take one argument, dummy
bash: [: : integer expression expected

How do I fix this so the bash error won't display?

Answer 1

while [ $X -lt "$1" ] is being evaluated even when there is no $1.

Move the rest of the code into an else block so this doesn't happen.

function random-word {
    # from linuxconfig.org 

    if [ $# -eq 0 ] 
    then 
        echo "I need an argument, dummy"
        # To be extra friendly, give them a random word.
        echo "Here's a random word:"
        random-word 1
    else
        # Constants 
        X=0

         ...

        sed `echo $random_number`"q;d" $ALL_NON_RANDOM_WORDS 
          let "X = X + 1" 
        done
    fi
}

Answer 2

You don't need an else block. And you don't need to fail if you receive more than one argument. You only need to fail if you don't get an argument and you can then just ignore everything else or quit if you don't get at least the one.

set -- "${1?ERR: Where\'s my argument?!?!}"

That statement does all of that. This does the same but also fails if the first argument is only the '' nullstring :

set -- "${1:?ERR: Where\'s my argument?!?!}"

Of course, if the point is to be a shell function called from an interactive shell, this might kill the interactive shell as well, so you can do:

(: "${1:?Where\'s my argument?}") || return && set -- "$1"

...which will handle that as well. But, in my opinion, a shell function should never affect an interactive shell unless absolutely necessary - like if it needs to alter a current shell variable or something. And so better than the above would be to declare the function as a subshell, like:

fn() (set -- "${1:?Where\'s my argument?}" && echo "$1")

...does.

Another way to do this is to accept all arguments and concatenate them - so all arguments are only treated as one in every case. You can do that like:

fn() (                              
    : "${1:?ERR: Where\'s my argument?}"
    set -- "$*" && echo "$1" 
)
fn '' ; fn here are a lot of arguments that will all be treated as one
###OUTPUT###
sh: line 2: 1: ERR: Where's my argument?
here are a lot of arguments that will all be treated as one

I personally don't much like the sh: line 2: 1: bit that usually happens - at least not in interactive shells. I usually stick a CTRL+V CTRL+M in before ERR: so it does a return to the head of the line in a terminal and writes over that bit but still outputs the more useful info into a log. Like:

fn() (                              
    : "${1:?^MERR: Where\'s my argument?}"
    set -- "$*" && echo "$1" 
)
fn ; fn 2>&1 | cat -A
###OUTPUT###
ERR: Where's my argument?
sh: line 2: 1: ^MERR: Where's my argument?$