Table of Contents

• Arrays
• Iterate array elements
• Join array elements
• case
• for
• if
• function
• Here document
• Here strings
• Shebang(#!/usr/bin)
• Escaping quotes
  • Escaping double quotes
  • Escaping single quotes within a single quoted string
• Usage of dash (-) in place of a filename, like cat -

Arrays reference

Declare an array variable

name[subscript]=value
declare -a nameo
declare -a name[subscript]  # 'subscript' is ignored
name=(value1 value2 … )

Usage

$ array=(one two three)

$ echo "${array[@]}"
one two three

# NOTE: indexing starts at 0 in bash,
# but some other shells like zsh starts at 1,
# to be consistent with arugments indexing
$ echo "${array[0]}"
one

$ echo "${array[2]}"
three

$ array[3]=four

$ echo "${array[@]}"
one two three four

$ echo "${#array[@]}" # length
4

$ echo "${!array[@]}" # indexes
0 1 2 3

unset array[1] # delete an element

echo "${array[@]}"
one three four

• The difference between ${name[*]} and ${name[@]} is corresponds to $* vs $@.

Iterate array elements howto

arr=(one two three)
if [[ "${#arr[@]}" -gt 0 ]]; then
  for n in "${arr[@]}"; do
    echo "$n"
  done
fi

• Bash empty array expansion with set -u may cause an error.
• There are many workarounds, but I think that it is the simplest to check empty before expansion

Join array elements howto

readonly X=('foo' 'bar' 'baz')
readonly Y="$(IFS=','; echo "${X[*]}")"
echo "${Y}"

foo,bar,baz

case reference

case "$1" in
  start)
    start
    ;;
  stop)
    stop
    ;;
  *)
    echo $"Usage: $0 {start|stop}"
    exit 1
    ;;
esac

for reference

• Put ; do and ; then on the same line as the while, for or if.
• Use a for loop if you are confident that the input will not contain spaces or special characters (usually, this means not user input).

for i in 1 2 3 4 5; do
  echo "$i"
done

for file in ~/repos/* ; do
  echo "$file"
done

# continue and break
for i in 1 2 3; do
  if [[ "$i" == 1 ]]; then
    continue
  fi
  if [[ "$i" == 3 ]]; then
    break
  fi
  echo "$i"
done

for (( i=1; i<=5; i++)); do
  echo "$i"
done

# requires bash v3.0+
for i in {1..5}; do
  echo "$i"
done

# requires bash v4.0+
for i in {0..10..2}; do
  echo "$i"
done

if reference

if commands; then
  commands
[elif commands; then
  commands ...]
[else
  commands]
fi

• [ and test are available in POSIX shells
• [[ works only in Bash, Zsh and the Korn shell, and is more powerful
• [[ is preferred over [, test (from Google Shell Style Guide)

if [[ -z "$foo" ]] && [[ -z "$bar" ]];
if [[ -z "$foo" && -z "$bar" ]]; # equivalent to above

function reference

print_something() {
    echo Hello $1
}
print_something Mars
print_something Jupiter

• The keyword function is optional, but must be used consistently throughout a project.
• If you're writing a package, separate package names with ::.

# Single function
my_func() {
    ...
}

# Part of a package
mypackage::my_func() {
    ...
}

#######################################
# Cleanup files from the backup dir
# Globals:
#   BACKUP_DIR
#   ORACLE_SID
# Arguments:
#   None
# Returns:
#   None
#######################################
cleanup() {
    ...
}

# If N is omitted, the return status is that of the
# last command executed within the function or script.
return [n]

Note that if you have set -e set at the top of your script and your return 1 or any other number besides 0, your entire script will exit. exit abandons the current shell.

• By default a variable is global.
• When we create a local variable within a function, it is only visible within that function.

var_change() {
    local var1='local 1'
    echo Inside function: var1 is $var1 : var2 is $var2
    var1='changed again'
    var2='2 changed again'
}
var1='global 1'
var2='global 2'
# only var2 changed

foo() {
  return 0 # return returns a value from a function.
}
bar() {
  exit 1 # exit abandons the current shell.
}

foo
echo 'hi'
bar
echo 'bye' # NOT printed

Here document reference

tr a-z A-Z << END_TEXT
one two three
four five six
END_TEXT

ONE TWO THREE
FOUR FIVE SIX

# Ignore leading tabs
tr a-z A-Z <<- END_TEXT
         one two three
         four five six
         END_TEXT

(Same as above)

# Disable string interpolation
cat << 'EOF'
\$ Working dir "$PWD" `pwd`
EOF

\$ Working dir "$PWD" `pwd`

• For redirections and pipelining:
• https://unix.stackexchange.com/questions/88490/how-do-you-use-output-redirection-in-combination-with-here-documents-and-cat

cat <<EOF | sh
touch somefile
echo foo > somefile
EOF

(
cat <<EOF
touch somefile
echo foo > somefile
EOF
) | sh

{
cat <<EOF
touch somefile
echo foo > somefile
EOF
} | sh

cat >out <<EOF
test
EOF

Here strings reference

• The key difference from here documents is that, in here documents, the delimiters are on separate lines;

$ tr a-z A-Z <<< one
ONE

$ FOO='one two three'
$ tr a-z A-Z <<< $FOO
ONE TWO THREE

• Here strings are particularly useful when the last command needs to run in the current process

$ echo 'one two three' | read a b c
$ echo $a $b $c
# yields nothing, because 'read' ran on subshell

$ read a b c <<< 'one two three'
$ echo $a $b $c
one two three

Shebang(#!/usr/bin) reference

Use #!/usr/bin/env bash for portability

*Different nixes put bash in different places, and using /usr/bin/env is a workaround to run the first bash found on the PATH.

Escaping quotes discussion

Escaping double quotes

• Escape it with backslash

"\""

• Double quoted shell expansion is valid within double quotes

$ echo 'echo $#' > arg-count
$ chmod +x arg-count
$ ./arg-count
0
$ echo "$(./arg-count $(echo foo bar))"
2
$ echo "$(./arg-count "$(echo foo bar)")"
1

Escaping single quotes within a single quoted string

alias rxvt='urxvt -fg '"'"'#111111'"'"' -bg '"'"'#111111'"'"
#                     ^^^^^       ^^^^^     ^^^^^       ^^^^
#                     12345       12345     12345       1234

1. ' End first quotation which uses single quotes.
2. " Start second quotation, using double-quotes.
3. ' Quoted character.
4. " End second quotation, using double-quotes.
5. ' Start third quotation, using single quotes.

Or, use ANSI C string:($''). We can escape a single quote with \'. But in this way, we loses bash's literal meaning. Other meta character like \n, \t will also get a special meaning.

echo $'Can\'t do that'

Usage of dash (-) in place of a filename, like cat - discussion

Using - as a filename to mean stdin / stdout is a convention that a lot of programs use. It is not a special property of the filename. If you want to use a file named as -, you should pass the argument like ./-.