Scripting

For scripting on a unix-like system you at least need a text-editor. Vi is available on any unix-system, emacs is far more sophiticated (it is context aware) and consequently even harder to learn.

#!/bin/sh Op eerste regel script.

Execute script in given shell, you may add -vx for loggin here too.

/dev/tty

Controlling Terminal, points always to the current terminal of the process.

VAR=$(cmd)

VAR wordt de output van cmd, dit is mooier dan VAR=`cmd`

$0

Name current procedure

$1

First passed argument ($2 is the second, $3… )

$*

All arguments given (together “$*” puts them in one string)

$@

All arguments given (apart “$@” is treated as separate strings)

$#

The number of passed arguments

$?

The returnstate for the last executed command. 0 = OK, all others not.

$$

ProcessID of current process, handy to use for temporary files

$!

ProcessID of last spawned process.

set VAR

vervang variabelen lijst

set $* VAR

Voeg toe aan variabelen lijst

set — -VAR

Hierna volgen geen opties meer – wordt als onderdeel van VAR
gezien.

set -n -e -u

u = foutmelding bij gebruik niet bestaande VAR (gebruiken in
scripts), e = breek script af bij fout, n = noexec niets doen, alleen
syntaxcheck.

VAR=

Empty VAR

unset VAR

Remove variable (not just empty it)

typeset -ul(Rn)(RZn) VAR

zet masker voor VAR l = lowercase u = uppercase, Rn Right justify
numbers, RZn = Rn met voorloop0

VAR=xx cmd

VAR is passed to cmd. VAR is not part of current environment, it is
only in the child process.

${str#??}

Remove the first 2 chars

${str#* *}

Remove the first 2 words

${str%??}

Remove the last 2 chars

${str%e*?}

Remove the last ‘e’

${str% * *}

Remove the last 2 tokens

${#str}

Length of the string

readonly VAR=xx

VAR wordt readonly, in sommige shells mag unset wel, readonly
attribuut wordt door children soms geërft.

‘bla bla’

Geen substitutie (variabelen en filenames)

“bla bla”

Alleen geen file name generation

eval <statements and strings>

Forces the shell to evalute the result of shell substitution (e.g.
filename expansion).

IO=”blabla > hoi”
echo ${IO}

returns: blabla>hoi

eval echo ${IO}

puts blabla in the file hoi

!!!! Voorkom test op lege string of keyword door voor variabelen een x te
zetten

Onderstaande zonder : zijn alleen test op het bestaan van de
variable

${VAR:=xx}

Als VAR leeg is, return xx, VAR=xx

${VAR:-xx}

Als VAR leeg is, return xx, VAR blijft leeg. (Zonder : xx als VAR
niet bestaat)

${VAR:+xx}

Als VAR niet leeg is, return xx, VAR blijft ongewijzigd (Zonder : xx
als VAR wel bestaat)

${VAR:?”bla”}

Als VAR leeg is, return “VAR: bla” en verlaat het script

${#VAR}

Lengte VAR

${VAR#patroon}

VAR vanaf <patroon> (kortst mogelijke partoon) ## (langst
mogelijke patroon)

${VAR%patroon}

VAR tot <patroon> (kortst mogelijke patroon) %% (langst
mogelijke patroon)

[ expr ]

= test expr, results in 1 (not true) or 0 (true). If [[ ]] is used,
no shell-interpretation (faster), no whitespace needed.

-eq, -lt, -le, -gt, -ge

For Integers; Equal, Lower Than, Lower or Equal, Greater Than,
Greater or Equal

=, <, =<, >, >=

For strings Equal, Lower Than, Lower or Equal, Greater Than, Greater
or Equal

!

not

-a, -o

And, or bij [[ ]] ook && of
||

!

not

|, &

or, and

^

bitwise eXclusive or

Arithmetic –> nice site outside

Bash and ksh only work with integers.

+, -, *, /, %

add, substract, multiply, divide, remainder.

**

bash, Exponentiation

10#00012

For bash, force the figure (00012) to be interpreted as decimal. Figures starting with 0 are considered octal by default.

expr <expr>

voer expr uit, bij boolean wordt 1 (onwaar) of 0 (waar) gegeven

((VAR=x+y))

let $VAR=x+y

VAR=$(expr x + y)

Calculate

let VAR+=2

Add two to VAR

Strings

<string> : <RE>

<string> als deze aan <RE> voldoet.

substr <string> <pos> <length>

Substring uit <string> halen.

index <string> <chars>

Waar is <chars> in string te vinden.

quote <string>

Beschouw <string> als string ook als het een keyword is
(bash)

Control statements

LET OP !!!

Bij nohup en nice mogen geen control statement meegegeven worden. Dit is op
te lossen door:

nohup ksh -c “if ……..”

Hier is ksh het commando dat aan nohup gegeven wordt en dat mag dus
wel.

if <statement>
then <statement>
else <statement>
fi

voer commando’s achter then uit als <statement> exit code 0
heeft, anders commando’s achter else. Else is optioneel.

case $VAR in
val1) <statement1> ;;
val2) <statement> ;;
*) <statement> ;;
esac

Voer <statement1> uit als $VAR de waarde val1 heeft. *) staat
voor alle overige waarden, *val1 mag ook, reguliere expressies worden (beperkt ondersteund). Er wordt maar een(1) <statement>
uitgevoerd.

while read VAR
do
<statement>
done < <file>

Read values for $VAR form <file> (first field of each line) than execute <statemant>.
More variables can be read. (read VAR1 VAR2….) The loop is ended when the statement after while is no longer true ($? = 0) for read this happens at <EOF>.
!!!! If the loop contains calls to external systems (remsh, ssh) this call swallows all input, the loop is ended, this can be prevented by assigning specific input to the call (e.g. ssh user@system command < /dev/null) !!!!!!!!!!!!
!!!!!!!!!! bash does not handle piped loops very well, a subprocess is created so variable inside the loop are not available outside the loop, use ksh!!!!!!!!!!!!!!!!!!!!!!!

cat <file>| while read VAR
do
<statement>
done

Works the same as the loop above in ksh. In bash piping opens a new sub-shell. This implies variables set inside the loop are not available outside the loop.

break

Leave loop now

&& <statement>

Voer <statement> alleen uit als het voorgaande commando
exit-code 0 heeft (ok)

|| <statement>

Voer <statement> alleen uit als het voorgaande commando
exit-code 1 heeft (fout)

trap <cmd> <signal>

Voer bij het ontvangen van <signal> <cmd> uit. Signals are as used in kill Bijv. trap
“rm ${TMP}.*;exit” SIGQUIT

trap “” <signal>

Negeer <signal>

trap – <signal>

Reset <signal> naar oorspronkelijke gedrag.

getopts a:bc var_a

Lees eerstvolgende optie van commandline. a heeft een argument nodig
dat in var_a staat
$OPTIND bevat het volgnummer van het te verwerken argument
$OPTARG bevat het argument bij de huidige optie

Functions:

function <naam> { cmdlist }

Define a function (subroutine), must be run by the script before you can call it.
A function is called by the function name and eventual parameters. Parameters are positional like when you call a scripts ($1, $2,…). Variables that already exist when you call the functions are global.

typeset VAR=<value>

Define local variables in a function.
Functions can be made available in the loginshell by defining them in the $ENV script or by putting the script in $FPATH.

unset -f <function>

Undefine function