Download: [PDF|HTML|ConTEXt|GitHub]

Bourne-Again SHell and Linux CLI

Set interpreter: #!/bin/bash    Remarks: # this is comment

Interactive control

Command line history

• history, fc -l – display numbered history of commands
• !n – run command number n
• !p – run last command beginning by p
• !! – repeat last entered command
• !!:n – expand n-th parameter of last command
• !$ – expand the last parameter of last command
• fc – run defined $EDITOR wit last command
• fc -e vim z k – open vim editor with commands from z to k
• ^old^new – substitute old with new in last command
• !n:s/old/new/ – substitute old in command number n
• program `!!` – use output of last command as input

Help and manuals

• type -a command – information about command
• help command – brief help on bash command
• man command, info command – detailed help
• man -k key, apropos key, whatis key – find command

Debugging

Run a script as: bash option script and its parameters

• bash -x – print commands before execution
• bash -u – stop with error if undefined variable is used
• bash -v – print script lines before execution
• bash -n – do not execute commands

Variables, arrays and hashes

• NAME=10 – set value to variable $NAME, ${NAME}
• export NAME=10, typedef -x NAME – set as environment variable
• D=$(date); D=`date` – variable contains output of command date
• env, printenv – list all environment variables
• set – list env. variables, can set bash options and flags shopt
• unset name – destroy variable of function
• typeset, declare – set type of variable
• readonly variable – set as read only
• local variable – set local variable inside function
• ${ !var}, eval \$$var – indirect reference
• ${parameter-word} – if parameter has value, then it is used, else word is used
• ${parameter=word} – if parameter has no value assing word. Doesn't work with $1, $2, ets.
• ${parameter:-word} – works with $1, $2, etc.
• ${parameter?word} – if parameter has value, use it; if no display word and exit script.
• ${parameter+word} – if parameter has value, use word, else use empty string
• array=(a b c); echo ${array[1]} – print „b“
• array+=(d e f) – append new item/array at the end
• ${array[*]}, ${array[@]} – all items of array
• ${#array[*]}, ${#array[@]} – number of array items
• declare -A hash – create associative array (from version)
• hash=([key1]=value ["other key2"]="other value") – store items
• ${hash["other key2"]}, ${hash[other key2]} – access
• ${hash[@]}, ${hash[*]} – all items
• ${!hash[@]}, ${!hash[*]} – all keys

Strings

• STRING="Hello" – indexing: H₀ e₁ l₂ l₃ o₄
• STRING+=" world!" – concatenate strings
• ${#string}, expr length $string – string length
• ${string:position} – extract substring from position
• ${string:position:length} – extract substr. of length from position
• ${string/substring/substitution} – substitute first occurrence
• ${string//substring/substitution} – substitute all
• ${string/%substring/substitution} – substitute last occurrence
• ${string#substring} – erase shortest substring
• ${string##substring} – erase longest substring

Embedded variables

• ~, $HOME – home directory of current user
• $PS1, $PS2 – primary, secundary user prompt
• $PWD, ~+ / $OLDPWD, ~- – actual/previous directory
• $RANDOM – random number generator, 0 – 32,767
• $? – return value of last command
• $$ – process id. of current process
• $! – process id. of last background command
• $PPID – process id. of parent process
• $- – display of bash flags
• $LINENO – current line number in executed script
• $PATH – list of paths to executable commands
• $IFS – Internal field separator. List of chars, that delimiter words from input, usually space, tabulator $'\t' and new line $'\n'.

Script command line parameters

• $0, ${0} – name of script/executable
• $1 to $9, ${1} to ${255} – positional command line parameters
• PAR=${1:?"Missing parameter"} – error when ${1} is not set
• PAR=${1:-default} – when ${1} is not set, use default value
• $# – number of command line parameters (argc)
• ${!#} – the last command line parameter
• $* – expand all parameters, "$*" = "$1 $2 $3…"
• $@ – expand all parameters, "$@" = "$1" "$2" "$3"…
• $_ – last parameter of previous command
• shift – rename arguments, $2 to $1, $3 to $2, etc.; lower counter $#
• xargs command – read stdin and put it as parameters of command

Read options from command line

 while getopts "a:b" opt; do case $opt in
      a) echo a = $OPTARG ;;
      b) echo b ;;
      \?) echo "Unknown parameter!" ;;
esac; done
shift $(($OPTIND - 1)); echo "Last: $1" 

Control expressions

• (commands), $(commands), `commands`, {commands;} – run in subshell
• $(program), `program` – output of program replaces command
• test, [ ] – condition evaluation:
  • numeric comparison: a -eq b … a=b, a -ge b … a≥b, a -gt b … a>b, a -le b … a≤b, a -lt b … a<b
  • file system: -d file is directory, -f file exists and is not dir., -r file exists and is readable, -w file exists and is writable, -s file is non-zero size, -a file exists
  • logical: -a and, -o or, ! negation
• [[ ]] – comparison of strings, equal =, non-equal !=, -z string is zero sized, -n string is non-zero sized, <, > lexical comparison
• [ condition ] && [ condition ]
• true – returns 0 value
• false – returns 1 value
• break – terminates executed cycle
• continue – starts new iteration of cycle
• eval parameters – executes parameters as command
• exit value – terminates script with return value
• . script, source script – reads and interprets another script
• : argument – just expand argument or do redirect
• alias name='commands' – expand name to commands
• unalias name – cancel alias
• if [ condition ]; then commands;
elif [ condition ]; then commands;
else commands; fi
• for variable in arguments; do commands; done
  • {a..z – expands to a b c … z
  • {i..n..s} – sequence from i to n with step s
  • \"{a,b,c}\" – expands to "a" "b" "c"
  • {1,2}{a,b} – expands to 1a 1b 2a 2b
  • seq start step end – number sequence
• for((i=1; i<10; i++)); do commands; done
• while returns true; do commands; done
• until [ test returns true ]; do commands; done
• case $prom in value_1) commands ;;
  value_2) commands ;; *) implicit. commands ;;
  esac
• Function definition: function name () { commands; }
• return value – return value of the function
• declare -f function – print function declaration

Redirections and pipes

• 0 stdin/input, 1 stdout/output, 2 stderr/error output
• > file – redirection, create new file or truncate it to zero size
• >> file – append new data at the end of file
• command1<<<command2 – ouput from 2^nd to stdin of 1^st
• command < file – read stdin from file
• tee file – read stdin, writes to file and to stdout
• command 2> file – redirect error messages to file
• exec 1> >(tee -a log.txt) – redirect stdout also to file
• 2>&1 – merge stderr and stdout
• exec 3<>/dev/tcp/addr/port – create descriptor for network read/write
• exec 3>&- – close descriptor
• command > /dev/null 2>&1 – suppress all output
• n> n>> n>&m – operation redirect for descriptors n, m
• mkfifo name – make a named pipe, it can be written and read as file
• command₁ | command₂ – pipe, connection between processes
• command 2>&1 | \periods[3] – can be shortened to command |& \periods[3]
• ${PIPESTATUS[0]}, ${PIPESTATUS[1]} – retvals before and after pipe
• read parameters – read input line and separate it into parameters

Input for interactive programs (here documents)

./program <<  EOF      ./program <<-'EOF' # suppress tabulators
Input1                      Input1
Input2                      Input2
EOF                         EOF

Process file line by line

Evaluating mathematical expressions

• let expression, expr expression, $((expression)), $((expression1, expression2)), $[expression]
• Numeric systems: base#number; hexa 0xABC, octal 0253, binary 2#10101011
• Operators: i++, ++i, i--, --i, +, -; ** power, *, /, % remainder; logical: ! neg., && and, || or; binary: ~, &, |; <<, >> shifts; assignment: = *= /= %= += -= <>= &= ^= |= >>= <<=; relations: < <= > >=
• factor n – factorize n into primes
• Floating point operations: echo "scale=10; 22/7" | bc

Screen output

• echo "text" – print text, echo * print all files in current dir
• echo -e "text" – interpret escape-sequences (\t tab., \a beep, \f new page, \n new line), -n, \c suppressing \n, \xHH hex-byte, \nnn oct. byte, \u03B1 „α“ (U+03B1) in UTF-8
• stty – change and print terminal line settings
• tty – print name of terminal connected to stdout
• printf format values – format output
• printf -v variable form. val. – form. output into variable
  • % [flags][width][.precision][length]specifier
  • Specifier: %u, %d, %i decimal; %E, %f float, %x, %X hex; %o octal, %s string, %% char %
  • Width: n prints at least n chars, spaces from right, 0n print at least n chars, zeros from left, * width specified in preceding parameter
  • Precision: min. number of digits, digits after decimal point, number of printed chars, * number of chars given by preceding parameter
  • Flags: - left-justify, + prints number with sign +/-
• printf "%d" \'A – display ASCII code of char “A” (65)
• printf \\$(printf '%03o' 65) – print char given by ASCII code
• tput action – terminal dependent action
• reset, tput sgr0, tset – reset terminal, cancel attributes
• clear, tput clear – clear screen

Process management

• command & – run command in background
• prog1 && prog2 – run prog₂, if prog₁ ends with success
• prog1 || prog2 – rub prog₂, if prog₁ ends with error
• Ctrl+z – stop process (SIGSTOP)
• bg / fg – run last stopped process in background/foreground
• jobs – list processes running in background
• exec command – shell is replaced by command
• wait – wait for end of background tasks
• top – watch CPU, memory, system utilization
• ps -xau – list processes and users, ps -xaf, pstree tree listing
• pgrep process, pidof process – get PID by name of process
• nice -n p command – priority p od -20 (max.) to 19 (min.)
• renice -n p -p pid – change priority of running process
• kill -s k n – send signal k to proces id. n, 0, 1 SIGHUP; 2 SIGINT Ctrl+c; 3 SIGQUIT; 9 SIGKILL; 15 SIGTERM; 24 SIGSTOP
• trap 'command' signals – run command when signal received
• killall name – send signals to process by name
• nohup command & – command will continue after logout
• time command – print time of process execution
• times – print user and system time utilization in current shell
• watch -n s command – every s seconds run command
• timeout N command – quit command after N seconds

Time and process planning

• date – print date, date --date=@unix_time
• date +"%Y%m%d %H:%M:%S %Z" – format to 20130610 13:39:02 CEST
• printf '%(%Y-%m-%d
• cal – display calendar
• crontab -e – edit crontab, -l list, format min hour date month day command, * * * * * command run every minute, 1 * * * * command 1^st min of every hour
• at, batch, atq, atrm – queue, examine or delete jobs for later execution