Bash w przykładach - część pierwsza

1.  Podstawy programowania w Bourne again shell (bash)

Wprowadzenie

Dlaczego powinniśmy uczyć się programowania w bashu? Poniżej znajduje się kilka powodów:

Bash już działa w naszym systemie

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?

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.

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 znaleźć 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.

Zmienne środowiskowe

Korzystając z basha (i prawie wszystkich innych powłok), użytkownik może definiować zmienne środowiskowe, które tworzone są wewnętrznie jako łańcuchy znaków ASCII. Jedną z najbardziej przydatnych właściwości zmiennych środowiskowych jest to, że są one standardową częścią modelu działania UNIX-a. Oznacza to, że zmienne środowiskowe są dostępne nie tylko dla skryptów shella, ale również mogą zostać wykorzystane przez skompilowane programy. Gdy wyeksportujemy zmienną środowiskową, każdy uruchomiony program będzie mógł odczytać nasze ustawienia, niezależnie od tego czy jest to skrypt shella czy nie. Dobrym przykładem jest tu użycie komendy vipw, która pozwala użytkownikowi root edycję plików systemowych z hasłami. Poprzez ustawienie w zmiennej środowiskowej EDITOR nazwy ulubionego edytora, możemy skonfigurować vipw, aby korzystało w niego zamiast z vi. Jest to przydatne jeśli nie lubimy vi lub wolimy używać innego edytora.

Standardowym sposobem zdefiniowania zmiennej środowiskowej w bashu jest wpisanie komendy:

$ myvar='To moja zmienna środowiskowa!'

Powyższa komenda definiuje zmienną środowiskową o nazwie "myvar", zawierającą łańcuch "To moja zmienna środowiskowa!". Należy zwrócić uwagę na kilka kwestii: po pierwsze, nie ma żadnych białych znaków (spacja, znak tabulacji) po obu stronach znaku =; jakakolwiek przewra spowoduje błąd. Druga sprawa to możliwość pominięcia znaków cudzysłowu w sytuacji, gdy przypisujemy zmiennej jako wartość jedno słowo (ciąg niezawierający białych znaków). Cudzysłów jest konieczny, jeśli wartość zmiennej zawiera więcej niż jedno słowo.

Po trzecie, o ile zazwyczaj możemy używać podwójnych znaków cudzysłowu zamiast pojedynczych, próba dokonania tego w powyższym przykładzie spowoduje błąd. Dlaczego? Ponieważ podwójne znaki cudzysłowu umożliwiają bashowi dokonanie ekspansji, podczas której specjalne znaki i sekwencje znaków zostają zastąpione odpowiednimi wartościami. Na rzykład znak "!" jest symbolem ekspansji historii basha i zazwyczaj zostaje zastąpiony ostatnio wpisaną komendą (w tej serii artykułów nie opiszemy możliwości ekspansji historii, ponieważ nie jest to często wykorzytywana właściwość basha; więcej informacji na ten temat można uzyskać w sekcji "HISTORY EXPANSION" na stronie man basha). Funkcje te (nazywane funkcjami macro) mogą być bardzo pomocne, jednak w tym momencie zależy nam na umieszczeniu prostego literału na końcu zmiennej środowiskowej.

Teraz zobaczmy w jaki sposób można korzystać ze zmiennych środowiskowych. Oto przykład:

$ echo $myvar
To moja zmienna środowiskowa!

Poprzez poprzedzenie nazwy zmiennej środowiskowej znakiem $, nakazujemy powłoce bash zastąpienie tego wywołania wartością zmiennej. W terminologii basha nazywane jest to ekspansją zmiennych. Jednak co się stanie jeśli spróbujemy wykonać komendę:

$ echo foo$myvarbar
foo

Chcieliśmy uzyskać na wyjściu napis "fooTo moja zmienna środowiskowa!bar", jednak polecenie nie powiodło się. Co poszło źle? Ekspansja zmiennych nie była w stanie poprawnie zadziałać. Nie było możliwe określenie czy chcemy dokonać ekspansji zmiennej $,m ,$my, $myvar, $myvrbar czy jeszcze jakiejś innej. Musimy bardziej precyzyjnie określić o jaką zmienną nam chodzi. Spróbujmy wykonać polecenie:

$ echo foo${myvar}bar
fooTo moja zmienna środowiskowa!bar

Jak widać, możemy objąć nazwę zmiennej środowiskowej nawiasami klamrowymi, gdy nie jest ona oddzielona od otaczającego ją tekstu w inny sposób. Podczas gdy "$myvar" jest szybsze do wpisania i będzie poprawnie działać w większości przypadków, "${myvar}" zostanie właściwie zinterpretowane w prawie każdej sytuacji. Obie formy dają taki sam efekt i obie będą wykorzystywane w dalszej części artykułu. Należy zapamiętać, że gdy nazwa zmiennej środowiskowej nie jest oddzielona od otaczającego tekstu białymi znakami, należy ująć ją w nawiasy klamrowe.

Wspomnieliśmy wcześniej, że możliwe jest wyeksportowanie zmiennych. Gdy tego dokonujemy, zmienna staje się automatycznie dostępna dla wszystkich działających programów i skryptów. Te drugie mogą uzyskać dostęp do zmiennych środowiskowych poprzez ich obsługę wbudowaną w powłokę. Natomiast programy w języku C mogą skorzystać z funkcji getenv(). Poniżej znajduje się przykładowy kod źródłowy, który warto przekopiować do pliku i skompilować - pozwala on na zrozumienie zagadnienia zmiennych środowiskowych z perspektywy języka C.

#include <stdio.h>
#include <stdlib.h>

int main(void) {
  char *myenvvar=getenv("EDITOR");
  printf("Zmienna środowiskowa EDITOR posiada wartość %s\n",myenvvar);
}

Zapiszmy powyższy kod źródłowy w pliku o nazwie myenv.c i skompilujmy do przy użyciu komendy:

$ gcc myenv.c -o myenv

Teraz w aktualnym katalogu znajduje się program, który po uruchomieniu wyświetli wartość zmiennej środowiskowej EDITOR, jeśli została ona określona. Na moim komputerze daje to efekt:

$ ./myenv
Zmienna środowiskowa EDITOR posiada wartość (null)

Ponieważ wartość zmiennej środowiskowej EDITOR nie została określona, program otrzymuje pusty łańcuch. Spróbujmy ustawić wartość dla zmiennej EDITOR i jeszcze raz uruchomić program:

$ EDITOR=xemacs
$ ./myenv
Zmienna środowiskowa EDITOR posiada wartość (null)

Choć mogło wydawać się, że program wypisze wartość "xemacs", ponownie zwrócił on wartość pustą. Stało się tak, ponieważ nie wyeksportowaliśmy zmiennej EDITOR. Tym razem powinno się udać:

$ export EDITOR
$ ./myenv
Zmienna środowiskowa EDITOR posiada wartość xemacs

Na tym przykładzie widzimy, że inne procesy (w tym przypadku nasz program w języku C) nie widzą zmiennych środowiskowych nim nie zostaną one wyeksportowane. Zdefiniowania i wyeksportowania zmiennej środowiskowej można dokonać przy użyciu jednej komendy:

$ export EDITOR=xemacs

Działa to identycznie jak dwie oddzielne komendy. Przyszedł czas na przedstawienie sposoby na usunięcie wartości zmiennej środowiskowej przy użyciu polecenia unset:

$ unset EDITOR
$ ./myenv
Zmienna środowiskowa EDITOR posiada wartość (null)

Przegląd sposobów rozrywania łańcuchów

Rozrywanie łańcuchów - dzielenie ich na mniejsze, oddzielne fragmenty - jest jednym z tych zadań, które jest wykonywane każdego dnia przez skrypty powłoki. Wiele razy sprypt pobiera pełną ścieżkę, aby określić nazwę wykonywanego pliku lub katalogu, w którym się on znajduje. Podczas gdy jest możliwe (i przyjemne!) napisanie tego w bashu, standardowa komenda UNIX-a basename radzi sobie w tej sytuacji idealnie:

$ basename /usr/local/share/doc/foo/foo.txt
foo.txt
$ basename /usr/home/drobbins
drobbins

basename jest bardzo przydatnym narzędziem do dzielenia łańcuchów. Jego przeciwieństwo, czyli dirname zwraca pozostałą część ściżki, którą odrzuca basename:

$ dirname /usr/local/share/doc/foo/foo.txt
/usr/local/share/doc/foo
$ dirname /usr/home/drobbins/
/usr/home

Podstawianie komend

Inną bardzo przydatną umiejętnością jest przekazanie rezultatu wykonania komendy do zmiennej środowiskowej. Jest to bardzo proste do zrobienia:

$ MYDIR=`dirname /usr/local/share/doc/foo/foo.txt`
$ echo $MYDIR
/usr/local/share/doc/foo

To co zrobiliśmy powyżej nazywane jest podstawianiem komend. Warto zwrócić tutaj uwagę na kilka rzeczy. W pierwszej linii objeliśmy podstawianą komendę odwróconymi apostrofami. Nie jest to zwykły pojedynczy cudzysłów, ale symbol, który na klawiaturze znajduje się zazwyczaj na przyciskiem tabulacji (na tym samym klawiszu co tylda). Możemy wykonać dokładnie to samo działanie przy użyciu alternatywnej składni podstawiania poleceń basha:

$ MYDIR=$(dirname /usr/local/share/doc/foo/foo.txt)
$ echo $MYDIR
/usr/local/share/doc/foo

Jak widać bash dostarcza wielu sposobów na wykonanie dokładnie tych samych działań. Używając podstawiania komend możemy umieścić dowolną komendę lub strumień komend pomiędzy znakami ` ` lub $( ) i przypisać dzięki temu ich wynik do zmiennej środowiskowej. To bardzo przydatna właściwość! Poniżej znajduje się przykład wykorzystania podstawiania komend w odniesieniu do strumieni:

$ MYFILES=$(ls /etc | grep pa)
$ echo $MYFILES
pam.d passwd

Zaawansowane rozrywanie łańcuchów

basename i dirname to bardzo przydatne narzędzia, jednak może zdarzyć się tak, że będziemy potrzebować bardziej zaawansowanych funkcji dzielenia łańchuchów, niż zwykłe manipulacje na ścieżkach. W takiej sytuacji możemy skorzystać z zaawansowanych możliwości basha w dziedzinie ekspansji zmiennych. Używaliśmy już standardowego sposobu ekspansji zmiennych, który ma postać ${MYVAR}. Bash oferuje jednak kilka przydatnych spsobów rozrywania zmiennych poddawanych ekspansji. Popatrzmy na następujące przykłady:

$ MYVAR=foodforthought.jpg
$ echo ${MYVAR##*fo}
rthought.jpg
$ echo ${MYVAR#*fo}
odforthought.jpg

W pierwszym przykładzie nakazaliśmy wyświetlenie efektu działnia ekspansji zdefiniowanej jako ${MYVAR##*fo}. Co dokładnie oznacza tego typu ekspansja zmiennej? Wewnątrz ${ } wpisaliśmy nazwę zmiennej środowiskowej, znaki ## i wyrażenie *fo. Bash odnalazł w zmiennej MYVAR najdłuższy ciąg znaków pasujący do wyrażenia *fo i usunął go z początku łańcucha. Jest to nieco trudne do zrozumienia za pierwszym razem, więc aby poznać działanie znaków ## przyjrzyjmy się w jaki sposób bash przeprowadził tą ekspansję. Zaczął on sprawdzać od początku łańcuch "foodforthought.jpg" w poszukiwaniu fragmentów, które pasują do wyrażenia .*fo. Oto kolejne etapy sprawdzania zmiennej środowiskowej:

f
fo              ODPOWIADA *fo
foo
food
foodf
foodfo          ODPOWIADA *fo
foodfor
foodfort
foodforth
foodfortho
foodforthou
foodforthoug
foodforthought
foodforthought.j
foodforthought.jp
foodforthought.jpg

Jak widać, bash znalazł dwa fragmenty odpowiadające naszemu wyrażeniu. Wykorzystanie znaków ## podczas ekspansji zmiennej nakazuje wybranie najdłuższego z pasujących ciągów. Gdy został on prawidłowo zidentyfikowany, bash usunął go z początku zmiennej i zwrócił pozostałą część.

Drugi przykład ekspansji zmiennej jest taki sam jak pierwszy poza wykorzystaniem pojedynczego znaku #, zamiast dwóch takich znaków w pierwszym przypadku. Bash przeprowadza tutaj niemal identyczny proces. Sprawdzane są te same fragmenty łańcucha co poprzednio, jednak z początku zmiennej usunięty zostaje najkrótszy ciąg pasujący do wyrażenia *fo. Więc gdy tylko bash sprawdzi fragment "fo", usuwa go i zwraca "odforthought.jpg".

Początkowo trudnym do zapamiętania może wydawać się kiedy korzystamy z #, a kiedy z ##. Istnieje prosty sposób aby to przyswoić. Szukając najdłuższego fragmentu łańcuch, używamy ##, bo jest dłuższe niż #. Analogicznie najkrótszy fragment odnajdziemy przy użyciu #. Jednak w jaki sposób zapamiętać, że # usunie znaki z początku zmiennej? Bardzo prosto - na klawiaturach typu us wciśnięcie shift+4 daje znak $, symbolizyjący ekspansję zmiennych. Na lewo od tego znaku na klawiaturze znajduje się znak #. Widać że # jest "na początku" $, więc służy on do usuwania znaków z początku zmiennej. Jeśli zastanawiamy się w jaki sposób usunąć znaki z końca łańcucha wystarczy spojrzeć na prawo od znaku $ na klawiaturze - służy do tego znak %. Poniżej kilka przykładów jego wykorzystania:

$ MYFOO="chickensoup.tar.gz"
$ echo ${MYFOO%%.*}
chickensoup
$ echo ${MYFOO%.*}
chickensoup.tar

Jak widać, opcje ekspansji zmiennych % i %% działają tak, jak # oraz ##, jednak usuwają pasujący do podanego wyrażenia fragment zmiennej z jej końca. Należy przy tym pamiętać, że nie jest konieczne użycie znaku *, jeśli chcemy usunąć ściśle określony fragment zmiennej.

MYFOOD="chickensoup"
$ echo ${MYFOOD%%soup}
chicken

W tym przypadku nie ma znaczenia czy użyjemy %% czy %, gdyż tylko jeden fragment odpowiada podanemy wyrażeniu. Jeśli nie będziemy pamiętali czy powinniśmy użyć # czy %, można spojrzeć na klawisze 3, 4, 5 - układ znaków symbolicznie odpowiada funkcjom przez nie pełnionym.

Ekspansja zmiennych pozwala także na pobranie określonego przez nas fragmentu łańcucha, na podstawie indeksu pierwszego znaku jaki ma znaleźć się w wycinku i jego długości. Spróbujmy wprowadzić następujące komendy:

$ EXCLAIM=cowabunga
$ echo ${EXCLAIM:0:3}
cow
$ echo ${EXCLAIM:3:7}
abunga

Ten sposób dzielenia łańcuchów może okazać się bardzo przydatny. Wystarczy podać indeks znaku od którego zacznie się tworzenie wycinka (pierwszy znak ma indeks 0 - jak w pierwszym przykładzie) i ilość znaków jaką ma on zawierać (wszystkie informacje rozdzielone dwukropkami).

Implementacja rozrywania łańcuchów

Gdy poznaliśmy sposoby rozrywania łańcuchów, napiszmy prosty skrypt. Nasz skrypt będzie przyjmował jeden argument w postaci nazwy pliku i wyświetlał informacje czy jest to tarball czy też nie. Plik jest tarballem, jeśli na końcu jego nazwy znajduje się ciąg ".tar". Oto skrypt:

#!/bin/bash

if [ "${1##*.}" = "tar" ]
then
       echo Plik jest tarballem.
else
       echo Na pierwszy rzut oka plik nie wygląda na tarballa.
fi

Aby wykonać skrypt, należy skopiwać jego kod do pliku mytar.sh i wykonać komendę chmod 755 mytar.sh, co nada mu prawo do wykonywania. Następnie wykonujemy skrypt jak poniżej:

$ ./mytar.sh thisfile.tar
Plik jest tarballem.
$ ./mytar.sh thatfile.gz
Na pierwszy rzut oka plik nie wygląda na tarballa.

Skrypt działa, jednak nie jest zbyt funkcjonalny. Zanim sprawimy, że stanie się on bardziej przydatny, przyjrzyjmy się konstrukcji if w kodzie skryptu. Znajduje się w niej wyrażenie typu boolean. W bashu operator porównania = sprawdza czy łańcuchy po obu jego stronach są takie same. Wszystkie wyrażenia typu boolean należy umieszczać w nawiasach kwadratowych. Co dokładnie jest obiektem wyrażenia typu boolean? Popatrzmy na jego lewą stronę. Zgodnie z tym czego się do tej pory nauczyliśmy, konstrukcja ${1##*.} usunie z początku łańcucha, znajdującego się w zmiennej środowiskowej 1, najdłuższy fragment pasujący do wzorca *. i zwróci pozostałą jego część. Otrzymamy w ten sposób znaki snajdujące się po ostatniej kropce. Oczywiste jest, że jeśli nazwa pliku kończy się ciągiem ".tar", wynikiem tej operacji będzie ciąg "tar", który w porównaniu z p-wartością (wartością po prawej stronie operatora porównania) da wynik całego wyrażenia w postaci prawdy.

Być może nie jest do końca jasne czym tak naprawdę jest zmienna środowiskowa o nazwie 1. To bardzo proste - $1 to pierwszy argument skryptu podany w wierszu poleceń, $2 to drugi argument itd. Przeanalizowaliśmy już wyrażenie typu boolean, jakie pojawiło się z naszym skrypcie. Przyjrzyjmy się teraz bliżej konstrukcji if.

Konstrukcja if

Jak większość języków, bash ma swoje własne konstrukcje warunkowe. Podczas ich używania należy trzymać się formatu jaki pokazano w przykładzie powyżej: if oraz then muszą znajdować się w oddzielnych liniach, ponadto te słowa kluczowe oraz else i fi (które musi znaleźć się na końcu każdej konstrukcji warunkowej), należy wyrównać w ten sam sposób. Czyni to kod łatwiejszym do czytania i debugowania. Poza podstawową formą "if,else", konstrukcja warunkowa może przyjmować bardziej złożone postacie.

if      [ warunek ]
then
        akcja
fi

Konstrukcja if w takiej formie wykona jakąś akcję tylko jeśli warunek jest prawdziwy, w przeciwnym razie nie zostaną podjęte żadne czynności i wykonanie skryptu będzie kontynuowane w liniach po kończącym fi.

if [ warunek ]
then
        akcja
elif [ warunek2 ]
then
        akcja2
.
.
.
elif [ warunek3 ]
then
        akcja3
else
        akcjax
fi

Zastosowana powyżej formuła elif będzie sprawdzać kolejne warunki i wykona akcje odpowiadające pierwszemu warunkowi, który zostanie określony jako prawdziwy. Gdy żaden z warunków nie będzie prawdziwy, wykonane zostaną akcje z sekcjielse, jeśli taka występuje (w powyższym przykadzie występuje). Po tych czynościach wykonanie skryptu będzie kontynuowane w liniach znajdujących się po całej konstrukcji "if,elif,else".

Kolejna część kursu

Kiedy poznaliśmy już podstawowe funkcjonalności basha, czas podnieść poprzeczkę i przygotować się do pisania prawdziwych skryptów. W drugim artykule z tej serii przedstawimy pętle, funkcje, przestrzenie nazw i inne fundamentalne zagadnienia. Dzięki temu będziemy gotowi do pisania bardziej złożonych skryptów. Trzeci (i zarazem ostatni) artykuł tego kursu skupia się niemal wyłącznie na skomplikowanych skryptach i funkcjach, a także na opisie kilku strategii projektowych.

2.  Zasoby informacji

Przydatne linki

• Bash w przykładach - część druga.
• Bash w przykładach - część trzecia.
• Strona GNU bash