Bash

The double-bracket [[ syntax is called "new-test".

-n is a string comparison operator that tests if a string is not null zero-length.

foo() {
    [[ -n "$1" ]] || {
        echo "Error: param 1 is required"
        return 1
    }
    echo "Param is: $1"
}

foo
foo ""
foo bar

Error: param 1 is required
Error: param 1 is required
Param is: bar

Same as above, but not as good. For more info, see FAQ: "What is the difference between test, [ and [[?"

foo() {
    [ -n "$1" ] || {
        echo "Error: param 1 is required"
        return 1
    }
}

Note that [ ] is an alias for test. The above example could be written as:

foo() {
    a=${1-}
    test -n "$a" || {
        echo "Error: a is required"
        return 1
    }
}

foo() {
    if [ -z ${1+x} ]; then
        echo "Error: param 1 is required"
        return 1
    else
        local a=$1
    fi
    echo "a is '$a'"
}

foo
foo ""
foo bar

Error: param 1 is required
a is ''
a is 'bar'

Without set -u this works fine and prints nothing, even though foo is not bound.

echo $foo

This produces an error: "bash: line 2: foo: unbound variable" (TODO: org mode to print this).

set -u
echo $foo

Works with eval.

set -u
vars="FOO=foo BAR=bar"
eval $vars
echo $FOO

foo

See home/bin/ssm script for a good example.

showHelp() {
    cat <<END
Usage: $(basename "$0") [-p profile]
END
}

while getopts :hp: arg; do
    case ${arg} in
        h)
            showHelp
            exit 0
            ;;
        p)
            profile="$OPTARG"
            ;;
        \?)
            echo "Invalid option: -$OPTARG" >&2
            exit 1
            ;;
        :)
            echo "Option -$OPTARG requires an argument" >&2
            exit 1
            ;;
    esac
done
shift $((OPTIND -1))

# Define default option values
profile=${profile:="chrisc"}

aws="aws --profile $profile --region us-east-1"

Use <<-. Each line in the HEREDOC has to begin with a TAB. Having trouble getting this working with org-babel.

foo="bar"
a=$(cat <<-EOF
hello
$foo
EOF
)
echo "$a"

hello
bar
EOF

A heredoc can interpolate variable names to values, or the whole heredoc can be taken completely literally without any interpolation. The difference is whether the limit string has single quotes around it.

• GNU Bash docs section on paremeter expansion
• The Open Group has some excellent POSIX documentation with a section on parameter expansion

Docs for ${parameter:-[word]}

If parameter is unset or null, the expansion of word (or an empty string if word is omitted) shall be substituted; otherwise, the value of parameter shall be substituted.

var=""
if [ -z ${var:-x"} ]; then
    echo "var is unset"
else
    echo "var is set to '$var'"
fi

var is set to ''

if [ -z ${var:-"foo"} ]; then
    echo "var is unset"
else
    echo "var is set to '$var'"
fi

Docs for ${parameter:+[word]}

If parameter is unset or null, null shall be substituted; otherwise, the expansion of word (or an empty string if word is omitted) shall be substituted.

-z is a comparison operator that tests if the argument is null or empty.

var=""
if [ -z ${var+x} ]; then
    echo "var is unset"
else
    echo "var is set to '$var'"
fi

var is set to ''

In this case, var is the empty string, which is not "unset or null". Therefore the + parameter expansion expands this to x (which passes the -z check).

if [ -z ${var+x} ]; then
    echo "var is unset"
else
    echo "var is set to '$var'"
fi

var is unset

In this case, var has not been declared, so it is "unset or null". The + parameter expansion expands it to null.

var=""
if [ -z ${var+} ]; then
    echo "var is unset"
else
    echo "var is set to '$var'"
fi

var is unset

In this case we leave the word spot empty in the parameter expansion, so if var is empty, it is subsituted by an empty string. Now the -z test sees an empty argument, and this prints out var is unset.

Remove largest prefix pattern.

a_list=("foo/aa.foo" "bar/ab.foo" "baz/ac.foo")
for a in ${a_list[@]}; do
    # The "*/" is a regex
    echo ${a##*/}
done

aa.foo
ab.foo
ac.foo

See this StackOverflow answer.

The difference between [@] and [*]-expanded arrays in double-quotes is that "${myarray[@]}" leads to each element of the array being treated as a separate shell-word, while "${myarray[*]}" results in a single shell-word with all of the elements of the array separated by spaces (or whatever the first character of IFS is).

Usually, the [@] behavior is what you want.

arr=("foo" "bar" "baz")
echo ${arr[@]}

foo bar baz

arr=("foo" "bar" "baz")
for x in "${arr[@]}"; do
    echo $x
done

foo
bar
baz

arr=("foo" "bar" "baz")
echo ${#arr[@]}

3

Start a subprocess per element in an array, where each subprocess runs $script.

script=$(cat <<"EOF"
echo "some {}"
EOF
)
arr=("foo" "bar" "baz")
printf "%s\n" "${arr[@]}" \
    | xargs -n 1 \
            -P ${#arr[@]} \
            -I {} \
            bash -c "$script"

some foo
some bar
some baz

arr=("key1,val1",
     "key2,val2",
     "key3,val3")

for i in "${arr[@]}"; do
    k=$(echo "$i" | cut -d, -f 1)
    v=$(echo "$i" | cut -d, -f 2)
    echo "Key is $k and val is $v"
done

Key is key1 and val is val1
Key is key2 and val is val2
Key is key3 and val is val3

Notice that echo adds a newline.

echo "foo" | od -c

0000000    f   o   o  \n
0000004

While printf does not.

printf "foo" | od -c

0000000    f   o   o
0000003

echo $a prints a heredoc on one line, while echo "$a" preserves the newlines in the heredoc. Why is that?

a=$(cat <<EOF
hello
world
EOF
)
echo $a
echo "---"
echo "$a"

hello world
---
hello
world