Bash scripting cheatsheet

Introduction Example Variables

This is a quick reference to getting started with#!/usr/bin/env

Bash scripting. bash
NAME="John"

echo $NAME

NAME="John"
echo "$NAME"

Learn bash in y minutes echo "Hello $NAME!"

echo "${NAME}!"

(learnxinyminutes.com)

Bash Guide String quotes Shell execution

(mywiki.wooledge.org)
NAME="John"
echo "I'm in $(pwd)"

echo "Hi $NAME" #=> Hi John

echo "I'm in `pwd`"

Conditional execution echo 'Hi $NAME' #=> Hi $NAME

# Same

git commit && git push

Functions See Command substitution
git commit || echo "Commit failed"

get_name() {
Conditionals
Strict mode echo "John"

if [[ -z "$string" ]]; then

set -euo pipefail

echo "String is empty"

echo "You are $(get_name)"

IFS=$'\n\t'
elif [[ -n "$string" ]]; then

echo "String is not empty"

See: Functions fi

See: Unofficial bash strict mode

Brace expansion See: Conditionals

 echo {A,B}.js

{A,B}

{A,B}.js

{1..5}

See: Brace expansion

# Parameter expansions
Basics Substitution Comments

name="John"
${FOO%suffix} # Single line comment

echo ${name}

echo ${name/J/j} #=> ${FOO#prefix}

"john" (substitution)

: '

echo ${name:0:2} #=>

"Jo" (slicing)

${FOO%%suffix} This is a

echo ${name::2} #=>

"Jo" (slicing)

multi line

echo ${name::-1} #=>

"Joh" (slicing)

${FOO##prefix} comment

echo ${name:(-1)} #=> "n" (slicing from right)

'

echo ${name:(-2):1} #=> "h" (slicing from right)

echo ${food:-Cake} #=> $food or "Cake"

${FOO/from/to}
Substrings
${FOO//from/to}
length=2

echo ${name:0:length} #=> "Jo"

${FOO/%from/to} ${FOO:0:3}

${FOO/#from/to} ${FOO:(-3):3}
See: Parameter expansion
 STR="/path/to/foo.cpp"
Length Manipulation
echo ${STR%.cpp} # /path/to/foo
echo ${STR%.cpp}.o # /path/to/foo.o
${#FOO}
STR="HELLO WORLD!"

echo ${STR%/*} # /path/to

Default values echo ${STR,} #=> "hELLO WORLD!"

echo ${STR,,} #=> "hello world!"
echo ${STR##*.} # cpp (extension)

echo ${STR##*/} # foo.cpp (basepath)

${FOO:-val}
STR="hello world!"

${FOO:=val} echo ${STR^} #=> "Hello world!"

echo ${STR#*/} # path/to/foo.cpp

echo ${STR^^} #=> "HELLO WORLD!"

echo ${STR##*/} # foo.cpp

${FOO:+val}
echo ${STR/foo/bar} # /path/to/bar.cpp

${FOO:?message} Show

STR="Hello world"
Omitting the : removes the (non)nullity checks, e.g. ${FOO-val} expands to val if unset othe
echo ${STR:6:5} # "world"

echo ${STR: -5:5} # "world"

SRC="/path/to/foo.cpp"

BASE=${SRC##*/} #=> "foo.cpp" (basepath)

DIR=${SRC%$BASE} #=> "/path/to/" (dirpath)

# Loops
Basic for loop C-like for loop Ranges

for i in /etc/rc.*; do
for ((i = 0 ; i < 100 ; i++)); do
for i in {1..5}; do

echo $i
echo $i
echo "Welcome $i"

 done
done
done

Reading lines Forever With step size

for i in {5..50..5}; do

cat file.txt | while read line; do

while true; do
echo "Welcome $i"

echo $line
···
done

done
done

# Functions
Defining functions Returning values Raising errors

myfunc() {
myfunc() {
myfunc() {

echo "hello $1"

local myresult='some value'
return 1

}
echo $myresult
}

# Same as above (alternate syntax)

if myfunc; then

function myfunc() {
result="$(myfunc)"
echo "success"

echo "hello $1"

else

}
echo "failure"

Arguments fi

myfunc "John"

$#

$*

$@

$1
 $_

Note: $@ and $* must be quoted in order to perform as described.

Otherwise, they do exactly
strings).

See Special parameters.

# Conditionals
Conditions File conditions Example

[[ -e FILE ]]
Note that [[ is actually a command/program that returns either 0 (true) or 1 (false). Any program that obeys the same logic (like all base
# String

utils, such as grep(1) or ping(1)) can be used as condition, see examples. if [[ -z "$string" ]]; then

[[ -r FILE ]] echo "String is empty"

elif [[ -n "$string" ]]; then

[[ -z STRING ]] [[ -h FILE ]] Empty string

echo "String is not empty"

else

[[ -n STRING ]] [[ -d FILE ]] Not empty string

echo "This never happens"

fi

[[ STRING == STRING ]] [[ -w FILE ]] Equal

[[ STRING != STRING ]] [[ -s FILE ]] # Combinations

Not Equal
if [[ X && Y ]]; then

[[ NUM -eq NUM ]] [[ -f FILE ]] ...

Equal
fi

[[ NUM -ne NUM ]] [[ -x FILE ]] Not equal

 [[ NUM -lt NUM ]] [[ FILE1 -nt FILE2 ]] # Equal
Less than
if [[ "$A" == "$B" ]]

[[ NUM -le NUM ]] [[ FILE1 -ot FILE2 ]] Less than or equal

# Regex

[[ NUM -gt NUM ]] [[ FILE1 -ef FILE2 ]] Greater than

if [[ "A" =~ . ]]

[[ NUM -ge NUM ]] Greater than or equal

if (( $a < $b )); then

[[ STRING =~ STRING ]] echo "$a is smaller Regexp

than $b"

fi

(( NUM < NUM )) Numeric conditions

More conditions if [[ -e "file.txt" ]]; then

echo "file exists"

[[ -o noclobber ]] If OPTIONNAME is enabled

fi

[[ ! EXPR ]] Not

[[ X && Y ]] And

[[ X || Y ]] Or

# Arrays
 Defining arrays Working with arrays

Fruits=('Apple' 'Banana' 'Orange')

echo ${Fruits[0]} # Element #0

echo ${Fruits[-1]} # Last element

echo ${Fruits[@]} # All elements, space-sepa

Fruits[0]="Apple"

echo ${#Fruits[@]} # Number of elements

Fruits[1]="Banana"

echo ${#Fruits} # String length of the 1st

Fruits[2]="Orange"

echo ${#Fruits[3]} # String length of the Nth

Operations echo ${Fruits[@]:3:2} # Range (from position 3,
echo ${!Fruits[@]} # Keys of all elements, sp

Fruits=("${Fruits[@]}" "Watermelon") # Push

Iteration
Fruits+=('Watermelon') # Also Push

Fruits=( ${Fruits[@]/Ap*/} ) # Remove by regex match

unset Fruits[2] # Remove one item

for i in "${arrayName[@]}"; do

Fruits=("${Fruits[@]}") # Duplicate
echo $i

Fruits=("${Fruits[@]}" "${Veggies[@]}") # Concatenate

done

lines=(`cat "logfile"`) # Read from file

# Dictionaries
Defining Working with dictionaries Iteration

Iterate over values

declare -A sounds
echo ${sounds[dog]} # Dog's sound

echo ${sounds[@]} # All values

for val in "${sounds[@]}"; do

echo ${!sounds[@]} # All keys

sounds[dog]="bark"
echo $val

echo ${#sounds[@]} # Number of elements

sounds[cow]="moo"
done

unset sounds[dog] # Delete dog

sounds[bird]="tweet"

sounds[wolf]="howl"
Iterate over keys
 for key in "${!sounds[@]}"; do

Declares sound as a Dictionary object (aka associative array). echo $key

done

# Options
Options Glob options

set -o noclobber # Avoid overlay files (echo "hi" > foo)

shopt -s nullglob # Non-matching globs are removed
set -o errexit # Used to exit upon error, avoiding cascading shopt
errors

-s failglob # Non-matching globs throw errors

set -o pipefail # Unveils hidden failures
shopt -s nocaseglob # Case insensitive globs

set -o nounset # Exposes unset variables

shopt -s dotglob # Wildcards match dotfiles ("*.sh
shopt -s globstar # Allow ** for recursive matches

Set GLOBIGNORE as a colon-separated list of patterns to be remove

# History
Commands Expansions

history !$ Show history

shopt -s histverify !* Don’t execute expanded result immediately

 Operations !-n

!n
!! Execute last command again
!<command>
!!:s/<FROM>/<TO>/ Replace first occurrence of <FROM> to <TO> in most recent command
Slices
!!:gs/<FROM>/<TO>/ Replace all occurrences of <FROM> to <TO> in most recent command

!!:n Expand only

!$:t Expand only basename from last parameter of most recent command

!^
!$:h Expand only directory from last parameter of most recent command

!$
!! and !$ can be replaced with any valid expansion.
!!:n-m

!!:n-$

!! can be replaced with any valid expansion i.e. !cat, !-2, !42, etc

# Miscellaneous
Numeric calculations Subshells

$((a + 200)) # Add 200 to $a

(cd somedir; echo "I'm now in $PWD")

pwd # still in first directory

$(($RANDOM%200)) # Random number 0..199

Redirection
Inspecting commands python hello.py > output.txt # stdout to (file)

python hello.py >> output.txt # stdout to (file), app

command -V cd
python hello.py 2> error.log # stderr to (file)

#=> "cd is a function/alias/whatever"

python hello.py 2>&1 # stderr to stdout

python hello.py 2>/dev/null # stderr to (null)

python hello.py &>/dev/null # stdout and stderr to

Trap errors

python hello.py < foo.txt # feed foo.txt to stdin

trap 'echo Error at about $LINENO' ERR
diff <(ls -r) <(ls) # Compare two stdout wi

or
Case/switch
traperr() {

echo "ERROR: ${BASH_SOURCE[1]} at about ${BASH_LINENO[0]}"

case "$1" in

}
start | up)

vagrant up

set -o errtrace
;;

trap traperr ERR

*)

Source relative echo "Usage: $0 {start|stop|ssh}"

;;

esac

source "${0%/*}/../share/foo.sh"

printf
Directory of script
printf "Hello %s, I'm %s" Sven Olga

DIR="${0%/*}"
#=> "Hello Sven, I'm Olga

printf "1 + 1 = %d" 2

Getting options #=> "1 + 1 = 2"

 printf "This is how you print a float: %f" 2

while [[ "$1" =~ ^- && ! "$1" == "--" ]]; do case $1 in

#=> "This is how you print a float: 2.000000"

-V | --version )

echo $version Heredoc

exit

;;

-s | --string ) cat <<END

shift; string=$1
hello world

;;
END

-f | --flag )

flag=1

;;

Reading input
esac; shift; done

if [[ "$1" == '--' ]]; then shift; fi

echo -n "Proceed? [y/n]: "

Special variables read ans

echo $ans

$? Exit status of last task

read -n 1 ans # Just one character

$! PID of last background task

Go to previous directory
$$ PID of shell

$0 pwd # /home/user/foo
Filename of the shell script
cd bar/

$_ Last argument of the previous command

pwd # /home/user/foo/bar

cd -

See Special parameters. pwd # /home/user/foo

Grep check Check for command’s result

if grep -q 'foo' ~/.bash_history; then

if ping -c 1 google.com; then

echo "You appear to have typed 'foo' in the past"

echo "It appears you have a working internet connect
fi
fi