How to call bash function with boolean parameter?

Question

I have a function called install_cont that is called twice from my bash script. However, inside that function there is a code block that I want to execute only if the boolean parameter is true. In Python I would do:

def install_cont(expres=False):
    if expres:
         # Do some code...

install_cont(True)
install_cont() # Can call with default False

How do I achieve this in bash? Reading online, I understand that all variables are string. However, what is the best way to achieve a boolean-like parameter?

Answer 1

Shell scripting doesn't have booleans, but it does have a convention for representing success as an integer. Confusingly for programmers coming from other languages, this is that 0 is success, and anything else is failure.

This is the basis of the if construct which runs a command, and tests its result for success. You can't test a variable directly with if, but you can use the test built-in, which "succeeds" if a particular test passes.

test is also spelled [ which is why you'll often see code with if [ ... ] - those brackets aren't part of the if syntax, they're just a command with a funny name. (Bash also has a [[ built-in with some extra features, but [ is more standard, so worth learning.)

The test command can perform various tests - examining numbers, checking the file system, etc. For a command-line option, you could test against the string true or false with the = binary operator.

So what you end up with is something like this:

install_cont() {
    # Name the parameter for convenience
    local expres="$1";

    if [ "$expres" = "true" ];
    then
         # Do some code...
    fi;
}

install_cont true
install_cont # default will not pass the test

If you want fancier parameters, you can have actual defaults with the slightly awkward ${foo:-default} and ${foo:=default} parameter expansion syntaxes. For example:

install_cont() {
    # Default the mode to "boring"
    local mode="${1:-boring}";

    if [ "$mode" = "exciting" ];
    then
         # Do some code...
    elif [ "$mode" = "boring" ];
    then
         # Do some code...
    else
         echo "Unrecognised mode";
    fi;
}

Answer 2

Like this perhaps.

your_func () {
    if [[ $1 ]]; then
        # do things if parameter was present
    fi
    # do unconditional things
}

Answer 3

Bash on it's own does not have built-in boolean handling. What it does is handles strings and integers. However, you can define strings and numbers for definite exit status codes and make pseudo-boolean logic by design. Where ever you see true or false in bash, you are seeing constructs with specific exit codes. Since the default command exit codes are 0 or 1, unless you assign one to the contrary, you basically have a built-in method, if not inherently for the purpose, to perform boolean logic.

Using the test command with subsequent [] or [[]] will output a 0 for true or a 1 for false. But these are merely exit status codes.

Answer 4

Unix provides two commands:

• true: return true value (i.e. exit value is 0)
• false: return false value (i.e. exit value is non-0)

You can use them in if, while and until constructs.

Example:

install_cont()
{
    local expres="${1:-false}"    # Default value is false

    if "$expres"; then
        # Do some code...
    else
        # Do something else...
    fi
}

install_cont true
install_cont          # false implied

You are using Bash. If you want booleans that are also valid in arithmetic operations, then you can also use arithmetic booleans:

declare -i false=0 true=1

cond1="$true"
cond2="$false"
if ((cond1 || cond2)); then
    # Do some code...
fi

Personally, I don't use arithmetic booleans as I'm perfectly happy with true and false commands.

Answer 5

One of the tricky things about bash and other Bourne-derived shells is that a condition used in an if or while statement is not an expression. It's a command, and the condition is treated as true or false depending on whether the command succeeded or failed. A command indicates success by returning an exit status of 0, and failure by returning anything else.

The built-in commands true and false do nothing other than returning an exit status denoting success or failure, respectively.

The [ ... ] and [[ ... ]] constructs can be used to simulate using an expression as a condition. [ is actually a command, very nearly equivalent to the test command.

If I need the equivalent of a Boolean variable in a bash script, I use a variable whose value is either the string true or the string false. If I use that variable as a condition, it expands to the command name true or false. I just have to be careful to ensure that such a variable never takes some value other than true or false.

And it's important to remember not to use the [ ... ] syntax. With a single argument, for example

if [ false ] ; then # This is incorrect!

the command succeeds because false is a non-empty string. Remember that the [ and ] are not part of the syntax of an if statement (though they're designed to look like they are).

An example:

#!/bin/bash

func() {
    if $1 ; then
        echo In func, the condition is true
    else
        echo In func, the condition is false
    fi
}

func false
func true

The output:

In func, the condition is false
In func, the condition is true

This technique does have some drawbacks. It can break if you assign a value other than exactly true or false to a variable, or even if you misspell the name of a variable. And unlike in languages with a built-in Boolean type and false and true literals, the shell is likely to fail to diagnose such errors, causing your script to silently misbehave.