• bash

bash

Coding style

General

• When in doubt, be consistent.
• This document is no dogma. The specification may be changed if there are good reasons.

Examples

• Google - Shell Style Guide

• Gitlab - Shell scripting standards and style guidelines

• https://editorconfig.org/

Formatter

shfmt

• shfmt is shell formatter, which supports POSIX Shell, Bash, and mksh.

• github.com mvdan/sh

• Your IDE probably has similar options,

  because it will use shfmt in the background.

Install shfmt

   1 aptitude install shfmt

vim

• vim#Formatting

Just use gg=G or :Shfmt

Header

• Add a header to the file containing

  • SHEBANG line #!/path/to/executables args containing the shell, the script has been written for.

    • #!/usr/bin/env bash

      • Searches PATH for executable.

    • #!/bin/bash

  • Author
  • Company
  • Description
  • License
• A header is informational and protects your and others rights.

Shellcheck

• https://www.shellcheck.net/

• Use shellcheck!
  • Adhere to shellcheck. It's gonna make you write better code!

• https://docs.gitlab.com/ee/development/shell_scripting_guide/#linting

Indentation with tabs and alignment with spaces

General

• Use tabs for indentation
  • No, do not expand tabs
  • Adjust tab-width to your preference in your editor

    • Just as a reminder a tab are 8 spaces. This leads to earlier line-continuations.

  • Corresponds to shfmt options

       1        -i, --indent <uint>
       2            Indent: 0 for tabs (default), >0 for number of spaces.
    

• Use spaces for alignment

  • :retab! may be necessary before

  • Corresponds to shfmt options

       1        -kp, --keep-padding
       2            Keep column alignment paddings.
    

Example with bash heredoc

   1 ### FUNCTIONS
   2 PROGRAM="${0#*/}"
   3 
   4 synopsis() {
   5 \t      cat <<-EOF
   6 
   7 \t      \t      Synosis:
   8 
   9 \t      \t      $PROGRAM [options] [--] … 
  10 
  11 \t      \t      Where options are:
  12 \t      \t      ··-h|--help     Display this help page
  13 \t      \t      ··-v|--verbose  Print more verbose output
  14 
  15 \t      EOF
  16 }

Indent switch cases

• Also indent switch cases

  • Corresponds to shfmt options

       1        -ci, --case-indent
       2            Switch cases will be indented.
    

  • Example case indent (with getopt case handling)

       1 while true; do
       2         case "$1" in
       3                 '-h'|'--help')
       4                         usage
       5                         exit 0
       6                         ;;
       7                 '-v'|'--verbose')
       8                         VERBOSE=true
       9                         shift
      10                         continue
      11                         ;;
      12                 '--')
      13                         shift
      14                         break
      15                         ;;
      16                 *)
      17                         echo 'Internal error!' >&2
      18                         echo "Unknown option '$1'"
      19                         synopsis
      20                         exit 1
      21                         ;;
      22         esac
      23 done
    

Binary operators and pipelines

• Indent line-continuations with an additional tab to the current depth

  • Corresponds to shfmt options

       1        -bn, --binary-next-line
       2            Binary ops like && and | may start a line.
    

  • Binary operators and pipelines are continued on a new line (and therefor additionally indented)
  • Senseless example just for the purpose of demonstration

       1 find . | sed 's/a/b/' \
       2         | cat - \
       3         | xargs
       4 
       5 if "$COND1" \
       6         && $COND2 \
       7         || $COND3; then
       8         do_something;
       9 fi
    

Lines

• Maximum line length is 80 characters
  • A tab is one char …
• No trailing spaces in the end of line
• Separate blocks with an empty line

VARIABLES

• Variable names are in SCREAMING_CAPITAL_CASE

function_definitions

• Function names are snake_case

• Keyword function is optional, but has to be used consistently across the file

• The double parenthesis () must directly follow the function_name

  •    1 split_list() {
       2         local LIST="$1"
       3         local DELIM="${2:-,}"
       4         local -a RETURN
       5 
       6         readarray -td "$DELIM" RETURN < <(echo -n "$LIST")
       7 
       8         printf '%s\n' "${RETURN[@]}"
       9 }
    

Use arrays to pass options to a program

• Don't use plain strings

   1 declare -a TOOL_OPTS
   2 if $COND || [ "$VARIABLE_NOT_EMPTY" ]; then
   3         TOOL_OPTS+=( "--option" "option_argument" )
   4 fi
   5 $TOOL --fixed-options  \
   6         "${TOOL_OPTS[@]}" \
   7         "$SINGLE_MORE_ARG"

Command grouping and subshells

Bash Command-Grouping with () and {}

i++

   1 i=0
   2 ((i++))
   3 echo $((i++))

for

   1 for ((i = 0 ; i < 10 ; i++ )); do
   2          echo "$i";
   3 done

while

In a while read loop, outer and inner read-commands are fed by the same STDIN. This makes confirmation requests impossible.

   1 while read LINE; do                                                                                                           :(
   2         echo "LOOP: '$LINE'"
   3         read INNER
   4         echo "INNER: '$INNER'"
   5 done <<< \
   6         "a
   7         1
   8         b
   9         2
  10         c
  11         3"
  12 LOOP: 'a'
  13 INNER: '1'
  14 LOOP: 'b'
  15 INNER: '2'
  16 LOOP: 'c'
  17 INNER: '3'

round with printf

   1 PI=3.141592653589793
   2 printf '%.0f\n' "$PI"
   3 printf '%.1f\n' "$PI"
   4 printf '%.2f\n' "$PI"
   5 printf '%.3f\n' "$PI"
   6 printf '%.4f\n' "$PI"
   7 printf '%.5f\n' "$PI"
   8 3
   9 3.1
  10 3.14
  11 3.142
  12 3.1416
  13 3.14159

list of ranges

   1 #!/bin/bash
   2 
   3 RANGE_LIST_INPUT="$1"
   4 RANGE_INCR="${2:-1}"
   5 
   6 sequ() (
   7         local MIN="$1"
   8         local INCR="$2"
   9         local MAX="$3"
  10         echo "for (i = $MIN; i <= $MAX; i+=$INCR) i" | bc -l
  11 )
  12 
  13 split_list() {
  14         local LIST="$1"
  15         local DELIM="${2:-,}"
  16         local -a RETURN
  17 
  18         readarray -td "$DELIM" RETURN < <(echo -n "$LIST")
  19 
  20         printf '%s\n' "${RETURN[@]}"
  21 }
  22 
  23 expand_range() {
  24         local RANGE="$1"
  25         local DELIM="${2:--}"
  26         local MIN MAX
  27         local -a RETURN
  28 
  29         MIN="$(cut -f1 -d"$DELIM" <<< "$RANGE")"
  30         if grep -q "$DELIM" <<< "$RANGE"; then
  31                 MAX="$(cut -f2 -d"$DELIM" <<< "$RANGE")"
  32         else
  33                 MAX="$MIN"
  34         fi
  35 
  36         readarray -t RETURN < <(sequ "$MIN" "$RANGE_INCR" "$MAX")
  37 
  38         printf '%s\n' "${RETURN[@]}"
  39 }
  40 
  41 expand_range_list() {
  42         local RANGE_LIST="$1"
  43         local RANGE
  44         local -a RETURN
  45         local -a RANGES
  46         local -a RANGE_EXPANDED
  47 
  48         readarray -t RANGES < <(split_list "$RANGE_LIST" ",")
  49 
  50         for RANGE in "${RANGES[@]}"; do
  51                 readarray -t RANGE_EXPANDED < <(expand_range "$RANGE")
  52                 RETURN+=( "${RANGE_EXPANDED[@]}" )
  53                 unset RANGE_EXPANDED
  54         done
  55 
  56         readarray -t RETURN \
  57                 < <(printf "%s\n" "${RETURN[@]}" |sort -nu)
  58 
  59         printf '%s\n' "${RETURN[@]}"
  60 }
  61 
  62 readarray -t RANGE_LIST_EXPANDED \
  63         < <(expand_range_list "$RANGE_LIST_INPUT" ",")
  64 
  65 echo "RANGE_LIST_EXPANDED: ${RANGE_LIST_EXPANDED[*]}"

Trapping errors

   1 #!/bin/bash
   2 PROGRAM="${0#*/}"
   3 
   4 NORMAL=$(tput sgr0)
   5 YELLOW=$(tput setaf 3)
   6 
   7 error() {
   8         echo -e "${YELLOW}ERROR: '$PROGRAM' failed running command" \
   9         "'$BASH_COMMAND' at line $BASH_LINENO${NORMAL}" >&2
  10 }
  11 
  12 trap error ERR