Powłoka BASH
################################################################
################# MeGa BASH - Powłoka BASH #####################
######### Executor(TomILm82) POLITECHNIKA CZ
STOCHOWSKA #######
################################################################
ARTUKUA
POCHODZI Z MOJEJ KOLEKCJI - Udostępniony przez RedMan Cz-Wa
1. BASH - Bourne Again Shell
a. Interpreter poleceń powłoki BASH
b. Dokańczanie poleceń
c. Historia poleceń
d. Aliasy
e. Symbole wieloznaczne
f. Znak zachęty
g. Ścieżki przeszukiwania
h. Konfiguracja powłoki
i. ZarzÄ…dzanie zadaniami
2. Wprowadzenie do tworzenia skryptów dla bash`a
a. Nieśmiertelne Hello World!
b. Słowa zastrzeżone (ang. reserved words)
c. Cytowanie
d. Zmienne programowe (ang. program variables)
e. Zmienne specjalne (ang. special variables, special parameters)
f. Zmienne środowiskowe (ang.environment variables)
g. Nazwy zmiennych w cudzysłowach
h. Używanie nawiasów klamrowych do ochrony nazw zmiennych
i. Strumienie danych
j. Instrukcja warunkowa if
k. Polecenie test
l. Instrukcja case
m. Pętla for
n. Pętla while
o. Pętla until
p. Funkcje
q. Przykładowe skrypty
1. BASH - Bourne Again Shell
a. Interpreter poleceń powłoki BASH
Powłoka systemu operacyjnego to program, który udostępnia interfejs pomiędzy użytkownikiem a jądrem systemu; ma on postać
wiersza poleceń. Jądro systemu zawiera wszelkie podprogramy potrzebne do przeprowadzania operacji wejścia i wyjścia,
zarządzania plikami itp. Powłoka pozwala korzystać z tych podprogramów za pomocą wiersza poleceń. Bash jest domyślną
powłoką użytkownika w Linuksie. Zawiera 48 wbudowanych poleceń (biult-in) oraz 12 funkcji wywołania.
b. Dokańczanie poleceń
Dokańczanie poleceń jest bardzo wygodną i przyspieszającą pracę opcją powłoki Bash. Dzięki niej nie musimy wpisywać pełnej
nazwy programu (ścieżki do katalogu, pliku itp.) lub znać jego dokładnej nazwy. Wystarczy, że wpiszemy jego pierwszą literkę i
wciśniemy klawisz TAB. Wtedy Linux spróbuje wyszukać wszystkie dostępne programy, katalogi, pliki, których pierwsza litera
nazwy odpowiada wpisanej przez nas. Jeśli więcej programów zaczyna się na tę sam znak powłoka wylistuje nam ich nazwy i
poinformuje nas za pomocą brzęczyka, że należy podać dodatkowe informacje.
c. Historia poleceń
Bash zapamiętuje wydane przez użytkownika polecenia. Dzięki temu za pomocą klawiszy kursora (góra - dół), możemy szybko
przywołać polecenie, które już wcześniej wydaliśmy. Jest to szczególnie przydatne gdy w bardzo skomplikowanym poleceniu
zmieniamy np. tylko nazwę pliku, na którym ma zostać wykonane, a cała składnia polecenia nie ulega modyfikacjom. Lista
wydanych przez nas poleceń jest ładowana z pliku historii, który domyślnie nosi nazwę .bash_history. Aby obejrzeć na ekranie
dostępne z historii polecenia wystarczy użyć polecenia:
history liczba_poleceń
d. Aliasy
Aliasy są to skróty, które przyspieszają naszą pracę z powłoką. Jeśli np. codziennie uaktualniamy naszą stronę główną, której plik
startowy to /home/artur/linux/index.html to zamiast ciągle wpisywać mcedit /home/artur/linux/index.html możemy utworzyć do
niego alias po wywołaniu którego otworzony zostanie do edycji ten właśnie plik. Nasz alias będzie nosił nazwę linux i właśnie to
słowo będziemy mogli wpisać, aby wywołać do edycji plik index.html.
alias linux='mcedit /home/artur/linux/index.html'
Warto pamiętać, że utworzone z linii poleceń aliasy stają się nieaktualne po wylogowaniu się z powłoki.
e. Symbole wieloznaczne
Powłoka bash obsługuje trzy rodzaje symboli wieloznaczych. Są to: *, które zastępuje dowolny znak lub ich ciąg, ? - zastępuje
dowolny znak (tylko jeden) oraz [...], które zastępuje dowolny znak występujący pomiędzy nawisami. Symbole wieloznaczne
wykorzystywane są najczęściej do wykonywania tego samego polecenia na różnych plikach, bądz
katalogach. Jeśli chcemy
skopiować wszystkie pliki zawarte w katalogu linux do katalogu linux-kopia wystarczy wydać polecenie:
cp linux/* linux-kopia/
Następny symbol wieloznaczny (?) zastępuje pojedynczy znak. Wydając polecenie:
cp plik?.txt linux/
spowodujemy, że zostaną skopiowane wszystkie pliki, których nazwa brzmi plik[jakiś symbol], np. plik5, pliks.
Aby określić szczegółowo jakie pliki mają być kopiowane użyjemy trzeciego symbolu wieloznacznego [...]. Przypuśćmy, że w
katalogu mamy pliki: plik1, plik2, plik3 i plik4. Chcemy skopiować tylko pliki z numerami 1,2 i 3. Wydajemy zatem polecenie:
cp plik[123].txt linux/ lub cp plik[1-3].txt linux/
f. Znak zachęty
Znak zachęty to tekst, który informuje użytkownika, że system czeka na wprowadzenie przez niego danych. W powłoce bash
istnieją dwa poziomy znaku zachęty - pierwszy, który otrzymamy zaraz po zalogowaniu informuje nas, że system czeka na
wprowadzenie polecenia. Drugi poziom jest wyświetlany gdy interpreter potrzebuje dodatkowych danych, które musimy
wprowadzić. Jest on przechowywany w zmiennej PS2 i standardowo ma postać ">". Jeśli wydamy polecenie:
export PS1="To mój komputer"
wtedy nasz znak zachęty będzie wyglądał: To mój komputer.
Standardową zmienną PS1 ma postać: PS1="[\u@\h \W]\\$ ".
Pierwszy znak [ - jest znakiem statycznym, dzięki niemu dane przedstawione są w estetycznej formie, kod \u wyświetla
identyfikator użytkownika, @ to następny znak statyczny, \h pokazuje nazwę komputera, a \W wyświetla podstawową nazwę
katalogu. Następnie znak ] zamyka nawias, a po nim następuje kod \$, który wyświetla znak # gdy jesteśmy zalogowani jako root,
lub $ gdy jako zwykły user. Spacje są znakami wyświetlanymi na ekranie.
zapis PS1="[\u@\h \W]\\$ " po przetworzeniu: [root@nazwa /root]#
Lista kodów specjalnych, które mogą zostać użyte do konfiguracji znaku zachęty:
\! - wyświetla numer polecenia historii \# - wyświetla numer aktualnego polecenia, \$ - wyświetla # dla root`a i $ dla zwykłego
użytkownika \\ - wyświetla znak \ \d - wyświetla datę \t - wyświetla czas \h - wyświetla nazwę komputera \n - przechodzi do
nowego wiersza \nnn - wyświetla znak, który odpowiada wartości ósemkowej nnn \s - wyświetla nazwę powłoki \u - wyświetla
login użytkownika \W - wyświetla podstawową nazwę bieżącego katalogu \w - wyświetla nazwę bieżącego katalogu
g. Ścieżki przeszukiwania
Zmienna PATH jest zmienną środowiskową. Wykorzystywana jest do przechowywania ścieżki przeszukiwania, czyli listy
katalogów, w których należy szukać plików wykonywalnych w przypadku, gdy nie zostanie podana pełna ścieżka dostępu do nich.
Poszczególne katalogi wchodzące w skład zmiennej PATH oddziela się od siebie dwukropkami.
np. /bin:/usr/bin:/usr/X11R6/bin
Aby dodać jakiś katalog do zmiennej PATH używamy operatora $, który umożliwia odniesienie do poprzedniej wartości a następnie
dołączeniu nowego elementu.
Export PATH=$PATH:nowy_katalog
h. Konfiguracja powłoki
Edycja czy dodawanie nowych zmiennych środowiskowych za pomocą wiersza poleceń jest rozwiązaniem prawidłowym ale
wprowadzane zmiany nie mają charakteru stałego tzn. nie będą aktywne po następnym zalogowaniu się. Można jednak ustawić je w
plikach konfiguracyjnych tak by były odczytywane podczas każdego uruchamiania powłoki (logowania). W przypadku powłoki
bash zmienne można umieścić w plikach /etc/profile, gdy jesteśmy administratorem lub w katalogu użytkownika w pliku o
nazwie .profile lub .bash_profile. Właśnie w nich dodajemy aliasy, zmienne, ścieżki itp.
i. ZarzÄ…dzanie zadaniami
Powłoka Bash oferuje możliwość uruchamiania programów w tle - udostępnia użytkownikowi kontrolę nad systemową
wielozadaniowością.
Najprostszym przykładem jest tzw. puszczenie procesu "w tle". Oznacza to, że uruchamianemu programowi nakazuje się działanie
w ukryciu a użytkownik natychmiast dostaje z powrotem znak zgłoszenia shella. Efekt taki uzyskuje się poprzez postawienie znaku
ampersand (&) na końcu wydawanego polecenia.
Przykład:
$ find /home/user -name '.*' > plikiukryte &
Można też wysłać działający program w tło używając kombinacji klawiszy CTRL+Z, która spowoduje, że program zostanie
zatrzymany, a następnie uruchomimy go w tle wpisując bg. Wydajemy polecenie:
find /usr -name kde* > pliki_z_kde
i wciskamy CTRL+Z. Następnie wpisujemy bg.
Aby ponownie przywrócić program na pierwszy plan skorzystajmy z polecenia fg [numer zadania]. Ponieważ dowolnie możemy
korzystać z bg i fg system musi wiedzieć, na którym procesie ma operować. Polecenie jobs wyświetla listę wszystkich działających
bÄ…dz
zatrzymanych procesach wraz z ich numerem, którego potrzebujemy.
2. Wprowadzenie do tworzenia skryptów dla bash`a
a. Nieśmiertelne Hello World!
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 do niego wpisać:
#!/bin/bash
echo "Hello world"
Znak # 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 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 uruchamiamy:
./naszskrypt
b. 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
[
]
c. Cytowanie
Znaki cytowania służą do usuwania interpretacji znaków specjalnych przez powłokę.
Wyróżniamy następują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, umożliwia zacytowanie polecenia
Przykład:
Kod:
#!/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:
Kod:
#!/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
Przykład:
Kod:
#!/bin/bash
x=`ls -la $PWD`
echo $x #pokaże rezultat polecenia
Alternatywny zapis:
#!/bin/bash
echo $(ls -la $PWD)
backslash czyli znak maskujÄ…cy
\
Przykład:
echo "$HOME" #wydrukuje /home/ja
aby wyłączyć interpretacje przez powłokę tej zmiennej, trzeba napisać:
echo \$HOME #wypisze napis $HOME
d. Zmienne programowe (ang. program variables)
To zmienne definiowane samodzielnie przez użytkownika.
nazwa_zmiennej="wartość"
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
Uwaga ! Nie może być spacji po obu stronach.
x = "napis"
ten zapis jest błędny
cudzysłów, jest potrzebne tylko, gdy w wartości zmiennej znajdują się spacje.
X=hello world # błąd
X="hello world" # OK
Pod zmienną możemy podstawić wynik jakiegoś polecenia, można to zrobić na dwa sposoby:
Poprzez użycie odwrotnych apostrofów:
`polecenie`
Przykład:
Kod:
#!/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:
Kod:
#!/bin/bash
GDZIE_JESTEM=$(pwd)
echo "Jestem w katalogu $GDZIE_JESTEM"
e. 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
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
echo "$1 $2 $3"
Jeśli wywołamy skrypt z jakimiś parametrami to przypisane zostaną zmiennym: od $1 do $9.
$@
Pokaże wszystkie parametry przekazywane do skryptu (też wyjątek), równoważne $1 $2 $3..., jeśli nie
podane są żadne parametry $@ interpretowana jest jako nic.
echo "Skrypt uruchomiono z parametrami: $@"
$?
kod powrotu ostatnio wykonywanego polecenia
$$
PID procesu bieżącej powłoki
Przykład:
Kod:
#wyświetlanie argumentów z wiersza poleceń
#!/bin/bash
if [ $# -eq 0 ]
then
echo "Proszę podać identyfikator uzytkownika w wierszu polecen!"
else
echo "Witaj " $1
fi #koniec instrukcji if
#zmienna $# oznaczająca liczbę parametrów podanych w wierszu poleceń
# operator -eq służy do porównania wartości zmiennej $# z zerem
#zmienna $1 zawiera wartość pierwszego argumentu przekazywanego w
# wierszu poleceń
f. Zmienne środowiskowe (ang.environment variables)
Definiują ś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
Dla uzmysłowienia różnicy między nimi pomoże przykład:
otwórz xterma (widoczny podshell) i wpisz:
x="napis"
echo $x
xterm
x="napis" #zdefiniowanie zmiennej x, która ma wartość "napis"
echo $x #wyświetla wartość zmiennej x
xterm #wywołanie podshella
następnie wpisanie:
echo $x nie pokaże nic, bo zmienne lokalne nie są widoczne w podshellach
Aby zainicjować zmienną globalną piszemy :
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.
Polecenie:
export -n zmienna
spowoduje usunięcie atrybutu eksportu dla danej zmiennej
Niektóre przykłady zmiennych środowiskowych:
$HOME #katalogu domowy użytkownika
$USER #login
$SHELL #nazwa bieżącej powłoki
$PATH #katalog bieżący
itp. dostępne zmienne środowiskowe można wyświetlić za pomocą polecenia:
printenv | more lub set
g. Nazwy zmiennych w cudzysłowach
Niekiedy należy ujmować nazwy zmiennych w cudzysłowy. Jest to istotne, gdy wartość zmiennej
- zawiera spacje
- jest pustym ciÄ…giem.
Na przykład:
Kod:
#!/bin/bash
X=""
if [ -n $X ]; then # -n testuje, czy argument nie jest pusty
echo "Zmienna X nie jest pusta"
fi
Działanie tego da następujący efekt:
Zmienna X nie jest pusta
Stało siętam ponieważ shell zamienia $X na pusty ciąg. Wyrażenie [ -n ] zwraca prawdę (ponieważ nie
dostało żadnego argumentu). Poprawny skrypt powinien wyglądać następująco:
Kod:
#!/bin/bash
X=""
if [ -n "$X" ]; then # -n testuje, czy argument nie jest pusty
echo "Zmienna X nie jest pusta"
fi
W tym przykładzie shell rozwinie wyrażenie do postaci [ -n "" ], co zwraca fałsz, ponieważ ciąg zawarty w
cudzysłowach jest pusty.
h. Używanie nawiasów klamrowych do ochrony nazw zmiennych
Załóżmy, że chcesz wypisać na ekranie zawartość zmiennej X i bezpośrednio za nią litery "abc". Spróbujmy:
Kod:
#!/bin/bash
X=ABC
echo "$Xabc"
Ekran pozostaje pusty; Shell zrozumiał, że chodzi nam o zawartość zmiennej Xabc, która nie została
zainicjalizowana. Nazwę zmiennej należy ująć w nawiasy klamrowe, aby oddzielić ja od innych znaków.
Poniższy kod daje pożądany rezulat.
#!/bin/bash
X=ABC
echo "${X}abc"
i. 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
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
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:
Kod:
#!/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:
Kod:
#!/bin/bash
echo "Stderr jest skierowane do pliku error"
ls -y 2< ~/error #błąd
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.
j. 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:
Kod:
#!/bin/bash
if [ -z $1 ]
then
echo "Musisz podac parametr !!!";
exit 0; # zakończ w tym miejscu prace i wyjdz
fi;
Opcja "-z" sprawdza czy dany parametr jest pusty. Jak tak do wypisz komunikat i wyjdz. Jesli nie to nic nie
zrobi skrypt ponieważ warunek nie jest spełniony. Przejdzie do miejsca fi;
W sytuacji gdy test warunku zakończy się wynikiem negatywnym można wykonać inny zestaw poleceń, które
umieszczamy po słowie kluczowym else:
Składnia:
if warunek
then
polecenie1
else
polecenie2
fi
Przykład:
Kod:
#!/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 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
fi
Przykład:
Kod:
#!/bin/bash
if [ -z $1 ]
then
echo "Muszisz podać nazwe pliku do rozpakowania";
elif [ -f $1 ] #Czy istnieje plik z parametru pierwszego
then
echo "Ok plik istnieje rozpakowywuje";
tar zxpvf $1;
else
echo "Nie ma takiego pliku !!!";
echo "sprawdz czy sie nie pomyliłeś w nazwie";
fi;
k. Polecenie test
Polecenie test zwraca wartość 0 (true) jeśli warunek jest spełniony i wartość 1 (false) jeśli warunek nie jest
spełniony. Wartość ta umieszczana jest w zmiennej specjalnej $?. (Uwaga! Nie można skryptom nadawać
nazwy test)
Składnia:
test wyrażenie1 operator wyrażenie2
lub może być zapisane w postaci nawiasów kwadratowych:
[ wyrażenie1 operator wyrażenie2 ]
Uwaga ! Odstępy są potrzebne, ponieważ pierwszy ciąg bez spacji jest interpretowany jako operator (jeżeli
zaczyna się od '-') lub operand (jeżeli zaczyna się od czegoś innego).
Przykład:
Kod:
if [ 1=2 ]; then
echo "hello"
fi
Daje zły wynik, tzn. wypisuje "hello", ponieważ widzi operand, ale żadnych operatorów.
Przykład:
Kod:
#!/bin/bash
X="-n"
Y=""
if [ $X = $Y ] ; then
echo "X=Y"
fi
Wynik działania tego skryptu będzie bardzo mylący, ponieważ shell rozwinie wyrażenie do postaci
[ -n = ]
a ciąg "=" ma niezerową długość
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
Przykład:
Kod:
#!/bin/bash
X=3
Y=4
empty_string=""
if [ $X -lt $Y ] # czy $X jest mniejsze niż $Y ?
then
echo "\$X=${X} jest większe niż \$Y=${Y}"
fi
if [ -n "$pusty_ciag" ]; then
echo "pusty_ciag nie jest pusty"
fi
l. 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. Musi być taka sama jak wzorzec do
którego chcemy się odwołać. Jeśli 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 skryptu.
Składnia:
case zmienna in
"wzorzec1") polecenie1 ;;
"wzorzec2") polecenie2 ;;
"wzorzec3") polecenie3 ;;
*) polecenie_domyślne
esac
Przykład:
Kod:
#!/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
W skrypcie są 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ś".
Przykład:
Podajemy parametr którym jest plik. Skrypt znajdzie rozszerzenie i w zależności od niego rozpakuje
archiwum gz, tar, bz2.
Kod:
#!/bin/bash
NAZWA=$1; # pobranie nazwy pliku
LICZBA_ZNAKOW=$(ls $NAZWA | wc -c );
START=$(( $LICZBA_ZNAKOW - 3 ));
ROZSZERZENIE=$(ls $NAZWA | cut -b$START-);
case $ROZSZERZENIE in
.tar) tar xpvf $NAZWA;;
.gz) tar zxvf $NAZWA;;
.bz2) tar yxvf $NAZWA;
esac;
ls $NAZWA | wc -c jest to wyświetlenie(ls) pliku $nazwa. | - oznacza przekierowanie dalej (informuje aby
BASH nie wyświetlał efektu polecenia tylko przekazał je dalej). "wc" jest to WordCounter(licznik słow) z
opcją -c wyświetla tylko długość łańcucha wejściowego w tym przypadku jest to nasza NAZWA(pliku). Efekt
dostajemy długość(ilość) znaków naszego pliku.
START - informować nas będzie gdzie zacznie się rozszerzenie pliku. $(()) jest to wyrażenie matematyczne;
odjęcie od LICZBA_ZNAKOW trzech ostatnich dlatego że trzy ostatnie znaki to nasze rozszerzenia tar, .gz,
bz2.
ls $NAZWA | cut -b$START- - przekierowanie nazwy pliku (ls $NAZWA) do polecenia cut. Cut dostaje
parametr -b$START- oznacza on(parametr) że odetnie znaki od $START do końca stringa(łańcucha) "-".
case - dla wartości tar parametru $ROZSZERZENIE wykonaj rozpakowanie dla tar`a itd.
m. 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
Zmiennej x przypisana jest lista, która składa się z trzech elementów: jeden, dwa, trzy. Wartością 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:
Kod:
#!/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:
Kod:
#!/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.
n. 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:
Kod:
#!/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.
Przykład:
Kod:
#!/bin/bash
POCZATEK=$1;
KONIEC=$2;
while [ $POCZATEK -le $KONIEC ]; do
sed -n "$POCZATEK p" $3;
POCZATEK=$(( $POCZATEK + 1));
done;
Wywołanie pętli while dla warunku $POCZATEK <= $KONIEC oznacza wykonuj naszą pętle do momentu
gdy $POCZATEK jest mniejsze lub równe $KONIEC. Jeśli $POCZATEK będzie większe od $KONIEC pętla
przeskoczy do momentu done.
Wywołanie edytora sed -n "$POCZATEK p" $3; oznacza wyświetlenie linii z numerem $POCZATEK z pliku
$3.
POCZATEK=$(( $POCZATEK + 1)) - podstaw za zmienna POCZATEK jej wartość bieżąca + 1.
o. 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:
Kod:
#!/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.
p. Funkcje
Funkcje to coś w rodzaju podprogramów. Stosuje się je gdy w naszym skrypcie powtarza się grupa poleceń.
Wówczas możemy umieścić wszystko w funkcji. Do danej funkcji odwołujemy się podając jej nazwę, co
spowoduje wykonanie poleceń zawartych między nawiasami { }, skraca to znacznie długość skryptu.
Składnia:
function nazwa_funkcji
{
polecenie1
polecenie2
polecenie3
}
Przykład:
Kod:
#!/bin/bash
function witaj
{
echo "Witaj Åšwiecie";
exit 0;
}
function hello
 {
echo "Hello World";
exit 0;
}
OPCJA=$1;
case $OPCJA in
hello) hello ;;
witaj) witaj ;;
esac;
Nazwę funkcji umieszczamy po słowie kluczowym function, w powyższym przykładzie mamy funkcje o
nazwie witaj i hello, 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
Uwaga ! Trzeba pamiętać o podaniu kropki i spacji przed nazwą pliku
q. Przykładowe skrypty
Proste menu
W tym przykładzie menu zrobione na instrukcji case wyświetla trzy opcje plus wyjście. Oparte jest na pętli
until i funkcji.
Kod:
#!/bin/bash
KONIEC="x";
function wybor
{
case $KONIEC in
s) echo "JesteÅ› w katalogu : $(pwd)" ;;
p) echo "teraz wypisze wszystkie twoje procesy";
ps -e ;;
w) echo "Oto lista plików w tym katalogu";
ls ;;
esac;
}
function menu # poczatek menu
{
until [ $KONIEC = k ];do
echo "Wciśnij Enter aby kontynuować";
read;
clear; # czyść ekran
echo $KONIEC;
echo " Proste Menu ";
echo;
echo "s - wyświetl ścieżkę w której znajduje się skrypt.";
echo "p - wyświetl listę procesów użytkownika.";
echo "w - wyświetl wszystkie pliki w tym katalogu.";
echo "k - zakończ skrypt.";
read KONIEC;
wybor;
done;
}
menu;
Dzięki komendzie read możemy wpisywać z klawiatury dane do zmiennych.
1. W menu pętla until sprawdza czy jest spełniony warunek.
2. Zaczyna się funkcja, wyświetla menu i następnie "wchodzi" do funkcji wybor
3. W wybor instrukcja case wybiera naszą opcje i wywołuje ją.
4. Powrót do menu
Dane z pliku
Poniższy skrypt odczytuje parametry z pliku o nazwie dane.dat i wyświetla je na ekranie.
Kod:
#!/bin/bash
NAZWA_P="dane.dat"; # nasz plik baza danych
KOLOR=$(sed -n "1 p" $NAZWA_P); # Odczytuje kolor z pliku
JASNOSC=$(sed -n "2 p" $NAZWA_P); # - || - JASNOSC
echo "Odczytany kolor : $KOLOR";
echo "Odczytana wartość jasności dla koloru : $KOLOR to : $JASNOSC"
Aby przesłać wynik działania komendy basha do zmiennej piszemy:
ZMIENNA=$( komenda_basha )
Dane do pliku
Skrypt tworzy plik dane.dat z poprzedniego zadania i wpisuje tam nasze wartości przy pomocy prostego
przekierowania:
echo "To ma trafić do pliku" > nasz_plik
Kod:
#!/bin/bash
NAZWA_P="dane.dat";
echo "Podaj kolor :";
read KOLOR;
echo "Podaj Jasność w % :";
read JASNOSC;
echo "$KOLOR" > $NAZWA_P
echo "$JASNOSC" >> $NAZWA_P