Bez względu na to, jak prosty jest interfejs graficzny w systemie Linux i bez względu na liczbę funkcji, nadal istnieją zadania, które wygodniej jest rozwiązać za pomocą terminala. Po pierwsze dlatego, że jest szybszy, a po drugie nie wszystkie maszyny mają interfejs graficzny, na przykład na serwerach wszystkie akcje wykonywane są za pośrednictwem terminala, w celu zaoszczędzenia zasobów obliczeniowych.

Jeśli jesteś już bardziej doświadczonym użytkownikiem, prawdopodobnie często wykonujesz różne zadania za pośrednictwem terminala. Często zdarzają się zadania, dla których trzeba wykonać po kolei kilka poleceń, np. aby zaktualizować system, należy najpierw zaktualizować repozytoria, a dopiero potem pobrać nowe wersje pakietów. To tylko przykład, a takich działań jest wiele, nawet wykonywanie kopii zapasowych i przesyłanie skopiowanych plików na zdalny serwer. Dlatego, aby nie wpisywać kilkakrotnie tych samych poleceń, możesz skorzystać ze skryptów. W tym artykule przyjrzymy się pisaniu skryptów w Bash, przyjrzymy się podstawowym operatorom, a także temu, jak działają, że tak powiem, skrypty bash od podstaw.

Skrypt lub jak to się nazywa skrypt to sekwencja poleceń, które są kolejno odczytywane i wykonywane przez program interpretujący, w naszym przypadku jest to program wiersza poleceń - bash.

Skrypt to zwykły plik tekstowy, który zawiera listę zwykłych poleceń, które są przyzwyczajone do ręcznego wprowadzania, a także program, który je wykona. Program ładujący, który wykona skrypt, nie wie, jak pracować ze zmiennymi środowiskowymi, więc musi podać dokładną ścieżkę do uruchamianego programu. A następnie przekaże twój skrypt do tego programu i rozpocznie się wykonanie.

Najprostszy przykład skryptu dla powłoki Bash:

!/kosz/bash
echo "Witaj świecie"

Narzędzie echo wyświetla na ekranie ciąg przekazany do niego jako parametr. Pierwsza linia jest specjalna, określa program, który wykona polecenia. Ogólnie rzecz biorąc, możemy stworzyć skrypt w dowolnym innym języku programowania i określić pożądany interpreter, na przykład w pythonie:

!/usr/bin/env python
print("Witaj świecie")

Lub w PHP:

!/usr/bin/env php
echo "Witaj świecie";

W pierwszym przypadku bezpośrednio wskazywaliśmy program, który będzie wykonywał polecenia, w kolejnych dwóch nie znamy dokładnego adresu programu, dlatego prosimy narzędzie env o wyszukanie go po nazwie i uruchomienie. Takie podejście jest stosowane w wielu skryptach. Ale to nie wszystko. W systemie Linux, aby system mógł wykonać skrypt, musisz ustawić flagę wykonywalny na pliku z nim.

Ta flaga nie zmienia niczego w samym pliku, informuje tylko system, że nie jest to tylko plik tekstowy, ale program i musi zostać wykonany, otworzyć plik, znaleźć interpreter i wykonać. Jeśli nie określono interpretera, domyślnie używany będzie interpreter użytkownika. Ale ponieważ nie wszyscy używają basha, musisz to wyraźnie określić.

Biegać:

chmod ugo+x plik_skryptu

Teraz uruchamiamy nasz mały pierwszy program:

./plik_skryptu

Wszystko działa. Wiesz już, jak napisać mały skrypt dla, powiedzmy, aktualizacji. Jak widać, skrypty zawierają te same polecenia, które są wykonywane w terminalu, są bardzo łatwe do napisania. Ale teraz trochę skomplikujemy zadanie. Ponieważ skrypt jest programem, musi sam podejmować pewne decyzje, przechowywać wyniki wykonania poleceń i wykonywać pętle. Wszystko to można zrobić za pomocą powłoki Bash. To prawda, tutaj wszystko jest znacznie bardziej skomplikowane. Zacznijmy prosto.

Zmienne w skryptach

Pisanie skryptów w Bash rzadko kończy się bez przechowywania danych tymczasowych, co oznacza tworzenie zmiennych. Żaden język programowania nie może obejść się bez zmiennych, podobnie jak nasz prymitywny język powłoki.

Mogłeś już wcześniej napotkać zmienne środowiskowe. To są te same zmienne i działają w ten sam sposób.

Na przykład zadeklarujmy zmienną łańcuchową:

string="Witaj świecie"

Wartość naszego ciągu jest w cudzysłowie. Ale w rzeczywistości cytaty nie zawsze są potrzebne. Zachowana jest tu główna zasada bash - spacja jest znakiem specjalnym, separatorem, więc jeśli nie użyjesz cudzysłowów, świat będzie już traktowany jako osobna komenda, z tego samego powodu nie umieszczamy spacji przed i po równości podpisać.

Symbol $ służy do wyświetlania wartości zmiennej. Na przykład:

Zmodyfikujmy nasz skrypt:

!/kosz/bash
string1="cześć"
ciąg2=świat
ciąg=$ciąg1$ciąg2
echo $string

I sprawdzamy:

Bash nie rozróżnia typów zmiennych w sposób, w jaki robią to języki wysokiego poziomu, takie jak C++, do zmiennej można przypisać zarówno liczbę, jak i ciąg. Podobnie, wszystko to będzie uważane za ciąg. Powłoka obsługuje tylko łączenie łańcuchów, aby to zrobić, po prostu wpisz nazwy zmiennych w wierszu:

!/kosz/bash
string1="cześć"
ciąg2=świat
string=$ciąg1$ciąg2\ i\ ja
ciąg3=$ciąg1$ciąg2" i ja"
echo $string3

Sprawdzamy:

Zwróć uwagę, że, jak powiedziałem, cudzysłowy są opcjonalne, jeśli w ciągu nie ma znaków specjalnych. Przyjrzyj się bliżej obu sposobom łączenia ciągów znaków, tutaj pokazano również rolę cudzysłowów. Jeśli potrzebujesz bardziej złożonego przetwarzania łańcuchów lub operacji arytmetycznych, nie jest to uwzględnione w możliwościach powłoki, używane są do tego zwykłe narzędzia.

Zmienne i wyjście poleceń

Zmienne nie byłyby tak przydatne, gdyby nie mogły przechowywać wyników działania narzędzi. Służy do tego następująca składnia:

$(zespół )

Dzięki tej konstrukcji dane wyjściowe polecenia zostaną przekierowane bezpośrednio do miejsca, z którego zostało wywołane, a nie do ekranu. Na przykład narzędzie date zwraca bieżącą datę. Te polecenia są równoważne:

Czy rozumiesz? Napiszmy skrypt, w którym będą wyświetlane hello world i data:

string1="Witaj świecie"
string2=$(data)

ciąg=$ciąg1$ciąg2

Teraz wiesz już wystarczająco dużo o zmiennych i jesteś gotowy do stworzenia skryptu bash, ale jest jeszcze więcej. Następnie przyjrzymy się parametrom i strukturom kontrolnym. Przypomnę, że są to wszystkie zwykłe polecenia basha i nie musisz ich zapisywać w pliku, możesz je wykonać natychmiast w podróży.

Opcje skryptu

Nie zawsze jest możliwe stworzenie skryptu bash, który nie zależy od danych wejściowych użytkownika. W większości przypadków musisz zapytać użytkownika, jaką czynność wykonać lub jakiego pliku użyć. Wywołując skrypt możemy przekazać do niego parametry. Wszystkie te parametry są dostępne jako zmienne o nazwach liczbowych.

Zmienna o nazwie 1 zawiera wartość pierwszego parametru, zmiennej 2, drugiego i tak dalej. Ten skrypt bash zwróci wartość pierwszego parametru:

!/kosz/bash
echo $1

Konstrukcje kontrolne w skryptach

Stworzenie skryptu basha nie byłoby tak przydatne bez możliwości analizy pewnych czynników i wykonania w odpowiedzi na nie niezbędnych działań. To dość złożony temat, ale jest bardzo ważny przy tworzeniu skryptu bash.

W Bash istnieje polecenie sprawdzania warunków, którego składnia jest następująca:

jeśli warunek_komendy
następnie
zespół
w przeciwnym razie
zespół
fi

Polecenie to sprawdza kod zakończenia polecenia warunku, a jeśli 0 (sukces) to wykonuje polecenie lub kilka poleceń po słowie, to jeśli kod zakończenia wynosi 1, wykonywany jest blok else, fi oznacza zakończenie bloku polecenia.

Ponieważ jednak najczęściej interesuje nas nie kod powrotny polecenia, a porównywanie ciągów i liczb, wprowadzono polecenie [[, które umożliwia wykonywanie różnych porównań i wystawianie kodu powrotnego w zależności od wyniku porównania. Jego składnia to:

[[ parametr1 operator parametr2 ]]

Dla porównania używamy znanych już operatorów<,>,=,!= itd. Jeśli wyrażenie jest prawdziwe, polecenie zwróci 0, jeśli nie - 1. Możesz trochę przetestować jego zachowanie w terminalu. Kod powrotu ostatniego polecenia jest przechowywany w zmiennej $?:

Teraz, łącząc to wszystko, otrzymujemy skrypt z wyrażeniem warunkowym:

!/kosz/bash
jeśli [[ $1 > 2 ]]
następnie
echo $1" jest większe niż 2"
w przeciwnym razie
echo $1" jest mniejsze niż 2 lub 2"
fi

Oczywiście ten projekt ma bardziej zaawansowane funkcje, ale omówienie ich w tym artykule jest zbyt skomplikowane. Może o tym napiszę później. Na razie przejdźmy do cykli.

Pętle w skryptach

Zaletą programów jest to, że możemy w kilku linijkach określić, jakie akcje należy wykonać kilka razy. Na przykład możliwe jest pisanie skryptów bash, które składają się tylko z kilku linii, ale działają godzinami, analizując parametry i wykonując niezbędne czynności.

Przyjrzyjmy się najpierw pętli for. Oto jego składnia:

dla zmiennej na liście
robić
zespół
Gotowe

Iteruje po całej liście i kolejno przypisuje wartość z listy do zmiennej, po każdym przypisaniu wykonuje polecenia znajdujące się pomiędzy do i done.

Na przykład przeprowadźmy iterację po pięciu cyfrach:

dla indeksu w 1 2 3 4 5
robić
echo $indeks
Gotowe

Lub możesz wyświetlić listę wszystkich plików w bieżącym katalogu:

dla pliku w $(ls -l); wykonaj echo "$plik"; Gotowe

Jak rozumiesz, możesz nie tylko wyświetlać nazwy, ale także wykonywać niezbędne czynności, jest to bardzo przydatne podczas tworzenia skryptu bash.

Druga pętla, której się przyjrzymy, to pętla while, która działa, gdy polecenie warunku zwraca kod 0, sukces. Rozważ składnię:

podczas warunku polecenia
robić
zespół
Gotowe

Rozważ przykład:

!/kosz/bash
indeks=1
podczas gdy [[ $indeks< 5 ]]
robić
echo $indeks
niech „indeks=indeks+1”
Gotowe

Jak widać, wszystko jest zrobione, polecenie let po prostu wykonuje określoną operację matematyczną, w naszym przypadku zwiększa wartość zmiennej o jeden.

Chciałbym zwrócić uwagę na coś innego. Konstrukcje takie jak while, for, jeśli są przeznaczone do zapisywania w wielu wierszach, a jeśli spróbujesz napisać je w jednym wierszu, otrzymasz błąd. Niemniej jednak jest możliwe, aby tam, gdzie powinno być przerwanie wiersza, wstaw średnik „;”. Na przykład poprzednia pętla mogła zostać wykonana jako pojedyncza linia:

indeks=1; podczas gdy [[ $indeks< 5 ]]; do echo $index; let "index=index+1"; done;

Wszystko jest bardzo proste, starałem się nie komplikować artykułu dodatkowymi terminami i funkcjami bash, tylko najbardziej podstawowymi. W niektórych przypadkach może być konieczne utworzenie interfejsu użytkownika dla skryptu bash, a następnie możesz użyć programów takich jak zenity lub kdialog, dzięki którym bardzo wygodnie jest wyświetlać wiadomości użytkownikowi, a nawet prosić go o informacje.

wnioski

Teraz rozumiesz podstawy pisania skryptów w Linuksie i możesz napisać potrzebny skrypt, na przykład do tworzenia kopii zapasowych. Próbowałem spojrzeć na skrypty basha od podstaw. Dlatego nie wszystkie aspekty zostały wzięte pod uwagę. Być może wrócimy do tego tematu w jednym z kolejnych artykułów.

Pisanie skryptów w Linuksie (uczenie się na przykładach)

———————————————————————————-

1. Wstęp

Czego potrzebujesz do pisania skryptów
Znajomość narzędzi wiersza poleceń i ich niezbędnych opcji.
Podstawowa znajomość języka angielskiego na poziomie szkoły podstawowej nie będzie przeszkadzać.

Dlaczego potrzebne są skrypty
Po pierwsze, administracja serwerem linuksowym, w takim czy innym stopniu, sprowadza się do systematycznego wykonywania tych samych poleceń. Co więcej, nie jest konieczne, aby te polecenia były wykonywane przez osobę. Mogą być zaprogramowane do wykonania przez maszynę.
Po drugie, nawet wykonanie zwykłego zadania, które (nagle) wynosi 20-1000… powtarzalnych operacji jest DUŻO łatwiejsze do zaimplementowania w skrypcie.

Co to jest skrypt
Skrypt to zestaw instrukcji, które komputer musi wykonać w określonej kolejności iw określonym czasie. Instrukcje mogą być albo wewnętrznymi poleceniami powłoki (pętle, warunki, przetwarzanie informacji tekstowych, praca ze zmiennymi środowiskowymi itp.), albo dowolnym programem, który wykonujemy w konsoli z niezbędnymi parametrami.

Jak napisać scenariusz
W naszym przypadku skrypt będzie plikiem tekstowym z atrybutami wykonania. Jeśli plik skryptu zaczyna się od #!, co w świecie UNIXa nazywa się sha-bang, informuje to system, którego interpretera ma użyć do wykonania skryptu. Jeśli jest to trudne do zrozumienia, pamiętaj tylko, że zaczniemy pisać wszystkie skrypty od linii #!/bin/bash lub #!/bin/sh, a potem polecenia i komentarze do nich pójdą.

pożegnalne słowo
Szczerze radzę napisać jak najwięcej komentarzy do prawie każdej linii w skrypcie. Czas minie i będziesz musiał zmienić lub unowocześnić napisany raz scenariusz. Jeśli nie pamiętasz lub nie rozumiesz, co jest napisane w skrypcie, trudno to zmienić, łatwiej jest pisać od zera.

Jakie skrypty możemy potrzebować:

ustawianie reguł zapory podczas uruchamiania systemu.

wykonywanie kopii zapasowej ustawień i danych.

dodawanie skrzynek pocztowych do serwera pocztowego (a dokładniej do bazy mysql)

uruchamianie o określonej godzinie (najlepiej co noc) programu, który skanuje logi serwera proxy i wydaje wygodny raport internetowy o ilości pobieranego ruchu.

przesyłanie nam drogą mailową informacji o tym, że ktoś uzyskał dostęp do naszego serwera przez ssh, czas połączenia i adres klienta.

O technice skryptowej
Tworzymy plik tekstowy, edytujemy go, ustawiamy uprawnienia wykonawcze, uruchamiamy, sprawdzamy błędy, naprawiamy, uruchamiamy, sprawdzamy błędy...
Gdy wszystko jest lizane i działa poprawnie, umieszczamy to w autoloadzie lub w harmonogramie na określony czas.

———————————————————————————-

2. Nauka pisania skryptów w wewnętrznym języku BASH
oryginał: https://www.linuxconfig.org/Bash_scripting_Tutorial

Ten przewodnik nie zakłada wcześniejszej wiedzy na temat pisania skryptów (zwanych dalej skryptami) przy użyciu wewnętrznego języka Bash. Z pomocą tego poradnika szybko odkryjesz, że pisanie skryptów jest bardzo łatwym zadaniem. Zacznijmy nasz samouczek od prostego skryptu, który wyświetla ciąg „Hello World!” (przetłumaczone z angielskiego - Witam wszystkich!)

1. Scenariusz „Witam wszystkich”
Oto twój pierwszy przykład skryptu basha:

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

Przejdź do katalogu zawierającego nasz plik hello_world.sh i uczyń go wykonywalnym:

Kod: Zaznacz wszystkie $ chmod +x hello_world.sh

Uruchom skrypt do wykonania

Kod: Zaznacz wszystkie $ ./hello_world.sh

2. Prosty skrypt do archiwizacji bash

#!/kosz/bash
tar -czf katalog_mojego_domu.tar.gz /home/użytkownik

Kod: Zaznacz wszystkie $ ./backup.sh

$ du -sh katalog_mojego_domu.tar.gz
41 mln mój katalog_domowy.tar.gz

3. Praca ze zmiennymi
W tym przykładzie deklarujemy prostą zmienną i wyświetlamy ją na ekranie za pomocą polecenia echo.

#!/kosz/bash
STRING="WITAJCIE ŚWIECIE!!!"
echo $STRING

Kod: Zaznacz wszystkie $ ./hello_world.sh
WITAJ ŚWIECIE!!!

Nasz skrypt archiwizujący ze zmiennymi:

#!/kosz/bash
OF=myhome_directory_$(data +%Y%m%d).tar.gz
JEŻELI=/dom/użytkownik
tar -czf $OF $JEŻELI

Kod: Zaznacz wszystkie $ ./backup.sh
tar: Usuwanie początkowego „\" z nazw członków
$ du -sh *tar.gz
41 mln mój katalog_domowy_201000123.tar.gz

3.1 Zmienne globalne i lokalne

#!/kosz/bash
# Zadeklaruj zmienną globalną
# Ta zmienna może być używana w dowolnym miejscu w tym skrypcie
VAR="zmienna globalna"
funkcja bash (
# Zadeklaruj zmienną lokalną
# Taka zmienna jest ważna tylko dla funkcji, w której jest zadeklarowana
local VAR="zmienne lokalne"
echo $VAR
}
echo $VAR
grzmotnąć
# Zauważ, że zmienna globalna się nie zmieniła
echo $VAR

Kod: Zaznacz wszystkie $ ./variables.sh
zmienne globalne
zmienna lokalna
zmienne globalne

4. Przekazywanie argumentów do skryptu

#!/kosz/bash
# Użyj predefiniowanych zmiennych, aby uzyskać dostęp do argumentów
# Wydrukuj argumenty na ekranie
echo $1 $2 $3 ‘ -> echo $1 $2 $3’

#Możemy również uzyskać dostęp do argumentów poprzez specjalną tablicę args=(" [e-mail chroniony]»)
# Wydrukuj argumenty na ekranie
echo $(args) $(args) $(args) ‘ -> args=(“ [e-mail chroniony]»); echo $(argumenty) $(argumenty) $(argumenty)'

# Użyj zmiennej [e-mail chroniony] wyświetlić wszystkie argumenty na raz
Echo [e-mail chroniony]' -> echo [e-mail chroniony]’

Użyj zmiennej $#, aby wyświetlić liczbę argumentów przekazanych do skryptu
echo Liczba przekazanych argumentów: $# ‘ -> echo Liczba przekazanych argumentów: $#’

Kod: Zaznacz wszystkie $ ./arguments.sh Bash Scripting Tutorial
Bash Scripting Tutorial -> echo $1 $2 $3
Samouczek dotyczący skryptów Bash -> args=(" [e-mail chroniony]"); echo $(args) $(args) $(args)
Samouczek dotyczący skryptów Bash -> echo [e-mail chroniony]
Liczba przekazanych argumentów: 3 -> echo Liczba przekazanych argumentów: $#

5. Wykonywanie poleceń powłoki w skrypcie

#!/kosz/bash
# użyj backticków » ` ` », aby wykonać polecenie powłoki
echo `uname -o`
# teraz spróbujmy bez cudzysłowów
echo uname -o

Kod: Zaznacz wszystkie $ uname -o
GNU/Linux
$ ./bash_backtricks.sh
GNU/Linux
bezimienny

Jak widać, w drugim przypadku zostało wyświetlone samo polecenie, a nie wynik jego wykonania.

6. Czytaj dane wprowadzone przez użytkownika (interaktywność)

#!/kosz/bash
echo -e "Cześć, wpisz słowo: \c"
przeczytaj słowo
echo "Wprowadzone słowo to: $słowo"
echo -e "Czy możesz wpisać dwa słowa? »
przeczytaj słowo1 słowo2
echo "Oto twoje dane wejściowe: \"$słowo1\" \"$słowo2\""
echo -e "Co myślisz o skryptach basha? »
# polecenie read przechowuje teraz odpowiedź w domyślnej zmiennej wbudowanej $REPLY
czytać
echo "Powiedziałeś $ODPOWIEDŹ, cieszę się, że to słyszę! »
echo -e "Jakie są twoje ulubione kolory ? »
# -a powoduje odczytanie polecenia odczytu do tablicy
przeczytaj -a kolory
echo "Moje ulubione kolory to także $(kolory), $(kolory) i $(kolory):-)"

Kod: Zaznacz wszystkie $ ./read.sh
Cześć, wpisz słowo: coś
Wpisane słowo to: coś
Czy możesz wpisać dwa słowa?
Debian Linux
Oto twój wkład: "Debian" "Linux"
Co sądzisz o pisaniu skryptów basha?
Dobry
Powiedziałeś dobrze, cieszę się, że to słyszę!
Jakie są Twoje ulubione kolory?
niebieski zielony czarny
Moje ulubione kolory to także niebieski, zielony i czarny :-)

7. Korzystanie z pułapki

#!/kosz/bash
# zadeklaruj pułapkę
pułapka bashtrap INT
# wyczyść ekran
jasne;
# funkcja przechwytująca jest wykonywana, gdy użytkownik naciśnie CTRL-C:
# Wyświetli => Wykonanie podprogramu bash trap !
# ale skrypt będzie nadal działał
bashtrap()
{
echo "Wykryto CTRL+C !…wykonywanie pułapki bash !"
}
# skrypt liczy do 10
dla a w "seq 1 10"; robić
echo "$a/10 do wyjścia."
sen1;
Gotowe
echo "Przykład wyjścia z pułapki Bash!!!"

Kod: Zaznacz wszystkie $ ./trap.sh
1/10
2/10
3/10
4/10
5/10
6/10

7/10
8/10
9/10
CTRL+C wykryto !...wykonywanie pułapki bash !
10/10
Przykład wyjścia z pułapki Bash!!!

Jak widać, kombinacja klawiszy Ctrl-C nie zatrzymała wykonywania skryptu.

8. Tablice
8.1 Deklarowanie prostej tablicy

#!/kosz/bash
# Zadeklaruj prostą tablicę z 4 elementami
ARRAY=('Debian Linux' 'Redhat Linux' Ubuntu Linux)
# Pobierz liczbę elementów w tablicy
ELEMENTS=$(#TABLICA[@])

# pętla przez każdy element tablicy
dla ((i=0;i<$ELEMENTS;i++)); do
echo $(TABLICA[$(i)])
Gotowe

Kod: Zaznacz wszystkie $./arrays.sh
Debian Linux
linux redhat
ubuntu
linux

8.2 Wypełnianie tablicy wartościami z pliku

#!/kosz/bash
# Zadeklaruj tablicę
zadeklaruj -a ARRAY
# exec polecenie # stdin (zwykle klawiatura) zostanie utworzone z tego pliku. Dzięki temu można czytać
# zawartość pliku, linia po linii, i parsuj każdą linię wprowadzoną za pomocą sed i/lub awk.
exec 10 letcount=0

podczas czytania LINE<&10; do

TABLICA[$liczba]=$LINE
((liczba++))
Gotowe

echo Liczba elementów: $(#ARRAY[@])
# Wyświetl wartości tablicy
echo $(TABLICA[@])
# zamknij plik
exec 10>&-

Kod: Zaznacz wszystkie $cat bash.txt
Debian Linux
linux redhat
ubuntu
linux
$ ./tablice.sh
Liczba elementów: 4
Debian Linux Redhat Linux Ubuntu Linux

9. Warunki „jeśli to inaczej”
9.1. Proste użycie warunków „jeżeli-w przeciwnym razie”
Zwróć uwagę na spacje w nawiasach kwadratowych, bez których warunek nie zadziała.

#!/kosz/bash
directory="./BashScripting"

# sprawdź, czy katalog istnieje
if [ -d $katalog ]; następnie
echo "Katalog istnieje"
w przeciwnym razie
echo "Katalog nie istnieje"
fi

Kod: Zaznacz wszystkie $ ./if_else.sh
Katalog nie istnieje
$ mkdir BashScripting
$ ./if_else.sh
Katalog istnieje

9.2 Zagnieżdżone warunki if-else

#!/kosz/bash
# Zadeklaruj zmienną o wartości 4
wybór=4
# Wyświetlacz
echo "1. grzmotnąć"
echo "2. Skrypty»
echo "3. Instruktaż"

# Wykonaj, gdy zmienna jest równa czterem
# zapętlanie
while [ $wybór -eq 4 ]; robić

# przeczytaj dane wprowadzone przez użytkownika
przeczytaj wybór
# zagnieżdżony warunek "if-else"
if [ $wybór -eq 1 ] ; następnie

echo "Wybrałeś słowo: Bash"

if [ $wybór -eq 2 ] ; następnie
echo "Wybrałeś słowo: Skrypty"
w przeciwnym razie

if [ $wybór -eq 3 ] ; następnie
echo "Wybrałeś słowo: Samouczek"
w przeciwnym razie
echo "Proszę dokonać wyboru między 1-3!"
echo "1. grzmotnąć"
echo "2. Skrypty»
echo "3. Instruktaż"
echo -n "Proszę wybrać słowo ? »
wybór=4
fi
fi
fi
Gotowe

Kod: Zaznacz wszystkie $ ./nested.sh
1. bash
2. Skrypty
3. Samouczek

5

1. bash
2. Skrypty
3. Samouczek
Proszę wybrać słowo
4
Proszę dokonać wyboru pomiędzy 1-3 !
1. bash
2. Skrypty
3. Samouczek
Proszę wybrać słowo
3
Wybrałeś słowo: Tutorial

W ten sposób najpierw wykonywane jest ciało pętli „while”, ponieważ zmienna wyboru jest początkowo ustawiona na cztery. Następnie wczytujemy do niego dane wejściowe użytkownika, a jeśli dane wejściowe nie są równe 1,2 lub 3, to ponownie ustawiamy naszą zmienną na 4, w związku z czym ciało pętli się powtarza (trzeba ponownie wpisać 1,2 lub 3).

10. Porównania
10.1 Porównania arytmetyczne

Lt<
-gt>
-le<=
-ge >=
-równ ==
-ne !=

#!/kosz/bash

NUM1=2
NUM2=2
if [ $LICZ1 -eq $LICZ2]; następnie
echo "Obie wartości są równe"
w przeciwnym razie
echo "Wartości NIE są równe"
fi

Kod: Zaznacz wszystkie $ ./equals.sh
Obie wartości są równe

#!/kosz/bash
# Zadeklaruj zmienne z wartościami całkowitymi
NUM1=2
NUM2=3
if [ $LICZ1 -eq $LICZ2]; następnie
echo "Obie wartości są równe"
w przeciwnym razie
echo "Wartości NIE są równe"
fi

Kod: Zaznacz wszystkie $ ./equals.sh
Wartości NIE są równe

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

Kod: Zaznacz wszystkie $ ./equals.sh
2 jest większe niż 1

10.2 Porównania znaków z tekstem

Ten sam
!= nie to samo
< меньще чем
> więcej niż
-n zmienna s1 s1 nie jest pusta
-z s1 zmienna s1 jest pusta

#!/kosz/bash

S1="Uderzenie"

S2="Skrypty"
if [ $S1 = $S2 ]; następnie

w przeciwnym razie
echo "Ciągi NIE są równe"
fi

Kod: Zaznacz wszystkie $ ./statement.sh
Ciągi NIE są równe

#!/kosz/bash
# Zadeklaruj zmienną symboliczną S1
S1="Uderzenie"
# Zadeklaruj zmienną symboliczną S2
S2="Uderz"
if [ $S1 = $S2 ]; następnie
echo "Oba ciągi są równe"
w przeciwnym razie
echo "Ciągi NIE są równe"
fi

Kod: Zaznacz wszystkie $ ./statement.sh
Oba ciągi są równe

11. Sprawdzanie plików

B nazwa pliku Blokuj specjalny plik
-c nazwa pliku plik znaków specjalnych
-d nazwa_katalogu Sprawdź, czy istnieje katalog
-e nazwa pliku Sprawdź, czy istnieje plik
-f nazwa_pliku Sprawdź, czy istnieje zwykły plik, a nie katalog
-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ź, czy plik jest czytelny
-S nazwa pliku Sprawdź, czy plik jest gniazdem
-s nazwa pliku Sprawdź, czy plik ma niezerowy rozmiar
-u nazwa_pliku Sprawdź, czy bit set-ser-id pliku jest ustawiony
-w nazwa pliku Sprawdź, czy plik jest zapisywalny
-x nazwa pliku Sprawdź, czy plik jest wykonywalny

#!/kosz/bash
plik="./plik"
if [ -e $plik ]; następnie
echo "Plik istnieje"
w przeciwnym razie
echo "Plik nie istnieje"
fi

Kod: Zaznacz wszystkie $ ls
plik.sh
$ ./plik.sh
Plik nie istnieje
$ kliknij plik
$ls
plik plik.sh
$ ./plik.sh
plik istnieje

Podobnie w przykładzie możemy użyć pętli "while", aby sprawdzić, czy plik nie istnieje. Ten skrypt będzie uśpiony, dopóki plik nie będzie istniał. Zwróć uwagę na negatywny Bash „!” co neguje (odwraca) opcję -e.

12. Cykle
12.1. Dla pętli

#!/kosz/bash
# dla pętli
dla f w $(ls /var/); robić
echo $f
Gotowe

Uruchamianie pętli for z wiersza poleceń bash:

Kod: Zaznacz wszystkie $ dla f w $(ls /var/); wykonaj echo $f; gotowe Kod: Zaznacz wszystkie $ dla f w $(ls /var/); wykonaj echo $f; Gotowe
kopie zapasowe
Pamięć podręczna
rozbić się
Gry
lib
lokalny
Zamek
dziennik
Poczta
optować
biegać
szpula
tmp
www

12.2. podczas pętli

#!/kosz/bash
LICZBA=6
# podczas pętli
while [ $COUNT -gt 0 ]; robić

niech LICZBA=LICZBA-1
Gotowe

Kod: Zaznacz wszystkie $ ./while_loop.sh
Wartość zliczenia to: 6
Wartość zliczenia to: 5
Wartość zliczenia to: 4
Wartość zliczenia to: 3
Wartość zliczenia to: 2
Wartość zliczenia to: 1

12.3. aż do pętli

#!/kosz/bash
LICZBA=0
#do pętli
do [$COUNT -gt 5]; robić
echo Wartość licznika to: $COUNT
niech LICZBA=LICZBA+1
Gotowe

Kod: Zaznacz wszystkie $ ./until_loop.sh
Wartość zliczenia to: 0
Wartość zliczenia to: 1
Wartość zliczenia to: 2
Wartość zliczenia to: 3
Wartość zliczenia to: 4
Wartość zliczenia to: 5

12.4. Pętle z niejawnymi warunkami
W poniższym przykładzie warunkiem pętli while jest obecność standardowego wejścia.
Treść pętli będzie działała tak długo, jak długo istnieje coś do przekierowania ze standardowego wyjścia do polecenia read.

#!/kosz/bash
# Ten skrypt znajdzie i usunie spacje
# w plikach, zastępując je podkreśleniami
DIR="."
Sterowanie pętlą za pomocą polecenia read poprzez przekierowanie danych wyjściowych w pętli.
znajdź $DIR -typ f | podczas czytania pliku; robić
# użyj klasy POSIX [:space:], aby znaleźć spacje w nazwach plików
if [[ "$plik" = *[[:spacja:]]* ]]; następnie
# zamień spacje na podkreślenia
mv "$plik" `echo $plik | tr ‘ ‘ ‘_’`
fi;
Gotowe

Kod: Zaznacz wszystkie $ ls -1
skrypt.sh
$ dotknij "plik ze spacjami"
$ ls -1
plik ze spacjami
skrypt.sh
$ ./skrypt.sh
$ ls -1
file_with_spaces
skrypt.sh

13. Funkcje

#!/kosz/bash
# Funkcje można deklarować w dowolnej kolejności
funkcja funkcja_B(
funkcja echa B.
}
funkcja funkcja_A(
echo $1
}
funkcja funkcja_D(
funkcja echo D.
}
funkcja_C(
echo $1
}
# Funkcje połączeń
# przekaż parametr do funkcji A
function_A "Funkcja A."
funkcja_B
# przekaż parametr do funkcji C funkcji
function_C "Funkcja C."
funkcja_D

Kod: Zaznacz wszystkie $ ./functions.sh
Funkcja A.
Funkcja B.
Funkcja C.
Funkcja D.

14. Wybierz operatora - Wybierz

#!/kosz/bash
PS3='Wybierz jedno słowo:'
# Wybierz
wybierz słowo w "linux" "bash" "skrypty" "samouczek"
robić
echo "Wybranym słowem jest: $słowo"
# Przerwij, w przeciwnym razie pętla będzie nieskończona.
przerwanie
Gotowe
wyjście 0

Kod: Zaznacz wszystkie $ ./select.sh
1) linux
2) bash
3) skrypty
4) samouczek
Wybierz jedno słowo: 4
Wybrane przez Ciebie słowo to: samouczek

15. Operator selekcji - Case

#!/kosz/bash
echo "Jaki jest twój preferowany język programowania / skryptowy"
echo "1) bash"
echo "2) perl"
echo "3) fiton"
echo "4) c++"
echo "5) Nie wiem!"
przeczytaj przypadek;
# prosta struktura przypadku-wyboru
# zauważ, że w tym przykładzie $case to tylko zmienna
# i nie musi tak się nazywać. To tylko przykład
$przypadek w
1) echo "Wybrałeś bash";;
2) echo "Wybrałeś perla";;
3) echo "Wybrałeś fiton";;
4) echo "Wybrałeś c++";;
5) wyjście
esac

Kod: Zaznacz wszystkie $ ./case.sh
Jaki jest twój preferowany język programowania / skryptowania?
1) bash
2) perł
3) fiton
4) c++
5) Nie wiem!
4
Wybrałeś c++

———————————————————————————-

Bardziej szczegółowe informacje można uzyskać z różnych źródeł, na przykład tutaj
oryginał: https://www.linuxconfig.org/Bash_scripting_Tutorial
https://ruslandh.narod.ru/howto_ru/Bash-Prog-Intro/
https://bug.cf1.ru/2005-03-17/programmin … -book.html

https://ubuntologia.ru/forum/viewtopic.php?f=109&t=2296

Oczywiście wszyscy, którzy przynajmniej raz komunikują się z systemem Linux, mieli do czynienia (przynajmniej słyszeli na pewno) z powłoką poleceń BASH. Ale BASH to nie tylko powłoka poleceń, to także doskonały język programowania skryptowego.
Celem tego artykułu jest przybliżenie użytkownikom basha, omówienie składni, podstawowych sztuczek i funkcji języka, aby nawet zwykły użytkownik mógł szybko napisać prosty skrypt do wykonywania codziennej (-tygodniowej, -miesięcznej) rutynowej pracy lub powiedzmy „na kolanach » Zbuduj skrypt do tworzenia kopii zapasowej katalogu.

Wstęp

BASH - Bourne-Again SHell (co można przetłumaczyć jako „odrodzona powłoka” lub „ponownie Bourne-Again SHell”), najpopularniejszy interpreter poleceń w systemach uniksopodobnych, zwłaszcza w GNU/Linuksie. Poniżej znajduje się szereg wbudowanych poleceń, których użyjemy do tworzenia naszych skryptów.

Przerwij wyjście z pętli for, while lub until
kontynuuj wykonuje następną iterację pętli for, while lub until
echo wypisuje argumenty oddzielone spacjami na standardowe wyjście
wyjście wyjście z powłoki
export oznacza argumenty jako zmienne, które mają być przekazane do procesów potomnych w środowisku
hash zapamiętuje pełne ścieżki do poleceń podanych jako argumenty, aby nie były one wyszukiwane przy następnym wywołaniu
kill wysyła sygnał zakończenia do procesu
pwd wyświetla bieżący katalog roboczy
read odczytuje linię z wejścia powłoki i używa jej do przypisania wartości do określonych zmiennych.\
return powoduje, że funkcja powłoki kończy działanie z podaną wartością
shift przesuwa parametry pozycyjne w lewo
test ocenia wyrażenie warunkowe
times wyświetla nazwę użytkownika i czas systemowy używany przez powłokę i jej potomków
trap określa polecenia, które mają zostać wykonane, gdy powłoka otrzyma sygnał
unset powoduje zniszczenie zmiennych powłoki
wait czeka na zakończenie procesu potomnego i zgłasza stan wyjścia.

I oczywiście oprócz poleceń wbudowanych wykorzystamy całą masę zewnętrznych, osobnych poleceń programu, które poznamy już w trakcie.

Co musisz wiedzieć od samego początku

1. Każdy skrypt bash musi zaczynać się od linii:

#!/kosz/bash
w tym wierszu po #! ścieżka do interpretera bash jest określona, ​​więc jeśli zainstalowałeś go gdzie indziej (gdzie możesz dowiedzieć się, wpisując whereis bash), zmień go na swoją ścieżkę.
2. Komentarze zaczynają się od symbolu # (z wyjątkiem pierwszego wiersza).
3. W bash zmienne nie mają typu (zostaną omówione poniżej)

Zmienne i parametry skryptu

Podam mały przykład, który przeanalizujemy:

#!/kosz/bash
# określ, gdzie przechowujemy interpreter bash
parametr1=$1 #ustaw zmienną parametr1 na wartość pierwszego parametru skryptu
script_name=$0 #ustaw zmienną nazwa_skryptu na wartość nazwy skryptu
echo "Uruchomiłeś skrypt o nazwie $nazwa_skryptu i parametrze $parametr1" # polecenie echo wyświetla określony ciąg, zmienne są dostępne przez $nazwa_zmiennej.
echo "Uruchomiłeś skrypt o nazwie $nazwa_skryptu z parametrem $parametr1" # tutaj widzimy inne cudzysłowy, różnica polega na tym, że nie ma podstawienia zmiennych w pojedynczych cudzysłowach.
exit 0 #Wyjdź z kodem 0 (pomyślne zakończenie skryptu)

[e-mail chroniony]:~$ ./test.sh qwerty
Uruchomiłeś skrypt o nazwie ./test.sh z parametrem qwerty
Uruchomiłeś skrypt o nazwie $script_name i parametrze $parametr1

Teraz, gdy widzieliśmy, jak używać zmiennych i przekazywać parametry do skryptu, czas zapoznać się ze zmiennymi zarezerwowanymi:

$DIRSTACK - zawartość wierzchołka stosu katalogów
$EDITOR - domyślny edytor tekstu
$EUID — efektywny UID. Jeśli użyłeś programu su do wykonywania poleceń jako inny użytkownik, ta zmienna zawiera UID tego użytkownika, podczas gdy...
$UID - ...zawiera rzeczywisty identyfikator, który jest ustawiany dopiero po zalogowaniu.
$FUNCNAME - nazwa bieżącej funkcji w skrypcie.
$GROUPS - tablica grup, do których należy aktualny użytkownik
$HOME - katalog domowy użytkownika
$HOSTNAME - Twoja nazwa hosta
$HOSTTYPE - architektura hosta.
$LC_CTYPE - zmienna wewnętrzna określająca kodowanie znaków
$OLDPWD - stary katalog roboczy
$OSTYPE — typ systemu operacyjnego
$PATH - ścieżka wyszukiwania programu
$PPID — identyfikator procesu nadrzędnego
$SECONDS - czas działania skryptu (w sekundach)
$# - całkowita liczba parametrów przekazanych do skryptu
$* - wszystkie argumenty przekazane do skryptu (wyświetlane w ciągu)
[e-mail chroniony]- taki sam jak poprzedni, ale parametry są wyświetlane w kolumnie
$! - PID ostatniego procesu działającego w tle
$$ - PID samego skryptu

Semestry

Myślę, że operatory warunkowe są znane prawie każdemu, kto kiedykolwiek próbował na czymś pisać programy. W bash warunki są zapisane w następujący sposób. sposób (jak zwykle w przykładzie):
#!/kosz/bash
source=$1 # wstaw pierwszy parametr skryptu do zmiennej źródłowej
dest=$2 #wstaw drugi parametr skryptu do zmiennej dest

If [[ "$źródło" -eq "$dest" ]] # cytuj nazwy zmiennych do porównania. -eq - logiczne porównanie oznaczające "równe"
wtedy # jeśli są naprawdę równe, to
echo "Miejsce docelowe $dest i źródło $źródło to ten sam plik!" #wyświetl komunikat o błędzie, ponieważ $źródło i $cel są równe
wyjście 1 # wyjście z błędem (1 - kod błędu)
else # jeśli nie są równe
cp $source $dest # następnie wykonaj polecenie cp: skopiuj źródło do miejsca docelowego
echo "Udana kopia!"
fi #oznacza koniec warunku.

Wynik wykonania skryptu:
[e-mail chroniony]:~$ ./podkład2.sh 1 1
Wnioskodawca 1 i źródło 1 to ten sam plik!
[e-mail chroniony]:~$ ./podkład2.sh 1 2
Miłego kopiowania!

Struktura if-then-else jest używana w następujący sposób:
jeśli<команда или набор команд возвращающих код возврата(0 или 1)>
następnie
<если выражение после if истино, то выполняется этот блок>
w przeciwnym razie
<если выражение после if ложно, тот этот>
Struktury [[ , [ , test, (()) lub dowolne inne (lub kilka) komend linuksowych mogą działać jako komendy zwracające kod powrotu.
test - używany do logicznego porównania. po wyrażeniu wymagany jest nawias zamykający "]"
[ jest synonimem polecenia test
[[ - rozszerzona wersja "[" (od wersji 2.02) (jak w przykładzie), w ramach której || (albo i). Musi mieć nawias zamykający „]]”
(()) - porównanie matematyczne.
zbudować wielopoziomowe warunki formularza:
jeśli ...
następnie ....
w przeciwnym razie
jeśli ....
następnie....
w przeciwnym razie ....

Dla zwięzłości i czytelności kodu możesz użyć struktury:
jeśli..
następnie...
elif...
następnie...
elif...

Semestry. Wielokrotny wybór

Jeśli konieczne jest porównanie dowolnej zmiennej z dużą liczbą parametrów, bardziej wskazane jest użycie instrukcji case.
#!/kosz/bash
echo "Wybierz edytor do uruchomienia:"
echo "1 Działa nano"
echo "2 Uruchom program vi"
echo "3 Uruchom program emacs"
echo "4 Wyjście"
read robi #tutaj czytamy do zmiennej $doing ze standardowego wejścia

Sprawa $robienie w
1)
/usr/bin/nano # jeśli $robienie wynosi 1, uruchom nano
;;
2)
/usr/bin/vi # jeśli $doing zawiera 2 to uruchom vi
;;
3)
/usr/bin/emacs # jeśli $doing zawiera 3 to uruchom emacs
;;
4)
wyjście 0
;;
*) #jeżeli z klawiatury zostanie wprowadzone coś, co nie jest opisane w sprawie, wykonaj następujące czynności:
echo "Wprowadzono nieprawidłową czynność"

Esac #end case oświadczenie.

Wynik pracy:
[e-mail chroniony]:~$ ./menu2.sh
Wybierz edytor do uruchomienia:
1 Uruchamianie nano
2 Rozpoczęcie vi
3 Uruchom emacs
4 Wyjście

Po wybraniu numeru i wciśnięciu Enter uruchomi się wybrany przez Ciebie edytor (o ile oczywiście wszystkie ścieżki są poprawne i masz zainstalowane te edytory :))
Oto lista operatorów logicznych używanych w konstrukcji if-then-else-fi:
-z # linia jest pusta
-n # ciąg nie jest pusty
=, (==) # ciągi są równe
!= # ciągi nie są równe
-równ # równa się
-ne # nierówne
-lt,(<) # меньше
-le,(<=) # меньше или равно
-gt,(>) #więcej
-ge,(>=) #większe lub równe
! #negacja wyrażenia logicznego
-a,(&&) #logiczne AND
-o,(||) # logiczne "LUB"

Ustaliliśmy podstawy języka i warunki, aby nie przeciążać artykułu, podzielę go na kilka części (powiedzmy 3). W drugiej części przeanalizujemy operatory pętli i wykonanie operacji matematycznych.

UPD: Naprawiono kilka błędów
UPD: Zaktualizowano część dotyczącą warunków „jeśli-to-inaczej”

Wszyscy wiedzą, że powłoka Bash ma wbudowane polecenia, których nie ma w folderach /bin lub /usr/bin. Są wbudowane w powłokę i działają jako funkcje. W jednym z poprzednich artykułów rozważaliśmy. Omówiliśmy tam prawie wszystko, jak powinny wyglądać skrypty, zastosowanie warunków, pętli, zmiennych, ale nie poprzestaliśmy na funkcjach.

W dzisiejszym artykule naprawimy to niedociągnięcie. Podobnie jak w przypadku każdego języka programowania, Bash ma funkcje, które mogą być bardzo przydatne w użyciu. Przyjrzymy się używaniu funkcji basha, jak je pisać, a nawet jak tworzyć biblioteki z tych funkcji.

Najpierw musimy zrozumieć, czym jest funkcja w naszym kontekście. Funkcja to zbiór poleceń połączonych jedną nazwą, które wykonują określone zadanie. Funkcja wywoływana jest po nazwie, może przyjmować parametry i zwracać wynik pracy. Krótko mówiąc, funkcje Bash działają tak samo, jak w innych językach programowania.

Składnia tworzenia funkcji jest bardzo prosta:

nazwa_funkcji() ( lista poleceń )

Nazwa funkcji nie może być zgodna z żadnym z istniejących poleceń lub funkcji, a wszystkie polecenia w treści funkcji są zapisywane w nowym wierszu.

prosta funkcja

Napiszmy małą funkcję, która wyświetli napis na ekranie:

$ vi funkcja.sh

#!/kosz/bash
printstr()(
echo "witaj świecie"
}
printstr

Wywołanie funkcji bash odbywa się poprzez podanie jej nazwy, tak jak w przypadku każdego innego polecenia. Uruchom nasz skrypt do wykonania, nie zapomnij, że wcześniej musisz nadać mu uprawnienia do wykonania:

chmod u+x function.sh

Wszystko działa, teraz skomplikujmy zadanie, spróbujmy przekazać argumenty do funkcji.

Argumenty funkcji

Argumenty funkcji muszą być przekazywane podczas wywoływania i są odczytywane w taki sam sposób jak argumenty skryptu. Składnia wywołania funkcji z parametrami bash to:

nazwa_funkcji argument1 argument2 ... argumentN

Jak widać, wszystko jest dość proste. Parametry są oddzielone spacją. Teraz poprawmy naszą funkcję tak, aby wyświetlała podany przez nas ciąg:

!/kosz/bash
printstr()(
echo $1
}
printstr "Witaj świecie"

Możesz mieć wiele opcji:

!/kosz/bash
printstr()(
echo $1
echo $2
echo $3
echo $5
}
printstr "arg1" "arg2" "arg3" "arg4" "arg5"

Jest inny sposób na wyodrębnienie argumentów, tak jak w C, przy użyciu stosu. Pobieramy pierwszy argument, następnie przesuwamy wskaźnik stosu argumentów o jeden i ponownie pobieramy pierwszy argument. I tak dalej:

!/kosz/bash
printstr()(
echo $1
Zmiana
echo $1
Zmiana
echo $1
Zmiana
echo $1
}
printstr "arg1" "arg2" "arg3" "arg4"

Zwracanie wyniku funkcji

Możesz nie tylko korzystać z funkcji z parametrami bash, ale także uzyskać z nich wynik pracy. Służy do tego polecenie return. Kończy funkcję i zwraca wartość liczbową kodu powrotu. Może wynosić od 0 do 255:

!/kosz/bash
printstr()(
powrót 134;
}
printstr
echo $?

Jeśli musisz użyć wartości zwracanej przez funkcję bash zamiast kodu stanu, użyj echo. Łańcuch nie jest natychmiast wyprowadzany do terminala, ale jest zwracany jako wynik funkcji i można go zapisać do zmiennej, a następnie użyć:

!/kosz/bash
printstr()(
echo "test"
}
WARIANCJA=$(str.druku)
echo $VAR

Funkcje eksportu

Możesz udostępnić funkcję poza skryptem za pomocą polecenia define:

!/kosz/bash
printstr()(
echo "witaj świecie"
}
zadeklaruj -x -f printstr

Następnie uruchom skrypt poleceniem source:

funkcja źródłowa.sh
$printstr

rekurencja

Możesz wywołać funkcję z jej wnętrza, aby wykonać rekurencję:

!/kosz/bash
printstr()(
echo "witaj świecie"
printstr
}
printstr

Możesz poeksperymentować z użyciem rekurencji, może to być przydatne w wielu przypadkach, pamiętaj tylko o pierwszym wywołaniu funkcji Bash.

Zmienne lokalne w funkcji

Jeśli zadeklarujesz zwykłą zmienną w funkcji, będzie ona dostępna w całym skrypcie, jest to wygodne przy zwracaniu wartości funkcji, ale czasami może być konieczne utworzenie zmiennej lokalnej. Do tego służy lokalne polecenie:

!/kosz/bash
printstr()(
lokalna VAR = 1 USD
echo $(zmienna)
}
printstr "Witaj świecie"

Biblioteki funkcji

Możemy wziąć kilka funkcji basha i połączyć je w jedną bibliotekę, aby móc zaimportować te funkcje jednym poleceniem. Odbywa się to w podobny sposób jak eksportowanie funkcji. Najpierw utwórzmy plik biblioteki:

test1()(
echo "Witaj świecie od 1";
}
test2()(
echo "Witaj świecie od 2";
}
test3()(
echo "Witaj świecie z 3";
}

Teraz stwórzmy skrypt, który będzie wykorzystywał nasze funkcje. Możesz zaimportować bibliotekę za pomocą polecenia source lub po prostu określając nazwę skryptu:

!/kosz/bash
źródło lib.sh
test1
test2
test3

wnioski

W tym artykule przyjrzeliśmy się funkcjom basha, sposobom ich pisania, stosowania i łączenia w biblioteki. Jeśli często piszesz skrypty w Bash, te informacje będą dla Ciebie przydatne. Możesz stworzyć swój własny zestaw funkcji do wykorzystania w każdym skrypcie i tym samym ułatwić sobie pracę.