[www-it-traduzioni] [Capitolo 22 Editing interattivo] traduzione Introduction to the command line

[Fil]

Ciao a tutti,

riporto qui sotto la versione plain-text della traduzione del capitolo
22. Ho anche il tutto già impaginato in epub, se qualcuno vuole il file
impaginato, chieda e gli sarà dato ;)

Mi sono preso alcune licenze, in particolare ho tradotto
arbitrariamente:
"enter a command" -> "scrivere un comando" (invece che "inserire")
"set of bindings" -> "set di binding" (invariato)
"whirl across the command line" -> "muoversi come un fulmine lungo la
riga di comando"

Sono ben accette locuzioni alternative e/o più efficaci :)

Attendo istruzioni su cosa fare del testo tradotto(devo caricarlo da
qualche parte? devo inviarlo in privato a qualcuno?)

Ciao,

Fil

######################################################################
Editing Interattivo
Molte persone, specialmente i principianti, usano i tasti freccia per
muovere il cursore lungo la riga di comando. La maggior parte delle
persone impiega meno tempo a fare ciò, di quanto ne impiegherebbe ad
imparare le alternative disponibili, più potenti, ma più complicate. Ma
vale la pena di imparare alcuni di questi metodi, perciò li presenteremo
qui.
La shell include due diversi set di key bindings (scorciatoie da
tastiera), ispirati a due editor di testo estremamente potenti, Emacs e
vi (probabilmente i due più potenti che esistano). Sfruttando le
scorciatoie da tastiera che questi binding offrono, i maghi della riga
di comando sono in grado di scrivere e modificare righe di comando anche
lunghe, in una frazione di secondo. Se vi concederete del tempo per fare
pratica con i key binding offerti dalla shell, anche se potrebbero
sembrare scomodi inizialmente, ne sarete presto in grado anche voi.
Nota: Sarete in grado di sfruttare completamente i binding di Emacs e vi
solo se siete in grado di digitare correttamente sulla tastiera (usando
10 dita). Se non ne siete in grado, dovreste imparare a farlo il prima
possibile (ci sono molti siti web gratuiti che insegnano a farlo). Ne
vale decisamente la pena. Per imparare a digitare potete usare
un'applicazione chiamata Klavaro. 
La shell bash usa i binding Emacs come default. Se volete provare i
binding di vi, scrivete il seguente comando:
$ set -o vi
Potrete tornare al binding di Emacs scrivendo:
$ set -o emacs
Il binding di Emacs e quello di vi sono molto diversi, ed occorre un po'
di tempo per abituarsi a ciascuno dei due. Dovreste provare entrambi i
binding per capire con quale vi trovate meglio. Questo capitolo copre
quello di default, il binding Emacs. Se imparerete a usare vi, potrete
passare ai suoi binding e li troverete piuttosto intuitivi. 
Consiglio: Non cercate di imparare tutte le scorciatoie in una sola
volta! Il cervello unano non è fatto per questo genere di cose, perciò
le dimentichereste quasi tutte. Piuttosto, vi consigliamo di imparare le
4/5 scorciatoie che trovate più utili e che usate più regolarmente --
imparare facendo. Più avanti potrete ritornare su questo capitolo, per
prendere in cosiderazione altre scorciatoie. Vi ritroverete presto a
muovervi come un fulmine lungo la riga di comando.
I binding di Emacs
I binding di Emacs fanno un uso massiccio di Ctrl e Alt come tasti
modificatori. Gli utenti esperti di Emacs sono soliti rimappare il tasto
CapsLock sul tasto Ctrl per poter digitare più comodamente i comandi
Emacs (e per evitare infortuni da affaticamento ripetuto!). Quando
inizierete ad usare i binding Emacs regolarmente, vi consigliamo di fare
lo stesso.
*****************************************************************************************
This space reserved for instruction on remapping the CapsLock key
*******************************************************************************************
Spostarsi lungo la riga di comando
Le due più basilari combinazioni di tasti per spostarsi lungo la riga di
comando sono Ctrl + f e Ctrl + b, le quali muovono il cursore,
rispettivamente, a sinistra di un carattere e a destra di un carattere.
 Ctrl + f
 Muovi avanti di un carattere
 Ctrl + b
 Muovi indietro di un carattere
Ovviamente potete fare gli stessi movimenti usando le frecce
direzionali. Ma come abbiamo sottolineato prima, usare i binding Emacs
Ctrl + f e Ctrl + b può risultare più pratico, poichè le vostre dita non
devono allontanarsi dalla parte alfabetica della tastiera. Al momento,
potreste non notare alcuna differenza di velocità (soprattutto se ancora
non siete molto veloci nel digitare), ma quando avrete più esperienza
nell'uso della riga di comando, sicuramente non vorrete più utilizzare
le frecce direzionali! 
La tabella seguente elenca alcune combinazioni di tasti che vi
permettono di navigare lungo la riga di comando ancora più velocemente: 
 Alt + f
 Muovi avanti di una parola
 Alt + b
 Muovi indietro di una parola
 Ctrl + a
 Vai all'inizio della riga
 Ctrl + e 
 Vai alla fine della riga
Consiglio: La parola tedesca per "Inizio" è Anfang. Vi dimentichereste
mai di una parola così strana? Speriamo di no, perchè può aiutarvi a
ricordare che Ctrl + a vi porta all'inizio della riga di comando.
Approfittando delle combinazioni di tasti appena proposte, potete
velocizzare nettamente la vostra scrittura su riga di comando. Se, per
esempio, avete scritto male la prima lettera di un nome file
incredibilmente lungo, la combinazione Alt + b riporta il cursore
all'inizio della parola, eliminando la necessità di muovere scomodamente
il cursore carattere per carattere. I tasti home e end, se presenti,
offrono un'alternativa a Ctrl + a e Ctrl + e. 
Modificare il testo 
Due tra i più diffusi comandi di modifica sono i seguenti:
 Ctrl + t 
 Scambia il carattere prima del cursore con quello dopo, e viceversa. 
 Alt + t
 Scambia la parola prima del cursore con quella dopo il cursore, e
viceversa
Ci vuole un po' per abituarsi a questi due comandi, ma entrambi sono
molto utili. MentreCtrl + t è usato prevalentemente per correggere gli
errori di battitura, Alt + t è spesso usato per "trascinare" una parola
in avanti lungo la riga di comando. Date un'occhiata al comando seguente
(la sottolineatura segna la posizione del cursore):
$ echo uno due tre quattro
Se premete Alt + t in questa situazione, la parola prima del cursore
("uno") viene scambiata con la parola dopo il cursore ("due"). Provate!
Il risultato dovrebbe apparire così:
$ echo due uno tre quattro
Noterete due cose. La prima è che l'ordine delle parole "uno" e "due" è
stato scambiato. La seconda è che il cursore si è spostato in avanti
insieme alla parola "uno". Ora, la cosa interessante del fatto che anche
il cursore si sposti è che non dovrete fare altro che premere nuovamente
Alt + t per scambiare "uno" con la parola seguente, "tre":
$ echo due tre uno quattro
Perciò, premendo Alt + t ripetutamente, potrete "trascinare" in avanti
la parola prima del cursore, fino alla fine della riga. (Ovviamente,
potete fare la stessa cosa con un singolo carattere, usando Ctrl + t.)
All'inizio, il funzionamento elaborato dei due comandi di scambio può
confondere un po'. Vi basterà sperimentarli per qualche tempo, e presto
ne avrete la piena padronanza. 
Cancellare/sopprimere e reinserire il testo
Ecco alcuni pratici comandi per cancellare del testo:
 Ctrl + d 
 Cancella il carattere sotto il cursore 
 Alt + d 
 Sopprimi tutto il testo, a partire dal cursore, fino alla fine della
parola corrente.
 Alt + Backspace 
 Sopprimi tutto il testo, a partire dal cursore, fino all'inizio della
parola corrente.
E' da notare che Alt + d e Alt + Backspace non cancellano il testo, ma
lo sopprimono. Sopprimere è diverso da cancellare, in quanto il testo
cancellato sparisce per sempre, mentre il testo soppresso può essere
riportato in vita (il terime usato è "yanked", "strattonato") in un
momento successivo, usando il comando:
 Ctrl + y 
 Reinserisci (yank) il testo precedentemente soppresso 
Vediamo ora come funziona, attraverso un esempio:
$ echo uno due   
Come prima, la posizione del cursore è indicata dalla sottolineatura. Se
premete Alt + Backspace in questa situazione, la parola "due", così come
lo spazio successivo ad essa, sarà soppressa, lasciando la riga di
comando nella seguente condizione: 
$ echo uno   
Se ora premete Ctrl + y, il testo soppresso è "resuscitato" nuovamente
nella riga di comando. Potete ripeterlo più volte. Se premete Ctrl + y
tre volte, per esempio, otterrete la seguente riga: 
$ echo uno due due due   
Come potete vedere, sopprimere il testo equivale alla funzione "taglia"
dei moderni editor di testo. E' da notare che il testo non soppresso, ma
cancellato (premendo Ctrl + d) non può essere reinserito nella riga di
comando. L'unica maniera per riaverlo indietro è utilizzare la funzione
di annullamento, che sarà discussa qui sotto. 
Probabilmente i comandi più utili per sopprimere il testo sono i
seguenti: 
 Ctrl + k 
 Sopprimi tutto il testo a partire dal cursore, fino alla fine della
riga. 
 Ctrl + u 
 Sopprimi tutto il testo, a partire dal cursore, fino all'inizio della
riga (unix-discard-line) 
Come sempre, il modo migliore per imparare questi comandi è quello di
sperimentare. Vi renderete conto che sopprimere e, quando necessario,
reinserire grandi porzioni di testo, possono farvi risparmiare molto
tempo. 
Annullare i cambiamenti
Potete annullare l'ultimo cambiamento effettuato, usando il comando
seguente:
 Ctrl + _ 
 Annulla l'ultimo cambiamento. 
Un modo alternativo per fare lo stesso è premereCtrl + xu. (Premete
prima x e poi umentre tenete premuto Ctrl.)
Scorrere la cronologia della shell
La shell salva gli ultimi comandi digitati nella sua cronologia. Questo
vi permette di richiamare i comandi precedentemente digitati, cosa che
può risparmiarvi molte digitazioni. Ecco i comandi più importanti per
scorrere la cronologia della shell:
 Ctrl + p 
 Vai al comando precedente in cronologia 
 Ctrl + n 
 Vai al prossimo comando in cronologia
 Ctrl + > 
 Vai all'ultimo comando in cronologia 
 Ctrl + r 
 Cerca comandi precedentemente digitati in cronologia
(reverse-search-history)
 Ctrl + g 
 Cancella la cronologia dei comandi corrente 
Vediamo come funzionano questi comandi, attraverso un semplice esempio.
Aprite la shell e digitate i comandi seguenti:
$ echo due
due
$ echo tre
tre
$ echo quattro
quattro
Dopo aver inserito questi comandi, vi rimane una riga di comando vuota
che aspetta il vostro input. Ora premete Ctrl + p. Noterete che il
comando inserito precedentemente appare sulla riga di comando: echo
quattro. Se premete Ctrl + p un'altra volta, vi sposterete "più in su"
nella cronologia, così da far apparire echo tre nella riga di comando.
Ora premete Ctrl + n, e vedrete che siete tornati a echo quattro: Ctrl +
nfunziona esattamente come Ctrl + p, ma all'opposto. Le frecce
direzionali su e giù sono alternative a questi comandi. 
Dopo aver premuto Ctrl + p e magari anche Ctrl + n un po' di volte,
potreste voler tornare indietro al comando che stavate digitando quando
avete iniziato a scorrere la cronologia. Potete fare ciò, premendo Ctrl
+ >. 
Come vedete, la cronologia della shell non è altro che una lista dei
comandi digitati di recente. Potete scorrere in sù e in giù la lista
digitando, rispettivamente, Ctrl + p e Ctrl + n. E potete premere Enter
in ogni momento per eseguire il comando attualmente selezionato.
Dato che la cronologia dei comandi è soltanto una grande lista, è anche
possibile sottoporla a ricerca. Il comando più comunemente usato a tale
scopo è Ctrl + R. Di nuovo, assumiamo che abbiate digitato i comandi
echo uno, echo due e echo tre. Provate ora a premere Ctrl + R. Noterete
che apparirà una scritta come "reverse-i-search". Se ora digitate la
lettera "u", passerete diretatmente all'ultimo comando inserito che
conteneva una "u", che è ovviamente echo due. Da qui potete usare Ctrl +
p e Ctrl + n per scorrere la cronologia come spiegato sopra. Oppure
potete modificare la ricerca digitando una seconda lettera, ad esempio
"n". A questo punto passerete al comando echo uno, perchè è il primo
comando nella sequenza di cronologia, contenente la sequenza "un". O
potete semplicemente cancellare la ricerca premendo Ctrl + g.
Se vi sentite un po' persi nell'usare le funzioni di cronologia della
shell, non vi preoccupate! Se continuerete a fare pratica, presto
diventerà una routine, il saltare avanti e indietro nella cronologia,
evitando la scomodità di dovre riscrivere lunghe righe di comando.
Editing interattivo: un esempio
L'esempio seguente, ha lo scopo di dimostrarvi come le funzioni di
editing interattivo della shell possano drasticamente velocizzare il
vostro lavoro. Supponiamo che abbiate digitato il seguente comando:
$ echou no due tre
bash: echo: command not found
Bash ha lanciato un errore, perchè il comando echou non esiste.
Ovviamente, quello che volevate veramente scrivere era echo uno due tre.
Forse sarete sorpresi nel leggere che sono sufficienti cinque
digitazioni per correggere l'errore:
1. Premete Ctrl + p per recuperare a schermo il primo comando in
cronologia, ossia quello digitato erroneamente.
2. Premete Ctrl + a per muovere il cursore all'inizio della riga.
3. Premete Alt + f per muovere il cursore avanti di una parola. Il
cursore ora si trova tra le parole "echou" e "no".
4. Premete Ctrl + t. Vedrete che la "u" prima del cursore e lo spazio
sotto il cursore sono stati scambiati: "echou no" è diventato "echo
uno".
5. Infine, premete Enter per esegure il comando corretto!
####################################################################