I like Bash scripting - Scripting's my favorite

• cut is faster than awk
• work on a RAMdisk whenever possible
• remember cut can extract all specified fields from a file in a single operation :
  cut -d ';' -f n,m someFile

1. read the line from the CSV file
2. split the line into fields and store values in the corresponding variables

while IFS=, read -r field1 field2; do
	# do something with "$field1" and "$field2"
done < input.csv

There is (almost) no difference when working on GNU/Linux :

• is the POSIX syntax
• is more portable
• has less chances of failing when moving scripts to other shells/proprietary Unices

Possible function declaration syntaxes

List existing functions

Find where a function is defined

View the code of a function

• inside a function will be shared with the calling environment
• local will not be shared

Initialize an array :

declare -a myArray

myArray[0]='john'
myArray[1]='paul'
myArray[2]='george'
myArray[3]='ringo'

declare -a myArray=(john paul george ringo)

Display array values :

Browse array in a for loop :

for item in "${myArray[@]}"; do
	echo "$item"
done

john
paul
george
ringo

Append a value to the array :

myArray+=('the_5th_guy')
echo "${myArray[@]}"

john paul george ringo the_5th_guy

Create an associative array :

declare -A myArray
myArray[foo]='this is "foo"'
myArray[bar]='this is "bar"'
myArray[baz]='this is "baz"'

Browse by keys :

for key in "${!myArray[@]}"; do
	echo -e "key :\t$key"
	echo -e "value :\t${myArray[$key]}\n"
done

key :	bar
value :	this is "bar"

key :	baz
value :	this is "baz"

key :	foo
value :	this is "foo"

Browse by values :

for value in "${myArray[@]}"; do
	echo -e "value :\t$value\n"
done

value : this is "bar"

value : this is "baz"

value : this is "foo"

Let's check it :

1
2
3
4

How can I get the number of items in an array ?

3	number of fruits
5	length of string apple

Arrays can be sparse :

0 Lorem
1 ipsum
2 dolor
3 sit
4 amet
Length : 5

0 Lorem
1 ipsum
2 dolor
4 amet	no more myArray[3]
Length : 4

somePath='/path/to/directory/'

foo="${somePath}foo"
bar="${somePath}bar"

somePath='/path/to/directory'

foo="$somePath/foo"
bar="$somePath/bar"

The method 1 is 70 characters long, and the method 2 : 67. But after removing characters that are typed in both methods (variable names, =, $, , quotes, ...), we get (with { and } being 2 keystrokes each on a french keyboard) :

• method 1 : /{}{}, 9 keystrokes
• method 2 : //, 2 keystrokes

Let's settle on method 2 ! (until we find further arguments )

data='key1;value1 key2;value2'; for tuple in $data; do key=$(echo $tuple | cut -d ';' -f 1); value=$(echo $tuple | cut -d ';' -f 2); echo "tuple: '$tuple', key : '$key', value : '$value'"; done

Real-world example : testing a list of user accounts on a FTP server :

data="\without this, the 1st round has empty values
key1 value1
key2 value2
key3 value3"if the closing " is on a new line, the last round has empty values

while read key value; do
	echo "key: '$key', value: '$value'"
done <<< "$data"

key: 'key1', value: 'value1'
key: 'key2', value: 'value2'
key: 'key3', value: 'value3'

What if we terminate a line of data with \ ?

data="\
key1 value1
key2 value2\added \
key3 value3"

while read key value; do
	echo "key: '$key', value: '$value'"
done <<< "$data"

key: 'key1', value: 'value1'
key: 'key2', value: 'value2key3 value3'

theWorldIsFlat=true
# ...do something interesting...
if $theWorldIsFlat; then
	echo 'Be careful not to fall off!'
fi

Bash doesn't know booleans. This hack works because $myVariable is replaced by true at run time, which returns a Unix success (same would go on with false, returning a Unix failure).
If you're not convinced $myVariable is an alias of the true command, try these :

myVariable=true; if $myVariable; then echo OK; fi

OK

myVariable=false; if $myVariable; then echo OK; fi

(nothing)

myVariable=ooops; if $myVariable; then echo OK; fi

bash: ooops : command not found

true && true && echo A || echo B

A

true && false && echo A || echo B

B

#!/usr/bin/env bash

UNIX_SUCCESS=0
UNIX_FAILURE=1

returnBoolean() {
	wantedReturnValue="$1"

	case "$wantedReturnValue" in
		"$UNIX_SUCCESS")
			return $(true)
			;;
		"$UNIX_FAILURE")
			return $(false)
			;;
	esac
	}

for result in $UNIX_SUCCESS $UNIX_FAILURE; do
	returnBoolean $result
	returnCode=$?
	[ "$returnCode" -eq "$result" ] && echo OK || echo KO
done

unset a; [ "$a" ] && echo OK || echo KO; a=1; [ "$a" ] && echo OK || echo KO; a=0; [ "$a" ] && echo OK || echo KO

KO
OK
OK

#!/usr/bin/env bash

myVar='Hello'
dynamicVar="myVar"

echo "The value of '$dynamicVar' is '${!dynamicVar}'."

The value of 'myVar' is 'Hello'.

for variableToCheck in variableA variableB variableC; do
	echo "The variable '$variableToCheck' has value : '${!variableToCheck}'."
	if [ -z "${!variableToCheck}" ]; then
		<deal with it !>
	fi
done

When it comes to check the input of a script in search of missing parameters, it is better to simply count parameters rather than testing all variables. Indeed, when expecting command parameterA parameterB and getting command foo, you can't tell which of parameter A or B is missing (unless you're using named parameters, of course).

#!/usr/bin/env bash

listOfLists='colors fruits cars'
colors='red green blue'
fruits='apple banana grape'
cars='ferrari porsche lada'

output=''
# generate all permutations of the list of lists
for aList in $listOfLists; do
	for anotherList in $listOfLists; do
		[ "$anotherList" = "$aList" ] && continue
		for oneMoreList in $listOfLists; do
			[ "$oneMoreList" = "$anotherList" ] || [ "$oneMoreList" = "$aList" ] && continue

			output="$output\nLISTS: 1.$aList 2.$anotherList 3.$oneMoreList"

			# we now have all the list of lists, let's list the contents of all those lists
			for item1 in ${!aList}; do
				for item2 in ${!anotherList}; do
					for item3 in ${!oneMoreList}; do
						output="$output\n$item1 $item2 $item3"
					done
				done
			done
			# contents over

		done
	done
done
echo -e "$output" | column -s ' ' -t

It is a safe practice to always quote tested strings.

empty vs unset strings :

nonEmptyString='hello'; [ -n "$nonEmptyString" ] && echo A || echo B; [ -z "$nonEmptyString" ] && echo C || echo D
A
D

emptyString=''; [ -n "$emptyString" ] && echo A || echo B; [ -z "$emptyString" ] && echo C || echo D
B
C

unset unsetString; [ -n "$unsetString" ] && echo A || echo B; [ -z "$unsetString" ] && echo C || echo D
B
C

is equal to

[ "$a" = "$b" ]
[ "$a" == "$b" ]
[[ "$a" == "$b" ]]

is not equal to

[ "$a" != "$b" ]
[[ "$a" != "$b" ]]

is equal to

[ "$a" -eq "$b" ]
[[ "$a" = "$b" ]]
[[ "$a" == "$b" ]]

is not equal to

[ "$a" -ne "$b" ]
[[ "$a" != "$b" ]]

AND

if [ $condition1 ] && [ $condition2 ]

if [[ $condition1 && $condition2 ]]

if [ $condition1 -a $condition2 ]

OR

if [ $condition1 ] || [ $condition2 ]

if [[ $condition1 || $condition2 ]]

if [ $condition1 -o $condition2 ]

if(true) {
	
	}

• if [ "$myVar" -eq "$UNIX_SUCCESS" ]; then
  	
  	fi

• if [[ "$myVar" == "$UNIX_SUCCESS" ]]; then
  	
  	fi

Unary if and booleans :

0
1
0
0
0
0

Test a match (source) :

Test a no-match (source) :

Retrieve matched substrings (source) :

[ (test command) and [[ ("new test" command) are used to evaluate expressions :

• [ and test are available in POSIX shells.
• [[ works only in Bash, Zsh and the Korn shell, and is more powerful.

[ hello ] && echo ok || echo ko
ok								testing any non-empty string is a success (details)

[ '' ] && echo ok || echo ko
ko								testing an empty string is a failure (details)

[ -x /bin/true ] && echo ok
ok

[ -x /bin/true -a -e /bin/plop ] && echo ok || echo ko
ko

[ $(which cp) ] && echo ok || echo ko
ok

[ $(which plop) ] && echo ok || echo ko
ko								the $() construct returns an empty string, which causes the test to fail

[ "$(which plop)" ] && echo ok || echo ko
ko								no change when quoting a regular empty string 

[ $(which cp) -a $(which ls) ] && echo ok || echo ko
ok

[ $(which cp) -a $(which plop) ] && echo ok || echo ko
bash: [: /bin/cp: unary operator expected			this is because $(which cp) evaluates to /bin/cp
								and $(which plop) evaluates to  (i.e. unquoted empty string, aka no argument)
								 resulting in : [ /bin/cp -a ]

[ "$(which cp)" -a "$(which plop)" ] && echo ok || echo ko
ko								no more error because "" is a valid argument to -a

[ '$(which cp)' -a '$(which plop)' ] && echo ok || echo ko
ok								testing literal strings $(which plop) and $(which plop) : not empty, then success