Każdy początkujący Administrator systemu Linux prędzej czy później napotka takie pojęcie jak „ scenariusz”, czy to jeden ze skryptów rozruchowych, takich jak /etc/rc.d/rc lub skrypt konfiguracyjny napisany przez programistę skonfigurować. W tym artykule postaram się pokazać, że pisanie skryptów na powłoka nie jest czymś niezwykłym i jest w zasięgu nawet początkującego w świecie Linuksa.

Zacznijmy od tego, że przeanalizujemy, co kryje się za angielskimi terminami powłoka oraz scenariusz. Powłoka, lub powłoka, jak ten termin jest czasami tłumaczony, jest interpreterem poleceń, interfejsem między użytkownikiem a systemem operacyjnym, jego jądrem. Ale poza tym jest to również potężny język programowania i skryptowania. Zawiera własne słowa serwisowe i struktury sterujące oraz umożliwia pisanie na nich programów. Taki program w języku skryptowym o nazwie scenariusz, może łączyć wywołania systemowe i polecenia system operacyjny, a także narzędzia zewnętrzne, tworząc potężne narzędzie do Administracja systemu.

Jednym z zadań administracji systemem jest tworzenie kopii zapasowych ważna informacja. Dlatego spójrzmy na przykład skryptu, który implementuje informacje zapasowe.

Początek czasu

Przede wszystkim musimy więc zrozumieć strukturę skryptu. Nie jest niczym skomplikowanym. Ogólnie rzecz biorąc, najprostszy skrypt to tylko lista poleceń systemowych. Na przykład:

Echo To tylko przykład
kim jestem
uname-a

Te polecenia są połączone w jednym pliku. Ale powłoka musi wiedzieć, że musi przetworzyć ten plik, a nie tylko odczytać jego zawartość. Jest do tego specjalna konstrukcja: #!

Ten projekt nazywa się „ sha bang”. Właściwie # określa komentarz, ale w tym przypadku sha-bang oznacza, że po nim pójdzie ścieżka do obsługi skryptu. Na przykład:

#!/kosz/bash
#!/kosz/sz
#!/usr/bin/perl

Skupimy się na Bash, powłoce Bourne-Again. Ta powłoka jest domyślnie instalowana w prawie wszystkich systemach Linux i odnosi się do niej /bin/sh. Słowo serwisowe exit wskazuje na koniec skryptu.

Uzbrojeni w tę wiedzę napiszmy nasz pierwszy scenariusz:

#!/kosz/bash
echo Prosty skrypt # Polecenie echo wyświetla komunikat na ekranie
echo Ciebie:
whoami # whoami pokazuje imię zarejestrowanego użytkownika
echo Twój system został uruchomiony
uptime # uptime pokazuje czas włączenia maszyny
echo dzisiaj
data # data pokazuje aktualną datę i godzinę
echo To wszystko na razie
Wyjście

Zapiszmy ten plik jako tutor1.sh. Wykonajmy polecenie, aby skrypt był wykonywalny.

Chmod + rx tutor1.sh

Rezultatem uruchomienia skryptu będzie:

[e-mail chroniony]:~/Dokument/Open Source$ ./tutor1.sh
Prosty skrypt
Ty:
Voland
Twój system został uruchomiony
14:38:46 do 1:48, 2 użytkowników, średnie obciążenie: 0,47, 0,43, 0,41
Dziś
niedziela 26 lutego 14:38:46 MSK 2006
PA pa

Przejdźmy do czegoś poważniejszego.

Teraz, gdy nauczyliśmy się pisać najprostsze skrypty, nadszedł czas, aby przejść do poważnych rzeczy: pisania skryptu dla Zarezerwuj kopię.

Przede wszystkim należy ustalić – kopię zapasową tego, co będziemy robić. Dlatego nasz skrypt musi mieć możliwość pracy z wierszem poleceń. Argumenty wiersz poleceń są podane po nazwie skryptu oddzielone spacją: jakiśskrypt arg1 arg2 arg3. Skrypt akceptuje argumenty według ich numerów sekwencyjnych, więc użyjemy konstrukcji takich jak $argument_number, czyli 1 dolar, 2 dolary, 3 dolary. $ to symbol wieloznaczny, którego będziemy potrzebować również podczas pracy ze zmiennymi. Zmienne w skrypcie są określone w postaci nazwa_zmiennej=wartość. Użyjemy zmiennych MAXPARAMS do określenia maksymalnej liczby opcji wiersza poleceń, BACKUPFILE do nadania nazwy archiwum, BACKUPDIR do folderu, którego kopię zapasową będziemy tworzyć, oraz ARCHIVEDIR do folderu, w którym umieścimy archiwum. Najważniejszą częścią skryptu będą polecenia do wyszukiwania i archiwizowania wszystkich znalezionych plików i folderów we wskazanym:

znajdować. -typ f -print0 | xargs -0 tar rvf "$archive.tar" > /dev/null
gzip $archiwum.tar

Zobaczmy, co robią te polecenia. find przeszukuje bieżący katalog (jest to wskazywany przez pierwszy argument „.”) dla wszystkich plików i wyświetla pełną ścieżkę do nich (print0). Te ścieżki są przekierowywane do polecenia tar, które zbiera wszystkie pliki w jeden. Następnie używamy polecenia gzip do skompresowania wynikowego pliku tar. Zespół > /dev/null przydatne, jeśli archiwizujesz duża liczba akta. W takim przypadku ich nazwy i pełne ścieżki do nich nie są wyświetlane na konsoli.

Następnym krokiem jest dostarczenie użytkownikowi wskazówek, jak korzystać ze skryptu, jeśli popełni jakieś błędy.

Na przykład ta konstrukcja

If [ $# -lt "$MAXPARAMS" ];
następnie
Echo

Echo
wyjście 0
fi

pyta, co określił użytkownik niewystarczająca ilość argumenty wiersza poleceń. Jeśli [warunek]...fi definiuje konstrukcję warunkową. $# -lt "$MAXPARAMS" sprawdza wprowadzoną liczbę parametrów i jeśli ta liczba jest mniejsza niż MAXPARAMS, to użytkownik otrzyma komunikat o błędnym wprowadzeniu. Wyjście 0 spowoduje zakończenie działania skryptu bez podania kodu błędu. Podobnie sprawdzane jest przekroczenie dozwolonej liczby parametrów, ale zamiast ls (mniej niż - mniej niż) należy podać gt (większe niż - więcej). Teraz, gdy wyjaśniono główne punkty skryptu, możesz przejść do jego pełnej wersji:

#!/kosz/bash
# Opis:
#+ Tworzy kopię zapasową wszystkich plików w określonym katalogu
#+ w "tarball" (archiwum tar.gz).
#+ Użycie:
#+ sh backup.sh nazwa_archiwum folder źródłowy folder docelowy
#+

# Maksymalna liczba opcji wiersza poleceń
MAXPARAMETRY=3

if [ $# -lt "$MAXPARAMS" ];
następnie
Echo
echo "Użycie: sh `basename $0` nazwa zip folder źródłowy folder docelowy"
Echo
wyjście 0
fi

if [ $# -gt "$MAXPARAMS" ];
następnie
Echo
echo "Ten skrypt potrzebuje tylko argumentów wiersza poleceń $MAXPARAMS!"
Echo
wyjście 0
fi

# Zmienne, których używamy w skrypcie
BACKUPFILE=$1-kopia-zapasowa-$(data +%m-%d-%Y)
archiwum=$BACKUPFILE
BACKUPDIR = 2 USD
ARCHIWIZACJA=3 USD

# Sprawdź, czy istnieje folder źródłowy i folder docelowy
jeśli[! -e $BACKUPDIR];
następnie
Echo
echo "\"$BACKUPDIR\" nie istnieje!"
Echo
wyjście 0
fi

jeśli[! -e $ARCHIWID.];
następnie
Echo
echo "\"$ARCHIVEDIR\" nie istnieje, utwórz..."
mkdir $ARCHIVEDIR
echo „Gotowe”.
fi

# Sprawdź, czy w źródle i miejscu docelowym znajdują się archiwa.
cd $ARCHIVEDIR
if [ -e $archiwum.tar.gz ];
następnie rm $archive.tar.gz
fi

cd $BACKUPDIR
if [ -e $archiwum.tar.gz ];
następnie rm $archive.tar.gz
fi

# Główna część scenariusza...
echo "Kopia zapasowa \"$BACKUPDIR\" do pliku \"$archive.tar.gz\"..."
znajdować. -typ f -print0 | xargs -0 tar rvf "$archive.tar" > /dev/null
gzip $archiwum.tar
echo "\"$BACKUPDIR\" został pomyślnie zarchiwizowany do pliku \"$archive.tar.gz\"."

# Przenieś archiwum do folderu ARCHIVEDIR
echo "Przenoszenie archiwum \"$archive.tar.gz\" do folderu \"$ARCHIVEDIR\"."
mv $archive.tar.gz $ARCHIVEDIR/$archive.tar.gz
echo „Gotowe”.

Mam nadzieję, że skomentowałem główne punkty wystarczająco szczegółowo. Jeśli masz jakieś pytania, możesz skontaktować się ze mną pod adresem [e-mail chroniony] Polecam również wspaniałą książkę Advanced Bash-Scripting Guide autorstwa Mendla Coopera, która bardzo mi pomogła w czasie, gdy dopiero zapoznawałem się ze skryptami. Udanego programowania.

PS Wielkie dzięki zniszczyć za jej uwagi i rady.

Po przeczytaniu tego artykułu dowiesz się, co to jest grzmotnąć(standardowa powłoka linux), dowiedz się, jak obsługiwać standardowe polecenia: ls, cp, mv...zrozumieć przeznaczenie i-węzłów, twardych i symbolicznych dowiązań i nie tylko.

Ten samouczek jest przeznaczony dla tych, którzy są nowicjuszami w Linuksie i chcą przejrzeć lub poprawić swoje zrozumienie podstawowych pojęć Linuksa, takich jak kopiowanie i przenoszenie plików, tworzenie łączy, używanie standardowych poleceń Linuksa wraz z przekierowaniami i potokami. W tym artykule znajdziesz wiele przykładów wyjaśniających prezentowany materiał. Dla początkujących większość informacji będzie nowa, ale dla bardziej zaawansowanych użytkowników ten materiał może być doskonałym narzędziem do podsumowania posiadanej wiedzy i umiejętności.

Wprowadzenie do bash

Powłoka

Jeśli używasz Linuksa, to wiesz, że po zalogowaniu zostaniesz przywitany przez znak zachęty interpretera poleceń. Na przykład to:

Jeśli po zalogowaniu ładowana jest powłoka graficzna, to aby dostać się do interpretera poleceń, musisz uruchomić emulator terminala (gnome-terminal, xfce4-terminal, konsole, xterm, rxvt...) lub przełączyć się na jeden z terminali wirtualnych przez pilny klawisz kontrolny–Alt–F1 lub klawisz kontrolny–Alt–F2 itp.

Monit powłoki na twoim komputerze może różnić się od tego, co pokazano w przykładzie. Może zawierać nazwę użytkownika, nazwę komputera i nazwę bieżącego katalogu roboczego. Ale pomimo tych wszystkich różnic program, który wyświetla ten monit, nazywa się „ powłoka" (powłoka) i najprawdopodobniej twoja powłoka to program o nazwie grzmotnąć.

Prowadzisz bash?

Możesz sprawdzić, czy bash działa za pomocą następującego polecenia:

\$ echo \$SHELL/bin/bash

Jeśli pojawi się błąd w wyniku wykonania tego polecenia lub jego dane wyjściowe różnią się od tego w przykładzie, możliwe, że bash nie jest używany jako powłoka poleceń w twoim systemie. Mimo to większość materiałów będzie istotna, ale nadal zalecamy przejście na bash. Można to zrobić (jeśli w systemie jest zainstalowany bash) za pomocą polecenia:

\$ grzmotnąć

Co to jest bash

Bash (akronim dla „ B nasz- a osiągać CII ell") jest standardowym interpreterem poleceń w większości systemów Linux. Jest odpowiedzialny za przetwarzanie i wykonywanie poleceń, którymi użytkownik steruje komputerem. Po zakończeniu pracy możesz wyjść z procesu interpretera poleceń. Po naciśnięciu klawiszy klawisz kontrolny–D, polecenia Wyjście lub Wyloguj proces powłoki zostanie zakończony, a ekran ponownie poprosi o podanie nazwy użytkownika i hasła.

Korzystanie z „cd”

Zacznijmy używać bash do nawigacji w systemie plików. Aby rozpocząć, wpisz następujące polecenie:

$ płyta CD /

Za pomocą tego polecenia powiedzieliśmy bashowi, że chcemy przejść do katalogu głównego - / . Wszystkie katalogi w systemie są zorganizowane w strukturę drzewa i / to jest jego początek (lub korzeń). Zespół płyta CD służy do zmiany bieżącego katalogu roboczego.

Sposoby

Aby dowiedzieć się, gdzie w systemie plików ten moment jesteś w (bieżącym katalogu roboczym) wpisz:

\$ pwd /

W powyższym przykładzie / - argument polecenia płyta CD- nazywa sposób. To jest lokalizacja systemu plików, do której chcemy się przenieść. W tym przypadku / - ścieżka bezwzględna, co oznacza, że ścieżka jest względna do katalogu głównego.

Ścieżki absolutne

Oto kilka przykładów ścieżek absolutnych

/dev /usr /usr/bin /usr/local/bin

Jak mogłeś zauważyć, wszystkie te ścieżki łączy fakt, że zaczynają się od / . Określanie ścieżki /usr/local/bin jako argumentu polecenia płyta CD mówimy mu, aby przeszedł do katalogu głównego / , potem do katalogu usr, potem do lokalnego i bin. Ścieżki absolutne zawsze zaczynają się od /

Ścieżki względne

Drugi rodzaj ścieżek nazywa się względnymi. grzmotnąć, zespół płyta CD a inne polecenia liczą te ścieżki względem bieżącego katalogu. Względne ścieżki nigdy nie zaczynają się od / . Na przykład, jeśli jesteśmy w /usr

\$ cd /usr

Następnie możemy przejść do /usr/local/bin przy użyciu ścieżki względnej

\$ lokalna płyta CD/bin \$ pwd/usr/local/bin

Stosowanie ".."

Ścieżki względne mogą zawierać jeden lub więcej katalogów ".." . „..” wskazuje katalog nadrzędny naszego katalogu roboczego. Przykład:

\$ pwd/usr/local/bin\$ płyta CD.. \$ pwd/usr/lokalny

Jak widać polecenie płyta CD..„przenosi nas na wyższy poziom”.

Mogę dodać .. do ścieżki względnej. Spowoduje to przeniesienie do katalogu, który jest na tym samym poziomie, co ten, w którym się znajdujemy. Przykład:

\$ pwd/usr/lokalny\$ cd ../udostępnij \$ pwd/usr/share

Przykłady z wykorzystaniem ścieżek względnych

Ścieżki względne mogą być dość trudne. Oto kilka przykładów. Wynik wykonania poleceń nie jest wyświetlany, spróbuj określić, w którym katalogu się znajdziesz, używając basha.

\$ cd /bin \$ cd ../usr/share/zoneinfo \$ cd /usr/X11R6/bin \$ cd ../lib/X11 \$ cd /usr/bin \$ cd ../bin/../bin

Katalog roboczy "."

Zanim skończysz mówić o zespole płyta CD, należy wspomnieć o kilku innych rzeczach. Po pierwsze, jest inny specjalny katalog "." , który wskazuje na bieżący katalog. Ten katalog jest używany do uruchamiania plików wykonywalnych znajdujących się w bieżącym katalogu.

\$ ./myprog

W ostatni przykład myprog to plik wykonywalny w bieżącym katalogu, który zostanie wykonany.

cd i katalog domowy użytkownika

Aby przejść do katalogu domowego, wpisz

\$ płyta CD

Bez argumentu cd przeniesie Cię do Twojego katalogu domowego. Dla superużytkownika katalogiem domowym jest zwykle /root, a dla zwykłych użytkowników jest to /home/nazwa_użytkownika/. Ale co, jeśli chcemy określić konkretny plik znajdujący się w katalogu domowym. Na przykład jako argument do programu "mojprog"? Możesz pisać:

\$ ./myprog /home/user/myfile.txt

Jednak korzystanie z bezwzględnych ścieżek plików nie zawsze jest wygodne. Tę samą operację można wykonać za pomocą ~ –tyldy:

\$ ./mójprog ~/mójplik.txt

~ to specjalna nazwa, która wskazuje na katalog domowy użytkownika w bash.

Katalogi domowe innych użytkowników

Ale co, jeśli musimy wskazać plik w katalogu domowym innego użytkownika? Aby to zrobić, po tyldzie musisz podać nazwę tego użytkownika. Na przykład, aby wskazać plik fredsfile.txt znajdujący się w katalogu domowym użytkownika fred:

\$ ./myprog ~fred/fredsfile.txt

Polecenia Linuksa

Wprowadzenie do ls

Prawdopodobnie znasz już drużynę ls, który wywołany bez argumentów wyświetla listę plików przechowywanych w katalogu roboczym:

\$ cd /usr \$ ls X11R6 doc i686-pc-linux-gnu lib man sbin ssl bin gentoo-x86 include libexec portage share tmp distfiles i686-linux info lokalne portage.old src

Jeśli określisz opcję -a, będziesz mógł zobaczyć wszystkie pliki, w tym ukryte (którego nazwy zaczynają się od kropki).

\$ ls-a. bin gentoo-x86 include libexec portage share tmp .. distfiles i686-linux info lokalne portage.old src X11R6 doc i686-pc-linux-gnu lib man sbin ssl

Szczegółowa lista katalogów

Po komendzie ls jako argument można podać jeden lub więcej plików lub katalogów. Jeśli podasz nazwę pliku, to polecenie ls wyświetli informacje tylko o tym pliku. A jeśli podasz nazwę katalogu, ls pokaże całą jego zawartość. Opcja „-l” polecenia ls może być bardzo przydatne, jeśli chcesz wiedzieć więcej niż tylko nazwy plików dokładna informacja o nich (uprawnienia do pliku, nazwa właściciela, czas ostatniej modyfikacji pliku i jego rozmiar).

Poniższy przykład pokazuje użycie opcji „-l” aby wyświetlić informacje o plikach przechowywanych w katalogu /usr

\$ ls -l / usr drwxr-xr-x 7 root root 168 Nov 24 14:02 X11R6 drwxr-xr-x 2 root root 14576 Dec 27 08:56 bin drwxr-xr-x 2 root root 8856 Dec 26 12:47 distfiles lrwxrwxrwx 1 root root 9 22 grudnia 20:57 doc -> share/doc drwxr-xr-x 62 root root 1856 27 grudnia 15:54 gentoo-x86 drwxr-xr-x 4 root root 152 12 grudnia 23:10 i686-linux drwxr-xr-x 4 root root 96 Lis 24 13:17 i686-pc-linux-gnu drwxr-xr-x 54 root root 5992 Gru 24 22:30 include lrwxrwxrwx 1 root root 10 Dec 22 20:57 info -> share/info drwxr-xr -x 28 root root 13552 Dec 26 00:31 lib drwxr-xr-x 3 root root 72 Nov 25 00:34 libexec drwxr-xr-x 8 root root 240 Dec 22 20:57 local lrwxrwxrwx 1 root root 9 Dec 22 20 :57 man -> share/man lrwxrwxrwx 1 root root 11 grudnia 8 07:59 portage -> gentoo-x86/ drwxr-xr-x 60 root root 1864 8 grudnia 07:55 portage.old drwxr-xr-x 3 root root 3096 22 grudnia 20:57 sbin drwxr-xr-x 46 root root 1144 24 grudnia 15:32 udostępnij drwxr-xr-x 8 root root 25 ssl lrwxrwxrwx 1 root root 10 22 grudnia 20:57 tmp -> ../var/tmp

Pierwsza kolumna zawiera informacje o uprawnieniach dla każdego pliku na liście. (Nieco później wyjaśnię, która litera oznacza co). Następna kolumna pokazuje liczbę linków do każdego elementu listy. Trzecia i czwarta kolumna to odpowiednio właściciel i grupa pliku. Piąta kolumna to rozmiar. Szósty to czas ostatniej modyfikacji pliku („czas ostatniej modyfikacji” lub mtime). Ostatnia kolumna to nazwa pliku lub katalogu (jeśli jest to link, to po znaku „ –> „ to nazwa obiektu, do którego się odnosi).

Jak przeglądać tylko katalogi

Czasami istnieje potrzeba przeglądania informacji tylko o katalogach, a nie o całej ich zawartości. Opcja pomoże w tym zadaniu. "-d", który mówi poleceniu, aby wyświetlało tylko informacje o katalogach. Przykład:

\$ ls -dl /usr /usr/bin /usr/X11R6/bin ../share drwxr-xr-x 4 root root 96 18 grudnia 18:17 ../share drwxr-xr-x 17 root root 576 24 grudnia 09:03 /usr /X11R6/bin drwxr-xr-x 2 root root 14576 27 grudnia 08 :56 /usr/bin

Lista rekurencyjna i informacje o i-węźle

Akcja opcji "-R" działanie przeciwne "-d". Pozwala na rekurencyjne wyświetlanie informacji o plikach w katalogu. Zawartość katalogu jest pokazana jako pierwsza. Najwyższy poziom, następnie po kolei zawartość wszystkich podkatalogów i tak dalej. Dane wyjściowe tego polecenia mogą być dość duże, więc nie podajemy jego przykładu, ale możesz spróbować samodzielnie, wpisując „ ls -R" lub " ls-RL".

I wreszcie opcja "-i" używany do wyprowadzania i-węzłów każdego obiektu systemu plików.

\$ ls -i / usr 1409 314258 X11R6 i686-linux libexec 43090 13394 sbin 1417 1513 bin i686-pc-linux-gnu 5120 udział lokalny 13408 8316 pliki dystrybucyjne 1517 zawiera 776 man src 23779 43 1386 doc portage info 93892 36737 70744 ssl 1585 gentoo- 784 tmp

Czym są i-węzły?

Każdy obiekt systemu plików (plik, katalog...) ma swój własny unikalny numer zwany i-węzeł(numer i-węzła). Ta informacja może wydawać się nieistotna, ale zrozumienie funkcji i-węzłów pomoże ci zrozumieć wiele operacji na systemie plików. Na przykład spójrzmy na "." oraz ".." jak linki obecne w każdym katalogu. Aby zrozumieć, czym jest katalog ".." , znajdź i-węzeł katalogu /use/local

\$ ls -id /usr/local 5120 /usr/lokalny

Jak widać, i-węzeł katalogu /usr/local to 5120. Zobaczmy teraz, jaki i-węzeł ma katalog /usr/local/bin/..:

\$ ls -id /usr/local/bin/.. 5120 /usr/lokalny/bin/..

Okazuje się, że i-węzły katalogów /usr/local i /usr/local/bin/.. są takie same! Oznacza to, że dwie nazwy odnoszą się do i-węzła 5120: /usr/local i /usr/local/bin/.. To znaczy, są to dwie różne nazwy dla tego samego katalogu. Każdy i-węzeł wskazuje określoną lokalizację na dysku.

Z każdym i-węzłem może być powiązanych wiele nazw obiektów systemu plików. Liczba „synonimów” pliku (obiekty systemu plików odnoszące się do jednego i-węzła) pokazuje liczbę w drugiej kolumnie „ ls-l".

\$ ls -dl /usr/local drwxr-xr-x 8 root root 240 22 grudnia 20:57 /usr/local

W tym przykładzie widać (druga kolumna), że do katalogu /usr/local odwołuje się 8 różnych obiektów systemu plików. Oto ich imiona:

/usr/lokalny /usr/lokalny/. /usr/local/bin/.. /usr/local/games/.. /usr/local/lib/.. /usr/local/sbin/.. /usr/local/share/.. /usr/local/ nauka/..

mkdir

Rzućmy okiem na polecenie mkdir. Służy do tworzenia nowych katalogów. Poniższy przykład demonstruje tworzenie trzech nowych katalogów (tic, tac, toe) w katalogu /tmp

\$ cd /tmp $ mkdir kółko i krzyżyk

Domyślne polecenie mkdir nie można utworzyć zagnieżdżonej struktury katalogów. Dlatego jeśli potrzebujesz utworzyć kilka katalogów zagnieżdżonych ( wspaniale), wtedy będziesz musiał wywołać to polecenie trzy razy po kolei:

\$ mkdir wygrał/der/pełny mkdir: nie można utworzyć katalogu "won/der/ful": Brak takiego pliku lub katalogu \$ mkdir wygrał \$ mkdir wygrał/der \$ mkdir wygrał/der/pełny

Możesz uprościć tę operację, dodając opcję "-p" do polecenia mkdir. Ta opcja umożliwia utworzenie zagnieżdżonej struktury katalogów:

\$ mkdir -p łatwe/jako/pie

Aby dowiedzieć się więcej o możliwościach tego narzędzia, przeczytaj pomoc wywoływaną przez polecenie mężczyzna mkdir. Pomoc jest dostępna dla prawie wszystkich poleceń w tym podręczniku (na przykład mężczyzna jest), Oprócz płyta CD, ponieważ jest wbudowany w bash (dla takich poleceń pomoc nazywa się tak: CD z pomocą)

dotykać

Przejdźmy do nauki poleceń cp oraz mv, używany do kopiowania, zmiany nazwy i przenoszenia plików i katalogów. Ale wcześniej utwórzmy pusty plik w katalogu /tmp za pomocą polecenia dotykać:

\$ cd /tmp \$ dotknij kopiuj

Zespół dotykać aktualizuje czas ostatniego dostępu do pliku (szósta kolumna wyjścia polecenia) ls-l), jeśli już istnieje, lub tworzy nowy pusty plik, jeśli jeszcze nie istnieje. Po tej operacji powinniśmy mieć pusty plik /tmp/kopiuj.

Echo

Teraz, gdy mamy pusty plik, napiszmy do niego ciąg tekstowy za pomocą polecenia Echo, który wypisuje przekazany do niego argument na standardowe wyjście (w naszym przypadku terminal tekstowy).

\$ echo "pierwszy plik" pierwszy plik

Aby zapisać ciąg do naszego pliku, przekierowujemy do niego wyjście polecenia Echo:

\$ echo "pierwszy plik" > kopiuj

Znak > (większe niż) nakazuje powłoce przekierowanie wyjścia polecenia po lewej stronie do nazwy pliku po prawej stronie. Jeśli plik o tej samej nazwie nie istnieje, zostanie utworzony automatycznie. A jeśli taki plik już istnieje, to zostanie nadpisany (cała jego zawartość zostanie usunięta przed zapisaniem naszej linii). Zespół „ls-l” pokaże, że rozmiar naszego pliku wynosi teraz 10 bajtów - dziewięć bajtów zajmuje słowo "pierwszy plik", a jeden bajt to znak nowego wiersza.

\$ ls -l kopiuj-rw-r--r-- 1 root root 10 grudnia 28 14:13 copyme

kot i cp

Aby wyświetlić zawartość pliku na terminalu, użyj polecenia kot:

\$ kot kopia pierwszy plik

Teraz możemy zacząć analizować podstawową funkcjonalność polecenia cp. To polecenie przyjmuje dwa argumenty. Pierwsza to nazwa istniejącego pliku ("copyme"), druga to nazwa nowej kopii, którą chcemy wykonać ("copyme").

\$ cp copyme skopiowane

Możemy się upewnić, że nowa kopia plik ma inny numer i-węzła (oznacza to, że otrzymaliśmy naprawdę nowy oddzielny plik, a nie tylko link do starego)

\$ ls -i kopiuję skopiowany 648284 kopia

mv

Teraz zastosujmy polecenie mv zmienić nazwę pliku ("copiedme" –> "movedme"). Numer i-węzła po tej operacji nie zmienia się, zmienia się tylko nazwa pliku.

\$ mv skopiował-mnie-przeniósł-mnie \$ ls - przeniosłem się 648284 przeniósł mnie

Numer i-węzła nie zmienia się, chyba że plik o zmienionej nazwie pozostaje w tym samym systemie plików, co plik oryginalny. W dalszej części tego samouczka przyjrzymy się bliżej rozmieszczeniu systemów plików.

Zespół mv pozwala nie tylko zmieniać nazwy plików, ale także je przenosić. Na przykład, aby przenieść plik /var/tmp/mojplik.txt do katalogu /dom/użytkownik musisz wydać polecenie:

\$ mv /var/tmp/mójplik.txt /home/użytkownik

Plik zostanie przeniesiony do katalogu domowego użytkownika użytkownik nawet jeśli znajduje się w innym systemie plików (w tym przypadku plik zostanie skopiowany do nowej lokalizacji, po czym oryginał zostanie usunięty). Jak można się domyślić, przeniesienie pliku do innego systemu plików zmienia jego i-węzeł. Dzieje się tak, ponieważ każdy system plików ma własny zestaw i-węzłów.

Należy zauważyć, że istnieje możliwość, że nowy przypisany numer i-węzła może być taki sam jak stary, ale jest bardzo mały.

Aby przenieść kilka plików jednocześnie do jednego katalogu, musisz napisać:

\$ mv /var/tmp/mójplik1.txt /var/tmp/mójplik2.txt /home/użytkownik \$ mv -t /home/user /var/tmp/mójplik1.txt /var/tmp/mójplik2.txt

Jeśli dodasz opcję "-v", na ekranie zostanie wyświetlony raport z wykonanej operacji:

\$ mv -vt /home/user /var/tmp/mójplik1.txt /var/tmp/mójplik2.txt"/var/tmp/mójplik1.txt" -> "/home/user/mójplik1.txt" "/var/tmp/mójplik2.txt" -> "/home/użytkownik/mójplik2.txt"

Tworzenie linków i usuwanie plików

Twarde linki

Wspomniałem już o słowie „link”, kiedy mówiłem o katalogach i i-węzłach. W Linuksie są właściwie dwa rodzaje łączy. Pierwszy typ to dowiązania twarde. Z każdym i-węzłem może być powiązanych wiele łączy twardych. Okazuje się więc, że plik występuje w systemie pod kilkoma różnymi nazwami. Plik istnieje tak długo, jak co najmniej jedna nazwa jest powiązana z jego i-węzłem. Terminy „twarde łącze do pliku” i „nazwa pliku” są synonimami. Nowe twarde dowiązania do pliku można utworzyć za pomocą polecenia ja

\$ cd /tmp \$ dotknij pierwszego linku \$ W pierwszym linku drugim linku \$ ls -i pierwsze łącze drugie łącze 15782 pierwsze ogniwo 15782 drugie ogniwo

Jak widać na przykładzie, dowiązania twarde działają na poziomie i-węzła, wskazując na określony plik. W systemie Linux dowiązania twarde mają kilka ograniczeń. Po pierwsze, możesz tylko dołączyć pliki, a nie katalogi. Zgadza się, pomimo faktu, że w systemie są twarde linki do katalogów (" . " oraz " .. "), nawet superużytkownik nie może tworzyć dodatkowych twardych dowiązań do katalogów. Po drugie, niemożliwe jest utworzenie twardego dowiązania do pliku znajdującego się w innym systemie plików, ponieważ każdy system plików ma swój własny, unikalny zestaw i-węzłów.

Dowiązania symboliczne

W praktyce dowiązania symboliczne (lub dowiązania symboliczne). Dowiązanie symboliczne to specjalny rodzaj pliku, który łączy się z innym plikiem według nazwy, a nie bezpośrednio do i-węzła. Dowiązania symboliczne nie uniemożliwiają usunięcia pliku. Jeśli plik zostanie usunięty, dowiązanie symboliczne do niego przestanie działać (lub złamany).

Dowiązania symboliczne są tworzone przez polecenie ja z opcją "-s":

\$ ln -s drugie łącze trzecie łącze \$ ls -l pierwsze dowiązanie drugie dowiązanie trzecie dowiązanie-rw-rw-r-- 2 agriffis agriffis 0 31 grudnia 19:08 pierwszy link -rw-rw-r-- 2 agriffis agriffis 0 31 grudnia 19:08 drugi link lrwxrwxrwx 1 agriffis agriffis 10 31 grudnia 19:39 trzeci link -> drugi link

Dowiązanie symboliczne można rozpoznać po danych wyjściowych polecenia ls-l: po pierwsze, w pierwszej kolumnie dowiązań symbolicznych znajduje się litera „ja”(pierwsza litera angielskiego słowa link to link), a po drugie, rozmiar dowiązania symbolicznego jest równy liczbie liter w nazwie pliku, do którego się odnosi ( "drugi link" w naszym przypadku), po trzecie, ostatnia kolumna, oprócz nazwy linku, zawiera po znaku nazwę pliku, do którego się odnosi –>

Więcej o dowiązaniach symbolicznych

Rozważmy sytuację, w której chcemy utworzyć dowiązanie symboliczne, które wskazuje na /usr/local/bin i znajduje się w katalogu /tmp/. Możemy pisać:

\$ ln -s /usr/local/bin bin1 \$ ls -l bin1 lrwxrwxrwx 1 root root 14 stycznia 1 15:42 bin1 -> /usr/local/bin \$ ln -s ../usr/local/bin bin2 \$ ls -l bin2 lrwxrwxrwx 1 root root 16 stycznia 1 15:43 bin2 -> ../usr/local/bin \$ ls -l bin2 lrwxrwxrwx 1 root root 16 stycznia 1 15:43 bin2 -> ../usr/local/bin \$ mkdir mójnowydir \$ mv bin2 mynewdir \$ cd mynewdir \$ pojemnik na cd2 bash: cd: bin2: Brak takiego pliku lub katalogu

Ponieważ nie ma katalogu /tmp/usr/local/bin/, nie możemy zmienić katalogu roboczego na bin2; innymi słowy, po przeprowadzce łącze przestało działać (stało się „zepsute”).

Z tego powodu czasami warto unikać tworzenia dowiązań symbolicznych za pomocą ścieżek względnych. Ale czasami jest to wygodne. Rozważmy następujący przypadek: powiedzmy, że chcemy utworzyć link do programu w /usr/bin (lub innymi słowy nadać temu programowi alternatywną nazwę):

# ls -l /usr/bin/brelok-rwxr-xr-x 1 root root 10150 12 grudnia 20:09 /usr/bin/keychain

Superużytkownik (root) może chcieć połączyć się z programem „brelok” o krótszej nazwie „kc”. W tym przykładzie mamy dostęp do systemu jako root, o czym świadczy zmiana bash na "#" . Potrzebujemy uprawnień administratora, ponieważ normalni użytkownicy nie mogą tworzyć plików w katalogu /usr/bin/. Teraz możemy stworzyć alternatywną nazwę dla naszego programu w imieniu roota:

# cd /usr/bin # ln -s /usr/bin/brelok kc # ls -l brelok-rwxr-xr-x 1 root root 10150 12 grudnia 20:09 /usr/bin/keychain # ls -l kc lrwxrwxrwx 1 root root 17 marca 27 17:44 kc -> /usr/bin/keychain

W tym przykładzie stworzyliśmy dowiązanie symboliczne kc odnoszące się do /usr/bin/keychain.

# mv /usr/bin/brelok /usr/bin/kc /usr/local/bin # ls -l /usr/local/bin/kc lrwxrwxrwx 1 root root 17 marca 27 17:44 kc -> /usr/bin/keychain

Ponieważ podczas tworzenia łącza użyliśmy ścieżki bezwzględnej, nadal wskazuje ona na plik /usr/bin/keychain, który już nie istnieje. Ale gdybyśmy użyli ścieżki względnej podczas tworzenia linku, to nadal działałoby.

Często oba rodzaje dowiązań symbolicznych (bezwzględne i względne oraz ścieżki) działają dobrze. Poniższy przykład pokazuje sposób tworzenia dowiązania symbolicznego, które nadal działa po przeniesieniu go i pliku, do którego się odnosi, do innego katalogu:

# cd /usr/bin # ln -s brelok kc # ls -l kc lrwxrwxrwx 1 root root 8 stycznia 5 12:40 kc -> pęk kluczy # mv keychain kc /usr/local/bin # ls -l /usr/local/bin/brelok-rwxr-xr-x 1 root root 10150 12 grudnia 20:09 /usr/local/bin/keychain # ls -l /usr/local/bin/kc lrwxrwxrwx 1 root root 17 marca 27 17:44 kc -> pęk kluczy

Teraz możemy uruchomić program "brelok", otwierając go jako /usr/local/bin/kc

rm

Teraz, gdy wiemy, jak działają polecenia cp, mv oraz ja czas nauczyć się usuwać pliki. Zwykle usuwanie odbywa się za pomocą polecenia rm. Aby usunąć wiele plików, po prostu podaj ich nazwy oddzielone spacjami w wierszu poleceń jako argumenty rm:

\$ cd /tmp \$ dotknij plik1 plik2 \$ ls -l plik1 plik2-rw-r--r-- 1 root root 0 sty 1 16:41 plik1 -rw-r--r-- 1 root root 0 sty 1 16:41 plik2 \$ rm plik1 plik2 \$ ls -l plik1 plik2 ls: plik1: Brak takiego pliku lub katalogu ls: plik2: Brak takiego pliku lub katalogu

Zapamietaj to usunięte pliki niemożliwe do odzyskania (choć możesz spróbować). Dlatego wielu początkujących użytkowników Linuksa korzysta z tej opcji "-i" polecenia rm, co wymaga, aby użytkownik został poproszony o potwierdzenie usunięcia każdego pliku.

\$ rm -i plik1 plik2 rm: usunąć zwykły pusty plik `file1"? tak rm: usunąć zwykły pusty plik `file2"? tak

W ostatnim przykładzie, przed usunięciem każdego pliku, polecenie rm pyta: czy użytkownik naprawdę chce usunąć plik? Aby potwierdzić usunięcie należy żmudnie nacisnąć klawisz „y” na klawiaturze, a odmowy skasowania - klawisz "n".

Możesz przerwać wykonywanie dowolnego polecenia (jeśli coś poszło nie tak zgodnie z przeznaczeniem), naciskając kombinację klawisz kontrolny–C.

Spraw, aby polecenie rm poprosiło o potwierdzenie usunięcia każdego pliku, nawet bez opcji "-i" można dodać do pliku ~/.bashrc używając ulubionej linii edytora tekstu:

alias rm="rm -i"

rmdir

Są dwa sposoby usuwania katalogów: możesz usunąć całą zawartość katalogu jeden po drugim, a następnie użyć polecenia rmdir aby usunąć sam katalog:

\$ mkdir mydir \$ dotknij mójkatalog/plik1 \$ rm mójkatalog/plik1 \$ rmdir mydir

Ta metoda jest powszechnie nazywana „metodą przegranego usuwania katalogów”. O wiele wygodniej jest używać polecenia "rm -rf" aby usunąć katalog z całą jego zawartością.

\$ rm -rf mydir

Używaj tego polecenia ostrożnie, ponieważ niedoświadczonemu administratorowi (zwłaszcza z prawami roota) bardzo łatwo jest złamać drewno opałowe (i systemy Linux) z jego pomocą.

Korzystanie z symboli wieloznacznych

Czym są symbole wieloznaczne

W codziennym użytkowaniu Linuksa często pojawiają się sytuacje, kiedy trzeba je wykonać prosta obsługa(jak rm) w wielu plikach. W takim przypadku nie jest zbyt wygodne, aby wyświetlić wszystkie nazwy plików w wierszu poleceń:

\$ rm plik1 plik2 plik3 plik4 plik5 plik6 plik7 plik8

Możesz rozwiązać ten problem za pomocą wzorców zastępczych (wildcards). Powłoka Linuksa obsługuje możliwość określania wielu plików za pomocą symboli wieloznacznych (zwanych również „globbingiem” ze względów historycznych). Bash i inne polecenia Linuksa wybierają tylko pliki pasujące do wzorca. Tak więc, jeśli chcesz usunąć pliki z pliku 1 do pliku 8, napisałbyś:

\$ plik rm

A jeśli potrzebujesz usunąć wszystkie pliki, których nazwy zaczynają się od słowa plik i pliku o nazwie plik:

\$ plik rm*

Próbka * dopasowuje dowolny znak, sekwencję znaków lub „brak znaku”. Oczywiście wzorców można używać nie tylko do usuwania plików, co zostanie pokazane poniżej.

Jeśli nie znaleziono dopasowania

Jeśli chcesz wyświetlić listę plików w katalogu /etc/, których nazwy zaczynają się na literę "g" i plik o nazwie "g" (jeśli istnieje), napisałbyś:

\$ ls -d /etc/g*/etc/gconf /etc/ggi /etc/gimp /etc/gnome /etc/gnome-vfs-mime-magic /etc/gpm /etc/group /etc/group-

Zobaczmy, co się stanie, jeśli określisz wzorzec, który nie pasuje do żadnej z nazw plików:

\$ ls -d /usr/bin/asdf*jkl ls: /usr/bin/asdf*jkl: Brak takiego pliku lub katalogu

W tym przykładzie próbowaliśmy wyświetlić listę plików, których nazwy zaczynają się od „asdf” i kończą na „jkl”. Interpreter poleceń przekazał komunikat, że nie znaleziono plików o takich nazwach.

Składnia szablonu: * i?

Przyjrzeliśmy się, jak działa globbing (podstawianie nazw plików). Przyjrzyjmy się teraz bliżej składni szablonu:

* dopasowuje zero lub więcej znaków:

/itd/g*- wszystkie pliki w katalogu /etc/, których nazwy zaczynają się od "g" i plik o nazwie "g".
/tmp/moj*1- wszystkie pliki w katalogu /tmp, których nazwy zaczynają się na "my" i kończą na "1" (w tym plik o nazwie "my1")

? zastępuje dowolny pojedynczy znak:

mój plik?- dowolny plik, którego nazwa zaczyna się od słowa "myfile", po którym następuje jeden znak.
/tmp/notes?txt- dopasowuje pliki o nazwach "notes.txt" i "notes_txt" (jeśli istnieją w /tmp/).

Nawiasy kwadratowe:

Szablon „” jest bardzo podobny do „ ? ", ale pozwala na jawne określenie zestawu znaków. Wzorzec "" dopasowuje jeden znak spośród znaków podanych w nawiasach. Możesz także określić zakres znaków w nawiasach (w tym celu używany jest znak -/myślnik) lub kilka zakresów z rzędu, wtedy wzór będzie pasował do dowolnego znaku z tego zakresu:

mój plik- pasuje do myfile1 i myfile2. Szablon będzie działał tak długo, jak będzie istniał co najmniej jeden z tych dwóch plików.
Hangeog- dopasowuje pliki o nazwach Changelog, ChangeLog, changeLog i changelog. Jak być może zauważyłeś, użycie symbolu wieloznacznego jest przydatne podczas wyszukiwania nazw różniących się wielkością liter.
ls /etc/*- wyświetl listę plików w katalogu /etc/, których nazwy zaczynają się od cyfry.
ls /tmp/*- wyświetlić listę plików w katalogu /tmp/, których nazwy zaczynają się od litery (wielka lub mała)

Konstrukcja [ jest podobna do , z tą różnicą, że dopasowuje pojedynczy znak niewymieniony pomiędzy [[ oraz ] . Na przykład:

rm mójplik[- usunie wszystkie pliki, których nazwy składają się ze słowa "myfile", po którym następuje pojedyncza liczba, z wyjątkiem pliku "myfile9".

Przykłady użycia

Oto kilka przykładów korzystania z szablonów. Ponieważ bash interpretuje znaki ? , [ , ] , * jako wzorce zastępcze, należy zachować ostrożność podczas używania argumentów zawierających te znaki. Na przykład, jeśli chcesz utworzyć plik zawierający wiersz „ * ”, to następujące polecenie nie zrobi tego, czego chcesz:

\$ echo * > /tmp/mójnowyplik.txt

Jeśli twój katalog roboczy zawiera jeden lub więcej plików, których nazwy pasują do wzorca " * ", znajdziesz w /tmp/mynewfile.txt listę ich nazw, a nie napis " * ". Ale jak osiągnąć to, czego chcieliśmy? Pierwszym sposobem jest ujęcie ciągu w pojedynczych cudzysłowach. Bash traktuje pojedynczy ciąg w cudzysłowie tak, jakby był to normalny ciąg tekstowy i nie rozszerza znaków zastępczych.

\$ echo "*" > /tmp/mójnowyplik.txt

Po wykonaniu tego polecenia Twój plik będzie zawierał wiersz „ * zgodnie z oczekiwaniami. Innym sposobem jest uniknięcie znaków specjalnych za pomocą odwrotnego ukośnika ( \ ). Odwrotny ukośnik poprzedzający znak specjalny mówi interpreterowi, że znak powinien być traktowany jako zwykły tekst, a nie jako symbol wieloznaczny.

\$ echo \\* > /tmp/mójnowyplik.txt

Obie sugerowane metody (pojedyncze cudzysłowy i ucieczka) dają pożądany efekt. Skoro mówimy o ucieczce odwrotnego ukośnika, warto to powiedzieć, aby wskazać znak tekstowy "\" możesz zawrzeć go w pojedynczym cudzysłowie lub napisać "\\\" (ta kombinacja będzie odbierana przez tłumacza jako zwykły pojedynczy ukośnik odwrotny) "\" )

Komentarz: Podwójne cudzysłowy działają podobnie jak pojedyncze cudzysłowy, ale pozwalają bashowi interpretować niektóre znaki specjalne. Dlatego pojedyncze cytaty - Najlepszym sposobem wyślij tylko tekst do polecenia. Przeczytaj pomoc, aby uzyskać więcej informacji o szablonach. „człowiek 7 glob”. Aby uzyskać więcej informacji na temat korzystania z cudzysłowów, zobacz sekcję CYTOWANIE Bibliografia „człowiek 8 glob”.

Wniosek

Gratulacje, dotarłeś do końca naszego przeglądu podstaw Linuksa! Mam nadzieję, że materiał był dla Ciebie przydatny. Tematy omówione w tym samouczku, w tym podstawy basha, podstawowe polecenia systemu Linux, linki i symbole wieloznaczne, stanowią podstawę następującego artykułu z podstawami administracji, który obejmuje wyrażenia regularne, uprawnienia, zarządzanie kontami użytkowników i nie tylko.

Oto samouczek dotyczący skryptów basha, który zakłada, że twoja wiedza na temat basha jest równa lub bliska zeru. Obiecujemy, że z pomocą tego artykułu zrozumiesz, że tworzenie skryptów bash jest niezwykle proste. Jeśli jednak nadal nie znajdziesz odpowiedzi na wszystkie swoje pytania w tym artykule (cóż, lub potrzebujesz pomocy zewnętrznych źródeł z innych powodów), możesz skontaktować się bezpośrednio z naszym administratorem :)

Zacznijmy więc uczyć się powłoki Bash.
Zacznijmy nasz samouczek od prostego skryptu „Hello World”.

1. Skrypt Bash Hello World
Najpierw musisz dowiedzieć się, gdzie znajduje się tłumacz. Aby to zrobić, wpisz następujące polecenie:
$ który bash
Otwórz swoje ulubione Edytor tekstu i utwórz plik o nazwie hello_world.sh. W tym pliku zapisz następujące wiersze:
#!/bin/bash # deklaruj zmienną taką jak STRING STRING="Witaj świecie" #wydrukuj zmienną na ekran echo $STRING
Notatka. Każdy skrypt bash w tym samouczku zaczyna się od sekwencji znaków „#!”, która nie jest interpretowana jako komentarz!
Przejdź do katalogu, w którym zapisałeś plik hello_world.sh i uczyń ten plik wykonywalnym:
$ chmod +x hello_world.sh
Cóż, teraz jesteś gotowy do stworzenia swojego pierwszego skryptu bash:
./hello_world.sh

2. Prosty skrypt bash do tworzenia kopii zapasowych:
#!/bin/bash tar -czf katalog_mojego_domu.tar.gz /home/linuxconfig

3. Zmienne
W tym przykładzie zadeklarujemy prostą zmienną bash i wypiszemy ją na ekranie za pomocą polecenia echo.
#!/bin/bash STRING="WITAJCIE ŚWIECIE!!!" echo $STRING
Skrypt dla utworzyć kopię zapasową i zmienne:
#!/bin/bash OF=myhome_directory_$(data +%Y%m%d).tar.gz tar -czf $OF /home/linuxconfig

3.1. Zmienne globalne i lokalne
#!/bin/bash #Deklarowanie zmiennej globalnej #Ta zmienna jest globalna i może być używana w dowolnym miejscu w skrypcie Funkcja VAR="zmienna globalna" bash ( #Deklarowanie zmiennej lokalnej #Ta zmienna jest lokalna i może być używana tylko w tym bash function lokalna VAR ="zmienna lokalna" echo $VAR ) echo $VAR bash # Zauważ, że zmienna globalna nie uległa zmianie # "lokalna" jest słowem zastrzeżonym w bash echo $VAR

4. Przekazywanie argumentów do skryptu bash
#!/bin/bash # użyj wcześniej zdefiniowanych zmiennych, aby uzyskać dostęp do przekazanych argumentów, aby uzyskać dostęp do przekazanych argumentów # argumenty do ekranu echo $1 $2 $3 " -> echo $1 $2 $3" # Możemy zapisać argumenty z wiersza poleceń bash w specjalnej tablicy args = (" [e-mail chroniony]") # argumenty echa do powłoki echo $(args) $(args) $(args) " -> args=(" [e-mail chroniony]"); echo $(args) $(args) $(args)" # użyj [e-mail chroniony] wyświetlić wszystkie argumenty naraz echo [e-mail chroniony]" -> echo [e-mail chroniony]" # użyj zmiennej $# do wydrukowania # liczby zmiennych przekazanych do skryptu bash echo Liczba przekazanych argumentów: $# " -> echo Liczba przekazanych argumentów: $#" /arguments.sh Samouczek skryptów Bash

5. Wykonywanie poleceń powłoki za pomocą bash
#!/bin/bash # użyj odwrotnych cudzysłowów " ` ` ", aby wykonać polecenia powłoki echo `uname -o` # wykonuj polecenia bash bez cudzysłowów echo uname -o

6. Przeczytaj dane wprowadzone przez użytkownika
#!/bin/bash echo -e "Cześć, wpisz słowo: \c" przeczytaj słowo echo "Wpisane słowo to: $słowo" echo -e "Czy możesz wprowadzić dwa słowa? " przeczytaj słowo1 słowo2 echo " Oto twoje dane wejściowe: \"$słowo1\" \"$słowo2\"" echo -e "Co sądzisz o skryptach basha? " # read zapisuje odpowiedzi do domyślnej zmiennej $REPLY read echo "Powiedziałeś $REPLY, ja " Miło mi to słyszeć! " echo -e " Jakie są twoje ulubione kolory ? " # -a umożliwia poleceniu odczytu przechowywanie wielu wartości w tablicy read -a colors echo "Moje ulubione kolory to także $(colors), $(colours) i $(colours):-)"

7. Pułapka poleceń Bash
#!/bin/bash # pułapka polecenie pułapka bashtrap INT # bash wyczyść ekran polecenie wyczyść; # funkcja bash trap jest wykonywana po naciśnięciu CTRL-C # bash wyświetla komunikat => Uruchamianie bash trap ! bashtrap() ( echo "Wykryto CTRL+C !...wykonywanie bash trap !" ) # dla wartości od 1/10 do 10/10 dla a w `seq 1 10`; wykonaj echo „$a/10 do wyjścia”. sen1; done echo "Wyjdź z przykładu pułapki Bash!!!"

8. Tablice
8.1. Deklarowanie prostej tablicy bash
#!/bin/bash # deklaruj tablicę 3 elementów ARRAY=("Debian Linux" "Redhat Linux" " ubuntu linux") # pobranie liczby elementów tablicy ELEMENTS=$(#ARRAY[@]) # wyświetlenie każdego elementu tablicy # z podanym zakresem numerów elementów for ((i=0;i

8.2. Importuj plik do tablicy bash
#!/bin/bash # deklaracja tablicy deklaracja -a TABLICA # wyjscie deskryptora pliku 10 do stdin exec 10

Wykonanie skryptu bash z wyjściem do wykonania pliku z wyjściem:
linuxconfig.org $ cat bash.txt Samouczek dotyczący skryptów Bash linuxconfig.org $ ./bash-script.sh bash.txt Liczba elementów: 4 Samouczek dotyczący skryptów Bash linuxconfig.org $

9. Skrypty Bash z if / else / fi
9.1. Proste wyrażenie bash z if/else
Zwróć uwagę na spacje w nawiasach [ i ]! Bez tych spacji skrypt nie będzie działał.
#!/bin/bash directory="./BashScripting" # bash sprawdź, czy katalog istnieje if [ -d $katalog ]; then echo "Katalog istnieje" else echo "Katalog nie istnieje" fi

9.2. Wbudowany jeśli/inny
#!/bin/bash # Deklaracja wybranej zmiennej i ustawienie jej na 4 choice=4 # Drukowanie na standardowe wyjście echo "1. Bash" echo "2. Skrypty" echo "3. Samouczek" echo -n "Proszę wybrać słowo? " # Pętla, aż zmienna będzie równa 4 # bash loop while [ $choice -eq 4 ]; do # czytaj wartość wejściową czytaj wybór # bash zagnieżdżony if/else if [ $choice -eq 1 ] ; then echo "Wybrałeś słowo: Bash" else if [ $choice -eq 2 ] ; then echo "Wybrałeś słowo: Skryptowanie" else if [ $choice -eq 3 ] ; then echo "Wybrałeś słowo: Samouczek" else echo "Proszę dokonać wyboru między 1-3 !" echo "1. Bash" echo "2. Skrypty" echo "3. Samouczek" echo -n "Proszę wybrać słowo ? " choice=4 fi fi fi gotowe

10. Porównania Bash
10.1. Porównania arytmetyczne
-lt -gt >-le -ge >=
-równ ==
-ne !=
#!/bin/bash # deklarowanie zmiennych całkowitych LICZ1=2 LICZ2=2 if [ $NUM1 -eq $NUM2 ]; then echo "Obie wartości są równe" else echo "Wartości NIE są równe" fi

#!/bin/bash # deklarowanie zmiennych całkowitych LICZ1=2 LICZ2=1 if [ $NUM1 -eq $NUM2 ]; then echo "Obie wartości są równe" else echo "Wartości NIE są równe" fi

#!/bin/bash # deklarowanie zmiennych całkowitych LICZ1=2 LICZ2=1 if [ $NUM1 -eq $NUM2 ]; następnie echo "Obie wartości są równe" elif [ $LICZ1 -gt $LICZ2 ]; then echo "NUM1 jest większe niż NUM2" w przeciwnym razie echo "NUM2 jest większe niż NUM1" fi

10.2. Porównanie ciągów
= równe
!= nie równe
>większe
-n s1 ciąg s1 nie jest pusty
-z s1 ciąg s1 jest pusty
#!/bin/bash #Deklarowanie ciągu S1 S1="Bash" #Deklarowanie ciągu S2 S2="Skryptowanie" if [ $S1 = $S2 ]; then echo "Oba ciągi są równe" else echo "Ciągi NIE są równe" fi

#!/bin/bash #Zadeklaruj ciąg S1 S1="Bash" #Zadeklaruj ciąg S2 S2="Bash" if [ $S1 = $S2 ]; then echo "Oba ciągi są równe" else echo "Ciągi NIE są równe" fi

11. Sprawdzanie pliku Bash
-b nazwa pliku - blokada pliku
-c nazwa pliku - plik zawiera specyfikację. symbolika
-d nazwa katalogu - sprawdź, czy katalog istnieje
-e nazwa pliku - sprawdź istnienie pliku
-f nazwa pliku - sprawdź, czy istnieje katalog NOT
-G nazwa pliku Sprawdź, czy plik istnieje i czy należy do efektywnego identyfikatora grupy.
-g nazwa_pliku prawda, jeśli plik istnieje i ma ustawiony identyfikator grupy.
-k nazwa pliku Przyklejony bit
-L nazwa pliku Dowiązanie symboliczne
-O nazwa pliku Prawda, jeśli plik istnieje i należy do efektywnego identyfikatora użytkownika.
-r nazwa pliku - sprawdź dostępność pliku
-S nazwa pliku Sprawdź, czy plik jest gniazdem
-s nazwa pliku - sprawdź, czy rozmiar pliku jest większy od zera
-u nazwa_pliku Sprawdź, czy bit set-ser-id pliku jest ustawiony
-w nazwa_pliku - sprawdź możliwość zapisu pliku
-x nazwa pliku - sprawdź plik wykonywalny
#!/bin/bash plik="./plik" if [ -e $plik ]; then echo "Plik istnieje" else echo "Plik nie istnieje" fi
Podobnie możesz użyć pętli while do sprawdzenia istnienia pliku. Ten skrypt nie zostanie uruchomiony, gdy plik istnieje. Zwróć uwagę na operator negacji bash "!", który neguje funkcję -e.
#!/bin/bash podczas [ ! -e mójplik]; do # Nie odpowiadaj, gdy plik jest tworzony i istnieje sen 1 gotowe

12. Cykl
12.1. polecenie pętli bash
#!/bin/bash # bash loop for f in $(ls /var/); wykonaj echo $f gotowe
Uruchamianie pętli z wiersza poleceń basha:
$ for f w $(ls /var/); wykonaj echo $f; zrobione

12.2. Bash podczas pętli
#!/bin/bash COUNT=6 # bash pętla while while [ $COUNT -gt 0 ]; do echo Wartość licznika to: $COUNT let COUNT=COUNT-1 done

12.3. grzmotnąć aż do pętli
#!/bin/bash LICZBA=0 # bash pętla aż do [ $COUNT -gt 5 ]; do echo Wartość zliczania to: $LICZBA let COUNT=LICZBA+1 gotowe

12.4. kontrola pętli bash
Poniżej znajduje się przykład pętli while sterowanej przez standardowe wejście. Pętla while Bash działa tak długo, jak długo występuje przejście od STDOUT do STDIN do polecenia read.
#!/bin/bash # ten skrypt bash znajdzie i zamieni spacje # w nazwach plików DIR="." # kontroluj pętlę za pomocą polecenia bash read, przekierowując STDOUT na # STDIN w pętli while # polecenie find nie odrzuca nazw plików zawierających spacje find $DIR -type f | podczas odczytu pliku; do # użyj klasy POSIX [:space:] do wyszukania spacji w nazwie pliku if [[ "$file" = *[[:space:]]* ]]; następnie # zamień spację na "_" i stąd zmień nazwę pliku mv "$plik" `echo $plik | tr " " "_"` fi; # koniec pętli po zakończeniu

13. Funkcje Bash
#!/bin/bash # funkcje Bash można deklarować w dowolnej kolejności funkcja funkcja_B ( funkcja echo B. ) funkcja funkcja_A ( echo $1 ) funkcja funkcja_D ( funkcja echo D. ) funkcja funkcja_C ( echo $1 ) # wywoływanie funkcji # przekazywanie parametru do funkcji A function_A "Funkcja A." function_B # przekazywanie parametru do funkcji C function_C "Funkcja C." funkcja_D

14. Wybór Bash
#!/bin/bash PS3="Wybierz jedno słowo: " # bash wybierz słowo w "linux" "bash" "skrypty" "tutorial" do echo "Wybrane słowo to: $słowo" # zatrzymaj pętlę, w przeciwnym razie stanie się nieskończona przerwa zrobione wyjście 0

15. Przełącznik
#!/bin/bash echo "Jaki jest twój preferowany język programowania / skryptów" echo "1) bash" echo "2) perl" echo "3) python" echo "4) c++" echo "5) Nie wiem! " przeczytaj przypadek; # struktura prostego warunku bash # zauważ, że w tym przypadku $case jest zmienną, która nie musi być nazwana w ten sposób # tutaj jest nazwana jako przykładowy przypadek $case in 1) echo "Wybrałeś bash";; 2) echo "Wybrałeś perla";; 3) echo "Wybrałeś pytona";; 4) echo "Wybrałeś c++";; 5) wyjście esac

16. Cytaty w Bash
Cytaty są ważnym elementem języka bash i skryptów bash. Poniżej znajdziesz kilka podstaw korzystania z cudzysłowów w bashu.
16.1. Zastawianie znaki specjalne
Zanim zaczniemy używać cudzysłowów, musimy nauczyć się uciekać przed znakami specjalnymi. Ta procedura pozwoli bashowi bezpośrednio rozpoznać znaczenie tych znaków. Aby to zrobić, musimy użyć odwrotnego ukośnika „\". Na przykład:
#!/bin/bash # deklarowanie zmiennej bash typu string BASH_VAR="Skrypt Bash" # wyprowadzanie zmiennej BASH_VAR echo $BASH_VAR # jeśli znak specjalny "$" jest poprzedzony znakiem "\", można go rozpoznać bezpośrednio echo \$BASH_VAR # za odwrotnym ukośnikiem znajduje się również specjalna wartość, którą można rozszerzyć o kolejny ukośnik "\" echo "\\"

16.2. Pojedyncze cytaty
Pojedyncze cudzysłowy w bash unikają znaczenia wszystkich znaków specjalnych. W ten sposób znaki specjalne będą rozpoznawane dosłownie. W takim przypadku nie można użyć jednego cudzysłowu w dwóch innych cudzysłowach tego samego rodzaju, nawet jeśli jeden z nich jest poprzedzony ukośnikiem odwrotnym.
#!/bin/bash # deklarowanie zmiennej bash typu string BASH_VAR="Skrypt Bash" # wyświetlanie zmiennej BASH_VAR echo $BASH_VAR # wartość specjalna. znaki w bash są pominięte podczas używania pojedynczych cudzysłowów echo "$BASH_VAR "$BASH_VAR""

16.3. Podwójne cytaty
Podwójne cudzysłowy są używane w bash do zmiany znaczenia wszystkich znaków specjalnych z wyjątkiem „$”, „\" i „`”. Wszystkie inne specjalne znaki będą rozpoznawane dosłownie. W przeciwieństwie do poprzedniego akapitu, pojedyncze cudzysłowy mogą być używane wewnątrz podwójnych cudzysłowów. Jeśli potrzebujesz użyć innego podwójnego cudzysłowu między podwójnymi cudzysłowami, możesz zmusić bash do potraktowania ich dosłownie, używając odwrotnego ukośnika „\”. Na przykład:
#!/bin/bash # deklaracja zmiennej bash typu string BASH_VAR="Skrypt Bash" # echo zmienna BASH_VAR echo $BASH_VAR # spec. znak i jego wartość są pominięte # w przypadku używania podwójnych cudzysłowów zamiast "$", "\" i "`" echo "To jest $BASH_VAR i \"$BASH_VAR\" przy użyciu backticków: `data`"

16.4. Bash ucieka z ANSI-C
W bashu jest też inny rodzaj ucieczki, ANSI-C. Podczas korzystania z tego typu ucieczki, znaki oznaczone odwrotnym ukośnikiem "\" otrzymują specjalne znaczenie zgodnie ze standardem ANSI-C.
\alarm (dzwonek)
\bbackspace
\e znak ucieczki
\f kanał formularza
\nnowa linia
\r powrót karetki
\t pozioma zakładka
\v pionowa tabulator
\\ ukośnik wsteczny
\` pojedynczy cudzysłów
\nnn wartość ósemkowa znaków (patrz )
\xnn wartość szesnastkowa znaków (patrz )

Notacja ucieczki Ansi-c bash: $"" . Przykład:
#!/bin/bash # dla przykładu, w którym użyliśmy \n dla nowej linii, \x40 dla wartości szesnastkowej @ # i \56 dla wartości ósemkowej. echo $"web: www.linuxconfig.org\nemail: web\x40linuxconfig\56org"

17. Operacje arytmetyczne
17.1. przykład dodawania bash
#!/bin/bash let WYNIK1=$1+$2 echo $1+$2=$RESULT1 " -> # let WYNIK1=$1+$2" zadeklaruj -i WYNIK2 WYNIK2=$1+$2 echo $1+$2=$RESULT2 " -> # zadeklaruj -i WYNIK2; WYNIK2=$1+$2" echo $1+$2=$(($1 + $2)) " -> # $(($1 + $2))"

17.2. Arytmetyka w bash
#!/bin/bash echo "### let ###" # bash dodawanie let ADDITION=3+5 echo "3 + 5 =" $ADDITION # bash odejmowanie let ODEJMOWANIE=7-8 echo "7 - 8 =" $ODEJMOWANIE # bash pomnóż niech MULTIPLICATION=5*8 echo "5 * 8 =" $MULTIPLICATION # bash dzielenie niech DIVISION=4/2 echo "4 / 2 =" $DIVISION # bash modulus niech MODULUS=9%4 echo "9 % 4 =" $MODULUS # potęgowanie bash niech POWEROFTWO=2**2 echo "2 ^ 2 =" $POWEROFTWO echo "### Rozszerzenie arytmetyki Bash ###" # są dwa formaty zapisu wyrażeń arytmetycznych: $[ wyrażenie ] # i $((wyrażenie #)) — możesz wybrać to, które najbardziej Ci się podoba echo 4 + 5 = $((4 + 5)) echo 7 - 7 = $[ 7 - 7 ] echo 4 x 6 = $ ((3 * 2)) echo 6 / 3 = $((6 / 3)) echo 8 % 7 = $((8 % 7)) echo 2 ^ 8 = $[ 2 ** 8 ] echo "### Zadeklaruj ###" echo -e "Proszę wprowadzić dwie liczby \c" # rozpoznaj wejście odczyt num1 num2 zadeklaruj -i wynik wynik=$num1+$num2 echo "Wynik to:$wynik " # bash przekonwertuj liczbę binarną 10001 wynik=2# 10001 echo $wynik # bash konwertuj liczba ósemkowa 16 wynik=8#16 echo $wynik # bash przelicz liczbę szesnastkową 0xE6A wynik=16#E6A echo $wynik

17.3. Zaokrąglanie liczby zmiennoprzecinkowej
#!/bin/bash # pobranie liczby zmiennoprzecinkowej float_point_number=3.3446 echo $floating_point_number # zaokrąglanie liczby zmiennoprzecinkowej za pomocą bash dla bash_rounded_number in $(printf %.0f $floating_point_number); do echo "Liczba zaokrąglona z bashem:" $bash_rounded_number done

17.4. Obliczenia zmiennoprzecinkowe Bash
#!/bin/bash # implementacja prostego kalkulatora w linuksie na bash echo "Enter input:" read userinput # wypisz wynik z dwoma miejscami po przecinku echo "Wynik z 2 cyframi po przecinku:" echo "scale=2; $ (wprowadzane przez użytkownika)" | bc # wypisz wynik z dziesięcioma miejscami po przecinku echo "Wynik z 10 cyframi po przecinku:" echo "scale=10; $(userinput)" | bc # wypisz wynik jako zaokrągloną liczbę całkowitą echo "Wynik jako zaokrąglona liczba całkowita:" echo $userinput | pne

18. Przekierowania
18.1. STDOUT ze skryptu bash do STDERR
#!/bin/bash echo "Przekieruj to STDOUT na STDERR" 1>&2
Aby sprawdzić przekierowanie STDOUT do STDERR, możesz przekierować wyjście skryptu do pliku:

18.2. STDERR ze skryptu basha do STDOUT
#!/kosz/bash kot 1 USD 2>&1
Aby sprawdzić przekierowanie STDERR i na STDOUT, możesz przekierować wyjście skryptu do pliku:

18.3. STDOUT do ekranu
Prostym sposobem przekierowania STDOUT jest po prostu użycie dowolnego polecenia, ponieważ domyślnie STDOUT jest automatycznie wyświetlane na ekranie. Ale najpierw utwórz plik „file1”:
$ dotknij plik1 $ ls plik1 plik1
Jak widać z powyższego przykładu, wykonanie polecenia ls powoduje domyślnie wyświetlenie na ekranie STDOUT.

18.4. STDOUT do pliku
Aby zastąpić domyślne zachowanie STDOUT, możemy użyć ">" do przekierowania wyjścia do pliku:
$ ls plik1 > STDOUT $ cat STDOUT plik1

18.5. STDERR do pliku
Domyślnie STDERR jest drukowane na ekranie:
$ ls plik1 STDOUT $ ls plik2 ls: brak dostępu do pliku2: brak takiego pliku lub katalogu
W poniższym przykładzie przekierujemy błąd standardowy (stderr) do pliku, a stdout - domyślnie na ekran. Zauważ, że STDOUT jest wypisywane na ekranie, a STDERR jest zapisywane do pliku o nazwie STDERR:
$ ls plik1 STDOUT $ ls plik1 plik2 2> STDERR plik1 $ cat STDERR ls: brak dostępu do pliku2: brak takiego pliku lub katalogu

18.6. STDOUT do STDERR
Możliwe jest również przekierowanie STDOUT i STDERR do tego samego pliku. W poniższym przykładzie przekierujemy STDOUT do tego samego deskryptora co STDERR. Zarówno STDOUT, jak i STDERR zostaną przekierowane do pliku „STDERR_STDOUT”.
$ ls plik1 STDERR STDOUT $ ls plik1 plik2 2> STDERR_STDOUT 1>&2 $ cat STDERR_STDOUT ls: brak dostępu do pliku2: brak takiego pliku lub katalogu plik1
Plik STDERR_STDOUT zawiera teraz zarówno STDOUT, jak i STDERR.

18.7. STDERR do STDOUT
Powyższy przykład można zmodyfikować, aby przekierować STDERR do tego samego deskryptora co SDTOUT:
$ ls plik1 STDERR STDOUT $ ls plik1 plik2 > STDERR_STDOUT 2>&1 $ cat STDERR_STDOUT ls: brak dostępu do pliku2: brak takiego pliku lub katalogu plik1

18.8. STDERR i STDOUT do pliku
Oba powyższe przykłady przekierowywały STDOUT i STDERR do pliku. Jest inny sposób na osiągnięcie tego samego efektu:
$ ls plik1 STDERR STDOUT $ ls plik1 plik2 &> STDERR_STDOUT $ cat STDERR_STDOUT ls: brak dostępu do pliku2: brak takiego pliku lub katalogu plik1
lub
ls plik1 plik2 >& STDERR_STDOUT $ cat STDERR_STDOUT ls: brak dostępu do pliku2: brak takiego pliku lub katalogu plik1

Ten artykuł jest amatorskim tłumaczeniem artykułu z

Temat programowania w bash jest jednym z tych, które można omówić na kilku lub setkach stron. Harold Rodriguez wyjaśnia ten temat w dwuczęściowym przewodniku poniżej. Jego piękny i ekstrawagancki styl pozwolił mu na opisanie wszystkich istotnych cech programowania w bashu na zaledwie kilku stronach.

Jeśli nigdy wcześniej nie programowałeś w bash, teraz jest czas, aby zacząć. Nawet jeśli masz niewielką wiedzę o tym, czym jest bash, możesz spojrzeć na wiele interesujących skryptów, które analizuje Harold.

Wstęp

Podobnie jak inne powłoki dostępne w systemie Linux, powłoka Bourne Again (bash) to nie tylko powłoka, ale także język pisania skryptów (skryptów) ( słowa „skrypt” i „skrypt” są zwykle synonimami – ok. przeł.). Skrypty pozwalają w pełni wykorzystać możliwości powłoki i zautomatyzować wiele zadań, które w innym przypadku wymagałyby wprowadzenia wielu poleceń. Wiele programów działających na komputerze z systemem Linux to skrypty. Jeśli chcesz wiedzieć, jak działają lub je zmienić, ważne jest, aby zrozumieć ich składnię i semantykę. Ponadto, dzięki zrozumieniu języka bash, będziesz mógł pisać własne programy do wykonywania różnych zadań w wybrany przez Ciebie sposób.

Czyli to samo programowanie (programowanie) czy pisanie skryptów (skrypty)?

Nowicjusze w programowaniu są zdziwieni różnicą między rzeczywistymi językami programowania i skryptów. Programy napisane w niektórych językach programowania są zwykle znacznie potężniejsze i znacznie szybsze niż programy napisane w językach skryptowych. Przykładami języków programowania są C, C++ i Java. Tworzenie programu w dowolnym języku programowania zwykle zaczyna się od pisania kod źródłowy(plik tekstowy zawierający instrukcje dotyczące działania finalnego programu), należy go skompilować (wbudować) w plik wykonywalny. Ten plik wykonywalny nie jest łatwy do przenoszenia między różnymi systemami operacyjnymi. Na przykład, jeśli napiszesz program w C dla Linuksa, nie będziesz mógł go uruchomić w Windowsie. Aby to zrobić, będziesz musiał ponownie skompilować kod źródłowy w systemie Windows. Pisanie skryptu zaczyna się również od napisania kodu źródłowego, który nie kompiluje się do pliku wykonywalnego. Zamiast tego interpreter powłoki odczytuje sekwencyjnie instrukcje z pliku źródłowego i wykonuje je. Niestety, ponieważ interpreter musi czytać każdą instrukcję, szybkość wykonania skryptu jest zwykle mniejsza ( znacznie wolniej - ok. przeł.) niż skompilowany program. Główną zaletą skryptów jest to, że możesz łatwo przenieść plik źródłowy do dowolnego systemu operacyjnego i po prostu je uruchomić (np oczywiście, jeśli jest do tego tłumacztensystem operacyjny - ok. przeł.).

Bash to język skryptowy. Świetnie nadaje się do pisania małych programów, ale jeśli planujesz tworzyć potężne aplikacje, wybór odpowiedniego języka programowania jest dla Ciebie lepszy. Inne przykłady języków skryptowych to Perl, Lisp i Tcl.

Co musisz wiedzieć, aby pisać własne skrypty?

To wymaga wiedzy podstawowe polecenia linux. Na przykład musisz wiedzieć, jak kopiować, przenosić i tworzyć nowe pliki. Musi być w stanie korzystać z edytora tekstu. W systemie Linux istnieją trzy główne edytory tekstu: vi, emacs i pico ( autor zapomniał też o nano, które jest najlepsze dla początkujących, jeśli nie bierze się również pod uwagę mcedit. - Około. przeł.). Jeśli nie znasz vi lub emacs, użyj pico lub innego łatwego w użyciu edytora tekstu.

Uwaga!!!

Nie powinieneś uczyć się programowania w bashu jako użytkownik źródło! W przeciwnym razie wszystko może się zdarzyć! Nie biorę żadnej odpowiedzialności, jeśli przypadkowo popełnisz błąd i zepsujesz swój system. Zostałeś ostrzeżony! Posługiwać się rachunek zwykły użytkownik bez żadnych uprawnień. Możesz nawet utworzyć nowego użytkownika tylko po to, by nauczyć się pisania skryptów. Zatem najgorszą rzeczą, jaka się w tym przypadku stanie, jest zniknięcie danych w katalogu tego użytkownika.

Twój pierwszy program Bash

Naszym pierwszym programem będzie klasyczny „Hello World”. Oczywiście, jeśli programowałeś już wcześniej, musisz mieć dość takich przykładów. To jednak tradycja i kim jestem, żeby to zmienić? Program „Hello World” po prostu wyświetla na ekranie słowa „Hello World”. Uruchom edytor tekstu i wpisz w nim:

#!/kosz/bash
echo "Witaj świecie"

Pierwsza linia mówi Linuksowi, aby użył interpretera bash do uruchomienia tego skryptu. W tym przypadku bash znajduje się w katalogu /bin. Jeśli masz bash gdzie indziej, wprowadź odpowiednie zmiany w tej linii. Wyraźne określenie interpretera jest bardzo ważne, upewnij się, że określiłeś go ponownie, ponieważ podany ciąg mówi Linuksowi, którego interpretera użyć do wykonania instrukcji w skrypcie. Następną rzeczą do zrobienia jest zapisanie skryptu. Nazwijmy to hello.sh. Następnie musisz uczynić skrypt wykonywalnym:

$ chmod u+x cześć.sz

Jeśli nie rozumiesz, co robi to polecenie, przeczytaj stronę man polecenia chmod:

$ człowiek chmod

Gdy to zrobisz, możesz uruchomić program, wpisując po prostu jego nazwę:

$ ./witaj.sh

Witaj świecie

Stało się! To Twój pierwszy program! I choć jest nudny i nie robi nic pożytecznego, to pokazuje dokładnie, jak wszystko działa. Po prostu zapamiętaj tę prostą sekwencję: napisz kod, zapisz plik, uczyń go wykonywalnym za pomocą chmod i uruchom go.

Zespoły, zespoły i zespoły

Co dokładnie robi twój pierwszy program? Na ekranie drukuje słowa „Hello World”. Jak ona to robi? Używa poleceń. W naszym programie napisaliśmy tylko jedno polecenie - echo "Hello World". Jakie dokładnie jest tutaj polecenie? Echo. Ten program pobiera jeden argument i wyświetla go na ekranie.

Argumentem jest wszystko, co następuje po wpisaniu nazwy programu. W naszym przypadku „Hello World” jest argumentem przekazywanym do polecenia echo. Po wpisaniu polecenia ls /home/ argumentem polecenia ls jest /home. Cóż to wszystko znaczy? Oznacza to, że jeśli masz program, który pobiera jakiś argument i wyświetla coś na ekranie, możesz użyć tego zamiast echa. Załóżmy, że mamy program o nazwie foo. Ten program pobierze jeden argument (ciąg słów) i wyświetli je na ekranie. Następnie możemy przepisać nasz program w ten sposób:

#!/kosz/bash
bla " Witaj świecie "

Zapisz go, spraw, aby był wykonywalny i uruchom go ponownie ( uwaga dla początkujących - ten przykład nie zadziała. - Około. przeł.):

$./cześć
Witaj świecie

Dokładnie ten sam wynik. Czy był tu używany? Unikalny kod? Nie. Czy napisaliśmy jakiś program? Nie, chyba że jesteś autorem programu echo. Wszystko, co zrobiłeś, to po prostu osadzenie programu echo w naszym skrypcie i dostarczenie mu argumentu. Przykładem alternatywy dla używania polecenia echo w prawdziwym programowaniu jest polecenie printf, które ma więcej opcji, jeśli znasz programowanie w C. W rzeczywistości możesz uzyskać dokładnie ten sam wynik bez pisania skryptu:

$ echo "Witaj świecie"
Witaj świecie

Skrypty Bash oferują szeroki wachlarz możliwości i są łatwe do nauczenia. Jak właśnie zauważyłeś, używasz innych Polecenia Linuksa pisać własne skrypty. Twój program powłoki to kilka innych programów połączonych razem w celu wykonania zadania.

Inne przydatne programy

Teraz napiszemy program, który przeniesie wszystkie pliki do katalogu, usunie go wraz z zawartością, a następnie odtworzy katalog. Można to zrobić za pomocą następujących poleceń ( W przykładzie podanym w oryginale autor pokazuje, że nie na próżno polecił wykonanie powyższych ćwiczeń pod specjalnie stworzonym użytkownikiem. Wynikiem wykonania tej sekwencji poleceń będzie czysty katalog, w którym pracujesz. Najprawdopodobniej będzie to twój katalog domowy. Dlatego jeśli NIE CHCESZ usunąć wszystkich znajdujących się w nim plików - NIE uruchamiaj poleceń z oryginalnego artykułu . Co więcej, postępuj zgodnie z radą autora i stwórz osobnego użytkownika specjalnie do ćwiczeń skryptowych. Rozszerzyłem nieco ten przykład. a teraz nie jest taki niebezpieczny . Notatka. przeł. ):

$ dotknij plik1

$ mkdir śmieci
$mv plik1 śmieci
$ rm -rf śmieci
$ mkdir śmieci

Zamiast wprowadzać to wszystko interaktywnie, napiszmy skrypt, który wykonuje te polecenia:

#!/kosz/bash

dotknij plik1
mkdir śmieci
mv plik1 śmieci
rm -rf śmieci
mkdir śmieci
Echo" F Ile usunięte! ”

Zapisz go jako clean.sh, a teraz wystarczy go uruchomić. Przeniesie wszystkie pliki w katalogu, usunie je, ponownie utworzy katalog, a nawet wydrukuje komunikat o usunięciu pliku. Pamiętaj, że jeśli regularnie robisz coś, co wymaga wpisania tej samej sekwencji poleceń, możesz to zautomatyzować, pisząc skrypt.

Uwagi

Komentarze pomagają uczynić kod bardziej czytelnym. Nie mają wpływu na to, co wyprowadza program. Są napisane specjalnie do czytania. Wszystkie komentarze w Bash zaczynają się znakiem hash #, z wyjątkiem pierwszej linii (#!/bin/bash), która ma specjalne przeznaczenie. Pierwsza linia nie jest komentarzem. Jako przykład weźmy następujący kod:

#!/kosz/bash
# Ten program liczy od 1 do 10:
dla i w 1 2 3 4 5 6 7 8 9 10; robić
echo $i
zrobione

Nawet jeśli nie rozumiesz jeszcze skryptów Bash, dzięki komentarzowi od razu zrozumiesz, co robi powyższy przykład. Komentowanie kodu to dobra praktyka. Z biegiem czasu zdasz sobie sprawę, że jeśli musisz dbać o swoje skrypty, to posiadanie komentowanego kodu ułatwia to.

Zmienne

Zmienne to po prostu „kontenery”, które mają pewną wartość. Muszą być tworzone z wielu powodów. Będziesz musiał w jakiś sposób przechowywać dane wejściowe użytkownika, argumenty lub wartości liczbowe. Na przykład:

#!/kosz/bash
x=12
Echo" Wartość zmienna x - $x”

Tutaj przypisaliśmy wartość 12 do zmiennej x. Wiersz echo „Wartość zmiennej x to $x” wyświetli bieżącą wartość x. Podczas definiowania zmiennej nie można umieszczać spacji między nazwą zmiennej a operatorem przypisania: „=”. Składnia jest następująca:

#!/kosz/bash
echo "Wartość x wynosi 12".
echo "Mam 12 ołówków."
echo "Powiedział mi, że x to 12."
echo "Mam 12 lat."
echo "Jak to jest, że x to 12? "

OK, załóżmy teraz, że decydujesz się zmienić wartość x na 8 zamiast 12. Co musisz zrobić, aby to osiągnąć? Musisz zmienić wszystkie wiersze kodu, które mówią, że x to 12. Ale poczekaj… Są inne wiersze kodu, które wspominają ten numer, więc prosta autokorekta nie zadziała. Podajmy teraz podobny przykład, używając tylko zmiennych:

#!/kosz/bash
x=12 # ustaw zmienną x na 12
Echo " W wartość x = $x"
echo "mam 12 ołówków"
echo "Powiedział mi, że wartość x równa się $x"
echo "Mam 12 lat"

echo "Jak to jest, że wartość x równa się $ x ?"

Tutaj widzimy, że $x wypisuje bieżącą wartość x na 12. Więc teraz, jeśli chcesz ustawić nową wartość x na 8, wszystko, co musisz zrobić, to zmienić jedną linię z x=12 na x=8, i na wyjściu, wszystkie wiersze zawierające x również się zmieniają. Dlatego nie musisz ręcznie modyfikować pozostałych linii. Jak zobaczysz później, zmienne mają również inne zastosowania.

jeśli /etc/foo istnieje, to
skopiuj /etc/ bla do bieżącego katalogu

wydrukuj „Gotowe” na ekranie
Inaczej,
drukuj na ekranie "Ten plik nie istnieje"

wyjście

Czy można to zrobić w Bash? Na pewno! Zestaw instrukcji sterujących Bash obejmuje: if, while, until, for i case. Każdy z tych operatorów jest sparowany, to znaczy zaczyna się jednym znacznikiem, a kończy drugim. Na przykład, jeśli warunkowa instrukcja if zaczyna się od if i kończy na fi. Oświadczenia kontrolne nie są programy indywidualne w systemie są wbudowane w bash.

if … else … elif … fi

To jeden z najczęstszych operatorów. Pozwala programowi podejmować następujące decyzje – „jeśli warunek jest spełniony, robimy jedną rzecz, jeśli nie, robimy coś innego”. Aby efektywnie z niego korzystać, musisz najpierw nauczyć się korzystać z polecenia test. Ten program sprawdza stan (na przykład, czy plik istnieje, czy ma niezbędne uprawnienia). Oto przepisana wersja bar.sh:

#!/kosz/bash
if test -f /etc/foo
następnie
# Plik istnieje, skopiuj go i wydrukuj wiadomość na ekranie
cp /etc/foo .
echo „Gotowe”.
else # Plik nie istnieje, więc wypisujemy komunikat

# i dokończyć pracę
echo "Ten plik nie istnieje."
Wyjście

Zwróć uwagę na wcięcie linii po tym i jeszcze. Nie są one wymagane, ale znacznie ułatwiają odczytywanie kodu w tym sensie, że sprawiają, że logika programu jest bardziej wizualna. Teraz uruchom program. Jeśli masz plik /etc/foo, zostanie on skopiowany, w przeciwnym razie zostanie wyświetlony komunikat o błędzie. Polecenie test sprawdza istnienie pliku. Przełącznik -f sprawdza, czy argument jest zwykłym plikiem. Poniżej znajduje się lista opcji testowych ( Nie powinieneś próbować pamiętać ich wszystkich, ponieważ. to wciąż nierealne. Zawsze możesz to sprawdzić w instrukcji komendy test - test man. Notatka. przeł.):

klawisze poleceń testowych:

D sprawdza, czy istnieje plik i czy jest to katalog

E sprawdza istnienie pliku

Na przykład kod:

if test -f /etc/foo
następnie

Można to napisać tak:

if [ -f /etc/foo ]; następnie

Nawiasy kwadratowe to kolejny sposób na napisanie testu. Jeśli masz doświadczenie w programowaniu w C, ta składnia może być dla Ciebie wygodniejsza. Zwróć uwagę na spacje przed i po każdym nawiasie ( Powód spacji jest prosty: otwierający nawias kwadratowy to polecenie powłoki. Można to łatwo zweryfikować, wpisując w konsoli [. A skoro to osobny zespół, to trzeba go rozdzielićlukiz innych opcji.- Notatka. przeł.). Średnik: „;” nakazuje powłoce zakończenie jednej instrukcji i rozpoczęcie następnej. Wszystko po tej postaci będzie działać tak, jakby było włączone oddzielna linia. Dzięki temu kod jest łatwiejszy do odczytania i oczywiście taki zapis jest opcjonalny. Jeśli wolisz inną notację, możesz ją od razu umieścić w innej linii.

#!/kosz/bash
chwila:; robić
echo "Naciśnij CTRL-C, aby wyjść."
zrobione

Daje to dokładnie ten sam efekt, ale szybciej, ponieważ ":" to wbudowany bash. Jedyną różnicą jest poświęcenie czytelności kodu. Użyj tego, który najbardziej Ci się podoba z poniższych opcji. Poniżej znajduje się znacznie bardziej przydatny przypadek użycia zmiennych:

#!/kosz/bash
x=0;
while [ "$x" -le 10 ]; robić
echo "Aktualna wartość x: $x"
# Zwiększ wartość x:
x=$(wyrażenie $x + 1)
spać 1
zrobione

Tutaj używamy notacji nawiasów kwadratowych, aby sprawdzić stan zmiennej x. Opcja -le oznacza "mniejsze lub równe". W prostym języku powyższy kod mówi: „gdy (gdy) x jest mniejsze lub równe 10, wyświetl bieżącą wartość x, a następnie dodaj jeden do bieżącej wartości x”. Instrukcja sleep 1 wstrzymuje wykonywanie programu na jedną sekundę.

Poniżej znajduje się lista możliwych operacji porównywania liczb całkowitych ( pełna lista podane w teście człowieka. Notatka. przeł.):

x -równe y x = y (równe)

x -ne y x nie jest równe y (nie jest równe)

x -gt y x jest większe lub równe y (większe niż)

x -lt y x jest mniejsze lub równe y (mniejsze niż)

Operatory porównania ciągów:

x = y ciąg x jest identyczny z y

x != ciąg y x nie pasuje do y

Wyrażenie N x jest prawdziwe, jeśli ciąg x ma długość niezerową

Wyrażenie Z x jest prawdziwe, jeśli ciąg x ma długość zero

Powyższy skrypt nie jest trudny do zrozumienia, może poza tym wierszem:

x=$(wyrażenie $x + 1)