Portál AbcLinuxu, 16. května 2024 20:06

BASH - III

7. 11. 2003 | Jan Fuchs

Články - BASH - III

Tentokrát se podíváme na proměnné, napíšeme si náš první skript a vysvětlíme podmínky a cykly.

Obsah jednotlivých dílů

Úvod, editace příkazové řádky
Základní příkazy, roury a přesměrování
Proměnné, podmínky a cykly
Funkce a příkazy
Dokumenty here, regulární výrazy
Ladění skriptů, odchytávání signálů a příklady

Proměnné

Jsou pouze jednoho datového typu - řetězec znaků. Některé z nich mohou být určeny jen pro čtení. Proměnné můžeme rozdělit do tří částí.

Vnitřní proměnné shellu. O jejich inicializaci se stará shell.

$ echo $USER fuky $ echo $OSTYPE linux-gnu $ echo $LANG cs_CZ $ echo $SHELLOPTS braceexpand:hashall:histexpand:monitor: history:interactive-comments:emacs
Uživatelské proměnné. Jako výše uvedené proměnné se skládají pouze z alfanumerických znaků.
Proměnné speciálního významu, skládají se ze speciálních znaků. Například:
- $$ - PID shellu
- $! - PID posledního procesu, který byl spuštěn na pozadí
- $? - návratová hodnota posledního dokončeného procesu.

Proměnnou můžeme exportovat příkazem export do podřízeného shellu a příkazem readonly zajistíme, že bude určena pouze pro čtení (POZOR, toto omezení se nepřenáší do podřízeného shellu). Když chceme získat hodnotu proměnné, napíšeme před ni znak $. Ale když jí např. hodnotu přiřazujeme, nepíšeme před ní znak dolaru. Pro odstranění proměnné použijeme příkaz unset.


$ jedna="Lokální proměnná"

$ export DVA="Proměnná exportovaná do podřízeného shellu"

$ readonly TRI="Proměnná určená pouze pro čtení, ale jen na lokální urovni"


$ export TRI

$ export

declare -x DVA="Proměnná exportovaná do podřízeného shellu"

declare -rx TRI="Proměnná určená pouze pro čtení, ale jen na lokální urovni"

$ readonly

declare -rx TRI="Proměnná určená pouze pro čtení, ale jen na lokální urovni"

$ echo $jedna

Lokální proměnná

$ TRI="Nová hodnota"


bash: TRI: readonly variable

$ bash

$ TRI="Nová hodnota"

$ echo $jedna
$ echo $DVA

Proměnná exportovaná do podřízeného shellu

$ echo $TRI

Nová hodnota

$ unset TRI

První skript

Nadešel čas pro napsání a spuštění našeho prvního skriptu. Pak se ještě na chvíli vrátíme k proměnným. Pojmenujeme ho prvni.sh.


#!/bin/bash



# Tento skript nepotřebuje žádné komentáře

echo "Náš první skript byl právě spuštěn a za 3 vteřiny bude ukončen."

sleep 3

echo "Konec."




exit 0

Prvním řádkem zajistíme, že náš skript bude opravdu interpretován BASHEM. To je jediná výjimka při použití znaku #, řádka začínající tímto znakem je ignorována a slouží k okomentování zdrojového kódu. Každý správný programátor používá ve svých kódech komentáře. Když se k němu po čase vrátí, dříve ho pochopí a také zjednoduší pochopení ostatním. Potřeba naučit se správnému používání komentářů přijde časem sama. Uvidíte, kde jsou zbytečné a kde naopak velice důležité (POZOR, komentáře se píší ihned se zdrojovým kódem - podle mě není dobrý zvyk je psát až po dokončení programu). A nakonec samozřejmě nezapomeneme vrátit návratový kód exit 0.

Nyní si skript spustíme, ale nejprve musíme přidat právo pro spuštění, protože textový editor toto právo standardně k nově vytvořeným souborům nepřidává.


$ ls -l

-rw-r--r--    1 fuky    fuky       114 říj 19 14:43 prvni.sh


$ chmod +x ./prvni.sh

$ ls -l

-rwxr-xr-x    1 fuky    fuky       114 říj 19 14:43 prvni.sh

$ ./prvni.sh

Náš první skript byl právě spuštěn a za 3 vteřiny bude ukončen.


Konec.

Proměnné - dokončení

Nyní, když umíme spouštět skripty, tak si ukážeme na skriptu promenne.sh ještě několik zajímavých věcí.

#!/bin/bash

prvni="Níže uvedený zá"
echo "${prvni}pis umožní oddělit proměnnou od okolního textu"

# Kdyby byla $druha definována, byla by vrácena její hodnota,
# jelikož není, bude vrácen "náhradní výraz"
echo ${druha-"náhradní výraz"}
echo $druha

# To samé jako předchozí, ale $treti nezůstane nedefinovaná
echo ${treti="náhradní výraz"}
echo $treti

ctvrta="Příšerně žluťoučký kůň úpěl ďábelské ódy."

# Vrátí "náhradní výraz" je-li proměnná definována, jinak
# se nevrací žádná hodnota
echo ${ctvrta+"náhradní výraz"}
echo $ctvrta

# Vypíše délku $ctvrta
echo ${#ctvrta}

# Od konce odstraní nejkraší část $ctvrta, která odpovídá e*
echo ${ctvrta%e*}

# Od konce odstraní nejdelší část $ctvrta, která odpovídá e*
echo ${ctvrta%%e*}

# Od začátku odstraní nejkraší část $ctvrta, která odpovídá *e
echo ${ctvrta#*e}

# Od začátku odstraní nejdelší část $ctvrta, která odpovídá e*
echo ${ctvrta##*e}

exit 0

Ještě si skript spustíme pro lepší pochopení.


# ./promene.sh

Níže uvedený zápis umožní oddělit proměnnou od okolního textu

náhradní výraz



náhradní výraz


náhradní výraz

náhradní výraz

Příšerně žluťoučký kůň úpěl ďábelské ódy.

41

Příšerně žluťoučký kůň úpěl ďáb

Příš

rně žluťoučký kůň úpěl ďábelské ódy.

lské ódy.

V shellu si ještě vyzkoušíme několik příkazů, abychom pochopili, jak je to s uvozovkami, apostrofy a expanzí.


$ echo $promenna


./promenne.sh ./prvni.sh

$ echo '$promenna'

$promenna

$ echo "${promenna}vni.sh"

./*vni.sh

$ echo ${promenna}vni.sh

./prvni.sh

$ echo ${promenna}vni.pdf

./*vni.pdf


$ echo "$(echo $promenna) - výpis adresáře"

./promenne.sh ./prvni.sh - výpis adresáře

Podmínky

Skript if.sh nám ukáže použití konstrukce

if výraz; then příkazy elif výraz; then příkazy else příkazy fi

#!/bin/bash

if [ "$USER" == "root" ]; then
  echo "Ahoj admine";
fi

if [ "$USER" == "root" ]; then
  echo "Ahoj admine";
else
  echo "Ahoj uživateli";
fi

if [ "$USER" == "root" ]; then
  echo "Ahoj admine";
elif [ "$USER" == "fuky" ]; then
  echo "Ahoj Honzíku";
else
  echo "Ahoj uživateli";
fi

exit 0

POZOR, mezera za [ je důležitá! Znak [ je totiž program a to, co následuje za ním, jsou jeho argumenty.



$ which [

/usr/bin/[

Jak jsem už jednou říkal, všechny proměnné v shellu jsou jednoho datového typu. To vysvětluje, proč se řetězce a čísla porovnávají níže popsaným způsobem (výraz, výraz1, výraz2 vrací řetězec a teprve když ho chceme porovnávat jako číslo, tak ho shell bere jako číslo, jinak to je stále řetězec).

[ výraz ] - délka řetězce je nenulová
[ -z výraz ] - délka řetězce je nulová
[ výraz1 == výraz2 ] - řetězce jsou shodné
[ výraz1 != výraz2 ] - řetězce jsou různé
[ výraz1 -eq výraz2 ] - čísla jsou shodná
[ výraz1 -le výraz2 ] - výraz1 <= výraz2
[ výraz1 -lt výraz2 ] - výraz1 < výraz2
[ výraz1 -ge výraz2 ] - výraz1 >= výraz2
[ výraz1 -gt výraz2 ] - výraz1 > výraz2
[ výraz1 -ne výraz2 ] - čísla jsou různé

Testování souborů.

[ výraz1 -ef výraz2 ] - soubory sdílejí stejný i-uzel
[ výraz1 -nt výraz2 ] - první soubor je novější
[ výraz1 -no výraz2 ] - první soubor je starší
[ -e výraz ] - soubor existuje
[ -d výraz ] - soubor je adresář
[ -f výraz ] - soubor je obyčejný soubor
[ -L výraz ] - soubor je symbolický odkaz
[ -w výraz ] - soubor je zapisovatelný
[ -x výraz ] - soubor je spustitelný

Místo [ můžete používat test. Jsou to stejné programy svázané pevným odkazem.


$ if test /usr/bin/test -ef /usr/bin/\[; then echo "Je to opravdu tak..."; fi

Je to opravdu tak...

$ if [ /usr/bin/test -ef /usr/bin/\[ ]; then echo "Je to opravdu tak..."; fi

Je to opravdu tak...

Podmínky samozřejmě můžete spojovat pomocí operátorů && (a zároveň platí) a || (nebo platí).


# if [ $USER == "root" ] && [ $LANG == "cs_CZ" ]; then

> echo "Jsi český admin"

> fi

Jsi český admin

Na skriptu case.sh se podíváme na použítí konstrukce
case slovo in vzory ) příkazy;; ... esac:

#!/bin/bash

case "$USER" in
  root )
    echo "Ahoj admine"
    ;;
  fuky )
    echo "Ahoj Honzíku"
    ;;
  * )
    echo "Ahoj uživateli"
    ;;
esac

case "$USER" in
  root | fuky )
    echo "Ahoj Honzíku"
    ;;
  * )
    echo "Ahoj uživateli"
    ;;
esac

exit 0

Cykly

Pro tento díl poslední skript cykly.sh nás zasvětí do používání cyklů for, while a until. Podle mě je dobrým zvykem uzavírat proměnné v podmínkách do uvozovek, protože kdyby proměnná obsahovala např. mezeru nebo nic, došlo by k chybě.

#!/bin/bash

# Vypíše všechny soubory v adresáři s příponou sh
for file in *.sh; do
  # Soubor je samozřejmě i adresář a co když nějaký šílenec
  # pojmenuje adresář jmeno_adresare.sh
  if [ -f "$file" ]; then
    echo $file
  fi
done

# Do $cislo bude postupně dosazovat čísla
for cislo in 10 20 30 40 50 60 70 80 90 100; do
  echo $cislo
done

cislo=0
# Podmínka je splněna jestliže $cislo != 100
while [ "$cislo" -ne 100 ]; do
  # Konstrukci $(()) zavedl shell ksh a je rychlejší a méně
  # náročná na systémové zdroje než příkaz expr
  cislo=$((cislo + 10))
  echo $cislo
done

cislo=0
# Cyklus pokračuje dokud není splněna podmínka
until [ "$cislo" -eq 100 ]; do
  cislo=$((cislo + 10))
  echo $cislo
done

exit 0

Do příště máte za domácí úkol všechno si poctivě vyzkoušet.

Seriál BASH (dílů: 6)

První díl: BASH - I, poslední díl: BASH - VI.
Předchozí díl: BASH - II
Následující díl: BASH - IV