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

[Fil]

Ciao,
grazie Enrico per la revisione :)

Ho scelto di non implementare un paio di modifiche che hai suggerito,
perché la versione originale era più aderente al testo originale.
Per il resto, ecco qui:

#################################################################################
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 provarli entrambi
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. Mentre Ctrl + 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', ma 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 u mentre 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 usati, 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 noterete che sarete tornati a echo quattro: Ctrl
+ n funziona 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 su 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 direttamente 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 saltare avanti e indietro nella cronologia,
evitando la scomodità di dover 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: echou: 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:

Premete Ctrl + p per recuperare a schermo il primo comando in
cronologia, ossia quello digitato erroneamente.
Premete Ctrl + a per muovere il cursore all'inizio della riga.
Premete Alt + f per muovere il cursore avanti di una parola. Il cursore
ora si trova tra le parole "echou" e "no".
Premete Ctrl + t. Vedrete che la "u" prima del cursore e lo spazio sotto
il cursore sono stati scambiati: "echou no" è diventato "echo uno".
Infine, premete Enter per eseguire il comando corretto.
##################################################################################

..continuo ad attendere istruzioni su cosa fare per convogliare il mio
lavoro con quello del gruppo (dove/a chi mando i testi tradotti e
impaginati?)

Grazie

Fil



Il giorno dom, 06/03/2016 alle 18.55 +0100, Enrico Bella ha scritto:
> Ciao,
> qui sotto trovi la mia revisione. Mi sembra vada bene, l'unica cosa
> che potrei consigliarti per rendere più scorrevole la lettura è di
> accorpare le frasi. In inglese si usano molto di più le frasi brevi
> rispetto all'italiano, ma a mio avviso sarebbe bene accorparle quando
> il testo diventa troppo spezzettato, in modo da renderlo più
> leggibile.
> 
> *******************************************
> 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 provarli entrambi per 
> capire con quale vi trovate meglio. Questo capitolo copre
> quello di default, il binding Emacs, ma se imparerete a usare vi potrete
> passare ai suoi binding e usarli in modo intuitivo. 
> 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  poi ritornare su questo capitolo, 
> prendere in considerazione altre scorciatoie e imparare 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. Mentre Ctrl + 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', ma 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 reinserire, quando 
> necessario,
> grandi porzioni di testo tramite i comandi citati può 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 u mentre 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 usati, 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 sarete tornati a echo quattro: Ctrl +
> n funziona 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 su 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 direttamente 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 saltare avanti e indietro nella cronologia,
> evitando la scomodità di dover 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: echou: 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 eseguire il comando corretto!
> 
> ***************************************
> 
> 
> 
> Ciao
> Enrico
> 
> Il 06/03/2016 14:53, Fil ha scritto:
> 
> > 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!
> > ####################################################################
> > 
> > 
> > --
> > http://savannah.gnu.org/projects/www-it/
> 
> --
> http://savannah.gnu.org/projects/www-it/