Писане на скриптове за bash шел : версия 2

Статията е взета от http://linux-bg.exco.net/

Тази статия е преведена с разрешението на автора и X_console.
Адресът на оригиналната статия е http://xfactor.itec.yorku.ca/~xconsole/.

Както всички шелове, който може да намерите за Linux BASH (Bourne Again SHell) е не само отличен команден интерпретатор но и език за писане на криптове. Шел(Shell) скриптовете ви позволяват максимално да използвате възможностите на шел интерпретатора и да автоматизирате множество задачи. Много от програмите, който може да намерите за Linux в последно време са шел скриптове. Ако искате да разберете как те работят или как може да ги редактирате е важно да рабирате синтаксиса и семантиката на BASH шела. В допълнение познаването на bash езика ви позволява да напишете ваши собствени програми, който да изпълняват точно това което искате.

Писането на собствени шел скриптове изисква от вас да знаете най-основните команди на Linux. Трябва да знаете например как да копирате, местите или създавате нови файлове. Едно от нещата което е задължително да знаете е как да работите с текстов редактор. За Linux има множество текстови редактори най-разпространените от който са vi, emacs, pico, mcedit.

#!/bin/bash

Първият ред от програмата казва че ще използваме bash интерпретатора за да подкараме програмата. В този случай bash се намира в /bin директорията. Ако bash се намира в друга директория на вашата система тогава направете необходимите премени в първия ред. Изричното споменаване на това кой интерпретататор ще изпълнява скрипта е много важно, тъи като той казва на Linux какви инструкции могат да бъдат използвани в скрипта. Следващото нещо което трябва да направите е да запишете файла под името hello.sh. Остава само да направите файла изпълним. За целта пишете:

xconsole$ chmod 700 ./hello.sh

Прочетете упътването за използване на chmod командата ако не знаете как да променяте правата на даден файл. След като сте направили програмата изпълнима я стартирайте като напишете:

xconsole$ ./hello.sh

Резултатът от която ще бъде следният надпис на екрана

Hello World

Това е! Запомнете последователноста от действия - писане на кода, записване на файла с кода, и променянето на файла в изпълним с командата chmod.

Аргумент е всичко което е написано след името на командата. В нашият случай това е "Hello World". Когато напишете  ls /home/root,   командата е ls а нейният аргимент е /home/root. Какво означава всичко това? Това означава че ако имате програма или команда, която изпечатва аргументите си на екрана то може да я използвате вместо echo. Нека да предположим че имаме такава команда която се казва foo. Тази комада ще изпечата своите аргументи на екрана. Тогава нашият скрипт може да изглежда така:

#!/bin/bash
foo "Hello World"

Запишете го и го направете изпълним с chmod след което го стартирайте:

xconsole$ ./hello
Hello World

Точно същият резултат. Всичко което правихте до сега е да използвате echo командата във вашия шел скрипт. Друга команда за изпечатване е printf. Командата printf позволява повече контрол при изпечатване на информацията, особено ако сте запознати с програмния език C. Фактически съшият резултат от нашият скрипт можем да постигнем просто ако напишем в командния ред:

xconsole$ echo "Hello World"
Hello World

Както виждате може да използвате  Linux команди при писането на шел скриптове. Вашият bash шел скрипт е колекция от различни програми, специално написани заедно за да изпълнят конкретна задача.

xconsole$ mkdir trash

Вместо да пишем последователно тези команди можем да ги запишем във файл:

#!/bin/bash
mkdir trash
mv * trash
rm -rf trash
mkdir trash
echo "Deleted all files!"

Запишете файла под името clean.sh. След като стартирате clean.sh  той ще премести   всички файлове в директория trash, след което ще изтрие директорията заедно със съдържанието и ще я създаде отново. Дори ще изпечата съобщение на екрана, когато свърши със тези действия. Този пример показва и как да автоматизирате многократното писане на последователности от команди.

#!/bin/bash

Дори и да не знаете bash, вие веднага може да се ориентирате какво прави скрипта, след като прочетете коментара. Добре е при писане на скриптове да използвате коментари. Ще откриете, че ако ви се наложи да промените накоя програма която сте писали преди време, коментарите ще ви бъдат от голяма полза.

#!/bin/bash

Всичко което се случва е да присвоим на променливата x стойност 12 и да я отпечатаме тази стойност с комадата echo. echo "Stoinosta na promenliwata x e $x" изпечатва текущата стойност на x. Когато давате стойност на дадена променлива не трябва да има шпации между нея и "=". Ето какъв е синтаксиса:

Стойноста на променливата можем да получим като поставим символа "$" пред нея.   В конкретния случай за да изпечатаме стойноста на& x   пишем echo $x.

Има два типа променливи - локални променливи и променливи на обкръжението(environment). Променливите на обкръжението се задават от системата и информация за тях може да се получи като се използва env командата. Например:

xconsole$ echo $SHELL

Ще отпечата

/bin/bash

Което е името на шела който използваме в момента.  Променливите на обкръжението са дефинирани в  /etc/profile и  ~/.bash_profile. С echo командата можете лесно да проверите текущата стойност на дадена променлива, биля тя от обкръжението или локална. Ако все още се чудите защо са ни нужни променливи следната програма е добър пример който илюстрира тяхното използване:

#!/bin/bash

Да предположим че в един момент решите да промените стойноста на x от 12 на 8. Какво трябва да направите?  Трябва да премените навсяскъде в кода 12 с 8. Да но... има редове в който 12 не е стойноста на x. Трябва ли да променяме и тези редове? Не защото те не са свързани с x. Не е ли объркващо? По надолу е същия пример само че се използват променливи:

#!/bin/bash
x=12     # stoinosta na promenliwata x e 12 e x
echo "Stoinosta na  x e $x."
echo "Az imam 12 moliwa."
echo "Toj mi kaza che stojnosta na x e $x."
echo "Az sym na 12 godini."
echo "Kak taka stojnosta na x e $x?"

В този пример $x ще изпечата текущата стойност на x, която е 12. По този начин ако искате да промените стойноста на x  от 12 на  8 е необходимо единствено да замените реда в който пише x=12 с x=8. Другите редовете няма да бъдат променени. Променливити имат и дуги полезни свойства както ще се убедите сами в последствие.

#!/bin/bash

Тази малка шел програма  копира файлът /etc/foo в текущата директория и изпечатва "Done" на екрана. Тази програма ще работи само при едно условие. Трябва да има файл /etc/foo. В противен случай ще се получи следния резултат:

xconsole$ ./bar.sh
cp: /etc/foo: No such file or directory
Done.

Както виждате имаме проблем. Не всеки който стартира вашата програма има файл /etc/foo на системата си. Ще бъде по-добре, ако вашата програма проверява дали файла /etc/foo съществува и ако това е така да продължи с копирането, в противен случай да спре изпълнението. С "псевдо" код това изглежда така:

if /etc/code exists, then
    copy /etc/code to the current directory
    print "Done." to the screen.
otherwise,
    print "This file does not exist." to the screen
    exit

Може ли това да бъде направено с bash? Разбира се! В bash условните оператори са: if, while, until, for, и case.   Всеки оператор започва с ключова дума и завършва с ключова дума. Например if оператора започва с ключовата дума if, и завършва с  fi. Условните оператори не са програми във вашата система. Те са вградени свойства на  bash.

#!/bin/bash

Забележете че редовете след  then и else са малко по-навътре. Това не е задължително, но се прави с цел програмата да бъде по-лесна за четене. Сега стартирайте програмата. Ако имате файл /etc/foo, тогава програмата ще го копира в текущата директория, в противен случай ще върне съобщение за грешка. Опцията  -f проверява дали това е обикновен файл. Ето списък с опциите на  командата test:

-d проверява дали файлът е директория
-e проверява дали файлът съществува
-f проверява дали файлът е обикновен файл
-g проверява дали файлът има SGID права
-r проверява дали файлът може да се чете
-s проверява дали файлът разнерът на файла не е 0
-u проверява дали файлът има SUID права
-w проверява дали върху файлът може да се пише
-x проверява дали файлът е изпълним

else се използва ако искате вашата програма да направи нещо друго, ако първото условие не е изпълнено. Има и ключова дума elif, която може да бъде използвана вместо да пишете друг if вътре в първия if.  elif идва от английското "else if". Използва се когато първото условие не е изпълнено и искате да проверите за друго условие.

Ако не се чувствате комфортно с  if и test синтаксиса, който е :

if test -f /etc/foo

тогава може да използвате следния вариант:

if [ -f /etc/foo ]; then

Квадратните скоби формират  test командата. Ако имате опит в програмирането на C този синтакс може да ви се стори по-удобен. Забележете, че трябва да има разстояние след отварящата квадратна скоба и преди затварящата. Точката и запетаята: ";" казва на шела че това е края на командата. Всичко след ";" ще бъде изпълнено сякаш се намира на следващия ред. Това прави програмата малко по-четима. Можете разбира се да сложите  then на следващия ред.

Когато използваме променливи с  test е добре да ги заградим с кавички. Например:

if [ "$name" -eq 5 ]; then

#!/bin/bash

true в действителност е програма. Това което прави тази програма е да се изпълнява безкрайно. Използването на  true се смята, че забавя вашата програма, защото шел интерпретатора първо трябва да извика програмата и след това да я изпълни. Вместо това може да използвате командата ":":

#!/bin/bash
while :; do
   echo "Press CTRL-C to quit."
done

По този начин вие постигате същия резултат, но доста по бързо. Единствения недостатък е, че програмата става по-трудно четима.  Ето един по-подробен пример, който използва променливи:

#!/bin/bash
x=0;     # initialize x to 0
while [ "$x" -le 10 ]; do
    echo "Current value of x: $x"
    # increment the value of x:
    x=$(expr $x + 1)
    sleep 1
done

Както виждате използваме  test (записана като квадратни скоби) за да проверим състоянието на променливата  x. Опцията  -le проверява дали  x е по-малко(less) или равно(equal) на 10. На говорим език това се превежда по следния начин "Докато(while) x е по-малко или равно на 10, покажи текущата стойност на x, и след това добави 1 към текущата стойност на x.". sleep 1  казва на програмата да спре изпълнението си за една секунда. Както виждате това което правим тук в да проверим за равенство. Ето списък с някой опции на test:

От горния пример единственият ред, който може да ви се стори по-труден за рабиране е следния:

x=$(expr $x + 1)

Това което прави този ред е да увеличи стойноста на  x с 1. Но какво значи $(...)? Дали е променлива? Не. На практика това е начин да кажете на  шел интерпретатора, че ще изпълнявате командата expr $x + 1, и резултата от тази команда ще бъде присвоен на x. Всяка команда която бъде записана в  $(...) ще бъде изпълнена:

#!/bin/bash
me=$(whoami)
echo "I am $me."

Опитайте с този пример за да разберете какво имам предвид. Горната програмка може да бъде написана по-следния начин:

#!/bin/bash
echo "I am $(whoami)."

Сами си решете кой от начините е по-лесен за вас. Има и друг начин да изпълните команда или да присвоите разултата от изпълнението на дадена команда на променлива. Този начин ще бъде обяснен по-нататък. За сега използвайте $(...).

#!/bin/bash

Този код може би ви изглежда познат. Проверете го и вижте какво прави.  until ще изпълнява командите докато стойноста на променливата x е по-голяма или равна на 10. Когато стойноста на x стане 10 цикълът ще спре. Ето защо последната стойност на x която ще се изпечата е  9.

#!/bin/bash

В случай, че не знаете опцията  -n на командата echo спира автоматичното добавяне на нов ред. Пробвайте командата веднъж с   -n опцията и веднъж без нея за да разберете за какво става дума. Променливата dots преминава през стойностите от 1 до 10.  Вижте следния пример:

#!/bin/bash
for x in paper pencil pen; do
    echo "The value of variable x is: $x"
    sleep 1
done

Когато стартирате програмата ще видите че x в началото ще има стойност paper, след което ще премине на следващата стойност, която е pencil, и след това pen. Когато свършат стойностите през който минава цикъла изпълненито му завършва.

Ето една доста полезна програма. Тя добавя .html разширение на всички файлове в текущата директория:

#!/bin/bash

Ако не знаете "*" е "wild card character". Това ще рече "всичко в текущата директория", което в нашия случай представлява всички файлове в тази директория. Променливата file ще премине през всички стойности, в този случай файловете в текущата директория. След което командата mv преименува стойностите на променливата file във такива с  .html разширение.

#!/bin/bash

Оператора case ще провери стойност на  x на коя от  3-те възможности отговаря. В този случай първо ще провери дали стойноста на x е 0, след което ще провери за 5 и 9. Накая ако никое от условия не е изпълнено ще се изпечата съобшението "Unrecognized value.". Имайте предвид, че "*" означава "всичко", и в този случай това означава "която и да е стойност различна от посочените". Ако стойноста на  x е различна от 0, 5, или 9, то тогава тя попада в случая "*". Когато използвате  case всяко условие трябва да завършва с две ";". Може би се чудите защо да използвате  case когато може да използвате if? Ето как изглежда еквивалентната програма написана с  if. Вижте коя програма е по-бърза и по лесна за четене:

#!/bin/bash
x=5     # initialize x to 5
if [ "$x" -eq 0 ]; then
    echo "Value of x is 0."
elif [ "$x" -eq 5 ]; then
    echo "Value of x is 5."
elif [ "$x" -eq 9 ]; then
    echo "Value of x is 9."
else
    echo "Unrecognized value."

fi

Кавички

Обикновено използваме двойната кавичка за да обозначим с нея низ от символи и да запазим шпацията. Например, "Този низ съдържа шпации.". Низ заграден от двойни кавички се третира като един аргумент. Вземете следният скрипт за пример:

xconsole$ mkdir hello world
xconsole$ ls -F
hello/     world/

Създадохме две директории. Командата mkdir взе думите hello и world като два аргумента, създавайки по този начин две директории. А какво ще се случи сега:

xconsole$ mkdir "hello world"
xconsole$ ls -F
hello/     hello world/     world/

Създадохме една директория състояща се от две думи. Двойните кавички направиха командата да третира  двете думи като един аргумент . Без тях  mkdir щеше да приеме hello за първи аргумент и world за втори.

Единична кавичка се използва обикновено когато се занимаваме с променливи. Ако една променлива е заградена от двойни кавички, то нейната стойност ще бъде оценена. Но това няма да се случи ако използваме единични кавички. За да ви стане по-ясно разгледайте следният пример:

#!/bin/bash

Виждате ли разликата? Може да използвате двойни кавички, ако не смятате да слагата и променливи в низът който ще заграждат кавичките. Ако се чудите дали единичните кавички запазват шпациите в даден низ както това правят двойните кавички погледнете следния пример:

xconsole$ mkdir 'hello world'
xconsole$ ls -F
hello world/

Обратно наклонените кавички коренно се различават от двойните и единични кавички. Те не се използват за да запазват шпациите. Ако си спомняте по-рано използвахме следния ред:

x=$(expr $x + 1)

Както вече знаете резултата от командата expr $x + 1 се присвоява на променливата x. Същият този резултат може да бъде постигнат ако използваме обратно наклонени кавички:

x=`expr $x + 1`

Кой от начините да използвате? Този който предпочитате. Ще откриете, че обратно наклонените кавички са по-често използвани от  $(...). В много случай обаче  $(...) прави кода по-лесен за четене. Вземете в предвид това:

$!/bin/bash
echo "I am `whoami`"

Аритметически операции с BASH
bash ви позволява да смятате различни аритметични изрази. Както вече видяхте аритметическите операции се използват посредством командата expr. Тaзи команда обаче, както и командата true се смята че са доста бавни. Причината за това е че шел интерпретатора трябва всеки път да стартира true и expr командите за да ги използва. Като алтернатива на true посочихме командата ":". А като алтернатива на expr ще изпозваме следния израз $((...)). Разликата със $(...) е броя на скобите. Нека да опитаме:

#!/bin/bash

Ако се чуствате по-комфортно с expr вместо $((...)), тогава го използвайте него.

С bash можете да събирате, изваждате, умножавате, делите числа както и да делите по модул. Ето и техните символи:

ДЕЙСТВИЕ             ОПЕРАТОР
Събиране +
Изваждане -
Умножение *
Деление /
Деление по модул %

Всеки от вас би трябвало да знае какво правят първите четири оператора. Ако не знаете какво означава деление по модул това е остатъка при деление на две стойности. Ето и малко bash аритметика:

#!/bin/bash
x=5   # initialize x to 5
y=3   # initialize y to 3

add=$(($x + $y))   # sumiraj  x sys  y i priswoj rezultata na promenliwata add

# otpechataj otgoworite:

Отново горният код можеше да бъде нашисан с командата expr. Например вместо add=$(($x + $y)), щяхме да пишем add=$(expr $x + $y), или  add=`expr $x + $y`.

#!/bin/bash

Променливата тук е  user_name. Разбира се може да я наречете както си искате. read ще ви изчака да въведето нещо и да натиснете клавиша ENTER. Ако не натиснете нищо, командата read ще чака докато натиснете ENTER . Ако  ENTER е натиснат без да е въведено нещо то ще продължи изпълнението на програмата от следващия ред. Ето и пример:

#!/bin/bash
# gets the name of the user and prints a greeting
echo -n "Enter your name: "
read user_name

# the user did not enter anything:

echo "Hello $user_name!"

Ако потребителя натисне само клавиша ENTER нашата програма ще се оплаче и ще прекрати изпълнението си. В противен случай ще изпечата поздравление. Четенето на информацията която се въвежда от клавиатурата е полезно когато правите интерактивни програми, който изискват потребителя да отговори на конкретни въпроси.

Функции
Функциите правят скрипта по-лесен за поддържане. Най-общо казано фумкциите разделят програмаата на малки части. Функциите изпълняват действия, който вие сте дефинирали и може да върне стойност от изпълнението си ако желаете. Преди да продължим ще ви покажа един пример на шел програма която използва функция:

#!/bin/bash

# functiqta hello() samo izpechatwa syobshtenie
hello()
{
    echo "Wie ste wyw funkciq hello()"
}

echo "Izwikwame funkciqta hello()..."

Опитайте се да напишете тази програма и да я стартирате. Единствената цел на  функцията hello() е да изпечата съобщение. Функциите естествено могат да изпълняват и по-сложни задачи. В горния пример ние извикахме функцията   hello() с този ред:

Когато се изпълнява този ред  bash интерпретатора претърсва скрипта за ред който започва с  hello(). След което открива този ред и изпълнява съдържанието на функцията.

Функциите винаги се извикват чрез тяхното име. Когато  пишете функция можете да започнете функцията с  function_name(), както беше направено в горния пример, или да използвате думата function т.е  function function_name(). Другия начин по-който можем да започнем нашата функция е  function hello():

function hello()

Функциите винаги започват с  отваряща и затваряща скоба"()", последвани от   отварящи и затварящи къдрави скоби: "{...}". Тези къдрави скоби бележат началото и края на функцията.  Всеки ред с код затворен в тези скоби ще бъде изпълнен и ще принадлежи единствено на функцията. Функциите трябва винаги да бъдат дефинирани преди да бъдат извикани. Нека погледнем нашата програма само, че този път ще извикаме функцията преди да е дефинирана:

#!/bin/bash
echo "Izwikwame funkciqta hello()..."
# call the hello() function:
hello
echo "Weche izleznahte ot  funkciqta hello()"

# function hello() just prints a message

Ето какъв е резултата когато се опитаме да изпълним програмата:

xconsole$ ./hello.sh
Izwikwame funkciqta hello()...
./hello.sh: hello: command not found
Weche izleznahte ot  funkciqta hello()

Както виждате програма върна грешка. Ето защо е добре да пишете вашите функции в началото  на скрипта или поне преди са ги извикате. Ето друг пример как да използваме функции:

#!/bin/bash
# admin.sh - administrative tool

# function new_user() creates a new user account

echo "1. Add user"

echo "Enter your choice: "

case $choice in

За да работи правилно тази програма трябва да сте влезли като root, тъй като adduser е програма която само root потребителя има право да изпълнява. Да се надяваме че този кратък пример ви е убедил в полезноста на фукциите.

#!/bin/bash

# da se zipylni funkciqta sorry() pri natiskane na CTRL-C:

# function sorry() prints a message

# count down from 10 to 1:

Сега докато програмата върви и брои числа в обратен ред натиснете CTRL-C. Това ще изпрати сигнал за прекъсване на програмата. Сигналът ще бъде прихванат от trap командата, която ще изпълни sorry() функцията. Можете да накарате trap да игнорира сигнал като поставите  "''" на мястото на действие. Можете да накарате trap да не прихваща сигнал като използвате  "-". Например:

# izpylni sorry() funkciqta kogato programa poluchi signal SIGINT:
trap sorry INT

# nakaraj programata da NE prihwashta SIGINT signala :

# ne prawi nishto kogato se prihwane signal SIGINT:

Когато кажете на  trap да не прихваща сигнала, то програма се подчинява на основното действие на сигнал, което в конкретния случай е да прекъсне програмата и да я "убие". Когато укажете trap да не прави нищо при получаване на конкретен сигнал, то програма ще продължи своето действие игнорирайки сигнала.

AND изразът проверява първо най-лявото условие. Ако условието е вярно се проверява второто условие. Ако и то е вярно се изпълнява останалата част от кода на скрипта. Ако условие условие_1 не е вярно(върне резултат  false), тогава   условие условие_2 няма да бъде проверено. С други думи:

Ето един пример с AND условие:

#!/bin/bash
x=5
y=10
if [ "$x" -eq 5 ] && [ "$y" -eq 10 ]; then
    echo "I dwete uslowiq sa wqrni."
else
    echo "Uslowiqta ne sa wqrni."
fi

Тук виждаме, че x и y имат стойността за която проверяваме. Променете стойноста на x от x=5 на  x=12, след което пуснете отново програмата и ще се убедите, че условието не е изпълнено( връща стойност false).

OR изразът е подобен. Единствената разлика е, че проверява дали най-левият израз не е верен(т.е връща резултат false). Ако това е изпълнено се проверява следващият израз, и по-следващия:

условие_1 || условие_2

С други думи това звучи така:

Ето защо кодът след този условен оператор ще бъде изпълнен ако поне едно от условията е вярно:

#!/bin/bash
x=3
y=2
if [ "$x" -eq 5 ] || [ "$y" -eq 2 ]; then
    echo "Edno ot uslowiqta e wqrno."
else
    echo "Nito edno ot uslowiqta ne e wqrno."
fi

В този пример ще се уверите, че едно от условията е вярно. Сменете стойността на променливата y и изпълнете отново програмата. Ще видите, че нито едно от условията не е вярно..

Ако се замислите, ще видите, че условният оператор  if може да замести употребата на AND и OR изразите. Това става чрез използването на вложени if оператори. "Влагане на if оператори"  означава да използваме if оператор в тялото на друг if оператор. Можете да правите влагане и на други оператори, а не само на if. Ето един пример с вложени ifоператори, който заместват използването на AND израз в кода на програмата:

#!/bin/bash

Резултатът е същия както и ако използвахме AND израз. Проблемът е, че кодът става по трудно четим и отнема повече време за да се напише. За да се предпазите от проблеми използвайте AND и OR изрази.

xconsole$ foo argument

$# ще има стойност 1 , защото има само един аргумент подаден на програмата. Ако имате два аргумента, тогава $# ще има стойност 2. В допълнение стойноста на всеки аргумент (нулевият аргумент е винаги името на програма - foo) може да се вземе като използвате променливите $0 - за името на програмата в случая foo, $1 за стойноста на първият аргумент -argument и т.н. Може да имате максимум 9 такива променливи от  $0 до $9. Нека да видим това в действие:

#!/bin/bash

echo "Stojnosta na argumenta e $1"

Тази програма очаква един и само един аргумент за да тръгне. Ако я стартирате без аргументи, или подадете повече от един аргумент, програмата ще изпечата съобщение за това как да се използва. В случай че имаме само един аргумент шел програмата ще отпечата стойноста на аргумента който сте подали. Припомнете си, че $0 е името на програмата. Ето защо тази специална променлива се използва в "usage" съобщението.

Пренасочване и PIPING
Обикновено, когато стартирате дадена команда, резултата от изпълнението се отпечатва на екрана. Например:

xconsole$ echo "Hello World"

"Пренасочването" ви позволява да съхраните резултата от изпълнението накъде другаде. В повечето случаи това става към файл. Операторът ">" се използва за пренасочване на изхода. Мислете за него като за стрелка сочеща  къде да отиде резултата. Ето еди пример за пренасочване на изхода към файл:

xconsole$ echo "Hello World" > foo.file
xconsole$ cat foo.file
Hello World

Тук резултатът от командата echo "Hello World" е пренасочен към файл с име foo.file. Когато прочетете съдържанието на файла ще видите там резултата. Има един проблем когато използвате оператора ">". Ако имате файл със същото име, то неговото съдържание няма да бъде запазено, а ще бъде изтрито и заместено с новото. Ами ако искате да добавите информация във файла без да изтривате старата? Тогава трябва да използвате оператора за добавяне : ">>". Използва се по същият начин с тази разлика, че не изтрива старото съдържание на файла, а го запазва и добавя новото съдържание накрая.

А сега ще ви запознаем с piping. Piping-ът ви позволява да вземете резултата от изпълнението на дадена програма и да го използвате като входни данни за друга програма. Piping става посредством оператора: "|". Забележете, че това не е малката буквата "L". Този оператор може да получите чрез натискане на клавиша SHIFT и \. Ето и един пример за piping:

xconsole$ cat /etc/passwd | grep xconsole

Тук четем целия файл /etc/passwd и след това резултатът е подаден за обработка на командата grep, която от своя страна, претърсва текста за низът   xconsole и изпечатва целия ред съдържащ този низ на екрана. Може да използвате и пренасочване за да запишете крайният резултат на файл:

xconsole$ cat /etc/passwd | grep xconsole > foo.file
xconsole$ cat foo.file
xconsole:x:1002:100:X_console,,,:/home/xconsole:/bin/bash

Работи. Файлът /etc/passwd е прочетен, и неговото съдържание е претърсено от командата grep за низът xconsole. След което крайният резултат е пренасочен към файл foo.file. Ще откриете, че пренасочване и piping  са много полезни средства когато пишете вашите шел програми.

xconsole$ touch hello

Ето го и нашият временен файл.

xconsole$ grep "foobar" /etc/passwd

Няма никъв резултат от изпълнението. Това означава че grep не е намерила съвпадение. Но може да направим програмата много по-полезна ако се появява съобщение, което пояснява резултата. Това е когато искате да проверите стойноста която се връща от дадена програма. Има една специална променлива, която съдържа крайният резултат от изпълнението на програмата. Тази променлива е $?.Разгледайте следният код:

#!/bin/bash
# grep for user foobar and pipe all output to /dev/null:
grep "foobar" /etc/passwd > /dev/null 2>&1
# capture the return value and act accordingly:
if [ "$?" -eq 0 ]; then
   echo "Match found."
    exit
else
    echo "No match found."
fi

Когато стартираме програмата променливата "$?" ще прихване резултата от командата grep. Ако той е равен на 0, значи има съвпадение и подходящо съобщение ще обяви за това. В противен случай, ще изпечата, че няма съвпадения. Това е един основен начин за получаване на резултата, който връща дадена програма. Ще откриете, че доста често ще ви се наложи да знаете стойността, която връща дадена програма за да продължите по-нататък.

Ако случайно се чудите какво значи 2>&1 сега ще ви обясня . Под Linux, тези номера обозначават файлови дескриптори. 0 е за стандартния вход (пример: клавиатура), 1 е за стандартния изход (пример: монитор) и 2 е за стандартния изход на грешките (пример: монитор). Всяка обикновена  информация се изпраща на файлов дескриптор 1, и ако има грешки те се изпращат на файлов дескриптор 2. Ако не искате тези съобщения да излизат просто можете да ги пренасочите към /dev/null. Забележете, че това няма да спре изпращането на информацията на стандартния изход. Например ако нямате права да четете от директория на друг потребител вие няма да можете да видите нейното съдържание:

xconsole$ ls /root

Както виждате съобщението за грешка не беше изпечатано. Същото важи както и за други програми така и за файлов дескриптор 1. Ако не искате резултата от изпълнението на програмата да се отпечатва на екрана, можете спокойно да го пренасочите към /dev/null. Ако не искате да виждате както резултата от изпълнението, така и съобщенията за грешка може да го направите по следният начин:

xconsole$ ls /root > /dev/null 2>&1

Това означава че резултата от програмата както и всяка грешка която предизвика тази програма ще бъдат изпратени на /dev/null, така че никога повече няма да можете да ги видите.

Какво трябва да направите ако искате вашият шел скрипт да връща стиойност при завършване на програмата? Командата  exit приема само един аргумент - число което трябва да се върне при   завършване на програмата. Обикновно числото 0 се използва за да кажем, че програмата е завършила успешно, т.е. не е възникнала никаква грешка по време на нейното изпълнение. Всичко по-голямо или по-малко от 0 обикновено обозначава, че е възникнала някаква грешка. Това го решавате вие като програмист. Нека проследим следната програма:

#!/bin/bash