V programátorských příručkách bývá zvykem začínat primitivním programem hello world. Psaní shellových skriptů je programování hodně podobné, a proto si zkusíme na primitivním programu ukázat náležitosti shellového skriptu:

#!/bin/bash

echo "Hello world."

Jednoduché, že? První řádka označuje, který interpret se má použít ke "spuštění" příslušného souboru. Na rozdíl od programovacích jazyků s kompilátory, které produkují spustitelný strojový kód, potřebují shellové skripty interpret, tedy program, který daný skript vykoná.

Takto opatřený soubor můžeme učinit spustitelným:

chmod a+x skript

Pak postačí jej spustit:

./skript

Všimněte si, že programy v aktuálním adresáři spouštíme tak, že se na aktuální adresář odkážeme v cestě. V unixových systémech totiž aktuální adresář není součástí cesty, která se prohledává při zadání příkazu. Je to vhodné bezpečnostní opatření pro případ, že někdo vytvoří škodlivý skript se stejným jménem jako některý z často používaných příkazů.

Výchozí cesta většinou obsahuje adresáře jako /bin či /usr/bin, kde se nachází spustitelné soubory všech nainstalovaných uživatelských programů. V GNU/Linuxu si tedy nemusíte dělat starosti s tím, kam se vám nainstaloval třeba Firefox, protože jeho spustitelný soubor se nachází v cestě, která se po zadání příkazu bude prohledávat. Není tedy problém spustit Firefox přímo z příkazového řádku:

[michal@griffon ~]$ firefox

Skripty lze samozřejmě spouštět "ručně", pomocí interpretu, takto:

bash skript

Dosud jsme nerozlišovali typ použitých příkazů. Vlastní příkaz může být název spustitelného souboru, který tvoří nějaký program, může to být ale i vestavěná funkce shellu nebo třeba alias. Příkazy jako ls, grep, cat či ssh jsou názvy spustitelných souborů, tedy programy. Naopak třeba příkaz cd je vestavěnou funkcí shellu. Není to žádný konkrétní program. Podobně jako třeba echo. Této znalosti můžeme využít, pokud budeme v prostředí, kde máme sice shell, ale už ne jednotlivé programy jako ls. Program ls můžeme nahradit právě použitím vestavěné funkce shellu echo:

echo *

Poslední kategorií jsou aliasy. Ty můžete specifikovat vedle dalších nastavení ve svém ~/.bashrc. Alias je jiné jméno pro nějaký příkaz. Můžete si tak namapovat nějaký komplikovanější příkaz na snadno zapamatovatelný alias:

alias la='ls -la'

Pokud by se vám stýskalo po logických označeních jednotek, můžete si pomoci třeba takto:

alias c:='cd /mnt/windows'

Pokud nevíte, co je daný příkaz zač, můžete zkusit vestavěnou funkci shellu type:

type prikaz

Proměnné slouží k uložení určitých hodnot či řetězců. Začneme proměnnými prostředí. O jedné jsme už několikrát mluvili, a sice o cestě, která se prohledává při zadání nějakého příkazu, který shell nerozpozná jako vestavěnou funkci. Proměnná se jmenuje PATH a její obsah můžeme zobrazit takto:

echo $PATH

Všechny proměnné prostředí můžeme vypsat pomocí příkazu set:

set

Další zajímavou proměnnou prostředí je PS1, která určuje tvar výzvy (prompt). Výzvu už jsme tu mnohokrát měli, vypadá třeba takto:

[michal@griffon ~]$

Mnoho informací o proměnných prostředí naleznete v manuálu bashe:

man bash

Proměnné nemusí ale být jenom proměnné prostředí. Můžete si je tvořit sami, což se zejména ve skriptech velice hodí. Proměnnou vytvoříte pomocí znaku =:

PROMENNA="Moje proměnná."

Vlevo je název proměnné, vpravo za = je její hodnota. Tento zápis netoleruje mezery. Pokud byste = oddělili mezerami, nebude to fungovat.

Hodnotu proměnné můžete dosadit kamkoliv, pokud před název proměnné zapíšete znak dolaru:

echo $PROMENNA

Ukažme si malý skriptík s proměnnou:

#!/bin/bash
         
LOG="~/log.txt"
cp soubor /tmp 2&>$LOG

Omlouvám se za takto primitivní příklad. Ano, jak tušíte, tento skript překopíruje soubor soubor do adresáře /tmp a veškeré případné chybové hlášky zapíše do souboru, který je specifikován v proměnné LOG. Pokud budete tvořit složitější skript, vyplácí se nějaké statické hodnoty (třeba adresáře, soubory, apod.) specifikovat v proměnných. Pak, když budete potřebovat hodnoty změnit, nemusíte procházet celý soubor, změníte pouze hodnotu v proměnné.

Do proměnných můžete přirozeně ukládat i výstup nějakého příkazu:

PROMENNA=$(ps au | grep "bash")

Základní matematiku (celočíselné operace) provádí následující syntax:

$((vyraz))

Za vyraz stačí dosadit nějakou matematickou operaci, třeba:

$((4+5*(5-20/5)))

Operace vyžadující plovoucí desetinnou čárku můžete provádět pomocí programu bc. Jeho použití je ale trošku složitější:

echo "scale=2; 4*4-6*(1/25)" | bc

Proměnná scale nastavuje počet desetinných míst. Přirozeně, na místě pro jednotlivá čísla můžete uvádět proměnné a výsledek ukládat do jiných proměnných.

Pokud často používáte nějaký sled příkazů, hodí se jej umístit do funkce, kterou lze pak spouštět jediným příkazem. Třeba takto:

#!/bin/bash

function nase_funkce {
   echo "Kopiruji soubor ..."
   cp soubor.txt /tmp
   du -h /tmp/soubor
}

nase_funkce

Tohle je opět značně primitivní příklad, ale svůj účel plní. Vidíme, jak se funkce vytváří i jak se používá. Funkcím lze předávat parametry:

#!/bin/bash

function funkce {
   echo "Parametr funkce c. 1: $1"
   echo "Parametr funkce c. 2: $2"
}

funkce parametr1 parametr2

O parametrech funkcí i skriptů se ale dozvíme více později.

Průběh skriptu může někdy narazit na situaci, kde bude třeba o něčem rozhodnout. Za tímto účelem máme k dispozici podmínku:

if [ podminka ]; then
  prikaz
fi

To je nejjednodušší možná konstrukce podmínky. Pokud je podmínka podminka pravdivá, provede se prikaz. Je však možné konstruovat i složitější podmínky, třeba jako je tato:

if [ vyraz1 ]; then
  prikaz1
elif [ vyraz2 ]; then
  prikaz2
else
  prikaz3
fi

V tomto případě se provede prikaz1, jestliže je podmínka vyraz1 pravdivá. Pokud není, ale je pravdivá podmínka vyraz2, provede se prikaz2. Pokud ani tato podmínka pravdivá, provede se prikaz3. Ještě než zkusíme nějaký reálný příklad, povíme si více o podmínkách.

if [ `grep -c ^michal /etc/passwd` -eq 0 ]; then
  echo "Uživatel 'michal' neexistuje."
else
  echo "Uživatel 'michal' existuje."
fi

if [ -f /var/run/mysqld.pid ]; then
  echo "MySQL server pravděpodobně běží."
else
  echo "MySQL server neběží."
fi

if [ -z "$PROMENNA" ]; then
  echo "Proměnná je prázdná."
else
  echo "Proměnná obsahuje '$PROMENNA'"
fi

#!/bin/bash

PROMENNA="dve slova"               

if [ -z $PROMENNA ]; then
  echo "Promenna je prazdna."
else
  echo "Promenna obsahuje $PROMENNA"
  fi

skript: line 5: [: dve: binary operator expected

if [ -z dve slova ]; then

if [ -z "$PROMENNA" ]; then

if [ -z "dve slova" ]; then

#!/bin/bash

CISLO="ahoj"

if [ "$CISLO" -eq 5 ]; then
   echo "Cislo je rovne 5."
else
   echo "Cislo neni rovne 5."
fi

skript: line 5: [: ahoj: integer expression expected

#!/bin/bash
PROMENNA="ahoj

if [ -z "$PROMENNA" ]; then
   echo "Promenna je prazdna."
else
   echo "$PROMENNA"
fi

./skript: line 7: unexpected EOF while looking for matching `"'
./skript: line 9: syntax error: unexpected end of file

bash -x skript

#!/bin/bash -x

#!/bin/bash

CISLO="ahoj"

set -x

if [ "$CISLO" -eq 5 ]; then
   echo "Cislo je rovne 5."
else
   echo "Cislo neni rovne 5."
fi

set +x

[...]

#!/bin/bash

CISLO="ahoj"

if [ "$CISLO" -eq 5 ]; then
   echo "Cislo je rovne 5."
#else
#   echo "Cislo neni rovne 5."
fi

#!/bin/bash

cp /var/log/messages /tmp
echo rm /tmp/messages

Pokud se rozhodujeme mezi dvěma možnostmi, je konstrukce if optimální. Pokud se naopak potřebujeme rozhodovat mezi více možnostmi podle obsahu proměnné, můžeme použít konstrukci case:

case $promenna in
   1 ) echo "Promenna je rovna 1" ;;
   2 ) echo "Promenna je rovna 2" ;;
   3 ) echo "Promenna je rovna 3" ;;
   * ) echo "Promenna neni rovna 1, 2 ani 3"
esac

Můžeme použít i složitější výrazy se zástupnými znaky:

case $promenna in
   [a-z] | [A-Z] ) echo "Jedno male nebo velke pismeno" ;;
   [0-9] ) echo "Jednociferne cislo" ;;
   * ) echo "Neco jineho"
esac

Někdy potřebujeme určitou činnost opakovat. A to je úloha pro cykly. Ty můžeme rozdělit do dvou kategorií. Cykly provádějící určitý počet opakování (cyklus for) a cykly založené na podmínce (cykly while a until).

for promenna in 1 2 3 4 5; do
   echo "$promenna"
done

1
2
3
4
5

for i in `seq 1 50`; do
   echo $i
done

for i in *; do
   echo $i            
done

cislo=4
until [ $cislo -eq 5 ]; do
  echo "$cislo"
  cislo=$((cislo+1))
done

while [ $cislo -gt 0 ]; do
  echo "$cislo"
  cislo=$((cislo-1))
done

4
5
4
3
2
1

cat soubor | while read radka; do
  echo $radka
done

#!/bin/bash

for i in 1 2 3 4 5 6; do
   if [ $i -eq 3 ]; then
      continue
   elif [ $i -eq 5 ]; then
      break
   fi
   echo $i
done

1
2
4

Skriptům nebo funkcím můžeme předávat parametry. Ty jsou pak k dispozici buď jako pole všech parametrů reprezentované proměnnou $@ nebo jako jednotlivé parametry v proměnných $1, $2, atd. Proměnná $0 obsahuje jméno souboru s vlastním skriptem.

Vše si ozřejmíme na následujícím příkladě. Mějme skript:

#!/bin/bash
         
echo "Soubor se skriptem: $0"
echo "Prvni parametr: $1"
echo "Druhy parametr: $2"
echo "Treti parametr: $3"
echo "Pole vsech parametru: $@"

Tento skript spustíme následujícím způsobem:

./skript jedna dve tri

Následně obdržíme tento výpis:

Soubor se skriptem: ./skript
Prvni parametr: jedna
Druhy parametr: dve
Treti parametr: tri
Pole vsech parametru: jedna dve tri

Někdy můžeme dát přednost interaktivnímu programu, který požádá uživatele o zadání nějaké hodnoty. V takové situaci můžeme použít příkaz read, který uloží uživatelský vstup do proměnné. Ukažme si to na příkladu:

#!/bin/bash

while true; do
  echo -n "Zadejte polomer (Ctrl-C ukonci skript): "
  read POLOMER
  echo -n "Obsah kruhu s polomerem $POLOMER je"
  echo "scale=3; 3.14*$POLOMER^2" | bc
done

Tento program využívá mnohé z toho, co jsme se naučili už dříve. Umožňuje spočítat obsah kruhu. Cyklus while má v tomto případě místo podmínky dosazený program, který navrací pravdivostní hodnotu 1 nebo true (pravda). To znamená, že cyklus se bude opakovat, dokud uživatel násilně neukončí skript pomocí Ctrl+C.

Dosavadních znalostí můžeme využít i pro vytvoření lepšího řešení:

#!/bin/bash

function obsah {
  echo -n "Obsah kruhu s polomerem $1 je "
  echo "scale=3; 3.14*$1^2" | bc
}

if [ -z "$1" ]; then
  while true; do
    echo -n "Zadejte polomer (Ctrl-C ukonci skript): "
    read POLOMER
    obsah $POLOMER
  done
else
  obsah "$1"
fi

Tento skript využívá funkci, která provádí vlastní výpočet, dále podmínku, která hlídá, zda-li uživatel zadal skriptu při spuštění parametr nebo ne. Pokud ano, provede výpočet na hodnotě získané z parametru, pokud uživatel parametr nezadal, nabídne mu "interaktivní" režim, kdy může hodnotu zadat sám. Interaktivní režim pak pracuje stejně jako příklad výše.

Pokud budeme pracovat s běžnými příkazy, může se stát, že některý z nich nebude schopen příslušnou operaci provést a selže:

#!/bin/bash

cp soubor adresar
rm soubor

Tento skript sice nic smysluplného nedělá, ale můžeme si na něm ukázat, o co jde. Pokud totiž první příkaz (cp) selže, kopie původního souboru se nevytvoří, a pokud bude skript pokračovat dál (což bude), smaže zdrojový soubor. V tomto případě by se tedy hodilo zjistit, jestli první příkaz proběhl úspěšně, a pokud ne, zastavit průběh skriptu.

Každý správně napsaný unixový program po sobě zanechá tzv. konečný stav (exit status). To je číslo, které nám pomůže zjistit, jestli program úspěšně skončil nebo jestli skončil s chybou. Nula představuje bezchybný konec, nenulové číslo poukazuje na chybu při práci programu. Hodnota konečného stavu naposledy spuštěného programu se uchovává v proměnné $?. Toho můžeme využít a skript adekvátně upravit:

#!/bin/bash

cp soubor adresar
if [ $? -gt 0 ]; then
  echo "Soubor se nepodarilo prekopirovat."
  exit 1
fi
rm soubor

Na tomto příkladě jsme si ukázali dvě věci. Jednak zpracování chybového stavu a jednak příkaz exit, který okamžitě ukončí běh skriptu. Jako parametr lze tomuto příkazu předat hodnotu, kterou má vrátit jako konečný stav. V tomto případě jsme zvolili nenulovou hodnotu, protože náš program v této situaci skončil s chybou.

Chybové stavy můžeme ošetřovat v rámci jednoho příkazu takto:

cp soubor adresar && echo "Soubor se zkopiroval."

Dva ampersandy za sebou fungují jako speciální oddělovač příkazů. Příkaz za nimi se provede pouze v případě, že příkaz před nimi bude korektně ukončen. Opačnou možnost nabízí dvě roury:

cp soubor adresar || echo "Nastala chyba."

V tomto případě se příkaz po dvou rourách provede pouze v situaci, kdy příkaz před nimi vrátí nenulový konečný stav.

trap "příkaz" signály

trap "rm $TEMP; exit" SIGHUP SIGINT SIGTERM

nohup prikaz &