touch skrypt

#!/bin/bash

#To jest komentarz.

echo "Hello world"

echo "Hello World"

Aby móc uruchomić skrypt należy mu jescze nadać atrybut wykonywalności za pomocą polecenia:

chmod +x skrypt

./naszskrypt

/home/user/skrypt

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

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:

• -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

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
• [
• ]

Znaki cytowania służą do usuwania interpretacji znaków specjalnych przez powłokę.

Wyróżnia się 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:

  #!/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: w celu by na ekranie pojawił się napis $HOME

  Przykład:

  echo "$HOME"                       #wydrukuje /home/ja
  

  aby wyłączyć interpretacje przez powłokę tej zmiennej, należy wpisać:

  echo \$HOME                        #i jest napis $HOME
  

To zmienne definiowane samodzielnie przez użytkownika.

nazwa_zmiennej="wartość"

x="napis"

echo $x

x = "napis"

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"
  

• $0

  nazwa bieżącego skryptu lub powłoki

  Przykład:

  #!/bin/bash
  
  echo "$0"
  

  Pokaże nazwę uruchomionego 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łany zostanie skrypt z jakimiś parametrami to przypisane zostaną zmiennym: od $1 do $9. Zobacz co się stanie jak podasz za małą liczbę parametrów oraz jaki będzie wynik podania za dużej liczby parametrów.

• $@
  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

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. W celu uzyskania listy aktualnie eksportowanych zmiennych należy wpisać export, opcjonalnie export -p . 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 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
  

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]}

• Odwołanie do elementów tablicy.

  Składnia:

  ${nazwa_zmiennej[wskaźnik]}

  Wskaźnikiami są indexy elementów tablicy, począwszy od 0 do n oraz @, *. Gdy odwołując się do zmiennej nie poda się wskaźnika: ${nazwa_zmiennej} to nastąpi odwołanie do elementu tablicy o indexie 0.Jeśli wskaźnikiem będą: @ lub * to zinterpretowane zostaną jako wszytskie elementy tablicy, w przypadku gdy tablica nie zawiera żadnych elemntów to zapisy: ${nazwa_zmiennej[wskaźnik]} lub ${nazwa_zmiennej[wskaźnik]} są interpretowane jako nic.

  Przykład:

  Poniższy skrypt robi to samo co wcześniejszy.

  #!/bin/bash
  
  tablica=(element1 element2 element3)
  
  echo ${tablica[*]}
  

  Można też uzyskać długość (liczba znaków) danego elementu tablicy:

  ${#nazwa_zmiennej[wskaź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 wskaź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[wskaź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[wskaźnik]

  Przykład:

  #!/bin/bash
  
  tablica=(element1 element2 element3)
  echo ${tablica[@]}
  unset tablica[2]
  echo ${tablica[*]}
  

  Usunięty został ostatni element tablicy.

  Aby usunąć całą tablicę wystarczy podać jako wskaź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.

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

• 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

• 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:

  #!/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
  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.

Składnia:

if warunek
then
  polecenie
fi

#!/bin/bash
if [ -e ~/.bashrc ]
then
  echo "Masz plik .bashrc"
fi

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

Składnia:

if warunek
then
  polecenie1
elif warunek
then
  polecenie2
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

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

[ wyrażenie1 operator wyrażenie2 ]

Uwaga! Między nawiasami a treścią warunku muszą być spacje, tak jak powyżej.

w przypadku sprawdzania warunków arytmetycznych:

(( wyrażenie1 operator wyrażenie2 ))

A to kilka przykładów operatorów polecenia test:

• -a operator and
• -o operator or
• -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.

Składnia:

case zmienna in
  "wzorzec1") polecenie1 ;;
  "wzorzec2") polecenie2 ;;
  "wzorzec3") polecenie3 ;;
  *) polecenie_domyślne
esac

#!/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

Wykonuje polecenia zawarte wewnątrz pętli, na każdym składniku listy (iteracja).

Składnia:

for zmienna in lista
do
  polecenie
done

for x in jeden dwa trzy
do
  echo "To jest $x"
done

#!/bin/bash
for x in *html
do
  echo "To jest plik $x"
done

#!/bin/bash
for nazwa in *
do
  mv $nazwa `echo $nazwa | tr '[A-Z]' '[a-z]'`
done

Składnia:

select zmienna in lista
do
  polecenie
done

Praktyczny przykład:

#!/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

Składnia:

while warunek
do
polecenie
done

#!/bin/bash
x=1;
while [ $x -le 10 ]; do
echo "Napis pojawił się po raz: $x"
x=$[x + 1]
done

Składnia:

until warunek
do
polecenie
done

#!/bin/bash
x=1;
until [ $x -ge 10 ]; do
echo "Napis pojawił się po raz: $x"
x=$[x + 1]
done

Składnia:

exit 10

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"

Przykład:

#!/bin/bash
echo "Wpisz coś:"

answer="napis"
read
echo "$answer"

Polecenie read pozwala na przypisanie kilku wartości kilku zmiennym.

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"

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"
  

• -t timeout

  czas wygaśnięcia w sekundach

• -s

  nie wyświetlaj znaków wpisanych przez użytkownika.

  #!/bin/bash
  
  #Hasło wpisywane bez echa, max. przez 30 sekund
  read -p "Password: " -s  -t 30 password
  echo $password
  

Funkcje

Składnia:

function nazwa_funkcji
{
polecenie1
polecenie2
polecenie3
}

lub:

function nazwa_funkcji()
{
polecenie1
polecenie2
polecenie3
}

Przykład:

#!/bin/bash

function napis
{
echo "To jest napis"
}

napis

. ~/naszplik_z_funkcjami
nazwa_funkcji

Przykład:

#!/bin/bash
function nasza_funkcja
{
echo -e 'Właśnie użyłeś funkcji o nazwie "nasza_funkcja".\a'
}

#!/bin/bash
echo "Test funkcji."
. funkcja
nasza_funkcja

Przekazywanie parametrów

nazwa_funkcji parametr_1 parametr_2

Przykład:

#!/bin/bash

funkcja_z_parametrami()
{
        echo "Przekazano $# parametrów"
        echo "Parametr $1"
        echo "Parametr $2"
}

funkcja_z_parametrami "param1" "param2"

Składnia:

$((wyrażenie)) lub $[wyrażenie]

Przykład:

#!/bin/bash

echo $((8/2))

wynik=$[4*5/2]
echo "$wynik"

#!/bin/bash

for pliki_html in $(ls *.html)
do
numer=$((numer+1))
echo "$numer. "
echo $pliki_html
done

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

• wersja oryginalna kursu Bash'a - link