Utente:Jango: differenze tra le versioni

Vai alla navigazione Vai alla ricerca
Nessun oggetto della modifica
Riga 1: Riga 1:
== Presentazione ==
==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.


Questo script bash confronta due file di configurazione del kernel e stampa
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�.
le voci che contengono una determinata stringa che siano settate (o non settate) nel primo e settate (o non settate) nel secondo.


Pu� essere utile per individuare quali voci mancano in un kernel ricompilato ripetto ad un kernel binario debian, in una particolare sezione del kernel.
==Per iniziare==
Prima di iniziare non posso non segnalare altre due guide presente sul wiki che danno dei tip molto utili su Bash:


== Sintassi ==
* [[Come abilitare il completamento automatico 'avanzato']]
Lo script va lanciato nel seguate modo (supponendo di averlo chiamato <tt>ker-conf</tt>):
* [[Colorare bash]]


  ker-conf config-1 config-2 stringa [s|n] [s|n]
==Shell Interattiva==
In questa sezione verranno elencate funzionalit� riguardanti l'uso interattivo di Bash.


I primi due parametri sono i due file di configurazione del kernel da confrontare. Il terzo parametro � la stringa che deve essere contenuta nelle voci di configurazione di entrambi i kernel (solo questo sotto-insieme viene confrontato).     La stringa di ricerca � ''case-insensitive'', valori di esempio sono: scsi, usb,
===Navigare velocemente tra le directory===
acpi, '*', ecc...
* Per andare sulla propria '''home''' basta digitare il comando '''cd''' senza nessun paramentro.
* Per tornare indietro alla precedente directory visitata � sufficiente il comando '''cd -'''
* E 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 comadi � 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.


Gli ultimi due parametri (opzionali) possono essere solo 's' o 'n' (settato o non
===Riutilizzo degli argomenti===
settato) e si riferiscono rispettivamente allo stato di config-1 e config-2.
Bash memorizza l'ultimo argomento del comando precedente in una speciale variabile chiamata $_. E' possibile fare riferimento all'ultimo argomento dell'ultimo comando usando direttamente $_ ma la via di gran lunga pi� veloce � comoda � usare 'ESC .'.  
Se gli ultimi due parametri vengono omessi viene usato il default: n s.


Quando l'ultimo parametro � s (e' il default se non specificato) le voci
Ecco un esempio stupido, creare un directory ed entrarvi:
sono stampate con lo stato (<tt>=y</tt> oppure <tt>=m</tt>) del secondo config.
<pre>
$ mkdir /usr/local/nuovo-programma
$ cd ESC.
</pre>


Per una breve decrizione del funzionamento dello script, basta lanciarlo senza alcun parametro.
Altro esempio forse un p� pi� utile, creare velocemente uno script:
<pre>
$ :> /usr/local/bin/nomescript
$ chmod +x ESC.
$ gvim ESC.
</pre>


===Editing della linea di comando===
Alcuni tasti di scelta rapida per l'editing da linea di comando:
: '''<tt>CTRL+a</tt>''': Vai all'inizio delle linea
: '''<tt>CTRL+e</tt>''': Vai alla fine della linea
: '''<tt>CTRL+k</tt>''': Cancella fino dalla posizione corrente alla fine della linea
: '''<tt>CTRL+u</tt>''': Cancella fino dalla posizione corrente all'inizio della linea
: '''<tt>CTRL+l</tt>''': Pulisce lo schermo
: '''<tt>META+f</tt>''': Vai una parola avanti
: '''<tt>META+b</tt>''': Vai una parola indietro
: '''<tt>META+d</tt>''': Cancella la parola successiva
: '''<tt>META+backspace</tt>''': Cancella la parola precedente


== Script ==
{{Box|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 permere due tasti conemporaneamente. 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 GIU. 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� immendiatamente 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.
 
Una volta trovato il comando lo si pu� eseguire con INVIO oppure editare 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:


<pre>
<pre>
#!/bin/bash
# PgUp/Down searches history in bash
#
"\e[5~":        history-search-backward
#  ckc - Confronta Kernel Config
"\e[6~":        history-search-forward
#  Versione: 0.0.3
</pre>
#
 
#  Copyright (C) 2005 - Davide Natalini <tindal@katamail.com>  
In questo esempio si � scelto di usare i tasti PGUP e PGDOWN.
#                      Antonio Ingargiola <debian@fastwebnet.it>
Da notare che il file inputrc contiene altre comodit� pronte all'uso: basta decommentarle!
#
 
#  Released under the GNU GENERAL PUBLIC LICENSE.
====Accesso diretto====
#
Il carattere ! permette di richiamare un preciso comando dello storico:
 
<pre>
$ !-3
</pre>
 
richiama ed esegue il terzultimo comando, mentre:
 
<pre>
$ !ta
</pre>
 
richiama ed esgue 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
 
<pre>
$ !ta:p
</pre>
 
stampa l'ultimo comando che inizia con ''ta''.
 
Per richiamare l'ultimo comando che contiene una certa parola (non all'inizio):
 
<pre>
$ !?parola?
</pre>
 
E' possibile anche richiamare un parametro di un comando usando ''':''' seguito dal numero del parametro (0 indica il comando stesso). Ad esempio:
 
<pre>
$ man !-1:0
</pre>


usage() {
visualizza la pagina di manuale dell'ultimo comando.
echo -e "\n  *** Errore: Parametri non corretti.\n"
echo -e "  USO: \n"
echo -e "  ${0##*/} config-1 config-2 stringa [s|n] [s|n]\n"
echo -e "  Lo script ${0##*/} confronta due file di configurazione del kernel e stampa"
echo -e "  le voci che contengono 'stringa' che siano settate (o non settate) nel primo"
echo -e "  e settate (o non settate) nel secondo.\n"
echo -e "  Gli ultimi due parametri possono essere solo 's' o 'n' (settato o non"
echo -e "  settato) e si riferiscono rispettivamente allo stato di config-1 e config-2."
echo -e "  Se gli ultimi due parametri vengono omessi viene usato il default: n s. \n"
echo -e "  Quando l'ultimo parametro e' s (e' il default se non specificato) le voci"
echo -e "  sono stampate con lo stato (built-in o modulo) del secondo config.\n"
exit 1
}


filter () {
Per eseguire un comando con gli stessi argomenti del comando precedente:
FILE=$1; STATUS=$2
BOOL=''; EXP='^ *$'; [ "$STATUS" = "s" ] && BOOL="-v" || EXP='=|is not set'
SED_EXP='s/\(# \)\?\([0-9a-zA-Z_]\+\)\(=.\)\?.*/\2\3/'
egrep $BOOL '^#' "$FILE" | egrep $BOOL "$EXP" | egrep -i "$PAR" | sed "$SED_EXP"
}
[ $# -lt 3 ] || [ $# -gt 5 ] && usage


NEW_CONFIG=$1;  REF_CONFIG=$2;  PAR=$3
<pre>
$ nuovocomando !!:1*
</pre>


STATUS_NEW=${4-n}; STATUS_REF=${5-s}
==Bash Scripting==
for S in $STATUS_NEW $STATUS_REF; do [ "$S" = "s" ] || [ "$S" = "n" ] || usage; done
In questa sezione verranno elencati alcuni brevi tip per lo scripting Bash. Questa non vuole essere assolutamente una guida completa, ma pi�ttosto un elenco di costrutti per lo scripting bash particolarmente eleganti, curiosi e/o poco noti.


TMP_FILE_NEW="/tmp/${0##*/}-new.tmp"
===Variabili speciali===
TMP_FILE_REF="/tmp/${0##*/}-ref.tmp"
ON_EXIT="rm -f $TMP_FILE_NEW $TMP_FILE_REF"


trap "$ON_EXIT" 0 15
; $? : 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.


filter $REF_CONFIG $STATUS_REF > $TMP_FILE_REF
; $@ : Contiene la lista dei paramentri passati allo script corrente. Ogni parametro viene opportunamente quotato e 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.
filter $NEW_CONFIG $STATUS_NEW > $TMP_FILE_NEW


for LINE_NEW in $( cat $TMP_FILE_NEW )
''Esempio:''
do
<pre>
egrep "${LINE_NEW/%=[ymn]/}(=[ymn])?$" $TMP_FILE_REF
FILES=$@
 
for file in $FILES; do
    # Fare quello che si vuole con $file
    echo $file 
    # ...
done
done
</pre>
; $$ : PID del processo corrente.


exit 0
; $! : 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 <tt>'''sh'''</tt>, 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. Una variabile si indica di solito con <tt>${nome}</tt> oppure con la forma abbreviata <tt>$nome</tt>. 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:
 
; <tt>#</tt> : sottrae dall'inizio della stringa ''(minimale)''
; <tt>%</tt> : sottrae dalla fine della stringa ''(minimale)''
; <tt>/</tt> : 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:
 
; <tt>##</tt> : sottrae dall'inizio della stringa ''(massimale)''
; <tt>%%</tt> : sottrae dalla fine della stringa ''(massimale)''
; <tt>//</tt> : 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 <tt>expr</tt>) vedere:
 
* [http://www.tldp.org/LDP/abs/html/string-manipulation.html Advanced Bash-Scripting Guide: Manipulating Strings]
 
==== 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
 
===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:
<pre>
usage () {
        echo "usage: ${0##*/} "
        exit 1
}
</pre>
</pre>
=== Cambiare l'estensione ai file ===
Rinomina tutti i file <tt>*.txt</tt> della directory corrente in <tt>*.log</tt>:
for f in *.txt; do mv "$f" "${f/%txt/log}"; done
==Link==
Link ad altre risorse su '''GNU Bash''':
* [http://www.gnu.org/software/bash/manual/bash.html Bash Referece Manual]: manuale ufficiale
* [http://www.tldp.org/LDP/abs/html/ Advanced Bash-Scripting Guide]: la '''Bibbia''' dello bash scripting.
----
Autore iniziale: [[Utente:TheNoise|~ The_Noise]]
Estratto da "https://guide.debianizzati.org/index.php/Utente:Jango"