Bash tips: differenze tra le versioni

Da Guide@Debianizzati.Org.
Vai alla navigazione Vai alla ricerca
(in espansione!)
Nessun oggetto della modifica
Riga 25: Riga 25:


Ecco un esempio stupido, creare una directory ed entrarvi:
Ecco un esempio stupido, creare una directory ed entrarvi:
<pre>
$ mkdir /usr/local/nuovo-programma
$ mkdir /usr/local/nuovo-programma
$ cd ESC.
$ cd ESC.
</pre>


Altro esempio forse un po' più utile, creare velocemente uno script:
Altro esempio forse un po' più utile, creare velocemente uno script:
<pre>
$ :> /usr/local/bin/nomescript
$ :> /usr/local/bin/nomescript
$ chmod +x ESC.
$ chmod +x ESC.
$ gvim ESC.
$ gvim ESC.
</pre>


===Editing della linea di comando===
===Editing della linea di comando===
Vi sono due differenti modalità di shortcut in bash che richiamano i comandi di due famosi editor di testo. La prima nonché quella di default è, per ragioni storiche, la modalità emacs, la seconda, ovvero quella '''VI'''ncente, è la modalità VI.
Vi sono due differenti modalità di shortcut in bash che richiamano i comandi di due famosi editor di testo. La prima nonché quella di default è, per ragioni storiche, la modalità emacs, la seconda, ovvero quella '''VI'''ncente, è la modalità VI.
Per passare dall'una all'altra si può dare nel prompt i seguenti comandi oppure inserirli nel file ~/.bashrc:
Per passare dall'una all'altra si può dare nel prompt i seguenti comandi oppure inserirli nel file ~/.bashrc:
<pre>set -o vi</pre>
$ set -o vi
<pre>set -o emacs</pre>
$ set -o emacs


Alcuni tasti di scelta rapida per l'editing da linea di comando:
Alcuni tasti di scelta rapida per l'editing da linea di comando:
Riga 106: Riga 102:
Questa funzionalità non è abilitata di default; bisogna modificare il file <code>/etc/inputrc</code> (o creare un analogo file <code>.inputrc</code> nella propria home), aggiungendo le righe:
Questa funzionalità non è abilitata di default; bisogna modificare il file <code>/etc/inputrc</code> (o creare un analogo file <code>.inputrc</code> nella propria home), aggiungendo le righe:


<pre>
# PgUp/Down searches history in bash
# PgUp/Down searches history in bash
"\e[5~":        history-search-backward
"\e[5~":        history-search-backward
"\e[6~":        history-search-forward
"\e[6~":        history-search-forward
</pre>


In questo esempio si è scelto di usare i tasti <code>PGUP</code> e <code>PGDOWN</code>.
In questo esempio si è scelto di usare i tasti <code>PGUP</code> e <code>PGDOWN</code>.
Riga 118: Riga 112:
Il carattere <code>!</code> permette di richiamare un preciso comando dello storico:
Il carattere <code>!</code> permette di richiamare un preciso comando dello storico:


<pre>
$ !-3
$ !-3
</pre>


richiama ed esegue il terzultimo comando, mentre:
richiama ed esegue il terzultimo comando, mentre:


<pre>
$ !ta
$ !ta
</pre>


richiama ed esegue l'ultimo comando che comincia con '''ta''' (potrebbe essere: <code>tail -f /var/log/messages</code>). Il <code>'''!!'''</code> richiama invece l'ultimo comando.
richiama ed esegue l'ultimo comando che comincia con '''ta''' (potrebbe essere: <code>tail -f /var/log/messages</code>). Il <code>'''!!'''</code> richiama invece l'ultimo comando.
Riga 132: Riga 122:
Se si vuole richiamare il comando ma non eseguirlo si può usare il modificatore <code>:p </code>(''print''), ad esempio
Se si vuole richiamare il comando ma non eseguirlo si può usare il modificatore <code>:p </code>(''print''), ad esempio


<pre>
$ !ta:p
$ !ta:p
</pre>


stampa l'ultimo comando che inizia con ''ta''.
stampa l'ultimo comando che inizia con ''ta''.
Riga 140: Riga 128:
Per richiamare l'ultimo comando che contiene una certa parola (non all'inizio):
Per richiamare l'ultimo comando che contiene una certa parola (non all'inizio):


<pre>
$ !?parola?
$ !?parola?
</pre>


È possibile anche richiamare un parametro di un comando usando <code>''':'''</code> seguito dal numero del parametro (0 indica il comando stesso). Ad esempio:
È possibile anche richiamare un parametro di un comando usando <code>''':'''</code> seguito dal numero del parametro (0 indica il comando stesso). Ad esempio:


<pre>
$ man !-1:0
$ man !-1:0
</pre>


visualizza la pagina di manuale dell'ultimo comando.
visualizza la pagina di manuale dell'ultimo comando.
Riga 154: Riga 138:
Per eseguire un comando con gli stessi argomenti del comando precedente:
Per eseguire un comando con gli stessi argomenti del comando precedente:


<pre>
$ nuovocomando !!:*
$ nuovocomando !!:*
 
</pre>
 
Il comando <code>'''history'''</code> mostra l'elenco numerato per una veloce ricerca dei comandi da richiamare con <code>'''!numero'''</code>; <code>'''!$'''</code> equivale all'ultimo argomento del precedente comando di conseguenza funziona anche <code>'''!numero$'''</code>.


Per ulteriori informazioni sull'uso interattivo dello storico si rimanda all'apposita sezione del manuale di riferimento:
Per ulteriori informazioni sull'uso interattivo dello storico si rimanda all'apposita sezione del manuale di riferimento:


* [http://www.gnu.org/software/bash/manual/bashref.html#SEC117 Hystory expansion]
* [http://www.gnu.org/software/bash/manual/bashref.html#History-Interaction Hystory expansion]


==Bash Scripting==
==Bash Scripting==
Riga 167: Riga 152:
===Variabili speciali===
===Variabili speciali===


; <code>$?</code> : contiene il valore di uscita dell'ultimo comando o funzione. Il comando ha successo se ritorna zero, qualsiasi altro valore indica invece un codice di errore;
; <code>$?</code> : contiene il valore di uscita dell'ultimo comando o funzione. Il comando ha successo se restituisce zero, qualsiasi altro valore indica invece un codice di errore;
 
''Esempio:''
$ cd ..
$ echo $?
0
 
$ cd ...
$ echo $?
1


; <code>$@</code> : contiene la lista dei parametri passati allo script corrente. Ogni parametro viene opportunamente quotato, questo permette l'utilizzo di questa variabile nei '''cicli for''' per processare (ad esempio) una lista di nomi di file che possono contenere anche spazi. L'uso di questa variabile è quindi in genere consigliato rispetto a <code>'''$*'''</code> che ha la stessa funzione ma non quota i vari parametri;
; <code>$@</code> : contiene la lista dei parametri passati allo script corrente. Ogni parametro viene opportunamente quotato, questo permette l'utilizzo di questa variabile nei '''cicli for''' per processare (ad esempio) una lista di nomi di file che possono contenere anche spazi. L'uso di questa variabile è quindi in genere consigliato rispetto a <code>'''$*'''</code> che ha la stessa funzione ma non quota i vari parametri;
Riga 173: Riga 167:
''Esempio:''
''Esempio:''
<pre>
<pre>
FILES=$@
FILES=$@


for file in $FILES; do
for file in $FILES; do
Riga 193: Riga 187:
In Bash una stringa non è altro che una variabile, si indica dunque con <code>${nome}</code> oppure con la forma abbreviata <code>$nome</code>. Il nome dentro le graffe può essere seguito da un modificatore che manipola la variabile, ad esempio:
In Bash una stringa non è altro che una variabile, si indica dunque con <code>${nome}</code> oppure con la forma abbreviata <code>$nome</code>. Il nome dentro le graffe può essere seguito da un modificatore che manipola la variabile, ad esempio:


<pre>VAR="stringa-di-esempio"
VAR="stringa-di-esempio"
echo ${VAR#stringa-}</pre>
echo ${VAR#stringa-}


elimina "stringa-" dall'inizio della variabile.
elimina "stringa-" dall'inizio della variabile.
Riga 238: Riga 232:
; <code>;</code> : separatore di comandi, il secondo comando verrà eseguito in ogni caso
; <code>;</code> : separatore di comandi, il secondo comando verrà eseguito in ogni caso


<pre>
$ cd ... && echo done
$ cd ... && echo done
$ cd ... ; echo done
$ cd ... ; echo done
</pre>


Nel caso specifico di un'applicazione che resta in esecuzione il secondo comando non verrà eseguito finché il
Nel caso specifico di un'applicazione che resta in esecuzione il secondo comando non verrà eseguito finché il
primo non sarà terminato, in questo caso si usa <code>'''&'''</code> e saranno eseguiti entrambi in quanto il primo comando viene mandato in background; prendiamo xterm come esempio:
primo non sarà terminato, in questo caso si usa <code>'''&'''</code> e saranno eseguiti entrambi in quanto il primo comando viene mandato in background; prendiamo xterm come esempio:


<pre>
$ xterm && xterm -rv
$ xterm && xterm -rv
$ xterm ; xterm -rv
$ xterm ; xterm -rv
$ xterm & xterm -rv
$ xterm & xterm -rv
</pre>


; <code>|</code> : pipe, passa l'output del comando che la precede come input del comando che la segue
; <code>|</code> : pipe, passa l'output del comando che la precede come input del comando che la segue


<pre>
$ ls -A1 | less
$ ls -A1 | less
</pre>


; <code>||</code> : operatore logico OR, restituisce esito positivo se almeno una delle condizioni di verifica valutate è vera
; <code>||</code> : operatore logico OR, restituisce esito positivo se almeno una delle condizioni di verifica valutate è vera
Riga 271: Riga 259:




Dirige output di comando su file: <pre> $ man xterm > xterm.txt </pre>
Dirige output di comando su file:
Dirige output di errore su file: <pre> $ xterm 2> xterm-errors.log </pre>
$ man xterm > xterm.txt
Entrambi su file diversi: <pre> $ xterm > xterm_out.log 2> xterm_err.log </pre>
Dirige output di errore su file:
Entrambi sullo stesso file: <pre> $ xterm &> xterm.log </pre>
$ xterm 2> xterm-errors.log
Entrambi sullo stesso file, alternativa:<pre>$ xterm > xterm.log 2>&1
Entrambi su file diversi:
$ xterm > /dev/null 2>&1 </pre>
$ xterm > xterm_out.log 2> xterm_err.log
Aggiunge nuovo testo ad un file: <pre> $ man uxterm >> xterm.txt </pre>
Entrambi sullo stesso file:
Cancella contenuto di un file: <pre> $ :> xterm.txt </pre>
$ xterm &> xterm.log
Entrambi sullo stesso file, alternativa:
$ xterm > xterm.log 2>&1
Appende nuovo testo a quello già presente in un file:
$ man uxterm >> xterm.txt
Cancella contenuto di un file:
$ :> xterm.txt




Riga 295: Riga 289:
Rinomina tutti i file <code>*.txt</code> della directory corrente in <code>*.log</code>:
Rinomina tutti i file <code>*.txt</code> della directory corrente in <code>*.log</code>:


<pre>for f in *.txt; do mv "$f" "${f/%txt/log}"; done</pre>
$ for f in *.txt; do mv "$f" "${f/%txt/log}"; done


==Miscellanea==
==Miscellanea==
Riga 301: Riga 295:
# seleziona, apri file, incolla, salva: noioso
# seleziona, apri file, incolla, salva: noioso
# quota il tutto e appendi ad un file con echo: già meglio
# quota il tutto e appendi ad un file con echo: già meglio
# <code>ctrl-x</code> <code>ctrl-e</code>, si apre il nostro editor di fiducia e salviamo: superbo
# <code>'''CTRL-x'''</code> <code>'''CTRL-e'''</code>, si apre il nostro editor di fiducia e salviamo: superbo
 
 
Processo in background.
Si avvia un processo che tiene occupato il prompt:
$ xterm
 
anziché chiuderlo è possibile interromperlo, per liberare momentaneamente il prompt e magari eseguire altro, digitando <code>'''CTRL-z'''</code>. Si può quindi controllare quali processi siano riesumabili:
$ jobs -l
  [1]+  5598 Stopped                xterm
 
Per riprenderlo si usa il numero tra le parentesi quadre (l'altro è il pid):
$ fg 1
 
Se invece si vuole riesumare mantenendo libero il prompt:
$ bg 1
 





Versione delle 15:12, 22 apr 2011

Document-page-setup.png Attenzione: questo articolo è ancora incompleto e in fase di scrittura da parte del suo autore.

Sentitevi liberi di contribuire, proponendo modifiche alla guida tramite l'apposita pagina di discussione, in modo da non interferire con il lavoro portato avanti sulla voce. Per altre informazioni si rimanda al template.



Debian-swirl.png Versioni Compatibili

Tutte le versioni supportate di Debian

Intro

GNU Bash è la shell *nix probabilmente più ricca di funzionalità sia per l'uso interattivo che per lo scripting. Spesso però molte funzioni sono poco note.

Questa pagina ha lo scopo di raccogliere il più ampio numero di "trucchi" più o meno noti riguardanti Bash, senza avere peraltro la pretesa di coprire tutte le funzionalità.

Per iniziare

Prima di iniziare non posso non segnalare altre due guide presente sul wiki che forniscono dei consigli molto utili su Bash:

Shell Interattiva

In questa sezione verranno elencate funzionalità riguardanti l'uso interattivo di Bash.

Navigare velocemente tra le directory

  • Per andare sulla propria home basta digitare il comando cd senza nessun parametro.
  • Per tornare indietro alla precedente directory visitata è sufficiente il comando cd -.
  • È possibile salvare un percorso con pushd e richiamarlo con popd. In realtà questi comandi (come il nome può fare intuire) implementano una coda FIFO (First In First Out) nella quale è possibile memorizzare un numero illimitato di percorsi per poi richiamarli dall'ultimo inserito in poi. Usare questi comandi è semplicissimo: basta usare pushd al posto di cd (in tal modo si memorizzano i percorsi via via visitati) e poi digitare popd una o più volte per tornare indietro.

Riutilizzo degli argomenti

Bash memorizza l'ultimo argomento del comando precedente in una speciale variabile chiamata $_. È possibile fare riferimento all'ultimo argomento dell'ultimo comando usando direttamente $_ ma la via di gran lunga più veloce è comoda è usare ESC .

Ecco un esempio stupido, creare una directory ed entrarvi:

$ mkdir /usr/local/nuovo-programma
$ cd ESC.

Altro esempio forse un po' più utile, creare velocemente uno script:

$ :> /usr/local/bin/nomescript
$ chmod +x ESC.
$ gvim ESC.

Editing della linea di comando

Vi sono due differenti modalità di shortcut in bash che richiamano i comandi di due famosi editor di testo. La prima nonché quella di default è, per ragioni storiche, la modalità emacs, la seconda, ovvero quella VIncente, è la modalità VI. Per passare dall'una all'altra si può dare nel prompt i seguenti comandi oppure inserirli nel file ~/.bashrc:

$ set -o vi
$ set -o emacs

Alcuni tasti di scelta rapida per l'editing da linea di comando:

Descrizione Vim-like(CommandMode) Emacs-like
Vai all'inizio delle linea 0 (zero) CTRL+a
Vai alla fine della linea $ CTRL+e
Cancella fino dalla posizione corrente alla fine della linea D CTRL+k
Cancella fino dalla posizione corrente all'inizio della linea d^ CTRL+u
Pulisce lo schermo CTRL+l CTRL+l
Vai una parola avanti w META+f
Vai una parola indietro b META+b
Cancella la parola successiva dw META+d
Cancella la parola precedente CTRL+w META+backspace
Info.png Nota per la modalità Command Mode
Si entra in Command Mode premendo ESC. Per tornare in modalità inserimento è necessario pigiare il tasto i.
Info.png Nota sul tasto META
Il tasto Meta può essere usato premendo ALT e contemporaneamente il carattere del comando che interessa, oppure premendo ESC e successivamente il tasto del comando che interessa. In quest'ultimo modo non è necessario premere due tasti contemporaneamente. Questa è una regola generica per gli shortcut di bash che usano il tasto Meta.


Uso avanzato dello storico

Come noto Bash memorizza gli ultimi (solitamente 500 ma il numero è impostabile in $HISTSIZE) comandi digitati ai quali è possibile accedere semplicemente con le freccette SU e GIÙ. Tuttavia è possibile effettuare molte altre operazioni per ricercare nello storico dei comandi.

Ricerca incrementale inversa

Sotto questo astruso nome si cela la possibilità di ricercare nello storico dei comandi semplicemente premendo CRTL+r e digitando qualche carattere del comando cercato. Verrà immediatamente mostrato l'ultimo comando che soddisfa i criteri di ricerca. Se più comandi soddisfano la ricerca è possibile scorrerli (dall'ultimo al primo) premendo nuovamente CTRL+r.

Ricerca incrementale

Quando si cerca con CRTL+r può succedere di superare il comando che ci interessa, a questo punto tocca interrompere con CRTL+g e ricominciare; con una piccola modifica è però possibile abilitare la ricerca nell'altro verso e quindi tornare avanti al comando appena superato, questo disabilitando il flow control.
Il flow control è la funzione di interrompere il flusso del terminale, ovvero l'output e l'input (CRTL+s / CRTL+q), oggigiorno è una funzione poco utile soprattutto in un terminale grafico che ha la funzione di scroll. Aggiungiamo quindi stty -ixon al file ~/.bashrc e d'ora in poi avremo CRTL+s che risponderà alle nostre ricerche.

Una volta trovato il comando lo si può eseguire con INVIO oppure modificare con CTRL+j.

Ricerca nella cronologia

Altra possibilità è cercare tra tutti i comandi precedenti che cominciano con un certo gruppo di lettere.

Questa funzionalità non è abilitata di default; bisogna modificare il file /etc/inputrc (o creare un analogo file .inputrc nella propria home), aggiungendo le righe:

# PgUp/Down searches history in bash
"\e[5~":        history-search-backward
"\e[6~":        history-search-forward

In questo esempio si è scelto di usare i tasti PGUP e PGDOWN. Da notare che il file inputrc contiene altre comodità pronte all'uso: basta decommentarle!

Accesso diretto

Il carattere ! permette di richiamare un preciso comando dello storico:

$ !-3

richiama ed esegue il terzultimo comando, mentre:

$ !ta

richiama ed esegue l'ultimo comando che comincia con ta (potrebbe essere: tail -f /var/log/messages). Il !! richiama invece l'ultimo comando.

Se si vuole richiamare il comando ma non eseguirlo si può usare il modificatore :p (print), ad esempio

$ !ta:p

stampa l'ultimo comando che inizia con ta.

Per richiamare l'ultimo comando che contiene una certa parola (non all'inizio):

$ !?parola?

È possibile anche richiamare un parametro di un comando usando : seguito dal numero del parametro (0 indica il comando stesso). Ad esempio:

$ man !-1:0

visualizza la pagina di manuale dell'ultimo comando.

Per eseguire un comando con gli stessi argomenti del comando precedente:

$ nuovocomando !!:*


Il comando history mostra l'elenco numerato per una veloce ricerca dei comandi da richiamare con !numero; !$ equivale all'ultimo argomento del precedente comando di conseguenza funziona anche !numero$.

Per ulteriori informazioni sull'uso interattivo dello storico si rimanda all'apposita sezione del manuale di riferimento:

Bash Scripting

In questa sezione verranno elencati alcuni brevi tip per lo scripting Bash. Questa non vuole essere assolutamente una guida completa, ma piuttosto un elenco di costrutti per lo scripting bash particolarmente eleganti, curiosi e/o poco noti.

Variabili speciali

$?
contiene il valore di uscita dell'ultimo comando o funzione. Il comando ha successo se restituisce zero, qualsiasi altro valore indica invece un codice di errore;

Esempio:

$ cd ..
$ echo $?
0
$ cd ...
$ echo $?
1
$@
contiene la lista dei parametri passati allo script corrente. Ogni parametro viene opportunamente quotato, questo permette l'utilizzo di questa variabile nei cicli for per processare (ad esempio) una lista di nomi di file che possono contenere anche spazi. L'uso di questa variabile è quindi in genere consigliato rispetto a $* che ha la stessa funzione ma non quota i vari parametri;

Esempio:

 FILES=$@

for file in $FILES; do
    # Fare quello che si vuole con $file
    echo $file   
    # ...
done
$$
PID del processo corrente;
$!
PID dell'ultimo job in background.

Manipolazione delle stringhe

Nelle shell *nix, storicamente, la manipolazione delle stringhe viene fatto attraverso programmi esterni alla shell come seq, awk e perl. Questi programmi vengono ancora usati quando si vuole mantenere la compatibilità con la shell sh, tuttavia imparare anche il solo sed (il più semplice dei tre) non è cosa immediata.

Se si usa Bash, non è necessario usare nessun programma esterno, ma basta imparare i tre operatori fondamentali ed alcuni concetti di base, per poter fare tutte le manipolazioni più comuni.

In Bash una stringa non è altro che una variabile, si indica dunque con ${nome} oppure con la forma abbreviata $nome. Il nome dentro le graffe può essere seguito da un modificatore che manipola la variabile, ad esempio:

VAR="stringa-di-esempio"
echo ${VAR#stringa-}

elimina "stringa-" dall'inizio della variabile.

I modificatori sono molti, ma possono essere facilmente ricordati se si imparano i tre fondamentali:

#
sottrae dall'inizio della stringa (minimale)
%
sottrae dalla fine della stringa (minimale)
/
sostituisce una sottostringa con un'altra (solo la prima volta che viene incontrata)

Questi operatori sono minimali, questo vuol dire che se si usano le espressioni regolari per indicare la sottostringa (da eliminare o sostituire) verrà individuata in caso di ambiguità la sottostringa più piccola (o solo la prima nel caso della sostituzione).

Per ottenere gli operatori massimali basta raddoppiare il simbolo:

##
sottrae dall'inizio della stringa (massimale)
%%
sottrae dalla fine della stringa (massimale)
//
sostituisce una sottostringa con un'altra (tutte le volte che viene incontrata)

Gli operatori massimali cercano di individuare la sottostringa più grande che corrisponde all'espressione regolare (nel caso del modificatore // tutte le sottostringhe vengono sostituite). Gli operatori di questo tipo vengono comunemente chiamati anche greedy (ingordi).

Per una spiegazione dettagliata di tutti i modificatori e anche di altri modi di manipolare le stringhe in Bash (ad esempio expr) vedere:

Esempi: manipolazione delle stringhe

VAR="questa.sarebbe.una.stringa.di.esempio"
  
                      # Risultato:
  
  echo ${VAR#*.}      # --> sarebbe.una.stringa.di.esempio
  echo ${VAR##*.}     # --> esempio
  
  echo ${VAR%.*}      # --> questa.sarebbe.una.stringa.di
  echo ${VAR%%.*}     # --> questa
  
  echo ${VAR/st/ST}   # --> queSTa.sarebbe.una.stringa.di.esempio
  echo ${VAR//st/ST}  # --> queSTa.sarebbe.una.STringa.di.esempio

Concatenazione e redirezione

&&
operatore logico AND, il secondo comando verrà eseguito solo se il primo avrà esito positivo
;
separatore di comandi, il secondo comando verrà eseguito in ogni caso
$ cd ... && echo done
$ cd ... ; echo done

Nel caso specifico di un'applicazione che resta in esecuzione il secondo comando non verrà eseguito finché il primo non sarà terminato, in questo caso si usa & e saranno eseguiti entrambi in quanto il primo comando viene mandato in background; prendiamo xterm come esempio:

$ xterm && xterm -rv
$ xterm ; xterm -rv
$ xterm & xterm -rv
|
pipe, passa l'output del comando che la precede come input del comando che la segue
$ ls -A1 | less
||
operatore logico OR, restituisce esito positivo se almeno una delle condizioni di verifica valutate è vera
$ if [ -f ~/.bashrc ] || [ -d ~/.config ]; then echo 'w00t!'; else echo 'no such file or directory'; fi

$ if [ -f ~/.bashrc ] || [ -d ~/.configs ]; then echo 'w00t!'; else echo 'no such file or directory'; fi

$ if [ -f ~/.bash ] || [ -d ~/.configs ]; then echo 'w00t!'; else echo 'no such file or directory'; fi


Dirige output di comando su file:

$ man xterm > xterm.txt

Dirige output di errore su file:

$ xterm 2> xterm-errors.log

Entrambi su file diversi:

$ xterm > xterm_out.log 2> xterm_err.log

Entrambi sullo stesso file:

$ xterm &> xterm.log

Entrambi sullo stesso file, alternativa:

$ xterm > xterm.log 2>&1

Appende nuovo testo a quello già presente in un file:

$ man uxterm >> xterm.txt

Cancella contenuto di un file:

$ :> xterm.txt


Alternativa a basename

Quando in uno script ci si deve riferire al nome dello script stesso è usuale utilizzare il comando (esterno a bash) basename. Tuttavia, tramite i modificatori del paragrafo precedente, Bash stessa è in grado di fornire questa funzionalità. Basta usare l'espressione ${0##*/}.

Esempio:

usage () {
        echo "usage: ${0##*/} "
        exit 1
}

Cambiare l'estensione ai file

Rinomina tutti i file *.txt della directory corrente in *.log:

$ for f in *.txt; do mv "$f" "${f/%txt/log}"; done

Miscellanea

Abbiamo il nostro bel comando al prompt, è lungo tre righe e vogliamo salvarlo perché ci piace o perché è effettivamente troppo lungo e starebbe meglio come alias, che si fa?

  1. seleziona, apri file, incolla, salva: noioso
  2. quota il tutto e appendi ad un file con echo: già meglio
  3. CTRL-x CTRL-e, si apre il nostro editor di fiducia e salviamo: superbo


Processo in background. Si avvia un processo che tiene occupato il prompt:

$ xterm

anziché chiuderlo è possibile interromperlo, per liberare momentaneamente il prompt e magari eseguire altro, digitando CTRL-z. Si può quindi controllare quali processi siano riesumabili:

$ jobs -l
 [1]+  5598 Stopped                 xterm

Per riprenderlo si usa il numero tra le parentesi quadre (l'altro è il pid):

$ fg 1

Se invece si vuole riesumare mantenendo libero il prompt:

$ bg 1


Link

Link ad altre risorse su GNU Bash:


Autore iniziale: ~ The_Noise