|
ot segv(17-09-2002)
reiting (85)
[ dobre ]
[ zle ]
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
Sinüo 0;34
Svetlo sinüo 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 >>
|
|