Bash scripting - Loops

With fixed parameters (start, stop, increment) :

With parameters (start, stop, increment) stored in variables :

If you don't just ++ at every loop :

for ((i=1; i<1000000000000000000; i=i*10)); do
echo "$i" | sed -r ': repeat s/([0-9]+)([0-9]{3})(,|$)/\1,\2/; t repeat'
done

Looping on items with SPACEs

FileBaseName='file with spaces '; tmpDir=$(mktemp -d); touch "$tmpDir/$FileBaseName"{1,2,3}

# doesn't work : for is puzzled by SPACEs
for someFile in $(find "$tmpDir" -type f); do echo "$someFile"; done

# works 
while read someFile; do echo "$someFile"; done < <(find "$tmpDir" -type f)

# clean before leaving
[ -d "$tmpDir" ] && rm -r "$tmpDir"

for vs while (source) :

With recursivity :

#!/usr/bin/env bash

doSomething() {
	random=$RANDOM
	echo "I'm working with '$1' and '$2' and '$3' (RANDOM = $random)"
	echo
	[ $random -lt 10000 ] && return 0 || return 1	faking failure
	}

doSomethingUntilSuccess() {
	loopNumber=$((loopNumber+1))
	echo "Doing 'doSomethingUntilSuccess' (loop $loopNumber) ..."
	doSomething 'foo' 'bar' 42 || doSomethingUntilSuccess
	}

loopNumber=0
doSomethingUntilSuccess
echo 'DONE !'

#!/usr/bin/env bash

generateOneWord() {
	local length=$1
	pwgen -0 $length 1
	}

generateWordsUntilMatchRegex() {
	local regex=$1
	echo -n '.'
	generateOneWord "$wordLength" | grep -Ei "$regex" || generateWordsUntilMatchRegex "$regex"
	}

wordLength=40
generateWordsUntilMatchRegex 'h.*e.*l.*l.*o'
generateWordsUntilMatchRegex '^w.*[orl].*d$'

With an until loop :

#!/usr/bin/env bash

trap "{ echo 'CTRL-C detected... Bye-bye.'; exit 1; }" SIGINT

# This function is the job to redo if failed
doSomething() {
	random=$RANDOM
	echo "I'm working with '$1' and '$2' and '$3' (RANDOM = $random)"
	echo
	[ $random -lt 10 ] && return 0 || return 1
	}

loopNumber=1

until doSomething 'foo' 'bar' 42; do
	echo "$loopNumber loops so far, and running ..."
	loopNumber=$((loopNumber+1))
done

echo "DONE !"
echo "In $loopNumber loops "

#!/usr/bin/env bash

doTheJob() {
	echo 'hello world'
	}

checkTheJobIsDone() {
	[ $(($RANDOM % 6)) -ge 5 ]
	}

main() {
	until checkTheJobIsDone; do
		doTheJob
		sleep 1
	done
	echo 'The job is done'
	}

main

Typical case : reading a file line by line :

tmpFile=$(mktemp)
echo -e 'Bob\nKevin\nStuart' > "$tmpFile";
while read name; do
	echo "Hello, '$name' !"
done < "$tmpFile"
rm "$tmpFile"

Hello, 'Bob' !
Hello, 'Kevin' !
Hello, 'Stuart' !

tmpFile=$(mktemp)
echo -e ' Bob \n Kevin \n Stuart ' > "$tmpFile";
while read name; do
	echo "Hello, '$name' !"
done < "$tmpFile"
while IFS= read name; do
	echo "Hello, '$name' !"
done < "$tmpFile"
rm "$tmpFile"

Hello, 'Bob' !
Hello, 'Kevin' !
Hello, 'Stuart' !
Hello, ' Bob ' !
Hello, ' Kevin ' !
Hello, ' Stuart ' !

tmpFile=$(mktemp)
echo -e 'apples\t12\nbananas\t3\ncoconuts\t42' > "$tmpFile";
while read fruit number; do
	echo -e "Number of '$fruit' : '$number'"
done < "$tmpFile"
while read -r fruit number; do
	echo -e "Number of '$fruit' : '$number'"
done < "$tmpFile"
rm "$tmpFile"

Number of 'apples' : '12'
Number of 'bananas' : '3'
Number of 'coconuts' : '42'
Number of 'apples' : '12'
Number of 'bananas' : '3'
Number of 'coconuts' : '42'

It also works with process substitution :

while read line; do
	echo "$line"
done < <(ps -u $(whoami) | head -10)

... and with heredocs too :

while read line; do
	echo "$line"
done <<< $(ps -u $(whoami) | head -10)

if condition; then
	some
	commands
else
	some
	different
	commands
fi

Snippets

An infinite loop

#!/bin/bash
something='hello world'
case $something in
	h*)
		echo 'foo'
		;;
	*)
		echo 'bar'
		;;
esac

foo

something

this is what the various patterns will be matched against

pattern)

• shell pattern matching (not regexp), do not use quotes (details and examples)
• before matching is attempted,
  1. tilde expansion
  2. parameter and variable expansion
  3. arithmetic expansion
  4. command substitution
  5. process substitution
  6. quote removal
  are performed
• the first pattern that matches is executed, the following ones are skipped
• the final semicolons ;; can not be omitted to create a "fallback" like in C or with the PHP switch

Some of the extended pattern matching operators require the extglob shell option to be enabled (and will produce shell errors otherwise) :

shopt -s extglob

;;

the double semicolon ;; is the "end of case" operator, but is not the only option available :

• ;; : no subsequent matches are attempted after the first pattern match
• ;& : causes execution to continue with the list associated with the next set of patterns

  #!/usr/bin/env bash
  
  myFunction() {
  	case "$1" in
  		a) echo a ;;
  		b) echo b ;&
  		c) echo c ;;
  		*) echo star ;;
  	esac
  	echo -----
  	}
  
  myFunction a
  myFunction b
  myFunction c
  myFunction z

  a	prints then hits ;; → stop
  -----
  b	prints then executes the code of the next case unconditionally
  c	prints then hits ;; → stop
  -----
  c	prints then hits ;; → stop
  -----
  star	prints then hits ;; → stop
  -----

• ;;& : causes the shell to
  1. test the next pattern list in the statement (if any)
  2. if this next pattern matches, execute the associated code
  3. then, continue the case statement execution as if the pattern list had not matched in (1)
  The exit status is zero if no pattern matches. Otherwise, it is the exit status of the last command executed in list.

  #!/usr/bin/env bash
  
  myFunction() {
  	case "$1" in
  		a) echo a ;;
  		b) echo b ;;&
  		c) echo c ;;
  		*) echo star ;;
  	esac
  	echo -----
  	}
  
  myFunction a
  myFunction b
  myFunction c
  myFunction z

  a	prints then hits ;; → stop
  -----
  b	prints then checks whether the next case matches (here, no match)
  star	continue evaluating the following cases : here the * matches
  -----
  c	prints then hits ;; → stop
  -----
  star	prints then hits ;; → stop
  -----