Importazione dello script sh in bash. Funzioni di Bash negli script. Variabili negli script

Scrivere script in Linux (apprendimento per esempio)

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

1. Introduzione

Di cosa hai bisogno per scrivere gli script
Competenza negli strumenti da riga di comando e nelle opzioni richieste.
La conoscenza di base dell'inglese a livello di scuola elementare non farà male.

Perché sono necessari gli script
In primo luogo, l'amministrazione di un server Linux, in un modo o nell'altro, si riduce all'esecuzione sistematica degli stessi comandi. Inoltre, non è necessario che questi comandi siano eseguiti da una persona. Possono essere programmati per essere eseguiti dalla macchina.
In secondo luogo, anche solo eseguire un compito comune, che (all'improvviso) ammonta a 20-1000 ... le operazioni ripetitive sono MOLTO più facili da implementare in uno script.

Cos'è una sceneggiatura?
Uno script è un insieme di istruzioni che un computer deve eseguire in un ordine specifico e in un momento specifico. Le istruzioni possono essere comandi di shell interni (loop, condizioni, elaborazione di informazioni di testo, utilizzo di variabili di ambiente, ecc.) o qualsiasi programma che eseguiamo nella console con i parametri necessari.

Come scrivere una sceneggiatura
Nel nostro caso, lo script sarà un file di testo con attributi di esecuzione. Se un file di script inizia con # !, che è chiamato sha-bang nel mondo UNIX, questo dice al sistema quale interprete usare per eseguire lo script. Se è difficile da capire, ricorda che inizieremo a scrivere tutti gli script esattamente dalla riga #! / Bin / bash o #! / Bin / sh, quindi seguiranno comandi e commenti.

Parole di commiato
Ti consiglio sinceramente di scrivere quanti più commenti possibili su quasi ogni riga dello script. Il tempo passerà e sarà necessario modificare o modernizzare lo script scritto una volta. Se non ricordi o capisci cosa è scritto nello script, diventa difficile cambiarlo, è più facile scrivere da zero.

Di quali script potremmo aver bisogno:

impostare le regole del firewall all'avvio del sistema.

eseguire il backup delle impostazioni e dei dati.

aggiungere caselle di posta al server di posta (più precisamente al database mysql)

che lancia ad una certa ora (preferibilmente ogni notte) un programma che scansiona i log del server proxy e genera un comodo report web sulla quantità di traffico scaricato.

inviandoci per posta le informazioni che qualcuno ha avuto accesso al nostro server tramite ssh, il tempo di connessione e l'indirizzo del cliente.

Informazioni sulle tecniche di scripting
Crea un file di testo, modificalo, imposta i permessi di esecuzione, avvia, controlla gli errori, correggi, avvia, controlla gli errori...
Quando tutto è leccato e funziona correttamente, lo mettiamo in autoload o nello scheduler per un certo tempo.

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

2. Imparare a scrivere script nel linguaggio interno BASH
originale: https://www.linuxconfig.org/Bash_scripting_Tutorial

Questa guida non presuppone alcuna conoscenza preliminare delle tecniche di scripting (scripting) che utilizzano il linguaggio Bash interno. Con questo tutorial, scoprirai presto che lo scripting è un compito molto semplice. Iniziamo il nostro tutorial con un semplice script che emette la stringa "Hello World!" (tradotto dall'inglese - Ciao a tutti!)

1. Scenario "Ciao a tutti"
Ecco il tuo primo esempio di script bash:

#!/bin/bash
echo "Ciao mondo"

Vai alla directory contenente il nostro file hello_world.sh e rendilo eseguibile:

Codice: seleziona tutto $ chmod + x hello_world.sh

Esegui lo script per l'esecuzione

Codice: Seleziona tutto $ ./hello_world.sh

2. Un semplice script bash per l'archiviazione

#!/bin/bash
tar -czf directory_miahome.tar.gz / home / utente

Codice: Seleziona tutto $ ./backup.sh

$ du -sh directory_mia_home.tar.gz
41M myhome_directory.tar.gz

3. Lavorare con le variabili
In questo esempio, dichiariamo una variabile semplice e la stampiamo sullo schermo usando il comando echo

#!/bin/bash
STRING = "CIAO MONDO!!!"
echo $ STRINGA

Codice: Seleziona tutto $ ./hello_world.sh
CIAO MONDO !!!

Il nostro script di archiviazione con variabili:

#!/bin/bash
OF = myhome_directory _ $ (data +% Y% m% d) .tar.gz
SE = / casa / utente
tar -czf $ DI $ SE

Codice: Seleziona tutto $ ./backup.sh
tar: rimozione di "\" iniziale dai nomi dei membri
$ du -sh * tar.gz
41M myhome_directory_20100123.tar.gz

3.1 Variabili globali e locali

#!/bin/bash
# Dichiara una variabile globale
# Tale variabile può essere utilizzata ovunque in questo script
VAR = "variabile globale"
funzione bash (
# Dichiara una variabile locale
# Tale variabile è valida solo per la funzione in cui è stata dichiarata
VAR locale = "variabile locale"
echo $ VAR
}
echo $ VAR
bash
# Nota che la variabile globale non è cambiata
echo $ VAR

Codice: Seleziona tutto $ ./variables.sh
variabile globale
variabile locale
variabile globale

4. Passare argomenti allo script

#!/bin/bash
# Usa variabili predefinite per accedere agli argomenti
# Visualizza argomenti sullo schermo
echo $ 1 $ 2 $ 3 '-> echo $ 1 $ 2 $ 3'

# Possiamo anche accedere agli argomenti tramite l'array speciale args = (“ [e-mail protetta]»)
# Visualizza argomenti sullo schermo
echo $ (argomenti) $ (argomenti) $ (argomenti) ‘-> argomenti = (“ [e-mail protetta]"); echo $ (argomenti) $ (argomenti) $ (argomenti) '

# Usa una variabile [e-mail protetta] per restituire tutti gli argomenti contemporaneamente
eco [e-mail protetta]‘-> eco [e-mail protetta]’

Usa la variabile $ # per visualizzare il numero di argomenti passati allo script
echo Numero di argomenti passati: $ # ‘-> echo Numero di argomenti passati: $ #'

Codice: Seleziona tutto $ ./arguments.sh Bash Scripting Tutorial
Tutorial script Bash -> echo $ 1 $ 2 $ 3
Bash Scripting Tutorial -> args = (" [e-mail protetta]"); echo $ (argomenti) $ (argomenti) $ (argomenti)
Tutorial script Bash -> echo [e-mail protetta]
Numero di argomenti passati: 3 -> echo Numero di argomenti passati: $ #

5. Esecuzione di comandi di shell in uno script

#!/bin/bash
# usa i backtick "" "" per eseguire il comando della shell
echo `uname -o`
# ora proviamo senza virgolette
echo uname -o

Codice: Seleziona tutto $ uname -o
GNU/Linux
$ ./bash_backtricks.sh
GNU/Linux
uname -o

Come puoi vedere, nel secondo caso, è stato visualizzato il comando stesso e non il risultato della sua esecuzione.

6. Lettura dell'input dell'utente (interattività)

#!/bin/bash
echo -e "Ciao, per favore digita la parola: \ c"
leggi la parola
echo "La parola che hai inserito è: $ parola"
echo -e “Puoi per favore inserire due parole? "
leggi parola1 parola2
echo "Ecco il tuo input: \" $ parola1 \ "\" $ parola2 \ ""
echo -e “Cosa ne pensi dello scripting bash? "
# comando read ora memorizza una risposta nella variabile predefinita $ REPLY
leggere
echo “Hai detto $ REPLY, mi fa piacere sentirlo! "
echo -e “Quali sono i tuoi colori preferiti? "
# -a rende il comando read per leggere in un array
leggi -a colori
echo "I miei colori preferiti sono anche $ (colori), $ (colori) e $ (colori) :-)"

Codice: Seleziona tutto $ ./read.sh
Ciao, per favore digita la parola: qualcosa
La parola che hai inserito è: qualcosa
Potete per favore inserire due parole?
Debian Linux
Ecco il tuo input: "Debian" "Linux"
Cosa ne pensi dello scripting bash?
Buona
Hai detto bene, sono felice di sentirlo!
Quali sono i tuoi colori preferiti?
blu verde nero
I miei colori preferiti sono anche blu, verde e nero :-)

7. Usare una trappola

#!/bin/bash
# dichiarare una trappola
trap trappola INT
# cancella lo schermo
chiaro;
# la funzione hook viene eseguita quando l'utente preme CTRL-C:
# Lo schermo visualizzerà => Sottoprogramma bash trap in esecuzione!
# ma lo script continuerà ad essere eseguito
trappola ()
{
echo "CTRL + C rilevato! ... in esecuzione bash trap!"
}
# script conterà fino a 10
per a in `seq 1 10`; fare
echo "$ a / 10 per uscire."
dormire 1;
fatto
echo "Esci dall'esempio di trappola Bash !!!"

Codice: Seleziona tutto $ ./trap.sh
1/10
2/10
3/10
4/10
5/10
6/10

7/10
8/10
9/10
CTRL + C Rilevato! ... in esecuzione bash trap!
10/10
Esci dall'esempio di trappola bash !!!

Come puoi vedere, la combinazione di tasti Ctrl-C non ha interrotto l'esecuzione dello script.

8. Matrici
8.1 Dichiarare un array semplice

#!/bin/bash
# Dichiara un array semplice con 4 elementi
ARRAY = ('Debian Linux' '' Redhat Linux 'Ubuntu Linux)
# Ottieni il numero di elementi nell'array
ELEMENTI = $ (# ARRAY [@])

# genera in un ciclo ogni elemento dell'array
per ((i = 0; i<$ELEMENTS;i++)); do
echo $ (ARRAY [$ (i)])
fatto

Codice: Seleziona tutto $. / Arrays.sh
Debian Linux
RedHat Linux
Ubuntu
Linux

8.2 Riempire l'array con i valori del file

#!/bin/bash
# Dichiara un array
dichiarare -a ARRAY
# Comando Esegui # stdin (di solito la tastiera) verrà prodotto da questo file. Questo rende possibile leggere
# il contenuto del file, riga per riga, e analizza ogni riga inserita con sed e/o awk.
esecutore 10 lascia contare = 0

mentre leggi LINE<&10; do

ARRAY [$ count] = $ LINE
((conta ++))
fatto

echo Numero di elementi: $ (# ARRAY [@])
# Emissione dei valori dell'array
echo $ (ARRAY [@])
# chiudi il file
esec 10> & -

Codice: Seleziona tutto $ cat bash.txt
Debian Linux
RedHat Linux
Ubuntu
Linux
$ ./arrays.sh
Numero di elementi: 4
Debian Linux Redhat Linux Ubuntu Linux

9. Condizioni se-allora-altrimenti
9.1. Uso semplice delle condizioni "se-altrimenti"
Prestare attenzione agli spazi tra parentesi quadre, senza i quali la condizione non funzionerà.

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

# controlla se la directory esiste
if [-d $ directory]; poi
echo "La directory esiste"
altro
echo "La directory non esiste"
fi

Codice: Seleziona tutto $ ./if_else.sh
La directory non esiste
$ mkdir BashScripting
$ ./if_else.sh
La directory esiste

9.2 Condizioni if-other nidificate

#!/bin/bash
# Dichiara una variabile con il valore 4
scelta = 4
# Visualizzazione
eco "1. Bacio"
eco "2. Scripting"
eco "3. Esercitazione "

# Esegui finché la variabile non è quattro
# Loop
while [$ scelta -eq 4]; fare

# leggi l'input dell'utente
leggi la scelta
# condizione if-other nidificata
if [$ scelta -eq 1]; poi

echo "Hai scelto la parola: Bash"

if [$ scelta -eq 2]; poi
echo "Hai scelto la parola: Scripting"
altro

if [$ scelta -eq 3]; poi
echo "Hai scelto la parola: Tutorial"
altro
echo "Per favore scegli tra 1-3!"
eco "1. Bacio"
eco "2. Scripting"
eco "3. Esercitazione "
echo -n “Scegli una parola? "
scelta = 4
fi
fi
fi
fatto

Codice: Seleziona tutto $ ./nested.sh
1. Bash
2. Script
3. Tutorial

5

1. Bash
2. Script
3. Tutorial
Per favore scegli una parola?
4
Si prega di scegliere tra 1-3!
1. Bash
2. Script
3. Tutorial
Per favore scegli una parola?
3
Hai scelto la parola: Tutorial

Quindi, in un primo momento, viene eseguito il corpo del ciclo "while", poiché la variabile scelta è inizialmente pari a quattro. Quindi leggiamo l'input dell'utente in esso e se l'input non è uguale a 1.2 o 3, rendiamo nuovamente la nostra variabile uguale a 4, in relazione alla quale viene ripetuto il corpo del ciclo (di nuovo è necessario inserire 1.2 o 3).

10. Confronti
10.1 Confronti aritmetici

Lt<
-gt>
-le<=
-ge> =
-eq ==
-ne! =

#!/bin/bash

NUM1 = 2
NUM2 = 2
if [$ NUM1 -eq $ NUM2]; poi
echo "Entrambi i valori sono uguali"
altro
echo "I valori NON sono uguali"
fi

Codice: Seleziona tutto $ ./equals.sh
Entrambi i valori sono uguali

#!/bin/bash
# Dichiara variabili con valori interi
NUM1 = 2
NUM2 = 3
if [$ NUM1 -eq $ NUM2]; poi
echo "Entrambi i valori sono uguali"
altro
echo "I valori NON sono uguali"
fi

Codice: Seleziona tutto $ ./equals.sh
I valori NON sono uguali

#!/bin/bash
# Dichiara variabili con valori interi
NUM1 = 2
NUM2 = 1
if [$ NUM1 -eq $ NUM2]; poi
echo "Entrambi i valori sono uguali"
elif [$ NUM1 -gt $ NUM2]; poi
echo "$ NUM1 è maggiore di $ NUM2"
altro
echo "$ NUM2 è maggiore di $ NUM1"
fi

Codice: Seleziona tutto $ ./equals.sh
2 è maggiore di 1

10.2 Confronti di testo simbolico

Lo stesso
! = non lo stesso
< меньще чем
> più di
-n s1 variabile s1 non è vuoto
-z s1 la variabile s1 è vuota

#!/bin/bash

S1 = "Colpo"

S2 = "Script"
se [$ S1 = $ S2]; poi

altro
echo "Le stringhe NON sono uguali"
fi

Codice: Seleziona tutto $ ./statement.sh
Le stringhe NON sono uguali

#!/bin/bash
# Dichiara la variabile simbolica S1
S1 = "Colpo"
# Dichiara la variabile simbolica S2
S2 = "Colpisci"
se [$ S1 = $ S2]; poi
echo "Entrambe le stringhe sono uguali"
altro
echo "Le stringhe NON sono uguali"
fi

Codice: Seleziona tutto $ ./statement.sh
Entrambe le stringhe sono uguali

11. Controllo dei file

B nome file Blocca file speciale
-c nomefile File di caratteri speciali
-d nomedirectory Controlla l'esistenza della directory
-e nomefile Controlla l'esistenza del file
-f nomefile Controlla l'esistenza di un file regolare, non una directory
-G nome file Controlla se il file esiste ed è di proprietà dell'ID di gruppo effettivo.
-g nomefile vero se il file esiste ed è set-group-id.
-k nome file Sticky bit
-L nome file Collegamento simbolico
-O nomefile Vero se il file esiste ed è di proprietà dell'ID utente effettivo.
-r nomefile Controlla se il file è leggibile
-S nomefile Controlla se il file è socket
-s nomefile Controlla se il file ha una dimensione diversa da zero
-u nomefile Controlla se il bit set-ser-id del file è impostato
-w nomefile Controlla se il file è scrivibile
-x nomefile Controlla se il file è eseguibile

#!/bin/bash
file = "./ file"
if [-e $ file]; poi
echo "Il file esiste"
altro
echo "Il file non esiste"
fi

Codice: Seleziona tutto $ ls
file.sh
$ ./file.sh
Il file non esiste
$ touch file
$ ls
file file.sh
$ ./file.sh
il file esiste

Allo stesso modo per l'esempio, possiamo usare i cicli "while" per verificare se il file non esiste. Questo script dormirà finché il file non esiste. Nota il negatore Bash "!" che nega (inverte) l'opzione -e.

12. Cicli
12.1. Per ciclo

#!/bin/bash
# per ciclo
per f in $ (ls / var /); fare
echo $ f
fatto

Eseguendo un ciclo for dalla riga di comando bash:

Codice: seleziona tutto $ per f in $ (ls / var /); fai echo $ f; done Codice: seleziona tutto $ per f in $ (ls / var /); fai echo $ f; fatto
backup
cache
incidente
Giochi
libi
Locale
serratura
tronco d'albero
posta
optare
correre
bobina
tmp
www

12.2. Mentre il ciclo

#!/bin/bash
CONTE = 6
# ciclo while
mentre [$ COUNT -gt 0]; fare

sia CONTA = CONTA-1
fatto

Codice: Seleziona tutto $ ./while_loop.sh
Il valore del conteggio è: 6
Il valore del conteggio è: 5
Il valore del conteggio è: 4
Il valore del conteggio è: 3
Il valore del conteggio è: 2
Il valore del conteggio è: 1

12.3. Fino al ciclo

#!/bin/bash
CONTA = 0
# fino al ciclo
fino a [$ COUNT -gt 5]; fare
echo Il valore di conteggio è: $ COUNT
sia CONTA = CONTA + 1
fatto

Codice: Seleziona tutto $ ./until_loop.sh
Il valore del conteggio è: 0
Il valore del conteggio è: 1
Il valore del conteggio è: 2
Il valore del conteggio è: 3
Il valore del conteggio è: 4
Il valore del conteggio è: 5

12.4. Cicli con condizioni implicite
Nell'esempio seguente, la condizione per un ciclo while è la presenza di un input standard.
Il corpo del ciclo verrà eseguito finché c'è qualcosa da reindirizzare dall'output standard al comando di lettura.

#!/bin/bash
# Questo script cercherà e rimuoverà gli spazi
# nei file, sostituendoli con caratteri di sottolineatura
DIR = "."
Controllo di un ciclo con un comando di lettura reindirizzando l'output in un ciclo.
trova $ DIR -tipo f | durante la lettura del file; fare
# usa la classe POSIX [: space:] per trovare gli spazi nei nomi dei file
if [["$ file" = * [[: spazio:]] *]]; poi
# sostituisci gli spazi con i trattini bassi
mv "$ file" `echo $ file | tr '' '_' '
fi;
fatto

Codice: Seleziona tutto $ ls -1
script.sh
$ tocca "file con spazi"
$ ls -1
file con spazi
script.sh
$ ./script.sh
$ ls -1
file_con_spazi
script.sh

13. Funzioni

#!/bin/bash
# Le funzioni possono essere dichiarate in qualsiasi ordine
funzione funzione_B (
funzione eco B.
}
funzione funzione_A (
eco $ 1
}
funzione funzione_D (
funzione eco D.
}
funzione funzione_C (
eco $ 1
}
# Chiamare le funzioni
# passa il parametro alla funzione funzione A
function_A "Funzione A."
funzione_B
# passa il parametro alla funzione funzione C
function_C "Funzione C."
funzione_D

Codice: Seleziona tutto $ ./functions.sh
Funzione A
Funzione B.
Funzione C.
Funzione D.

14. Selezione operatore - Seleziona

#!/bin/bash
PS3 = 'Scegli una parola:'
# Selezionare
seleziona la parola in "linux" "bash" "scripting" "tutorial"
fare
echo "La parola che hai selezionato è: $ parola"
# Interrompi, altrimenti il ​​ciclo sarà infinito.
rottura
fatto
esci 0

Codice: Seleziona tutto $ ./select.sh
1) linux
2) bash
3) scripting
4) tutorial
Scegli una parola: 4
La parola che hai selezionato è: tutorial

15. Operatore di scelta - Caso

#!/bin/bash
echo "Qual è il tuo linguaggio di programmazione/script preferito"
echo "1) bash"
echo "2) perla"
echo "3) pitone"
echo "4) c++"
echo "5) Non lo so!"
leggere il caso;
# semplice struttura di selezione dei casi
# nota che in questo esempio $ case è solo una variabile
# e non deve essere chiamato così. Questo è solo un esempio
caso $ caso in
1) echo "Hai selezionato bash" ;;
2) echo "Hai selezionato perl" ;;
3) echo "Hai selezionato phyton" ;;
4) echo "Hai selezionato c++" ;;
5) esci
esac

Codice: Seleziona tutto $ ./case.sh
Qual è il tuo linguaggio di programmazione / scripting preferito?
1) bash
2) perla
3) pitone
4) c++
5) Non lo so!
4
Hai selezionato c++

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

Informazioni più dettagliate possono essere ottenute da varie fonti, ad esempio da qui
originale: 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

Oggi parleremo degli script bash. Questi sono script da riga di comando scritti per la shell bash. Ci sono altre shell come zsh, tcsh, ksh, ma ci concentreremo su bash. Questo materiale è destinato a tutti, l'unica condizione è la capacità di lavorare nella riga di comando di Linux.

Gli script della riga di comando sono raccolte degli stessi comandi che possono essere immessi dalla tastiera, assemblati in file e uniti da uno scopo comune. In questo caso, i risultati del lavoro dei team possono essere di valore indipendente o servire come dati di input per altri team. Lo scripting è un modo potente per automatizzare le azioni eseguite di frequente.

Quindi, se parliamo della riga di comando, ti consente di eseguire più comandi contemporaneamente, inserendoli separati da punto e virgola:

Pwd; chi sono
In effetti, se l'hai provato nel tuo terminale, il tuo primo script bash che prevede due comandi è già stato scritto. Funziona così. Innanzitutto, il comando pwd visualizza le informazioni sulla directory di lavoro corrente, quindi il comando whoami visualizza le informazioni sull'utente con cui si è effettuato l'accesso.

Usando questo approccio, puoi combinare tutti i comandi che vuoi su una riga, la limitazione è solo nel numero massimo di argomenti che possono essere passati al programma. È possibile determinare questa limitazione utilizzando il seguente comando:

Getconf ARG_MAX
La riga di comando è un ottimo strumento, ma devi inserire i comandi ogni volta che ne hai bisogno. Cosa succede se scrivi una serie di comandi su un file e chiami semplicemente quel file per eseguirli? In effetti, il file di cui stiamo parlando si chiama script da riga di comando.

Come funzionano gli script bash

Crea un file vuoto usando il comando touch. Nella sua prima riga, dobbiamo indicare quale shell useremo. Siamo interessati a bash, quindi la prima riga del file sarà così:

#!/bin/bash
In altre righe di questo file, il carattere hash viene utilizzato per indicare i commenti che la shell non elabora. Tuttavia, la prima riga è un caso speciale, qui un cancelletto seguito da un punto esclamativo (questa sequenza è chiamata shebang) e il percorso per bash indicano al sistema che lo script è stato creato appositamente per bash.

I comandi della shell sono delimitati da feed di riga, i commenti sono delimitati da cancelletti. Ecco come appare:

#! / bin / bash # Questo è un commento pwd whoami
Qui, oltre che sulla riga di comando, puoi scrivere i comandi su una riga, separati da punto e virgola. Tuttavia, scrivere i comandi su righe separate rende il file più facile da leggere. In ogni caso, la shell li elaborerà.

Impostazione dei permessi del file di script

Salva il file con il nome myscript e lo script bash è quasi terminato. Ora non resta che rendere eseguibile questo file, altrimenti, provando a eseguirlo, si incontrerà l'errore Permesso negato.

Tentativo di eseguire un file di script con permessi configurati in modo errato

Rendiamo eseguibile il file:

Chmod + x ./myscript
Ora proviamo ad eseguirlo:

./myscript
Dopo aver impostato le autorizzazioni, tutto funziona come dovrebbe.

Esecuzione dello script bash con successo

Visualizzazione dei messaggi

Il comando echo viene utilizzato per inviare il testo alla console Linux. Approfittiamo della conoscenza di questo fatto e modifichiamo il nostro script, aggiungendo spiegazioni ai dati che vengono visualizzati dai comandi già in esso contenuti:

#! / bin / bash # il nostro commento è qui echo "La directory corrente è:" pwd echo "L'utente che ha effettuato l'accesso è:" whoami
Questo è ciò che accade dopo aver eseguito lo script aggiornato.

Visualizzazione di messaggi da uno script

Ora possiamo stampare note esplicative usando il comando echo. Se non sai come modificare un file utilizzando gli strumenti Linux o non hai mai visto il comando echo prima, dai un'occhiata a questa risorsa.

Utilizzo delle variabili

Le variabili consentono di memorizzare informazioni nel file di script, ad esempio i risultati dei comandi per l'utilizzo da parte di altri comandi.

Non c'è niente di sbagliato nell'eseguire i singoli comandi senza memorizzare i risultati del loro lavoro, ma le possibilità di questo approccio sono molto limitate.

Esistono due tipi di variabili che possono essere utilizzate negli script bash:

• variabili ambientali
• Variabili utente

variabili ambientali

A volte i comandi della shell devono funzionare con alcuni dati di sistema. Ad esempio, ecco come elencare la directory home dell'utente corrente:

#! / bin / bash # visualizza user home echo "La home dell'utente corrente è: $ HOME"
Si prega di notare che possiamo utilizzare la variabile di sistema $ HOME tra virgolette, questo non impedirà al sistema di riconoscerla. Questo è ciò che accade se esegui lo script sopra.

Utilizzo di una variabile d'ambiente in uno script

Cosa succede se si desidera visualizzare un simbolo del dollaro sullo schermo? Proviamo questo:

Echo "Ho $ 1 in tasca"
Il sistema rileva il simbolo del dollaro nella stringa tra virgolette e pensa che abbiamo fatto riferimento a una variabile. Lo script proverà a visualizzare il valore della variabile non definita $ 1. Questo non è quello che vogliamo. Cosa fare?

Un carattere di escape barra rovesciata prima del simbolo del dollaro può essere d'aiuto in questa situazione:

Echo "Ho \ $ 1 in tasca"
Lo script ora restituirà esattamente ciò che è previsto.

Utilizzo di una sequenza di escape per emettere un simbolo del dollaro

Variabili utente

Oltre alle variabili di ambiente, gli script bash consentono di impostare e utilizzare le proprie variabili nello script. Queste variabili mantengono il loro valore fino al termine dell'esecuzione dello script.

Come per le variabili di sistema, è possibile accedere alle variabili utente utilizzando il simbolo del dollaro:
TNW-CUS-FMP - codice promozionale per il 10% di sconto sui nostri servizi, attivabile entro 7 giorni
#! / bin / bash # variabili di test grado = 5 persona = "Adam" echo "$ persona è un bravo ragazzo, è in grado $ grado"
Ecco cosa succede dopo aver eseguito uno script di questo tipo.

Variabili personalizzate in uno script

Sostituzione del comando

Una delle caratteristiche più utili degli script bash è la capacità di estrarre informazioni dall'output dei comandi e assegnarle alle variabili, il che consente di utilizzare queste informazioni ovunque nel file di script.

Questo può essere fatto in due modi.

• Con il segno di spunta ""
• Usando il $ ()

Usando il primo approccio, assicurati di non usare una singola virgoletta invece del backtick. Il comando deve essere racchiuso in due di queste icone:

Mydir = `pwd`
Nel secondo approccio, la stessa cosa è scritta in questo modo:

Mydir = $ (pwd)
E lo script, alla fine, potrebbe assomigliare a questo:

#! / bin / bash miadir = $ (pwd) echo $ miadir
Durante il suo funzionamento, l'output del comando pwd verrà salvato nella variabile mydir, il cui contenuto, tramite il comando echo, andrà in console.

Uno script che memorizza i risultati di un comando in una variabile

Operazioni matematiche

Per eseguire operazioni matematiche in un file di script, puoi utilizzare una costruzione come $ ((a + b)):

#! / bin / bash var1 = $ ((5 + 5)) echo $ var1 var2 = $ (($ var1 * 2)) echo $ var2

Operazioni matematiche in uno script

Costrutto di controllo If-then

Alcuni scenari richiedono il controllo del flusso di esecuzione del comando. Ad esempio, se un valore è maggiore di cinque, è necessario eseguire un'azione, altrimenti un'altra. Questo è applicabile in moltissime situazioni e il costrutto di controllo if-then ci aiuterà qui. Nella sua forma più semplice, si presenta così:

Se comando allora comando fi
Ed ecco un esempio funzionante:

#! / bin / bash if pwd then echo "Funziona" fi
In questo caso, se il comando pwd viene completato con successo, nella console verrà visualizzato il testo "funziona".

Usiamo le nostre conoscenze e scriviamo uno script più complesso. Diciamo che devi trovare un determinato utente in / etc / passwd e, se riesci a trovarlo, segnala che esiste.

#! / bin / bash user = likegeeks if grep $ user / etc / passwd then echo "L'utente $ user esiste" fi
Questo è ciò che accade dopo aver eseguito questo script.

Cerca un utente

Qui abbiamo usato il comando grep per trovare l'utente nel file /etc/passwd. Se non hai familiarità con il comando grep, puoi trovarne la descrizione.

In questo esempio, se viene trovato un utente, lo script visualizzerà un messaggio appropriato. Cosa succede se l'utente non può essere trovato? In questo caso, lo script terminerà semplicemente la sua esecuzione senza dirci nulla. Vorrei che ci parlasse anche di questo, così miglioreremo il codice.

Costrutto di controllo If-then-else

Affinché il programma sia in grado di riportare sia i risultati di una ricerca riuscita che un fallimento, utilizzeremo la costruzione if-then-else. Ecco come funziona:

Se comando allora comandi altrimenti comandi fi comandi
Se il primo comando restituisce zero, il che significa che la sua esecuzione ha successo, la condizione sarà vera e l'esecuzione non seguirà il ramo else. Altrimenti, se viene restituito qualcosa di diverso da zero, il che significa un errore o un risultato falso, verranno eseguiti i comandi dopo l'altro.

Scriviamo uno script come questo:

#! / bin / bash user = otherUser if grep $ user / etc / passwd then echo "L'utente $ utente esiste" else echo "L'utente $ utente non esiste" fi
La sua esecuzione è andata lungo il ramo else.

Esecuzione di uno script con una costruzione if-then-else

Bene, continuiamo ad andare avanti e ad interrogarci su condizioni più difficili. Cosa succede se è necessario controllare più di una condizione, ma diverse? Ad esempio, se viene trovato l'utente desiderato, è necessario visualizzare un messaggio, se viene soddisfatta qualche altra condizione, un altro messaggio e così via. In una situazione del genere, le condizioni nidificate ci aiuteranno. Sembra così:

Se comando1 allora comanda elif comando2 allora fi comandi
Se il primo comando restituisce zero, che indica la sua corretta esecuzione, verranno eseguiti i comandi del primo blocco, altrimenti, se la prima condizione risulta falsa, e se il secondo comando restituisce zero, il secondo blocco di codice essere eseguito.

#! / bin / bash user = otherUser if grep $ user / etc / passwd then echo "L'utente $ user esiste" elif ls / home then echo "L'utente non esiste ma comunque c'è una directory sotto / home" fi
In uno script di questo tipo, puoi, ad esempio, creare un nuovo utente utilizzando il comando useradd se la ricerca non ha restituito alcun risultato o fare qualcos'altro di utile.

Confrontando i numeri

I valori numerici possono essere confrontati negli script. Di seguito è riportato un elenco dei comandi pertinenti.

n1 -eq n2 Restituisce vero se n1 è uguale a n2.
n1 -ge n2 Restituisce vero se n1 è maggiore o uguale a n2.
n1 -gt n2 Restituisce vero se n1 è maggiore di n2.
n1 -le n2 Restituisce vero se n1 è minore o uguale a n2.
n1 -lt n2 Restituisce vero se n1 è minore di n2.
n1 -ne n2 Restituisce vero se n1 non è uguale a n2.

Proviamo uno degli operatori di confronto come esempio. Notare che l'espressione è racchiusa tra parentesi quadre.

#! / bin / bash val1 = 6 if [$ val1 -gt 5] then echo "Il valore del test $ val1 è maggiore di 5" else echo "Il valore del test $ val1 non è maggiore di 5" fi
Questo è l'output di questo comando.

Confrontare i numeri negli script

Il valore della variabile val1 è maggiore di 5, di conseguenza viene eseguito il ramo poi dell'operatore di confronto e viene visualizzato un messaggio corrispondente sulla console.

Confronto di stringhe

Puoi anche confrontare i valori delle stringhe negli script. Gli operatori di confronto sembrano piuttosto semplici, ma le operazioni di confronto di stringhe hanno alcune peculiarità, di cui parleremo di seguito. Ecco un elenco di operatori.

str1 = str2 Verifica l'uguaglianza delle stringhe, restituisce true se le stringhe sono identiche.
s tr1! = str2 Restituisce vero se le stringhe non sono identiche.
str1< str2 Возвращает истину, если str1 меньше, чем str2 .
str1> str2 Restituisce vero se str1 è maggiore di str2.
-n str1 Restituisce vero se str1 è maggiore di zero.
-z str1 Restituisce vero se la lunghezza di str1 è zero.

Ecco un esempio di confronto di stringhe in uno script:

#! / bin / bash user = "likegeeks" if [$ user = $ USER] then echo "L'utente $ user è l'utente attualmente connesso" fi
Come risultato dell'esecuzione dello script, otteniamo quanto segue.

Confronto di stringhe negli script

Ecco una caratteristica del confronto delle stringhe che vale la pena menzionare. Vale a dire, gli operatori ">" e "<» необходимо экранировать с помощью обратной косой черты, иначе скрипт будет работать неправильно, хотя сообщений об ошибках и не появится. Скрипт интерпретирует знак «>"Come comando di reindirizzamento dell'output.

Ecco come funziona con questi operatori nel codice:

#! / bin / bash val1 = text val2 = "un altro testo" if [$ val1 \>
Ecco i risultati dello script.

Confronto di stringhe, avviso emesso

Si noti che lo script, sebbene eseguito, genera un avviso:

./myscript: riga 5: [: troppi argomenti
Per eliminare questo avviso, racchiudere $ val2 tra virgolette doppie:

#! / bin / bash val1 = text val2 = "un altro testo" if [$ val1 \> "$ val2"] then echo "$ val1 è maggiore di $ val2" else echo "$ val1 è minore di $ val2" fi
Ora tutto funziona come dovrebbe.

Confronto di stringhe

Un'altra caratteristica degli operatori ">" e "<» заключается в том, как они работают с символами в верхнем и нижнем регистрах. Для того, чтобы понять эту особенность, подготовим текстовый файл с таким содержимым:

Come geek come geek
Salviamolo, dando il nome miofile, e poi eseguiamo il seguente comando nel terminale:

Ordina il mio file
Ordina le righe del file in questo modo:

Likegeek Likegeek
Il comando sort, per impostazione predefinita, ordina le righe in ordine crescente, ovvero la lettera minuscola nel nostro esempio è più piccola di quella maiuscola. Ora prepariamo uno script che confronterà le stesse stringhe:

#! / bin / bash val1 = Likegeeks val2 = likegeeks if [$ val1 \> $ val2] then echo "$ val1 è maggiore di $ val2" else echo "$ val1 è minore di $ val2" fi
Se lo esegui, si scopre che è vero il contrario: la lettera minuscola ora è più grande di quella maiuscola.

Ordina il confronto tra comandi e righe in un file di script

I comandi di confronto hanno meno lettere maiuscole. Il confronto delle stringhe qui viene effettuato confrontando i codici dei caratteri ASCII, l'ordinamento dipende quindi dai codici dei caratteri.

Il comando sort, a sua volta, utilizza l'ordinamento specificato nelle impostazioni della lingua di sistema.

Controlli file

I comandi seguenti sono probabilmente i più comunemente usati negli script bash. Consentono di verificare varie condizioni relative ai file. Ecco un elenco di questi comandi.

-d file Controlla se un file esiste ed è una directory.
-e file Controlla se il file esiste.
-f file Controlla se il file esiste ed è un file.
-r file Controlla se il file esiste ed è leggibile.
-s file Controlla se il file esiste e non è vuoto.
-w file Controlla se il file esiste ed è scrivibile.
-x file Controlla se il file esiste ed è eseguibile.
file1 -nt file2 Controlla se file1 è più recente di file2.
file1 -ot file2 Controlla se file1 è più vecchio di file2.
-O file Controlla se il file esiste ed è di proprietà dell'utente corrente.
-G file Controlla se il file esiste e se il suo ID di gruppo corrisponde all'ID di gruppo dell'utente corrente.

Questi comandi, così come molti altri discussi oggi, sono facili da ricordare. I loro nomi, essendo abbreviazioni di varie parole, indicano direttamente i controlli che eseguono.

Proviamo uno dei comandi in pratica:

#! / bin / bash mydir = / home / likegeeks if [-d $ mydir] then echo "La directory $ mydir esiste" cd $ mydir ls else echo "La directory $ mydir non esiste" fi
Questo script, per una directory esistente, ne visualizzerà il contenuto.

Visualizzazione del contenuto di una directory

Crediamo che tu possa sperimentare tu stesso con il resto dei comandi, si applicano tutti allo stesso modo.

Risultati

Oggi abbiamo spiegato come iniziare a scrivere script bash e abbiamo trattato alcune cose di base. In effetti, l'argomento della programmazione bash è enorme. Questo articolo è una traduzione della prima parte di un'ampia serie di 11 articoli. Se vuoi continuare in questo momento, ecco un elenco degli originali di questi materiali. Per comodità, questo include la traduzione che hai appena letto.

Ovviamente tutti coloro che comunicano con Linux hanno avuto a che fare almeno una volta (almeno ne hanno sentito parlare di sicuro) con la shell di comando BASH. Ma BASH non è solo una shell di comando, è anche un eccellente linguaggio di programmazione per script.
Lo scopo di questo articolo è far conoscere più da vicino agli utenti bash, raccontare la sintassi, le tecniche di base e i trucchi del linguaggio, in modo che anche un utente normale possa scrivere rapidamente un semplice script da eseguire quotidianamente (-settimanale, -mensile) lavoro di routine o, diciamo, "in ginocchio »Crea uno script per un backup della directory.

introduzione

BASH - Bourne-Again SHell (che può essere tradotto come "reborn walk", o "Bourne walk again (creatore di sh)"), la shell più popolare nei sistemi Unix-like, specialmente in GNU/Linux. Di seguito sono riportati una serie di comandi incorporati che utilizzeremo per creare i nostri script.

Interrompi l'uscita da un ciclo for, while o fino
continuare a eseguire l'iterazione successiva di un ciclo for, while o fino
echo print argomenti, separati da spazi, allo standard output
esci esci dalla shell
export contrassegna gli argomenti come variabili da passare ai processi figlio nell'ambiente
hash ricorda i percorsi completi dei comandi specificati come argomenti in modo che non li cerchi alla chiamata successiva
kill invia un segnale di kill al processo
pwd mostra la directory di lavoro corrente
read legge una stringa dall'input della shell e la utilizza per assegnare valori alle variabili specificate. \
return fa sì che la funzione di shell esca con il valore specificato
shift sposta i parametri posizionali a sinistra
test valuta un'espressione condizionale
times visualizza il nome utente e l'ora di sistema utilizzati dalla shell e dai suoi discendenti
trap specifica i comandi da eseguire quando la shell riceve un segnale
unset provoca la distruzione delle variabili della shell
wait attende che il bambino esca e riporta lo stato di uscita.

E, naturalmente, oltre ai comandi integrati, utilizzeremo tutta una serie di programmi di comandi esterni e separati, che conosceremo già nel processo.

Quello che devi sapere dall'inizio

1. Qualsiasi script bash deve iniziare con la riga:

#!/bin/bash
su questa riga dopo #! il percorso dell'interprete bash è indicato, quindi se lo hai installato in un posto diverso (dove puoi scoprirlo digitando whereis bash), cambialo nel tuo percorso.
2. I commenti iniziano con un carattere # (ad eccezione della prima riga).
3. In bash, le variabili non hanno tipo (saranno discusse di seguito)

Variabili e parametri di script

Faccio come esempio un piccolo esempio che analizzeremo:

#!/bin/bash
# specifica dove memorizziamo l'interprete bash
parametr1 = $ 1 # assegna alla variabile parametr1 il valore del primo parametro dello script
script_name = $ 0 # assegna alla variabile script_name il valore del nome dello script
echo "Hai eseguito uno script con il nome $ nome_script e il parametro $ parametr1" # il comando echo restituisce una riga specifica, le variabili sono accessibili tramite $ nome_variabile.
echo "Hai eseguito uno script con il nome $ nome_script e il parametro $ parametr1" # qui vediamo altre virgolette, la differenza è che non c'è sostituzione di variabile tra virgolette singole.
exit 0 # Esci con il codice 0 (completamento dello script con successo)

[e-mail protetta]: ~ $ ./test.sh qwerty
Hai eseguito uno script chiamato. / Test.sh con parametro qwerty
Hai eseguito uno script chiamato $ nome_script e parametro $ parametro1

Ora che abbiamo visto come utilizzare le variabili e passare i parametri allo script, è ora di familiarizzare con le variabili riservate:

$ DIRSTACK - il contenuto della parte superiore dello stack di directory
$ EDITOR - editor di testo predefinito
$ EUID - UID effettivo. Se hai usato su per eseguire comandi da un altro utente, questa variabile contiene l'UID di quell'utente, mentre ...
$UID - ... contiene l'identificatore reale, che viene impostato solo al momento del login.
$ FUNCNAME è il nome della funzione corrente nello script.
$ GROUPS - array di gruppi a cui appartiene l'utente corrente
$ HOME - directory home dell'utente
$ HOSTNAME è il tuo nome host
$ HOSTTYPE - architettura della macchina.
$ LC_CTYPE - variabile interna che definisce la codifica dei caratteri
$ OLDPWD - vecchia directory di lavoro
$ OSTYPE - Tipo di sistema operativo
$ PATH - percorso di ricerca del programma
$ PPID - identificatore del processo padre
$ SECONDI - tempo di esecuzione dello script (in secondi)
$ # - il numero totale di parametri passati allo script
$ * - tutti gli argomenti non vengono passati allo script (output in stringa)
[e-mail protetta]- uguale al precedente, ma i parametri sono visualizzati in una colonna
$! - PID dell'ultimo processo in esecuzione in background
$$ - PID dello script stesso

Condizioni

Gli operatori condizionali, penso, sono familiari a quasi tutti coloro che hanno mai provato a scrivere programmi su qualcosa. In bash, vengono tracciate le condizioni. modo (come al solito con un esempio):
#!/bin/bash
source = $ 1 # inserisci il primo parametro dello script nella variabile source
dest = $ 2 # aggiunge il secondo parametro di script alla variabile dest

If [["$ source" -eq "$ dest"]] # tra virgolette specificare i nomi delle variabili per il confronto. -eq - confronto booleano che denota "uguale"
allora # se sono davvero uguali, allora
echo "Application $ dest e source $ source sono lo stesso file!" # visualizza un messaggio di errore, perché $ source e $ dest sono uguali
exit 1 # esci con un errore (1 - codice di errore)
altrimenti # se non sono uguali
cp $ source $ dest # quindi esegui il comando cp: copia la sorgente nella destinazione
echo "Copia riuscita!"
fi # denota la fine della condizione.

Il risultato dell'esecuzione dello script:
[e-mail protetta]: ~ $ ./primer2.sh 1 1
App 1 e sorgente 1 sono lo stesso file!
[e-mail protetta]: ~ $ ./primer2.sh 1 2
Copia riuscita!

La struttura if-then-else viene utilizzata come segue:
Se<команда или набор команд возвращающих код возврата(0 или 1)>
poi
<если выражение после if истино, то выполняется этот блок>
altro
<если выражение после if ложно, тот этот>
Le strutture [[, [, test, (()) o qualsiasi altro (o più) comando linux possono agire come comandi che restituiscono il codice di ritorno.
test - utilizzato per il confronto logico. dopo l'espressione, è richiesta una parentesi chiusa "]"
[- un sinonimo per il comando test
[[- versione estesa "[" (dalla versione 2.02) (come nell'esempio), all'interno della quale || (o), & (e). Deve avere una parentesi chiusa "]]"
(()) - confronto matematico.
per creare condizioni multilivello del modulo:
Se ...
poi ....
altro
Se ....
poi ....
altro ....

Per brevità e leggibilità del codice si può utilizzare la struttura:
Se ..
poi ...
elifa...
poi ...
elifa...

Condizioni. Scelta multipla

Se è necessario confrontare una singola variabile con un numero elevato di parametri, è più opportuno utilizzare l'istruzione case.
#!/bin/bash
echo "Seleziona un editor da eseguire:"
echo "1 Esegui programma nano"
echo "2 Esegui programma vi"
echo "3 Avvia il programma emacs"
echo "4 Esci"
leggi facendo # qui leggiamo nella variabile $ facendo dallo standard input

Caso $ facendo in
1)
/ usr / bin / nano # se $ do contiene 1, quindi esegui nano
;;
2)
/ usr / bin / vi # se $ do contiene 2, allora esegui vi
;;
3)
/ usr / bin / emacs # se $ do contiene 3 allora esegui emacs
;;
4)
esci 0
;;
*) # se dalla tastiera viene immesso qualcosa che non è descritto nel caso, procedere come segue:
echo "Azione inserita non valida"

Esac # fine di un'istruzione case.

Risultato del lavoro:
[e-mail protetta]: ~ $ ./menu2.sh
Seleziona un editor da eseguire:
1 Avvio del programma nano
2 Avvio del programma vi
3 Avviare il programma emacs
4 Esci

Dopo aver selezionato un numero e aver premuto Invio, si avvierà l'editor che hai scelto (a meno che, ovviamente, tutti i percorsi non siano specificati correttamente e tu abbia questi editor installati :))
Ecco un elenco di operatori logici utilizzati per la costruzione if-then-else-fi:
-z # la riga è vuota
-n # la riga non è vuota
=, (==) # le stringhe sono uguali
! = # le stringhe non sono uguali
-eq # uguale
-ne # disuguale
-lt, (<) # меньше
-le, (<=) # меньше или равно
-gt, (>) # altro
-ge, (> =) # maggiore o uguale
! # negazione dell'espressione booleana
-a, (&&) # AND logico
-o, (||) # "OR" logico

Abbiamo capito le basi della lingua e delle condizioni per non sovraccaricare l'articolo, lo dividerò in più parti (ad esempio, in 3). Nella seconda parte analizzeremo gli operatori di loop e l'esecuzione di operazioni matematiche.

AGGIORNAMENTO: Risolti alcuni bug
AGGIORNAMENTO: Aggiornata la parte sulle condizioni if-then-else

Probabilmente tutti sanno che la shell Bash ha comandi incorporati che non sono nelle cartelle /bin o /usr/bin. Sono integrati nella shell ed eseguiti come funzioni. In un precedente articolo abbiamo visto. Abbiamo discusso quasi di tutto lì, come dovrebbero apparire gli script, l'uso di condizioni, cicli, variabili, ma non ci siamo fermati alle funzioni.

Nell'articolo di oggi, correggeremo questo difetto. Come con qualsiasi linguaggio di programmazione, Bash ha funzioni che possono essere molto utili da usare. Vedremo come usare le funzioni bash, come scriverle e persino come creare librerie da queste funzioni.

Per prima cosa, devi capire cos'è una funzione nel nostro contesto. Una funzione è un insieme di comandi, uniti da un nome, che eseguono un compito specifico. La funzione viene chiamata con il suo nome, può prendere parametri e restituire il risultato del suo lavoro. In breve, le funzioni di Bash funzionano proprio come in altri linguaggi di programmazione.

La sintassi per creare una funzione è molto semplice:

nome_funzione() (elenco_comando)

Il nome della funzione non deve corrispondere a nessuno dei comandi o delle funzioni esistenti e tutti i comandi nel corpo della funzione vengono scritti su una nuova riga.

Funzione semplice

Scriviamo una piccola funzione che stamperà una stringa sullo schermo:

$ vi funzione.sh

#!/bin/bash
printstr() (
eco "ciao mondo"
}
printstr

La chiamata a una funzione bash viene eseguita specificando il suo nome, proprio come qualsiasi altro comando. Esegui il nostro script per l'esecuzione, non dimenticare che prima devi dargli i permessi di esecuzione:

chmod u + x funzione.sh

Tutto funziona, ora complichiamo il compito, proviamo a passare argomenti alla funzione.

Argomenti della funzione

Gli argomenti della funzione devono essere passati quando vengono chiamati e vengono letti allo stesso modo degli argomenti dello script. La sintassi per chiamare una funzione con parametri bash è:

nome_funzione arg1 arg2 ... argN

Come puoi vedere, tutto è abbastanza semplice. I parametri sono separati da uno spazio. Ora miglioriamo la nostra funzione per produrre la stringa che abbiamo specificato:

!/bin/bash
printstr() (
eco $ 1
}
printstr "Ciao mondo"

Puoi impostare diversi parametri:

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

C'è un altro modo per popolare gli argomenti, come in C, usando lo stack. Recuperiamo il primo argomento, quindi spostiamo il puntatore dello stack di argomenti di uno e recuperiamo di nuovo il primo argomento. Eccetera:

!/bin/bash
printstr() (
eco $ 1
spostare
eco $ 1
spostare
eco $ 1
spostare
eco $ 1
}
printstr "arg1" "arg2" "arg3" "arg4"

Restituzione del risultato di una funzione

Non solo puoi usare le funzioni con i parametri bash, ma anche ottenere il risultato del suo lavoro. Il comando return viene utilizzato per questo. Termina la funzione e restituisce il valore numerico del codice di ritorno. Può essere compreso tra 0 e 255:

!/bin/bash
printstr() (
ritorno 134;
}
printstr
eco $?

Se è necessario applicare un valore restituito dalla funzione bash anziché un codice di stato, utilizzare echo. La stringa non viene immediatamente inviata al terminale, ma viene restituita come risultato della funzione e può essere scritta in una variabile e quindi utilizzata:

!/bin/bash
printstr() (
eco "prova"
}
VAR = $ (printstr)
echo $ VAR

Funzioni di esportazione

Puoi rendere la funzione disponibile all'esterno dello script con il comando require:

!/bin/bash
printstr() (
eco "ciao mondo"
}
dichiarare -x -f printstr

Quindi esegui lo script usando il comando source:

source function.sh
$ printstr

ricorsione

Puoi chiamare una funzione dall'interno di se stessa per eseguire la ricorsione:

!/bin/bash
printstr() (
eco "ciao mondo"
printstr
}
printstr

Puoi sperimentare con la ricorsione, può essere utile in molti casi, ricorda solo di effettuare la prima chiamata alla funzione Bash.

Variabili locali in una funzione

Se dichiari una variabile ordinaria in una funzione, questa sarà disponibile in tutto lo script, questo è utile per restituire il valore di una funzione, ma a volte potrebbe essere necessario creare una variabile locale. C'è un comando locale per questo:

!/bin/bash
printstr() (
VAR locale = $ 1
eco $ (VAR)
}
printstr "Ciao mondo"

Librerie di funzioni

Possiamo prendere alcune funzioni bash e combinarle in un'unica libreria in modo da poter importare quelle funzioni con un comando. Questa operazione viene eseguita in modo simile all'esportazione delle funzioni. Per prima cosa, creiamo un file di libreria:

prova1 () (
echo "Ciao mondo da 1";
}
prova2 () (
echo "Ciao mondo da 2";
}
prova3 () (
echo "Ciao mondo da 3";
}

Ora creiamo uno script che utilizzerà le nostre funzioni. Puoi importare la libreria usando il comando source o semplicemente specificando il nome dello script:

!/bin/bash
fonte lib.sh
prova1
prova2
prova3

conclusioni

In questo articolo, abbiamo esaminato le funzioni bash, come scriverle, usarle e raggrupparle in librerie. Se scrivi spesso script in Bash, queste informazioni ti saranno utili. Puoi creare il tuo set di funzioni per usarle in ogni script e quindi semplificare il tuo lavoro.