ot segv(17-09-2002)

reiting (85)   [ dobre ]  [ zle ]

Printer Friendly Variant za otpechatvane

Sudurzhanie
1. Uvod
2. Hello, World script
3. Promenlivi
4. Vhod ot potrebitelia (user input), operatora <<, aritmentichni operatsii
5. Usloviia (if-then-else, elif, case)
6. TSikli (while, until, for, for-in)
7. Prenasochvane i kanali
8. Strukturata trap
9. Masivi
10. Funktsii
11. TSvetove
12. Izpolzvana literatura

[--- Uvod ---]

   Vsichki UNIX sistemi poddurzhat goliam broi programni ezitsi, pozvoliavashti na potrebitelite da si
praviat svoi sobsveni programi. Vsichki distributsii imat poddruzhka za programirane za mnozhestvo
komandni interpretatori, ezitsi ot po-visoko nivo kato Perl i Tcl/TK i GUI programirane za grafichni
sredi kato KDE i GNOME.
   Nai-chesto izpolzvanite obvivki (shells) sa:

bash - bourne again shell
sh   - shell
csh  - C shell
tcsh - Tenex C shell (C shell bez poddruzhka na tab-completion)
zsh  - Z shell
ksh  - Korn Shell

   Mozhete da prochetete poveche za vsiaka ot tiah v tehnite manual pages. V tozi tutorial shte se zani-
mavame s programirane za bash. Edna programa za bash kombinira UNIX komandite po daden
nachin, za da izpulni opredelena zadacha. Programata za bash predstavliava tekstov fail, sudurzhasht
komandi, koito mozhete da vuvedete sus nai-obiknoven tekstov redaktor kato pico, vi i dr. Tozi
tekstov fail se naricha skript za obvivkata.

###########################################################

[--- Hello, World script ---]

   Otvorete lyubimiia si tekstov redaktor i vuvedete

#!/bin/bash
echo "Hello, World"

   za da napravite traditsionniia Hello, World script. Mozhete da startirate skripta kato napishete
tochka (.) pred imeto na faila. Ako failut se kazva hello, komandata bi izglezhdala taka:

$ . hello
Hello, World
$

   Drugiiat nachin e da napravite skripta izpulnim:

$ chmod +x hello

   i da go startirate s:

$ ./hello
Hello, World
$

   Po-natatuk v tutorial-a shte izpolzvame vtoriia nachin.
   Skriptut hello sudurzha dva reda. Purviia red kazva na sistemata koia programa da polzva, za da
prochete komandite vuv faila, a vtoriia izkarva na ekrana Hello, World.
   Mozhete da vuvezhdate komentari v skriptovete si chrez znaka "#".

#!/bin/bash
# Tova e komentar
echo "Hello, World" # Tova sushto

###########################################################

[--- Promenlivi ---]

   Za da prisvoite niakakva stoinost na promenliva triabva da izpolzvate operatora za prisvoiavane
(znaka za ravenstvo (=)). Vuvedete imeto na promenlivata, znaka za ravenstvo i sled tova stoinostta i.
Primer:

num=10

   Oburnete vnimanie, che ne triabva da izpolzvate intervali okolo operatora za prisvoiavane. Ako
slozhite interval sled nego (num= 10), bash shte se opita da izpulni komanda "num=" s argument 10.
   Mozhete da se oburnete kum stoinostta na promenliva chrez znaka za dolar ($). Eto kak bi izglezhdal
skriptut Hello, World ako izpolzvame promenlivi:

#!/bin/bash

var="Hello, World"
echo $var

   Vupreki che stoinostite na promenlivite mogat da budat proizvolni simvoli, ako vklyuchite simvoli,
koito se izpolzvat ot obvivkata, vuznikvat problemi. Tezi simvoli sa: interval, tochka (.), znak za
dolar ($), po-goliamo (>) i po-malko (<), (|), (&), (*), ({) i (}). Tezi znatsi mogat da se izpolzvat
kato stoinost na promenliva ako sa postaveni v dvoini ili edinichni kavichki ili s obratno nakloneni
cherti. S dvoini kavichki mozhete da izpolzvate vsichki zapazeni znatsi bez znaka za dolar ($). Za da go
vklyuchite v stoinostta na promenlivata mozhete da izpolzvate obratno naklonena cherta predi nego (\$)
ili da ogradite stoinostta na promenlivata s edinichni kavichki. Sledvashtiia primer ilyustrira vsichko
opisano do sega.

#!/bin/bash

num1=10
num2=20
msg1="$num1 < $num2 & $num2 > $num1" # Tuk shte se pokazhat vsichki znatsi bez znaka za dolar,
                      # koito izpolzvame za da se oburnem kum stoinostta na
                      # promenlivata.
echo $msg1

msg2="\$100 > \$10" # Tuk izpolzvame obratno naklonena cherta za da pokazhem znaka za dolar
echo $msg2

msg3='Here we can use all of these symbols: ".", ">", "<", "|", "$", etc'
# po tozi nachin vsichki znatsi shte se pokazhat na ekrana, edinstveniiat simvol, koito ne mozhe da
# se izpolzva e edinichna kavichka (')
echo $msg3

# Pri vsichki primeri po-gore ne e nuzhno stringut da se slaga v promenliva.

echo ""\$msg1" is not needed to print '$num1 < $num2 & $num2 > $num1'"

   Izpulnenieto na skripta:

$ ./primer1
10 < 20 & 20 > 10
$100 > $10
Here we can use all of these symbols: ".", ">", "<", "|", "$", etc
$msg1 is not needed to print '10 < 20 & 20 > 10'
$

   Za da prisvoite na niakoia promenliva rezultata ot izpulnenieto na niakakva komanda, triabva da
ogradite komandata v obratno nakloneni apostrofi.

#!/bin/bash

lsvar=`ls ~`
echo $lsvar

   Izpulnenieto na skripta:

$ ./primer2
books docs ircd movies source work phun stuff
$

   Ako postavite komanda v edinichni kavichki sled tova mozhete da izpolzvate imeto na tazi promenliva
kato drugo ime na komandata.

#!/bin/bash

lssrc='ls ~/source/c'
$lssrc

   Izpulnenieto na skripta:

$ ./primer3
me0w.c m00.c
$

   Za da izpolzvate rezultata ot izpulnenieto na komanda v string ili promenliva triabva da zagradite
komandata v skobi i da postavite znaka za dolar pred neia ($(ls)).

#!/bin/bash

echo "The date is $(date)"

   Izpulnenieto na skripta:

$ ./primer4
The date is pn yuni 10 20:36:49 UTC 2002
$

   V bash ima i niakolko spetsialni promenlivi, koito se izpolzvat za argumentite na skripta za obvivkata.

$0       - ime na komanda
$1 do $9 - argumentite na skripta
$*       - vsichki argumenti ot komandniia red
$@       - vsichki argumenti ot komandniia red pootdelno
$#       - broiat na argumentite ot komandniia red

   SHTe razberete razlikata mezhdu $* i $@ sled kato prochetete za kontrolnata struktura for-in. Poglednete
dolniia primer za po-goliama iasnota za spetsialnite promenlivi.

#!/bin/bash

echo "The first argument is $1, the second $2"
echo "All arguments you entered: $*"
echo "There are $# arguments"

   Izpulnenieto na skripta:

$ ./primer5 arg1 arg2 arg3 arg4
The first argument is arg1, the second arg2
All arguments you entered: arg1 arg2 arg3 arg4
There are 4 arguments
$

   Ako izpulnite drug skript ot tekushto izpulniavashtiiat se, tekushtiiat skript spira izpulneniteto si i predava
kontrola na drugiia. Sled izpulnenieto mu se produlzhava purviia skript. Pri tozi sluchai vsichki promenlivi,
definirani v purviia skript ne mogat da se izpolzvat vuv vtoriia. No ako eksportirate promenlivite ot
purviia te shte mogat da se izpolzvat vuv vtoriia. Tova stava s komandata export.

#!/bin/bash

# Tova e purviiat fail.

var=100
export var
./primer6-a

# EOF


#!/bin/bash

# Vtoriiat fail.

echo "The value of var is $var"

# EOF

   Izpulnenieto na skripta (oburnete vnimanie che vtoriiat fail triabva da e primer6-a, ako izpolzvate drugo
ime, smenete imeto na faila v purviia skript).

$ ./primer6
The value of var is 100
$

   Drug nachin za deklarirane na promenlivi e komandata declare. Sintaksisut na tazi komanda e:

declare -tip ime-na-promenlivata

   Tipovete promenlivi sa:

-r   - readonly
-i   - integer (tsialo chislo)
-a   - array (masiv)
-x   - export

   Primer:

#!/bin/bash

declare -i var # deklarirame promenliva ot tip integer
var=100
echo $var
declare -r var2=123.456 # deklarirame readonly promenliva
echo $var2
var2=121.343 # opitvame se da promenim stoinostta na var2
echo $var2   # stoinostta na var2 shte e vse oshte 123.456

   Izpulnenieto na skripta:

$ ./primer7
100
123.456
bash: var2: readonly variable
123.456
$

   Poveche informatsiia mozhete da vidite v bash manual pages (man bash).

###########################################################

[--- User input, <<, aritmetichni operatsii ---]

   Za da chetete vhodni danni ot vashiia script triabva da izpolzvate komandata read. V neia niama nishto trudno,
no vse pak vizhte primera:

#!/bin/bash

echo -n "Enter a string: "
read str
echo "String you entered: $str"

   Izpulnenieto na skripta:

$ ./primer8
Enter a string: hello
String you entered: hello
$

   S operatora << mozhete da predavate danni na niakoia komanda. Sled nego triabva da postavite svoi ogranichitel,
koito predstavliava niakakva duma (pr. EOF) i sled dannite triabva da postavite sushtata duma. Primer:

#!/bin/bash

cat << EOF
sth
data
line
EOF

   Izpulnenieto na skripta:

$ ./primer9
sth
data
line
$

   Komandata let v bash se izpolzva za aritmetichni operatsii. S neia mozhete da sravnite dve stoinosti ili da
izvurshvate razlichni operatsii kato subirane i umnozhenie. Tezi operatsii chesto se izpolzvat za upravlenie na
kontrolni strukturi (naprimer tsikula for, za koito shte prochetete po-natatuk) ili za izvurshvane na izchisleniia.
Sintaksisut na komandata e pokazan po-dolu:

$ let value1 operator value2

   Osven tozi sintaksis mozhete da izpolzvate dvoini skobi.

$ (( value1 operator value2 ))

   Mozhete da izpolzvate napravo operatorite za aritmetichni operatsii ako i dvete promenlivi sa ot edin i sushti
tip (naprimer integer). Primer:

#!/bin/bash

echo -n "Enter the first number: "
read var1
echo -n "Enter the second: "
read var2
declare -i var3

echo ----------
echo "$var1 + $var2 = $(( $var1+$var2 ))" # tuk izpolzvame dvoini skobi, kakto vizhdate triabva da slozhim $ pred
            # izraza, za da se izchisli
let res=$var1*var2
echo "$var1 * $var2 = $res"
var3=100
var3=$var3+10
echo "$var3" # tui kato tazi promenliva e deklarirana kato integer ne e nuzhno da izpolzvame komandata let

   Izpulnenieto na skripta:

$ ./primer10
Enter the first number: 10
Enter the second: 3
----------
10 + 3 = 13
10 * 3 = 30
110
$

   Mozhete da izpolzvate vseki ot izbroenite po-dolu operatori s komandata let.

+ - subirane
- - izvazhdane
* - umnozhenie
/ - delenie
% - ostatuk pri delenie
> - po-goliamo
< - po-malko
>= - po-goliama ili ravno
<= - po-malko ili ravno
== - ravno
!= - ne e ravno
& - logichesko I (AND)
| - logichesko ILI (OR)
! - logichesko NE (NOT)

   Za aritmetichni operatsii i sravniavane mozhete da izpolzvate komandata expr, no tuk niama da ia opisvam. Za poveche
informatsiia vizhte neinata dokumentatsiia. Za da pravite po-tochni izchisleniia izpolzvaite ezika bc
(http://www.gnu.org/software/bc/bc.html).

###########################################################

[--- Usloviia ---]

   V tazi chast shte se zapoznaem s kontrolnite strukturi za usloviia. Mnogo ot tiah sa podobni na strukturite v drugite
ezitsi, no vupreki tova ima niakoi razliki. Usloviiata chesto iziskvat da se izpulni niakakva proverka, koiato sravniava
dve stoinosti. Tazi proverka se izvurshva chrez komandata test. Sintaksisut na komandata e pokazan tuk:

$ test value1 -option value2
$ test string operator string

   Oburnete vnimanie, che pri sravniavane na stringove se izpolzva operator, a ne optsiia. Vmesto komandata test mozhete
da izpolzvate kvadratni skobi ( [ i ] ). Komandata test $var -eq 1 mozhe da se zapishe taka:

$ [ $var -eq 1 ]

   Rezultatut ot komandata test se zapazva v spetsialnata promenliva $?. Ako toi e true, to $? e ravna na nula, ako e
false to $? e ravna na edno. (V promenlivata $? vsushtnost se suhraniava izhodniia kod na programata, koiato e izpulnena.
Ako tia e zavurshila uspeshno to toi e 0, ako ne, toi e drugo chislo. Pri komandata test, ako rezultatut e true tia spira
s izhoden kod 0, ako e false s 1) Primer:

#!/bin/bash

var1=10
var2="m000"
[ $var1 -eq 10 ]
echo $?
[ $var2 = "me0w" ]
echo $?

   Izpulnenieto na skripta:

$ ./primer11
0
1
$

   Nai-chesto izpolzvanite operatori i optsii v test:
   
Sravniavane za tseli chisla          Funktsiia
-gt (greater than)                Po-goliamo ot
-lt (less than)                   Po-malko ot
-ge (greater or equal)            Po-goliamo ili ravno
-le (less or equal)               Po-malko ili ravno
-eq (equal)                       Ravno
-ne (not equal)                   Neravno
Sravniavane na stringove
-z                                Proveriava za prazen string
=                                 Ravni stringove
!=  Neravni stringove
Proverki za failove
-f  Failut sushtestvuva
-s  Failut ne e prazen
-r  Failut mozhe da se chete
-w  Vuv failut mozhe da se zapisva
-x  Failut mozhe da se izpulniava

   Ima mnogo poveche optsii, no tuk niama da gi opisvam. Mozhete da prochetete za tiah v test manual pages (man test).

   Uslovieto if proveriava izhodnoto sustoianie na komanda. Ako to e nula komandite v strukturata se izpulniavat.
Ako e neshto razlichno ot nula komandite v strukturata ne se izpulniavat. Vsiaka if struktura zavurshva s klyuchova duma
fi i vsiaka case struktura zavurshva s esac. Kontrolnite strukturi za uslovie:

if komanda then Vtorata komandata se izpulniava ako izhodnoto sustoianie na purvata
 komanda                               komanda e 0.
       fi

if komanda then Ako izhodnoto sustoianie e 0 se izpulniava komandata v if, ako e
 komanda niakakvo drugo chislo se izpulniava komandata v else.
else
 komanda
fi

if komanda then elif vi pozvoliava da proveriavate niakolko situatsii v edna if struktura.
 komanda
elif komanda then
 komanda
else
 komanda
fi

case string in case tursi suvpadenie na stringa s niakoi ot shablonite, ako niama takova
shablon) se izpulniavat komandite po podrazbirane (ne e zadulzhitelno da ima takiva.
 komanda;;
*)
 komanda po podrazbirane;;
esac

       komanda && komanda                      logichesko I (AND)

       komanda || komanda                      logichesko ILI (OR)

       !komanda                                logichesko NE (NOT)

   Po-dolu sa pokazani primeri s gornite usloviia:

#!/bin/bash

echo -n "Enter a string: "
read str1
echo -n "Enter a string: "
read str2
echo -n "Enter a number: "
read num1

if [ $str1 == "m000" ]; then  # ';' se izpolzva za da mozhe then da e na sushtiia red
  echo "str1 = m000"
elif [ $str1 == "m000" ] && [ $str2 == "m000" ]; then # logichesko I, t.e. echo "str1 and str2 = m000" shte se
     # izpulni ako i dvete usloviia sa true
          echo "str1 and str2 = m000"
       else
  echo "str1 and str2 != m000"
       fi

if [ -f "/etc/passwd" ]; then # primer s failove
          cat /etc/passwd
       fi

if [ $num1 -eq 10 ]; then
          echo "num1 = 10"
elif [ $num1 -gt 100 ]; then
  echo "num1 > 100"
else
  echo "?!?"
fi

   Izpulnenieto na skripta:

$ ./primer12
Enter a string: m000
Enter a string: m000
Enter a number: 10
str1 = m000
root:x:0:0::/root:/bin/bash
bin:x:1:1:bin:/bin:
daemon:x:2:2:daemon:/sbin:
adm:x:3:4:adm:/var/log:
nobody:x:99:99:nobody:/:
segv:x:1000:100:,,,:/home/segv:/bin/bash
num1 = 10
$

   Mozhete da probvate skripta kato vuvezhdate drugi stoinosti. Edin primer za case:

#!/bin/bash

echo -n "Enter an option (l, s or al): "
read opt

case $opt in
l)
  ls -l;;
s)
  ls -s;;
al)
  ls -al;;
*) # ako $opt ne suvpada s nikoia ot gornite optsii
  ls;;
       esac

Izpulnenieto na skripta:

$ ./primer13
Enter an option (l, s or al): l
total 964
drwxr-xr-x   33 segv     users        4096 mai 24 19:58 books
drwxr-xr-x    5 segv     users        4096 yuni 12 19:35 docs
drwxr-xr-x    7 segv     users        4096 mai  6 12:34 ircd
drwxr-xr-x    2 segv     users        4096 mai 25 23:22 movies
drwxr-xr-x    7 segv     users        4096 mai 17 11:56 phun
drwxr-xr-x   10 segv     users        4096 yuni  8 15:54 source
drwxr-xr-x    2 segv     users        4096 yuni  1 15:27 stuff
drwxr-xr-x    2 segv     users        4096 yuni 15 08:40 work
$

   Tova e vsichko za usloviiata. Mozhete da probvate drugite operatori i optsii na test sami.

###########################################################

[--- TSikli ---]

   TSiklite se izpolzvat za povtariane na komandi. Kontrolnite strukturi za tsikli sa while, until, for i for-in.
while i until proveriavat rezultata na niakakva komanda dokato for i for-in obhozhdat spisuk ot stoinosti kato
prisvoiavat vsiaka stoinost na niakakva promenliva. Strukturite za tsikul sa pokazani po-dolu:

while komanda do while izpulniava dadena komanda dokato vrushtanata stoinost ot
  komanda        purvata komanda e 0 (true).
done

until komanda do until izpulniava dadena komanda dokato vrushtanata stoinost ot
  komanda purvata komanda e 1 (false).
done

for promenliva in spisuk ot stoinosti   Na promenlivata se prisvoiava posledovatelno vsiaka ot stoinostite
do v spisuka.
  komanda
done

for promenliva for e prednaznachen za obrushtane kum argumentite na skripta. Na
do promenlivata se prisvoiava posledovatelno vseki ot argumentite.
  komanda
done

   while izpulniava komandi dokato izhodnata stoinost na purvata komanda e 0. Kraia na tsikula se ukazva s klyuchovata
duma done.

#!/bin/bash

m00=yes

while [ $m00 == "yes" ]; do
  echo -n "Enter a string: "
  read str1
  echo "You entered: $str1"
  echo -n "Do you want to continue? "
  read m00
done

   Skriptut shte se izpulniava dokato vuvezhdate yes, pri vsiaka druga stoinost izpulnenieto spira zashtoto vrushtanata
stoinost ot [ $m00 == "yes" ] shte e 1 (false). Izpulnenieto na skripta e pokazano tuk:

$ ./primer14
Enter a string: asd
You entered: asd
Do you want to continue?  yes
Enter a string: asd1234123
You entered: asd1234123
Do you want to continue? no
$
   Edin primer s until:

#!/bin/bash

m00=yes

until [ $m00 == "no" ]; do
  echo -n "Enter a string: "
  read str1
  echo "You entered: $str1"
  echo -n "Do you want to continue? "
  read m00
done

   Tozi skript izvurshva sushtata funktsiia kato predniia, samo che se izpulniava dokato [ $m00 == "no" ] e false.

$ ./primer15
Enter a string: me0w
You entered: me0w
Do you want to continue? yes
Enter a string: zmpf
You entered: zmpf
Do you want to continue? no
$

   for-in se izpolzva za obhozhdane na spisuk ot stoinosti kato vsiaka ot stoinostite se prisvoiava posledovatelno
na promenliva.

#!/bin/bash

for cfile in ~/source/c/*.c # tova e sushtoto kato for cfile in $( ls ~/source/c/*.c )
do
  echo $cfile
done

   Izpulnenieto na skripta:

$ ./primer16
/home/segv/source/c/a.c
/home/segv/source/c/tmp.c
/home/segv/source/c/zmpf.c
$

   for e sushtoto kato for-in, no obhozhda argumentite na skripta.

#!/bin/bash

for m00
do
  echo $m00
done

   Tui kato argumentite na skripta se suhraniavat v spetsialnata promenliva $@, gorniiat skript mozhe da se napravi i
s for-in.

#!/bin/bash

for m00 in $@
do
  echo $m00
done

   Izpulnenieto na skripta:

$ ./primer17 m00 me0w m33p zmpf lkmnp
m00
me0w
m33p
zmpf
lkmnp
$

   Ima oshte niakolko komandi, koito chesto se izpolzvat v tsiklite. Tova sa komandite true, false i break. Komandata
true ima mnogo prosta funktsiia - izhodnata i stoinost e vinagi 0. false e sushtata, samo che neinata izhodna
stoinost e 1. break se izpolzva za izlizane ot tsikula.

#!/bin/bash

declare -i var=0

while true; do # tui kato nikoga ne mozhe uslovieto da stane false tsikulut e bezkraen
  echo -n $var
  var=$var+1
  if [ $var -eq 10 ]; then # ako $var e 10 tsikulut se prekratiava
     break
  fi
done

echo
echo bye

   Mozhete da napravite sushtiia tsikul ako izpolzvate until i false edinstvenata razlika e v reda:

while true; do

   Triabva da e

until false; do

###########################################################

[--- Prenasochvane i kanalizirane ---]

  Kogato izpulniavate komanda, tia izprashta dannite na standartniia izhod (konzolata). No mozhete da prenasochite dannite i
kum fail ili primerno kum stderr. Sushto taka dannite, koito vuvezhdate mogat da se vzemat ot fail. Prenasochvaneto na
izhodnite danni se izvurshva s znaka > sled komandata. Primer:

$ echo m000 > file
$ cat file
m000
$

   Ako iskate da dobavite danni kum sushtestvuvasht fail izpolzvaite >>, zashtoto > iztriva predishnoto sudurzhanie na faila.

#!/bin/bash

nums="1 2 3"

for num in $nums
do
  echo $num
done > nums

   Gorniia skript shte prenasochi izhodnite danni v faila nums.

$ ./nums
$ cat nums
1
2
3
$

   Kanaliziraneto e podobno na prenasochvaneto, s tazi razlika che izhodnite danni ot edna komanda se predavat kato vhodni
na druga. Nai-prost primer za kanalizirane e arhiviraneto i dezarhiviraneto s tar i gzip.

$ tar cvf - files/ | gzip -9 > files.tar.gz

   ili

$ gzip -cd files.tar.gz | tar xvf -

   Edin primer s bash skript.

#!/bin/bash

names="Ivan Koljo Asen Sasho Misho"

for name in $names
do
  echo $name
done | sort > names

   Skriptut predava izhodnite danni ot echo $name na komandata sort i sled tova izhodnite danni ot neia se prenasochvat vuv
faila names.

$ ./names
$ cat names
Asen
Ivan
Koljo
Misho
Sasho
$

   Kakto vizhdate imenata sa podredeni po azbuchen red tui kato izhodnite danni se predavat na komandata sort.


###########################################################

[--- Strukturata trap ---]

   Drug vid struktura e trap. trap izpulniava komanda pri niakakvo subitie. Tezi subitiia se narichat signali.
Tuk e daden sintaksisut na komandata trap.

$ trap 'komandi' nomer-na-signala

   Edin chesto izpolzvan signal e signalut za prekusvane (kogato potrebiteliat natisne CTRL+C).

#!/bin/bash

trap 'echo "Bye"; exit 1' 2

echo "Enter a string: "
read m00
echo "nah"

   Izpulnenieto na skripta:

$ ./trap-ex
Enter a string:
^CBye
$
 
   Kakto vizhdate sled kato natisnem CTRL+C se izpulniava echo "Bye" sled tova exit 1, s koeto programata spira
izpulnenieto si. Spisuk s razlichni nomera na signali e pokazan tuk:

0 Krai na programata      Programata zavurshva
2 Terminalno prekusvane   CTRL+C
9 kill    kill-vane na programata, ne mozhe da se ulovi s trap
24  Spirane na programata s CTRL+Z, ne mozhe da se ulovi

    Mozhete da vidite poveche nomera na signali za kill v kill manual pages.

###########################################################

[--- Masivi ---]

   Masivut mozhe da bude initsializiran s var[xx]="aa", kudeto xx e niakakvo chislo ili s komandata declare -a promenliva.
Za da se oburnem kum stoinostta na niakoi ot elementite na masiva triabva da go zagradim vuv figurni skobi ('{' i '}').
Primer:

#!/bin/bash

array[1]=m00
array[34]=me0w
array[40]=123

echo "array[1] = ${array[1]}"
echo "array[34] = ${array[34]}"
echo "array[40] = ${array[40]}"

   Drug nachin za prisvoiavane na stoinosti na elementite ot masiv e

array=( x y z ... )

   Sled tova h shte bude array[0] (zabelezhete purviiat element e 0 a ne 1), y - array[1], z - array[2] i t.n.

   Edin primer, demonstrirasht poveche vuzmozhnosti na masivite:

#!/bin/bash

declare -a array # deklarirame masiv s declare

echo -n "Enter some numbers separated by space: "
read -a array # prisvoiavame vuvedenite chisla na elementite na masiva (zabelezhete optsiiata na read '-a')

elements=${#array[@]} # tuk prisvoiavame na promenlivata elements broia elementi na masiva

# ${array[@]} sudurzha elementite na masiva pootdelno. Mozhete da go izpolzvate za tsikul for-in
# naprimer:
# for i in ${array[@]; do
#    echo $i
# done

# sega shte pokazhem elementite na masiva s tsikul while

i=0

while [ $i -lt $elements ]; do
  echo ${array[$i]}
  let "i = $i + 1"
done

echo "bye"

   Izpulnenieto na skripta:

$ ./primer18
Enter some numbers separated by space: 1 13 14 88 19
1
13
14
88
19
bye
$

   Mozhete da vidite mnogo poveche za masivite (razlichni algoritmi za sortirane i dr.) v Advanced Bash Scripting
(http://www.tldp.org/LDP/abs/html/arrays.html)

###########################################################

[--- Funktsii ---]

   Kakto v poveche programni ezitsi i v bash mozhete da izpolzvate funktsii za da grupirate niakolko komandi v edna.
Deklariraneto na funktsiia stava taka:

ime_na_funktsiia { komandi }

ili
ime_na_funktsiia() { komandi }

   Za da izvikate funktsiia prosto triabva da vuvedete neinoto ime.

#!/bin/bash

func() {
  echo "Hello"
  echo "This is function"
}

info() {
  echo "host uptime: $( uptime )"
  echo "date: $( date )"
}
func
info

echo "That's all folks :)"

  Izpulnenieto na skripta:

$ ./primer19
Hello
This is function
host uptime:   1:46pm  up 5 days, 14:39,  1 user,  load average: 0.08, 0.05, 0.04
date: sb yuni 15 13:46:23 UTC 2002
That's all folks :)
       $

###########################################################

[--- TSvetove ---]

   I poslednata chast ot tutorial-a sa tsvetovete v bash. Za da izkarame tsveten tekst shte izpolzvame komandata printf.
TSveta se opredelia s \e[X;XXm, kudeto H-ovete sa chisla. Spisuka s tsvetovete e pokazan po-dolu:

      CHerno       0;30     Tumno sivo         1;30
      Sino       0;34     Svetlo sino       1;34
      Zeleno      0;32     Svetlo zeleno      1;32
      Cyan        0;36     Light Cyan         1;36
      CHerveno     0;31     Svetlo cherveno     1;31
      Lilavo      0;35     Svetlo lilavo      1;35
      Kafiavo      0;33     ZHulto              1;33
      Svetlo sivo 0;37     Bialo               1;37
      Izchistva ekrana 2J (thanks zEAL)

   Primer:

#!/bin/bash

printf "\e[2J"
printf "\e[0;34mblue\n" # \n e za nov red
printf "\e[0;32mgreen\n"
printf "\e[0;37mand back to default color ...\n"

###########################################################

[--- Izpolzvana literatura ---]

Linux Programming A Beginner's Guide (Richard Petersen)
BASH Programming HOWTO - http://www.tldp.org/HOWTO/Bash-Prog-Intro-HOWTO.html
Advanced Bash-Scripting Guide - http://www.tldp.org/LDP/abs/html/



----------------
segv


<< Suzdavane na po-burzo i ustoichivo iadro | wireless sus prism2.5 linux draiveri i nastroiki dlinkDWL520 >>