UNIWERSYTET ŚL
SKI
WYDZIAA
INFORMATYKI I NAUKI O MATERIAA
ACH
INSTYTUT INFORMATYKI
ZAKA
AD SYSTEMÓW KOMPUTEROWYCH
LABORATORIUM SYSTEMÓW OPERACYJNYCH
Materiały do ćwiczeń laboratoryjnych
Temat ćwiczenia: Skrypty powłoki Linux
Systemy operacyjne Cwiczenie 8
SPIS TREŚCI
1 Wprowadzenie.................................................................................................................................................3
1.1 Już korzystamy z basha..............................................................................................................................3
1.2 Pozorny nieład basha .................................................................................................................................3
2 Początek...........................................................................................................................................................4
2.1 Nieśmiertelne Hello World!.......................................................................................................................4
2.2 Polecenie echo ...........................................................................................................................................4
2.3 Słowa zastrzeżone (ang. reserved words) ..................................................................................................5
3 Cytowanie........................................................................................................................................................5
4 Zmienne...........................................................................................................................................................6
4.1 Zmienne programowe (ang. program variables).......................................................................................6
4.2 Zmienne specjalne (ang. special variables, special parameters) ................................................................7
4.3 Zmienne środowiskowe (ang.environment variables) ...............................................................................8
4.4 Zmienne tablicowe.....................................................................................................................................9
5 Strumienie danych .........................................................................................................................................11
6 Instrukcje .......................................................................................................................................................13
6.1 Instrukcja warunkowa if ..........................................................................................................................13
6.2 test jak się sprawdza warunki?.................................................................................................................14
6.3 Instrukcja case .........................................................................................................................................15
7 Pętle ...............................................................................................................................................................15
7.1 Pętla for....................................................................................................................................................15
7.2 Pętla select ...............................................................................................................................................16
7.3 Pętla while ...............................................................................................................................................18
7.4 Pętla until.................................................................................................................................................19
8 Pobieranie danych .........................................................................................................................................19
8.1 Polecenie read..........................................................................................................................................19
9 Funkcje ..........................................................................................................................................................20
10 Interpretacja wyrażeń arytmetycznych. .........................................................................................................21
11 Okna dialogowe.............................................................................................................................................22
11.1 Okno yesno .........................................................................................................................................22
11.2 Okno menu..........................................................................................................................................23
11.3 Okno checklist ....................................................................................................................................23
11.4 Okno radiolist......................................................................................................................................24
11.5 Okno inputbox ....................................................................................................................................24
11.6 Okno msgbox......................................................................................................................................25
11.7 Okno infobox ......................................................................................................................................25
11.8 Okno textbox.......................................................................................................................................25
12 Przykłady skryptów ......................................................................................................................................26
2 / 29
Systemy operacyjne Cwiczenie 7.2
1 Wprowadzenie
Dlaczego powinniśmy uczyć się programowania w bashu? Poniżej znajduje się kilka powodów.
Gdybyśmy to sprawdzili, prawdopodobnie okazałoby się, że w tym momencie bash działa w naszym
systemie. Nawet jeśli zmieniliśmy domyślną powłokę, bash prawdopodobnie i tak działa, ponieważ
jest to standardowy shell Linuksa i system używa go do rozmaitych działań. W związku z tym, że bash
już działa, wszystkie dodatkowe skrypty, jakie uruchomimy nie będą właściwie zajmowały
dodatkowej pamięci, gdyż dzialą one pamięć z działającymi już procesami basha. Po co więc ładować
inny interpreter, jeśli już działa w naszym systemie coś, co wykona pracę i w dodatku zrobi to dobrze?
1.1 Już korzystamy z basha
Nie tylko bash działa w naszym systemie. Każdego dnia używamy go. Bash zawsze nam
towarzyszy, więc warto nauczyć się wykorzystywać jego pełny potencjał. Dzięki temu korzystanie z
systemu będzie przyjemniejsze i bardziej produktywne. Dlaczego jednak uczyć się programowania w
bashu? To proste - już myślimy w kategoriach wykonywania komend, kopiowania plików, tworzenia
strumieni i przekierowań. Warto jest uczyć się języka, który umożliwia wykorzystanie znanych nam
już potężnych i pozwalających na oszczędzenie czasu narzędzi. Powłoki udostępniają nam potencjał
systemu UNIX, a bash jest powłoką Linuksa. Jest wysokopoziomowym pośrednikiem pomiędzy nami
i komputerem. Poszerzając wiedzę o bashu zwiększamy produktywność naszej pracy w systemach
Linux i UNIX.
1.2 Pozorny nieład basha
Nauka basha w niewłaściwy sposób może wywołać wrażenie pozornego nieładu w jego
strukturach. Wielu początkujących użytkowników wpisuje man bash w celu wyświetlenia strony man
basha. Jednak tam znajdują się lakoniczne i bardzo techniczne opisy jego funkcjonalności. Inni
używają info bash, co daje efekt w postaci wyświetlenia strony man, lub tylko odrobinę bardziej
przyjaznej dokumentacji.
Choć początkujący użytkownicy mogą czuć się zawiedzeni, trzeba pamiętać, że dokumentacja
basha nie może być "wszystkim dla wszystkich" i jest skierowana do osób, które są już zaznajomione
z programowaniem powłoki. Z całą pewnością strona man basha zawiera wiele przydatnych
informacji technicznych, jednak dla początkującego użytkownika, są one niemal bezużyteczne.
Ta krótka seria jest przeznaczona właśnie dla początkujących, którzy chcą nauczyć się stosowania
podstawowych konstrukcji basha do budowy własnych skryptów. Zamiast technicznych opisów
można tu znalez
ć wyjaśnienia w przystępnym języku, dzięki czemu nie tylko będziemy wiedzieli co
robi dany element, ale także w jakich sytuacjach powinniśmy go stosować. Po przebrnięciu przez ten
kurs, będziemy w stanie pisać własne złożone skrypty - osiągniemy poziom na którym korzystanie z
basha stanie się dla nas komfortowe. Ponadto będziemy mogli dalej rozwijać swoje umiejętności
poprzez czytanie (i rozumienie) standardowej dokumentacji basha. Zaczynajmy.
Jeśli używałeś plików .BAT, aby ułatwić sobie życie to to samo można zrobić w Linux-ie
używając aliasów. Ale jeśli twoje pliki .BAT były bardziej skomplikowane, to polubisz
programowanie w powłoce (nawet jeśli nie używałeś bardziej skomplikowanych plików .BAT, to i tak
będziesz z czasem programował w powłoce. Chociażby dlatego, że wszelkie wersje instalacyjne
programów pod Linux-a są napisane w skryptach.) Powłoka ma takie elementy jak: zmienne,
instrukcje while, case, for, if...then...else i wiele innych, co może być alternatywą nawet dla dobrego
języka programowania.
Aby napisać skrypt, wszystko co musisz zrobić, to napisać zwykły plik tekstowy zwierający
polecenia, zapisać go i uczynić wykonywalnym. To ostatnie możesz zrobić poleceniem:
chmod u+x
3 / 29
Systemy operacyjne Cwiczenie 8
Aby go wykonać wpisz jego nazwę - pamiętaj, że Linux nie widzi plików w katalogu bieżącym
więc dodaj ./ na początku nazwy, albo dodaj katalog bieżący '.' do zmiennej PATH.
2 Początek
2.1 Nieśmiertelne Hello World!
Większość podręczników, kursów programowania rozpoczyna się od napisania pierwszego
najprostszego programu "Hello World". Nie będę się więc odcinać od tej tradycji. Najpierw należy
stworzyć jakiś plik w którym umieścimy kod, do tworzenia pliku można użyć polecenia:
touch naszskrypt
Następnie za pomocą dowolnego edytora ASCII (mcedit, vi, itp.) należy wpisać do niego
następującą zawartość:
#!/bin/bash
#Tu jest komentarz.
echo "Hello world"
Znak # (hasz) oznacza komentarz, wszystko co znajduje się za nim w tej samej linii, jest pomijane
przez interpreter. Pierwsza linia skryptu zaczynająca się od znaków: #! ma szczególne znaczenie -
wskazuje na rodzaj shella w jakim skrypt ma być wykonany, tutaj skrypt zawsze będzie wykonywany
przez interpreter poleceń /bin/bash, niezależnie od tego jakiego rodzaju powłoki w danej chwili
używamy.
echo "Hello World"
Wydrukuje na standardowym wyjściu (stdout) czyli na ekranie napis: Hello World.
Aby móc uruchomić skrypt należy mu jescze nadać atrybut wykonywalności za pomocą
polecenia:
chmod +x naszskrypt
Jeśli katalog bieżący w którym znajduje się skrypt nie jest dopisany do zmiennej PATH, to nasz
skrypt możemy ururchomić w ten sposób:
./naszskrypt
2.2 Polecenie echo
Polecenie echo służy do wydrukowania na standardowym wyjściu (stdout - domyślnie jest to
ekran) napisu.
Składnia:
#!/bin/bash
echo -ne "jakiś napis"
echo "jakiś napis" #wydrukuje tekst na ekranie
Można też pisać do pliku. W tym wypadku echo wydrukuje tekst do pliku, ale zmaże całą jego
wcześniejszą zawartość, jeśli plik podany na standardowym wyjściu nie istnieje, zostanie utworzony.
echo "jakiś napis" > plik
Tutaj napis zostanie dopisany na końcu pliku, nie zmaże jego wcześniejszej zawartości.
echo "jakiś napis" >> plik
Parametry:
4 / 29
Systemy operacyjne Cwiczenie 7.2
-n nie jest wysyłany znak nowej linii
-e włącza inetrpretacje znaków specjalnych takich jak:
\a czyli alert, usłyszysz dzwonek
\b backspace
\c pomija znak kończący nowej linii
\f escape
\n form feed czyli wysuw strony
\r znak nowej linii
\t tabulacja pozioma
\v tabulacja pionowa
\\ backslash
\nnn znak, którego kod ASCII ma wartość ósemkowo
\xnnn znak, którego kod ASCII ma wartość szesnastkowo
2.3 Słowa zastrzeżone (ang. reserved words)
Mają dla powłoki specjalne znaczenie, wtedy gdy nie są cytowane.
Lista słów zastrzeżonych:
" !
" case
" do
" done
" elif
" else
" esac
" fi
" for
" function
" if
" in
" select
" then
" until
" while
" {
" }
" time
" [
" ]
3 Cytowanie
Znaki cytowania służą do usuwania interpretacji znaków specjalnych przez powłokę.
Wyróżniamy nastepujące znaki cytowania:
" cudzysłów (ang. double quote)
" "
Między cudzysłowami umieszcza się tekst, wartości zmiennych zawierające spacje.
Cudzysłowy zachowują znaczenie specjalne trzech znaków:
" $ wskazuje na nazwę zmiennej, umożliwiając podstawienie jej wartości
" \ znak maskujący
" ` ` odwrotny apostrof, umozliwia zacytowanie polecenia
"
Przykład:
5 / 29
Systemy operacyjne Cwiczenie 8
#!/bin/bash
x=2
echo "Wartość zmiennej x to $x" #wydrukuje Wartość zmiennej x to 2
echo -ne "Usłyszysz dzwonek\a"
echo "Polecenie date pokaże: `date`"
" apostrof (ang. single quote)
' '
Wszystko co ujęte w znaki apostrofu traktowane jest jak łańcuch tekstowy, apostrof
wyłącza interpretowanie wszystkich znaków specjalnych, traktowane są jak zwykłe znaki.
Przykład:
#!/bin/bash
echo '$USER' #nie wypisze twojego loginu
" odwrotny apostrof (ang. backquote)
` `
Umożliwia zacytowanie polecenia, bardzo przydatne jeśli chce się podstawić pod zmienną
wynik jakiegoś polecenia np:
Przykład:
#!/bin/bash
x=`ls -la $PWD`
echo $x #pokaże rezultat polecenia
Alternatywny zapis, który ma takie samo działanie wygląda tak:
#!/bin/bash
echo $(ls -la $PWD)
" backslash czyli znak maskujący
\
Jego działanie najlepiej wyjaśnić na przykładzie: chcesz by na ekranie pojawił się napis
$HOME
Przykład:
echo "$HOME" #wydrukuje /home/ja
aby wyłączyć interpretacje przez powłokę tej zmiennej, trzeba napisać:
echo \$HOME #i jest napis $HOME
4 Zmienne
4.1 Zmienne programowe (ang. program variables)
To zmienne definiowane samodzielnie przez użytkownika.
nazwa_zmiennej="wartość"
6 / 29
Systemy operacyjne Cwiczenie 7.2
Na przykład:
x="napis"
Do zmiennej odwołujemy się poprzez podanie jej nazwy poprzedzonej znakiem $ i tak dla
zmiennej x może to wyglądać następująco:
echo $x
Na co należy uważać? Nie może być spacji po obu stronach!
x = "napis"
ten zapis jest błędny .
Pod zmienną możemy podstawić wynik jakiegoś polecenia, można to zrobić na dwa sposoby:
" Poprzez użycie odwrotnych apostrofów:
`polecenie`
Przykład:
#!/bin/bash
GDZIE_JESTEM=`pwd`
echo "Jestem w katalogu $GDZIE_JESTEM"
Wartością zmiennej GDZIE_JESTEM jest wynik działania polecenia pwd, które wypisze
nazwę katalogu w jakim się w danej chwili znajdujemy.
" Za pomocą rozwijania zawartości nawiasów:
$(polecenie)
Przykład:
#!/bin/bash
GDZIE_JESTEM=$(pwd)
echo "Jestem w katalogu $GDZIE_JESTEM"
4.2 Zmienne specjalne (ang. special variables, special parameters)
To najbardziej prywatne zmienne powłoki, są udostępniane użytkownikowi tylko do odczytu (są
wyjątki). Kilka przykładów:
" $0
nazwa bieżącego skryptu lub powłoki
Przykład:
#!/bin/bash
echo "$0"
Pokaże nazwę naszego skryptu.
" $1..$9
Parametry przekazywane do skryptu (wyjątek, użytkownik może modyfikować ten rodzaj $-
ych specjalnych.
#!/bin/bash
7 / 29
Systemy operacyjne Cwiczenie 8
echo "$1 $2 $3"
Jeśli wywołamy skrypt z jakimiś parametrami to przypisane zostaną zmiennym: od $1 do
$9.
" $@
Pokaże wszystkie parametry przekzywane do skryptu (też wyjątek), równoważne $1 $2 $3...,
jeśli nie podane są żadne parametry $@ interpretowana jest jako nic.
Przykład:
#!/bin/bash
echo "Skrypt uruchomiono z parametrami: $@"
A teraz wywołaj ten skrypt z jakimiś parametrami, mogą być brane z powietrza np.:
./plik -a d
Efekt będzie wyglądał następująco:
Skrypt uruchomiono z paramertami -a d
" $?
kod powrotu ostanio wykonywanego polecenia
" $$
PID procesu bieżącej powłoki
4.3 Zmienne środowiskowe (ang.environment variables)
Definują środowisko użytkownika, dostępne dla wszystkich procesów potomnych. Można je podzielić
na:
" globalne - widoczne w każdym podshellu
" lokalne - widoczne tylko dla tego shella w którym został ustawione
Aby bardziej uzmysłowić sobie różnicę między nimi zrób mały eksperyment: otwórz xterma
(widoczny podshell) i wpisz:
x="napis"
echo $x
xterm
x="napis" zdefiniowałeś właśnie zmienną x, która ma wartość "napis"
echo $x wyświetli wartość zmiennej x
xterm wywołanie podshella
wpisz więc jeszcze raz:
echo $x nie pokaże nic, bo zmienne lokalne nie są widoczne w podshellach
Możesz teraz zainicjować zmienną globalną:
export x="napis"
Teraz zmienna x będzie widoczna w podshellach, jak widać wyżej służy do tego polecenie export,
nadaje ono wskazanym zmiennym atrybut zmiennych globalnych. Jeśli napiszesz samo export,
opcjonalnie export -p uzyskasz listę aktualnie eksportowanych zmiennych. Na tej liście przed nazwą
każdej zmiennej znajduje się zapis:
declare-x
To wewnętrzne polecenie BASH-a, służące do definiowania zmiennych i nadawania im
atrybutów, -x to atrybut eksportu czyli jest to, to samo co polecenie export. Ale tu uwaga! Polecenie
8 / 29
Systemy operacyjne Cwiczenie 7.2
declare występuje tylko w BASH-u, nie ma go w innych powłokach, natomiast export występuje w
ksh, ash i innych, które korzystają z plików startowych /etc/profile. Dlatego też zaleca się stosowanie
polecenia export.
export -n zmienna
spowoduje usunięcie atrybutu eksportu dla danej zmiennej
Niektóre przykłady zmiennych środowiskowych:
$HOME #ścieżka do twojego katalogu domowego
$USER #twój login
$HOSTNAME #nazwa twojego hosta
$OSTYPE #rodzaj systemu operacyjnego
itp. dostępne zmienne srodowiskowe można wyświetlić za pomoca polecenia:
printenv | more
4.4 Zmienne tablicowe
BASH pozwala na stosowanie zmiennych tablicowych jednowymiarowych. Czym jest tablica? To
zmienna która przechowuje listę jakichś wartości (rozdzielonych spacjami), w BASH'u nie ma
maksymalnego rozmiaru tablic. Kolejne wartości zmiennej tablicowej indexowane są przy pomocy
liczb całkowitych, zaczynając od 0.
Składnia
zmienna=(wartość1 wartość2 wartość3 wartośćn)
Przykład:
#!/bin/bash
tablica=(element1 element2 element3)
echo ${tablica[0]}
echo ${tablica[1]}
echo ${tablica[2]}
Zadeklarowana została zmienna tablicowa o nazwie: tablica, zawierająca trzy wartości: element1
element2 element3. Natomiast polecenie: echo ${tablica[0]} wydrukuje na ekranie pierwszy
elementu tablicy. W powyższym przykładzie w ten sposób wypisana zostanie cała zawartość tablicy.
Do elementów tablicy odwołujemy się za pomocą wskaz
ników.
" Odwołanie do elementów tablicy.
Składnia:
${nazwa_zmiennej[wskaz
nik]}
Wskaz
nikiami są indexy elementów tablicy, począwszy od 0 do n oraz @, *. Gdy odwołując
się do zmiennej nie podamy wskaz
nika: ${nazwa_zmiennej} to nastąpi odwołanie do elementu
tablicy o indexie 0.Jeśli wskaz
nikiem będą: @ lub * to zinterpretowane zostaną jako wszytskie
elementy tablicy, w przypadku gdy tablica nie zawiera żadnych elemntów to zapisy:
${nazwa_zmiennej[wskaz
nik]} lub ${nazwa_zmiennej[wskaz
nik]} są interpretowane jako nic.
Przykład:
Poniższy skrypt robi to samo co wcześniejszy.
9 / 29
Systemy operacyjne Cwiczenie 8
#!/bin/bash
tablica=(element1 element2 element3)
echo ${tablica[*]}
Można też uzyskać długość (liczba znaków) danego elementu tablicy:
${#nazwa_zmiennej[wskaz
nik]}
Przykład:
#!/bin/bash
tablica=(element1 element2 element3)
echo ${#tablica[0]}
Polecenie echo ${#tablica[0]} wydrukuje liczbę znaków z jakich składa się pierwszy element
tablicy: element1 wynik to 8. W podobny sposób można otrzymać liczbę wszystkich elementów
tablicy, wystarczy jako wskaz
nik podać: @ lub *.
Przykład:
#!/bin/bash
tablica=(element1 element2 element3)
echo ${#tablica[@]}
Co da wynik: 3.
" Dodawanie elementów do tablicy.
Składnia:
nazwa_zmiennej[wskaz
nik]=wartość
Przykład:
#!/bin/bash
tablica=(element1 element2 element3)
tablica[3]=element4
echo ${tablica[@]}
Jak wyżej widać do tablicy został dodany element4 o indexie 3. Mechanizm dodawania
elementów do tablicy, można wykorzystać do tworzenia tablic, gdy nie istnieje zmienna tablicowa do
której dodajemy jakiś element, to BASH automatycznie ją utworzy:
#!/bin/bash
linux[0]=slackware
linux[1]=debian
echo ${linux[@]}
Utworzona została tablica linux zawierająca dwa elementy.
" Usuwanie elementów tablic i całych tablic.
Dany element tablicy usuwa się za pomocą polecenia unset.
Składnia:
unset nazwa_zmiennej[wskaz
nik]
Przykład:
#!/bin/bash
10 / 29
Systemy operacyjne Cwiczenie 7.2
tablica=(element1 element2 element3)
echo ${tablica[@]}
unset tablica[2]
echo ${tablica[*]}
Usunięty został ostatni element tablicy.
Aby usunąć całą tablicę wystarczy podać jako wskaz
nik: @ lub *.
#!/bin/bash
tablica=(element1 element2 element3)
unset tablica[*]
echo ${tablica[@]}
Zmienna tablicowa o nazwie tablica przestała istnieć, polecenie: echo ${tablica[@]} nie
wyświetli nic.
5 Strumienie danych
Każdy uruchomiony w Linuxie proces skądś pobiera dane, gdzieś wysyła wyniki swojego
działania i komunikaty o błędach. Tak więc procesowi przypisane są trzy strumienie danych:
stdin (ang. standard input) czyli standardowe wejście, skąd proces pobiera dane, domyślnie jest
to klawiatura
stdout (ang. standard otuput) to standardowe wyjście, gdzie wysyłany jest wynik działania
procesu, domyślnie to ekran
stderr (ang. standard error) standardowe wyjście błędów, tam trafiają wszystkie komunikaty o
błędach, domyślnie ekran
Rysunek 1 Strumienie danych
Linux wszystko traktuje jako plik, niezależnie od tego czy to jest plik zwykły, katalog, urządzenie
blokowe (klawiatura, ekran) itd. Nie inaczej jest ze strumieniami, BASH identyfikuje je za pomocą
przyporządkowanych im liczb całkowitych ( od 0 do 2 ) tak zwanych deskryptorów plików.
I tak:
0 to plik z którego proces pobiera dane stdin
1 to plik do którego proces pisze wyniki swojego działania stdout
2 to plik do którego trafiają komunikaty o błędach stderr
Za pomocą operatorów przypisania można manipulować strumieniami, poprzez przypisanie
deskryptorów: 0, 1, 2 innym plikom, niż tym reprezentującym klawiaturę i ekran.
Przełączanie standardowego wejścia
Zamiast klawiatury jako standardowe wejście można otworzyć plik:
< plik
Przykład:
Najpierw stwórzmy plik lista o następującej zawartości:
slackaware
11 / 29
Systemy operacyjne Cwiczenie 8
redhat
debian
caldera
Użyjemy polecenia sort dla którego standardowym wejściem będzie nasz plik.
sort < lista
Wynikiem będzie wyświetlenie na ekranie posortowanej zawartość pliku lista:
caldera
debian
redhat
slackware
Przełączanie standardowego wyjścia
Wynik jakiegoś polecenia można wysłać do pliku, a nie na ekran, do tego celu używa się
operatora:
> plik
Przykład:
ls -la /usr/bin > ~/wynik
Rezultat działania polecenia ls -la /usr/bin trafi do pliku o nazwie wynik, jeśli wcześniej nie
istniał plik o takiej samej nazwie, to zostanie utworzony, jeśli istniał cała jego poprzednia
zawartość zostanie nadpisana.
Jeśli chcemy aby dane wyjściowe dopisywane były na końcu pliku, bez wymazywania jego
wcześniejszej zawartości, stosujemy operator:
>> plik
Przykład:
free -m >> ~/wynik
Wynik polecenia free -m (pokazuje wykorzystanie pamięci RAM i swap'a) zostanie dopisany na
końcu pliku wynik, nie naruszając jego wcześniejszej zawartości.
Przełączanie standardowego wyjścia błędów
Do pliku można też kierować strumień diagnostyczny:
2> plik
Przykład:
#!/bin/bash
echo "Stderr jest skierowane do pliku error"
ls -y 2< ~/error #błąd
W powyższym skrypcie polecenie ls jest użyte z błędną opcją -y, komunikat o błędzie trafi do
pliku error.
Za pomocą operatora:
<< plik
można dopisać do tego samego pliku kilka komunikatów o błędach, dopisanie kolejnego nie
spowoduje skasowania wcześniejszej zawartości pliku.
Przykład:
#!/bin/bash
echo "Stderr jest skierowane do pliku error"
ls -y 2< ~/error #błąd
12 / 29
Systemy operacyjne Cwiczenie 7.2
cat /etc/shadow 2< ~/error #błąd2
Jako błąd drugi zostanie potraktowane polecenie cat /etc/shadow (zakładając, że zalogowałeś się
jako użytkownik) ponieważ prawo odczytu pliku /etc/shadow ma tylko root.
6 Instrukcje
6.1 Instrukcja warunkowa if
Sprawdza czy warunek jest prawdziwy, jeśli tak to wykonane zostanie polecenie lub polecenia
znajdujące się po słowie kluczowym then. Instrukcja kończy się słowem fi.
Składnia:
if warunek
then
polecenie
fi
Przykład:
#!/bin/bash
if [ -e ~/.bashrc ]
then
echo "Masz plik .bashrc"
fi
Najpierw sprawdzany jest warunek: czy istnieje w twoim katalogu domowym plik .bashrc, zapis
~/ oznacza to samo co /home/twój_login lub $HOME. Jeśli sprawdzany warunek jest prawdziwy to
wyświetlony zostanie napis Masz plik .bashrc. W przeciwnym wypadku nic się nie stanie.
W sytuacji gdy test warunku zakończy się wynikiem negatywnym można wykonać inny zestaw
poleceń, które umiesczamy po słowie kluczowym else:
Składnia:
if warunek
then
polecenie1
else
polecenie2
fi
Przykład:
#!/bin/bash
if [ -e ~/.bashrc ]
then
echo "Masz plik.bashrc"
else
echo "Nie masz pliku .bashrc"
fi
Jeśli warunek jest fałszywy skrypt poinformuje Cię o tym.
Można też testować dowolną ilość warunków, jeśli pierwszy warunek nie będzie prawdziwy,
sprawdzony zostanie następny, kolejne testy warunków umieszczamy po słowie kluczowym elif.
Składnia:
if warunek
then
polecenie1
elif warunek
polecenie2
13 / 29
Systemy operacyjne Cwiczenie 8
fi
Przykład:
#!/bin/bash
if [ -x /opt/kde/bin/startkde ]; then
echo "Masz KDE w katalogu /opt"
elif [ -x /usr/bin/startkde ]; then
echo "Masz KDE w katalogu /usr"
elif [ -x /usr/local/bin/startkde ]; then
echo "Masz KDE w katalogu /usr/local"
else
echo "Nie wiem gdzie masz KDE"
fi
Ten skrypt sprawdza gdzie masz zainstalowane KDE, sprawdzane są trzy warunki, najpierw czy
plik wykonywalny startkde znajduje się w katalogu /opt/kde/bin jeśli go tam nie ma, szukany jest w
/usr/bin, gdy i tu nie występuje sprawdzany jest katalog /usr/local/bin.
6.2 test jak się sprawdza warunki?
Służy do tego polecenie test. (Uwaga! Nie można skryptom nadawać nazwy test! Nie będą
działać.)
Składnia:
test wyrażenie1 operator wyrażenie2
lub może być zapisane w postaci nawiasów kwadratowych:
[ wyrażenie1 operator wyrażenie2 ]
Uwaga! Między nawiasami a treścią warunku muszą być spacje, tak jak powyżej.
Polecnie test zwraca wartość 0 (true) jeśli warunek jest spełniony i wartość 1 (false) jeśli warunek
nie jest spełniony. A gdzie jest umieszczana ta wartość? W zmiennej specjalnej $?.
A to kilka przykładów operatorów polecenia test:
" -a plik istnieje
" -b plik istnieje i jest blokowym plikiem specjalnym
" - plik istnieje i jest plikiem znakowym
" -e plik istnieje
" -h plik istnieje i jest linkiem symbolicznym
" = sprawdza czy wyrażenia są równe
" != sprawdza czy wyrażenia są różne
" -n wyrażenie ma długość większą niż 0
" -d wyrażenie istnieje i jest katalogiem
" -z wyrażenie ma zerową długość
" -r można czytać plik
" -w można zapisywać do pliku
" -x można plik wykonać
" -f plik istnieje i jest plikiem zwykłym
" -p plik jest łączem nazwanym
" -N plik istnieje i był zmieniany od czasu jego ostatniego odczytu
" plik1 -nt plik2 plik1 jest nowszy od pliku2
" plik1 -ot plik2 plik1 jest starszy od pliku2
" -lt mniejsze niż
" -gt większe niż
" -ge większe lub równe
" -le mniejsze lub równe
Więcej przykładów operatorów w: man bash.
14 / 29
Systemy operacyjne Cwiczenie 7.2
6.3 Instrukcja case
Pozwala na dokonanie wyboru spośród kilku wzorców. Najpierw sprawdzana jest wartość
zmiennej po słowie kluczowym case i porównywana ze wszystkimi wariantami po kolei. Oczywiście
musi być taka sama jak wzorzec do którego chcemy się odwołać. Jesli dopasowanie zakończy się
sukcesem wykonane zostanie polecenie lub polecenia przypisane do danego wzorca. W przeciwnym
wypadku użyte zostanie polecenie domyślne oznaczone symbolem gwiazdki: *) polecenie_domyślne.
Co jest dobrym zabezpieczeniem na wypadek błędów popełnionych przez użytkownika naszego
skrytpu.
Składnia:
case zmienna in
"wzorzec1") polecenie1 ;;
"wzorzec2") polecenie2 ;;
"wzorzec3") polecenie3 ;;
*) polecenie_domyślne
esac
Przykład:
#!/bin/bash
echo "Podaj cyfrę dnia tygodnia"
read d
case "$d" in
"1") echo "Poniedziałek" ;;
"2") echo "Wtorek" ;;
"3") echo "Środa" ;;
"4") echo "Czwartek" ;;
"5") echo "Piątek" ;;
"6") echo "Sobota" ;;
"7") echo "Niedziela" ;;
*) echo "Nic nie wybrałeś"
esac
Jak widać mamy w skrypcie wzorce od 1 do 7 odpowiadające liczbie dni tygodnia, każdemu
przypisane jest jakieś polecenie, tutaj ma wydrukować na ekranie nazwę dnia tygodnia. Jeśli podamy 1
polecenie read czytające dane ze standardowego wejścia przypisze zmiennej d wartość 1 i zostanie
wykonany skok do wzorca 1, na ekranie zostanie wyświetlony napis Poniedziałek. W przypadku gdy
podamy cyfrę o liczbie większej niż 7 lub wpiszemy inny znak na przykład literę to wykonany
zostanie wariant defaultowy oznaczony gwiazdką:
*) echo "Nic nie wybrałeś".
7 Pętle
7.1 Pętla for
Wykonuje polecenia zawarte wewnątrz pętli, na każdym składniku listy (iteracja).
Składnia:
for zmienna in lista
do
polecenie
done
Przykład:
for x in jeden dwa trzy
do
echo "To jest $x"
done
15 / 29
Systemy operacyjne Cwiczenie 8
Zmiennej x przypisana jest lista, która składa się z trzech elementów: jeden, dwa, trzy. Wartośćią
zmiennej x staje się po kolei każdy element listy, na wszystkich wykonywane jest polecenie: echo "To
jest $x". Pętla for jest bardzo przydatna w sytuacjach, gdy chcemy wykonać jakąś operację na
wszystkich plikach w danym katalogu. Na przykład chcemy uzyskać listę wszystkich plików o danym
rozszerzeniu znajdujących się w jakimś katalogu, robimy to tak:
#!/bin/bash
for x in *html
do
echo "To jest plik $x"
done
lub jeśli chcemy zmienić nazwy plików pisane DUŻYMI literami na nazwy pisane małymi
literami:
#!/bin/bash
for nazwa in *
do
mv $nazwa `echo $nazwa tr '[A-Z]' '[a-z]'`
done
Za zmianę DUŻYCH liter na małe (i na odwrót) odpowiedzialne jest polecenie tr.
7.2 Pętla select
Wygeneruje z listy słów po in proste ponumerowane menu, każdej pozycji odpowiada kolejna
liczba od 1 wzwyż. Poniżej menu znajduje się znak zachęty PS3 gdzie wpisujemy cyfrę
odpowiadająca wybranej przez nas pozycji w menu. Jeśli nic nie wpiszemy i wciśniemy ENTER,
menu będzie wyświetlone ponownie. To co wpisaliśmy zachowywane jest w zmiennej REPLY. Gdy
odczytane zostaje EOF (ang. End Of File) czyli znak końca pliku (CTRL+D) to select kończy pracę.
Pętla działa dotąd dopóki nie wykonane zostaje polecenie break lub return.
Składnia:
select zmienna in lista
do
polecenie
done
Od razu nasuwa się możliwość zastosowania wewnątrz niej instrukcji case:
#!/bin/bash
echo "Co wybierasz?"
select y in X Y Z Quit
do
case $y in
"X") echo "Wybrałeś X" ;;
"Y") echo "Wybrałeś Y" ;;
"Z") echo "Wybrałeś Z" ;;
"Quit") exit ;;
*) echo "Nic nie wybrałeś"
esac
break
done
Najpierw zobaczymy proste ponumerowane menu, składające się z czterech elementów: X, Y, Z i
Quit, teraz wystarczy tylko wpisać numer inetersującej nas opcji, a resztę zrobi instrukcja case.
Polecenie break, które znajduje się w przedostatniej linii skryptu, kończy pracę pętli.
16 / 29
Systemy operacyjne Cwiczenie 7.2
A teraz bardziej praktyczny przykład, poniższy skrypt (Uwaga!) przeznaczony dla dystrybucji
Slackware wygeneruje menu składające się z listy Window Mangerów, po wybraniu konkretnej
pozycji uruchomiony zostanie dany WM. Oczywiście należy skrypt zmodyfikować pod kątem
własnego systemu. Jeśli komuś odpowiada takie rozwiązanie, wystarczy utworzyć alias: alias
startx="~/.ten_skrypt" i po ponownym zalogowaniu mamy po wpisaniu polecenia startx menu
wyboru Window Managerów.
#!/bin/bash
echo ""
echo "[ JAKI WINDOW MANAGER URUCHOMIĆ? WYBIERZ CYFR
Z
LISTY: ]"
echo ""
select l in BLACKBOX ENLIGHTENMENT GNOME ICEWM KDE MWM
OPENWIN TWM WMAKER WYJŚCIE
do
case "$l" in
"BLACKBOX") cat /etc/X11/xinit/xinitrc.blackbox >
~/.xinitrc; startx $@ ;;
"ENLIGHTENMENT") cat /etc/X11/xinit/xinitrc.e >
~/.xinitrc; startx $@ ;;
"GNOME") cat /etc/X11/xinit/xinitrc.gnome >
~/.xinitrc; startx $@ ;;
"ICEWM") cat /etc/X11/xinit/xinitrc.icewm >
~/.xinitrc; startx $@ ;;
"KDE") cat /etc/X11/xinit/xinitrc.kde > ~/.xinitrc;
startx $@ ;;
"MWM") cat /etc/X11/xinit/xinitrc.mwm > ~/.xinitrc;
startx $@ ;;
"OPENWIN") cat /etc/X11/xinit/xinitrc.openwin >
~/.xinitrc; startx $@ ;;
"TWM") cat /etc/X11/xinit/xinitrc.twm > ~/.xinitrc;
startx $@ ;;
"WMAKER") cat /etc/X11/xinit/xinitrc.wmaker >
~/.xinitrc; startx $@ ;;
"WYJŚCIE") exit ;;
*) startx $@
esac
break
done
Elementy składowe listy w pętli select, noszą takie same nazwy jak wzorce w instrukcji case co
umożliwia wykonanie skoku do danego wzorca i wykonania poleceń jemu przypisanych. Jak to
wygląda w praktyce? Na przykład chcemy uruchomić KDE, wybieramy więc z menu opcje o wyżej
wymienionej nazwie, następnie polecenie cat nadpisuje nasz domowy plik .xinitrc, kopiując do niego
zawartość pliku xinitrc zoptymalizowanego dla KDE, znajdującego się w katalogu:
/etc/X11/xinit/xinitrc.kde, po czym wykonywane jest polecenie startx. Zmienna $@ to zmienna
specjalna umożliwiająca przekazywanie do skryptu parametrów (startx to też skrypt powłoki), dzięki
czemu możemy spokojnie stosować wszelkie parametry np. dwukrotne odpalenie X-ów: startx -- :0 na
pierwszej konsoli i startx -- :1 na drugiej. Gdy nie wpiszemy żadnych parametrów $@ jest pusta. A co
się stanie w przypadku gdy podczas wyboru Window Managera podamy większą cyfrę niż tą jaką ma
ostatni element menu lub jakiś inny znak? Uruchomiony zostanie ten WM, który ostatnio odpalaliśmy.
Ten sam skrypt przeznaczony dla dystrybucji Red Hat W tym przypadku polecenie: echo "exec
window_manager" nadpisuje plik .XClients znajdujący się w naszym katalogu home. Z aliasem
postępujemy analogicznie jak w powyższym przykładzie.
#!/bin/bash
17 / 29
Systemy operacyjne Cwiczenie 8
echo ""
echo "[ JAKI WINDOW MANAGER URUCHOMIĆ? WYBIERZ CYFR
Z
LISTY: ]"
echo ""
select l in BLACKBOX ENLIGHTENMENT GNOME ICEWM KDE MWM
OPENWIN TWM WMAKER WYJŚCIE
do
case "$l" in
"BLACKBOX") echo "exec blackbox" > ~/.XClients;
startx $@ ;;
"ENLIGHTENMENT") echo "exec enligtenment" >
~/.XClients; startx $@ ;;
"GNOME") echo "exec gnome-session" > ~/.XClients;
startx $@ ;;
"ICEWM") echo "exec icewm" > ~/.XClients; startx $@
;;
"KDE") echo "exec startkde" > ~/.XClients; startx $@
;;
"MWM") echo "exec mwm" > ~/.XClients; startx $@ ;;
"OPENWIN") echo "exec openwin" > ~/.XClients; startx
$@ ;;
"TWM") echo "exec twm" > ~/.XClients; startx $@ ;;
"WMAKER") echo "exec wmaker" > ~/.XClients; startx $@
;;
"WYJŚCIE") exit ;;
*) startx $@
esac
break
done
7.3 Pętla while
Najpierw sprawdza warunek czy jest prawdziwy, jeśli tak to wykonane zostanie polecenie lub lista
poleceń zawartych wewnątrz pętli, gdy warunek stanie się fałszywy pętla zostanie zakończona.
Składnia:
while warunek
do
polecenie
done
Przykład:
#!/bin/bash
x=1;
while [ $x -le 10 ]; do
echo "Napis pojawił się po raz: $x"
x=$[x + 1]
done
Sprawdzany jest warunek czy zmienna x o wartości początkowej 1 jest mniejsza lub równa 10,
warunek jest prawdziwy w związku z czym wykonywane są polecenia zawarte wewnątrz pętli: echo
"Napis pojawił się po raz: $x" oraz x=$[x + 1], które zwiększa wartość zmiennej x o 1. Gdy wartość x
przekroczy 10, wykonanie pętli zostanie przerwane.
18 / 29
Systemy operacyjne Cwiczenie 7.2
7.4 Pętla until
Sprawdza czy warunek jest prawdziwy, gdy jest fałszywy wykonywane jest polecenie lub lista
poleceń zawartych wewnątrz pętli, miedzy słowami kluczowymi do a done. Pętla until kończy swoje
działanie w momencie gdy warunek stanie się prawdziwy.
Składnia:
until warunek
do
polecenie
done
Przykład:
#!/bin/bash
x=1;
until [ $x -ge 10 ]; do
echo "Napis pojawił się po raz: $x"
x=$[x + 1]
done
Mamy zmienną x, która przyjmuje wartość 1, następnie sprawdzany jest warunek czy wartość
zmiennej x jest większa lub równa 10, jeśli nie to wykonywane są polecenia zawarte wewnątrz pętli.
W momencie gdy zmienna x osiągnie wartość, 10 pętla zostanie zakończona.
8 Pobieranie danych
8.1 Polecenie read
Czyta ze standardowego wejścia pojedynczy wiersz.
Składnia:
read -opcje nazwa_zmiennej
Przykład:
#!/bin/bash
echo -n "Wpisz coś:\a"
read wpis
echo "$wpis"
To co zostało wpisane trafi do zmiennej wpis, której to wartość czyta polecenie read wpis,
zmienna nie musi być wcześniej tworzona, jeśli istniała wcześniej, jej zawartość zostanie zastąpiona
tym co wpisaliśmy.
Przykład:
#!/bin/bash
echo "Wpisz coś:"
answer="napis"
read
echo "$answer"
Wcześniejsza wartość zmiennej answer została zastąpiona.
Polecenie read pozwala na przypisanie kilku wartości kilku zmiennym.
19 / 29
Systemy operacyjne Cwiczenie 8
Przykład:
#!/bin/bash
echo "Wpisz cztery wartości:"
read a b c
echo "Wartość zmiennej a to: $a"
echo "Wartość zmiennej b to: $b"
echo "Wartość zmiennej c to: $c"
Nie przypadkiem w powyższym przykładzie pojawiło się polecenie wpisania czterech wartości,
pierwsza wartość trafi do zmiennej a, druga do zmiennej b, natomiast trzecia i czwarta oraz
rozdzielające je znaki separacji przypisane zostaną zmiennej c.
Wybrane opcje:
" p
Pokaże znak zachęty bez kończącego znaku nowej linii.
#!/bin/bash
read -p "Pisz:" odp
echo "$odp"
" a
Kolejne wartości przypisywane są do kolejnych indeksów zmiennej tablicowej.
Przykład:
#!/bin/bash
echo "Podaj elementy zmiennej tablicowej:"
read tablica
echo "${tablica[*]}"
" e
Jeśli nie podano żadnej nazwy zmienej, wiersz trafia do $REPLY.
Przykład:
#!/bin/bash
echo "Wpisz coś:"
read -e
echo "$REPLY"
9 Funkcje
Coś w rodzaju podprogramów. Stosuje się je gdy w naszym skrypcie powtarza się jakaś grupa
poleceń, po co pisać je kilka razy, skoro można to wszystko umieścić w funkcjach. Do danej funkcji
odwołujemy się podając jej nazwę, a wykonane zostanie wszystko co wpisaliśmy między nawiasy { },
skraca to znacznie długość skryptu.
Składnia:
function nazwa_funkcji
{
polecenie1
polecenie2
polecenie3
}
Przykład:
#!/bin/bash
20 / 29
Systemy operacyjne Cwiczenie 7.2
function napis
{
echo "To jest napis"
}
napis
Nazwę funkcji umieszczamy po słowie kluczowym function, w powyższym przykładzie mamy
funkcje o nazwie napis, odwołujemy się do niej podając jej nazwę, wykonane zostaną wtedy
wszystkie polecenia, jakie jej przypiszemy.
Funkcje moga się znajdować w innym pliku, co uczyni nasz skrypt bardziej przejrzystym i
wygodnym, tworzy się własne pliki nagłówkowe, wywołuje się je tak:
. ~/naszplik_z_funkcjami
nazwa_funkcji
Trzeba pamiętać o podaniu kropki + spacja przed nazwą pliku
Przykład:
#!/bin/bash
function nasza_funkcja
{
echo -e 'Właśnie użyłeś funkcji o nazwie
"nasza_funkcja".\a'
}
Teraz pozostało jeszcze utworzyć skrypt w którym wywołamy funkcje: nasza_funkcja:
#!/bin/bash
echo "Test funkcji."
. funkcja
nasza_funkcja
10 Interpretacja wyrażeń arytmetycznych.
Kiedy zachodzi potrzeba przeprowadzenia jakichś obliczeń można skorzystać z mechanizmu
interpretacji wyrażeń arytmetycznych, obliczenia dokonywane są na liczbach całkowitych, nie
przeprowadzana jest kontrola przepełnienia (ang. overflow).
Składnia:
$((wyrażenie)) lub $[wyrażenie]
Przykład:
#!/bin/bash
echo $((8/2))
wynik=$[4*5/2]
echo "$wynik"
W ten sposób (przykład poniżej) można ponumerować listę:
#!/bin/bash
for pliki_html in $(ls *.html)
do
numer=$((numer+1))
echo "$numer. "
echo $pliki_html
done
21 / 29
Systemy operacyjne Cwiczenie 8
Wynikiem będzie ponumerowana lista wszystkich plików o rozszerzeniu .html, znajdujących się
w bieżącym katalogu.
Polecenie let
Do przeprowadzenia obliczeń można też skorzystać z polecenia let.
Przykład:
#!/bin/bash
liczba1=5
liczba2=6
let wynik=liczba1*liczba2
echo $wynik
11 Okna dialogowe
Dialog
Czyli okna w skryptach shellowych za pomocą, których możemy tworzyć listy wyboru, zadawać
pytania i pobierać dane od użytkownika czy też informować go o przebiegu jakichś operacji, które
skrypt w danej chwili wykonuje.
Składnia:
dialog opcje okno_dialogowe
Lista okien dialogowych:
" yesno
" menu
" inputbox
" textbox
" infobox
" checklist
" radiolist
" gauge
Opcje:
--clear czyści ekran
--createrc plik Możemy użyć tej opcji do wygenerowania przykładowego pliku
konfiguracyjnego.
--separate-output Tą opcję stosuje się przy widgetach checklist, drukuje wyjście w osobnych
liniach, co umożliwia przetwarzanie uzyskanych danych przez inny program.
--title Tytuł, na górze okna dialogowego.
--backtitle Podtytuł, w tle okna dialogowego, znajduje się w lewym górnym rogu ekranu.
11.1 Okno yesno
Stosuje się je gdy chcemy zadać użytkownikowi pytanie na które musi odpowiedzieć tak lub nie.
Użytkownik zobaczy okno dialogowe z dwoma przyciskami: yes i no między którymi może się
przełączać za pomocą przycisku TAB lub strzałek.
Składnia:
--yesno tekst wysokość szerokość
Tak wygląda kod:
#!/bin/bash
22 / 29
Systemy operacyjne Cwiczenie 7.2
dialog --title "Okno yesno" \
--backtitle "Kurs programowania w shellu" \
--yesno "Wybierz tak lub nie." 5 30
11.2 Okno menu
Jak nazwa wskazuje służy do prezentowania listy wyborów w postaci menu. Podaje się nazwę
elementu i jego opis. Pierwsza litera elementu jest skrótem, równie dobrze mogą to być cyfry.
Użytkownik może wybrać tylko jedną pozycję. Wyświetlanych jest tyle wpisów ile jest podanych jako
wysokość_menu, jeśli, jest ich więcej lista będzie przewijana. Posiada przyciski ok i cancel.
Składnia:
--menu tekst wysokość szerokość wysokość_menu element opis
Tak wygląda kod:
#!/bin/bash
dialog --title "Okno menu" \
--backtitle "Kurs programowania w shellu" \
--menu "Memu" 9 50 3 \
1 jeden \
2 dwa \
3 trzy \
4 cztery
11.3 Okno checklist
Podobne do menu, z tą różnicą iż można zaznaczać lub odznaczać wiele wpisów naraz (za pomocą
krzyżyka). Niektóre wpisy mogą być domyślnie włączane za pomocą ustawienia status na on. Okno
checklist posiada przyciski ok i cancel. Na stderr drukowana jest lista elementów, które zostały
wybrane.
Składnia:
--checklist tekst wysokość szerokość wysokość_listy
Tak wygląda kod:
#!/bin/bash
dialog --clear --separate-output --title "Okno checklist"
\
23 / 29
Systemy operacyjne Cwiczenie 8
--backtitle "Kurs programowania w shellu" \
--checklist \
"Tu można zaznaczać wiele wpisów naraz:" 10 70 4 \
"1" "pierwszy element" "off" \
"2" "drugi element" "off" \
"3" "trzeci element" "off" \
"Cztery" "tu zaznaczone domyślnie" "on" \
2> wynik
11.4 Okno radiolist
Okno radiolist różni się od okna menu tylko tym, że możesz zaznaczyć krzyżykiem (wskazanie
jego statusu na on), który element menu wybierasz.
Składnia:
--radiolist tekst wysokość szerokość wysokość_listy
Tak wygląda kod:
#!/bin/bash
dialog --clear \
--title "Okno radiolist" \
--backtitle "Kurs programowania w shellu" \
--radiolist "Można zaznaczyć tylko jeden wpis:" 10 70 4 \
"1" "pierwszy element" "off" \
"2" "drugi element" "off" \
"3" "trzeci element" "off" \
"4" "czwarty element" "off"
11.5 Okno inputbox
Za pomocą okna inputbox można pobierać od użytkownika jakieś dane, jeśli chcesz aby pojawił
się domyślnie jakis napis, (np. Tu wpisz dane) podaj go jako parametr init. Pobrane dane zostaną
wydrukowane na standardowym wyjściu błędów.
Składnia:
--inputbox tekst wysokość szerokość
Tak wygląda kod:
#!/bin/bash
dialog --title "Okno inputbox" \
--backtitle "Kurs programowania w shellu" \
24 / 29
Systemy operacyjne Cwiczenie 7.2
--inputbox "Pobieranie danych od użytkownika" 8 40 "Tu
wpisz dane"
11.6 Okno msgbox
Okno msgbox służy do wyświetlania komunikatów (na przykład: informacje o tym co skrypt robi,
pomoc itp.) ma tylko jeden przycisk ok.
Składnia:
--msgbox tekst wysokość szerokość
Tak wygląda kod:
#!/bin/bash
dialog --title "Okno msgbox" \
--backtitle "Kurs programowania w shellu" \
--msgbox "Tutaj można wstawić jakikolwiek tekst, na
przykład informacje o tym co skrypt robi,
pomoc, itp." 7 45
11.7 Okno infobox
Podobne do msgbox, jednak nie ma żadnego przycisku, dialog skończy działanie po wyświetleniu
danej informacji. Ekran nie jest czyszczony, wiadomość zostaje na ekranie dopóki skrypt jej nie
wyczyści, często stosowane gdy skrypt wykonuje jakąś dłuższą operacje, a my chcemy poinformować
użytkownika o jej przebiegu.
Składnia:
--infobox tekst wysokość szerokość
Tak wygląda kod:
#!/bin/bash
dialog --title "Okno infobox" \
--backtitle "Kurs programowania w shellu" \
--infobox "Tu można poinformować użytkownika o przebiegu
jakiejś
operacji, która trwa dłużej, uspokoić go że wszystko w
porządku." 5 58
11.8 Okno textbox
Wyświetla zawartość pliku tekstowego w oknie
Składnia:
--textbox plik wysokość szerokość
Tak wygląda kod:
#!/bin/bash
25 / 29
Systemy operacyjne Cwiczenie 8
dialog --title "Okno textbox" \
--backtitle "Kurs prgramowania w shellu" \
--textbox text 5 40
12 Przykłady skryptów
#!/bin/sh
# Jestem sobie komentarzem
# nie zmieniaj pierwszej linii !!! - musi tam być
echo "To jest system: `uname -a`" # użyj wyjścia polecenia uname
echo "Nazywam się $0" # zmienne wbudowane
echo "Podałeś mi następujące $# parametry: "$*
echo "Pierwszy parametr to: "$1
echo -n "Jak się nazywasz? " ; read imie
echo spójrz na róznicę: "Cześć $imie" # cytowanie z "
echo spójrz na różnicę: 'Cześć $imie' # cytowanie z '
DIRS=0 ; FILES=0
for file in `ls .` ; do
if [ -d ${file} ] ; then # jeśli plik jest katalogiem
DIRS=`expr $DIRS + 1` # DIRS = DIRS + 1
elif [ -f ${file} ] ; then
FILES=`expr $FILES + 1`
fi
case ${file} in
*.gif|*jpg) echo "${file}: plik graficzny" ;;
*.txt|*.tex) echo "${file}: plik tekstowy" ;;
*.c|*.f|*.for) echo "${file}: plik żródłowy" ;;
*) echo "${file}: inny plik" ;;
esac
done
echo "Jest ${DIRS} katalogów i ${FILES} plików"
ls | grep "ZxY--!!!WKW"
if [ $? != 0 ] ; then # kod wyjścia ostatniego polecenia
echo "ZxY--!!!WKW nie znaleziono"
fi
echo "wystarczy... jeśli chcesz wiedzieć więcej, to poczytaj"
echo "podręcznik systemowy""
Polecenia BASHA moża łączyć ze sobą tworząc skrypty, które dodatkowo mogą zawierać np.
wyrażenia logiczne oraz odwoływać się do innych aplikacji.
Skrypt przykładowy 1 - Generator wizytówki - skrypt BASHA, który pobierze dane takie jak
Imię i Nazwisko, adres Email i numer GG i zapisze do pliku. Oto kod:
#!/bin/bash
echo 'Witaj w generatorze wizytówek v. 13.666'
echo '#####################################'
echo 'Program poprosi cię o wpisanie różnych danych.'
26 / 29
Systemy operacyjne Cwiczenie 7.2
echo 'Po wpisaniu wciśnij Enter by przejść dalej.'
echo '#####################################'
echo 'Podaj swoje Imię i Nazwisko:'
read name
echo 'Podaj swój adres E-Mail:'
read mail
echo 'Podaj numer Gadu-Gadu:'
read gg
echo '#####################################'
echo 'Pobieranie danych zakończone'
touch wizytowka.txt
echo "$name" >> wizytowka.txt
echo "Email: $mail" >> wizytowka.txt
echo "Gadu-Gadu $gg" >> wizytowka.txt
echo 'Generowanie wizytówki zakończone'
echo 'Plik wizytowka.txt gotowy!'
echo '#####################################'
Wykonanie skryptu będzie wyglądać np. tak:
Witaj w generatorze wizytówek v. 13.666
#####################################
Program poprosi cię o wpisanie różnych danych.
Po wpisaniu wciśnij Enter by przejść dalej.
#####################################
Podaj swoje Imię i Nazwisko:
Piotr M
Podaj swój adres E-Mail:
[e-mail]
Podaj numer Gadu-Gadu:
123456
#####################################
Pobieranie danych zakończone
Generowanie wizytówki zakończone
Plik wizytowka.txt gotowy!
I stworzy plik wizytowka.txt o zawartości:
Piotr M
Email: [e-mail]
Gadu-Gadu 123456
Przy okazji >> dopisuje dane do pliku więc wielokrotne wywołanie skryptu nie nadpisze danych...
Parametry wywołania Wiele aplikacji przyjmuje parametry, np. ls -a. Bardzo prosto parametry te
"przechwycić".
#!/bin/bash
echo "Nazwa skryptu to: $0"
echo '------------------------------------'
echo "Nazwa pierwszego argumentu to: $1"
echo '------------------------------------'
echo "Wszystkie argumenty: $*"
echo '------------------------------------'
echo "Podałeś $# poleceń"
Wywołanie ./a2.sh polecenie1 polecenie2 polecenie3 wyświetli:
27 / 29
Systemy operacyjne Cwiczenie 8
Nazwa skryptu to: ./a2.sh
------------------------------------
Nazwa pierwszego argumentu to: polecenie1
------------------------------------
Wszystkie argumenty: polecenie1 polecenie2 polecenie3
------------------------------------
Podałeś 3 poleceń
$0 - nazwa skryptu, $n - wartość n-tego parametru, $* - wszystkie parametry, $# - liczba poleceń.
Skrypt przykładowy 2 - Generator wizytówki z wyborem pliku
#!/bin/bash
echo 'Witaj w generatorze wizytówek v. 13.666'
echo '#####################################'
echo 'Program poprosi cię o wpisanie różnych danych.'
echo 'Po wpisaniu wciśnij Enter by przejść dalej.'
echo '#####################################'
echo 'Podaj swoje Imię i Nazwisko:'
read name
echo 'Podaj swój adres E-Mail:'
read mail
echo 'Podaj numer Gadu-Gadu:'
read gg
echo '#####################################'
echo 'Pobieranie danych zakończone'
touch $1
echo "$name" >> $1
echo "Email: $mail" >> $1
echo "Gadu-Gadu $gg" >> $1
echo 'Generowanie wizytówki zakończone'
echo "Plik $1 gotowy!"
echo '#####################################'
Skrypt wywołujemy: skrypt.sh plik1.txt plik2.txt - z nazwami plików jako parametry.
#!/bin/bash
powtorka = "tak"
while [ "$powtorka"==tak ]
do
echo -n $powtorka
echo 'Witaj w generatorze wizytówek v. 13.666'
echo '#####################################'
echo 'Program poprosi cię o wpisanie różnych danych.'
echo 'Po wpisaniu wciśnij Enter by przejść dalej.'
echo '#####################################'
echo 'Podaj swoje Imię i Nazwisko:'
read name
echo 'Podaj swój adres E-Mail:'
read mail
echo 'Podaj numer Gadu-Gadu:'
read gg
echo '#####################################'
echo 'Pobieranie danych zakończone'
touch $1
28 / 29
Systemy operacyjne Cwiczenie 7.2
echo "$name" >> $1
echo "Email: $mail" >> $1
echo "Gadu-Gadu $gg" >> $1
echo 'Generowanie wizytówki zakończone'
echo "Plik $1 gotowy!"
echo '#####################################'
echo 'Wpisz "tak" jeżeli chcesz dodać kolejny wpis'
read powtorka
done
Zródła:
http://www.linux.rk.edu.pl/
http://www.gentoo.org/doc/pl/articles/
http://www.republika.pl/dief/
Dodatkowe informacje obowiązujące na ćwiczeniach
Skrypt UŚ- M. J. Bargielski   Systemy operacyjne
 Rozdział 11.2  System Operacyjny Unix   Interpreter poleceń
29 / 29