Archivi Categorie: How to

Quale linguaggio usare

Lasciamo sbocciare cento fiori
毛泽东

Il post di oggi –breve che fa caldo– è una continuazione del precedente. Anche se affronta un argomento leggermente diverso, come scoprirete presto continuando a leggere 8)


Mi sono trovato a dover traslitterare (mi hanno detto che si dice così) in minuscolo il contenuto di un file, lungo e pieno di parole astruse. A farlo a mano ci sarebbe stato un grosso rischio di inserire errori, e poi è poco elegante.

Siccome stavo facendo altre cose con newLISP la decisione spontanea, immediata è stata di usarlo. Ed ecco cosa ne è uscito (tolower.nl)

#!/usr/bin/newlisp

;; converte il file in minuscolo

(set 'argv (main-args))
(set 'narg (length argv))
 
; il primo indice dei parametri è pex + 1
(if (find "newlisp" (argv 0))
	(set 'pex 1)
	(set 'pex 0)
)

; file da convertire
(if (> narg pex)
	(set 'sorgente (argv (++ pex)))
	(begin
		(println "nessun file")
		(exit)
	)
)

(if (not (file? sorgente))
	(begin
		(println "manca il file " sorgente)
		(exit)
	)
)

(set 'text (read-file sorgente))
(set 'text (lower-case text))

(set 'bak (join (list sorgente "bak") "."))
(if (file? bak)
	(delete-file bak))
(rename-file sorgente bak)  
(write-file sorgente text)

(exit)

Sono una quarantina di righe ma quella fondamentale è (set 'text (lower-case text)). Proviamolo su un file di prova (prova), otteniamo

OK! perfetto 😀 O no?

Sì funziona ma c’è un fatto: “quando hai un buon martello tutto sembra un chiodo“. Forse si poteva fare con mezzi più semplici, con tools resi disponibili dal Sistema Operativo. Sì se fosse stato su Linux, nell’ambiente in cui mi trovavo (quello che spesso mostra una schermata blu con scritte bianche che ti dicono di prenderti una pausa mentre riavvii) no.

Tornato a casa non ho resistito, dovevo farlo 8)

La prima idea è stata di usare AWK, per ragioni storiche: tutte le volte che ne proponevo l’uso mi dicevano di no; adesso posso e allora (lc-awk.sh)

#!/bin/sh
cat $1 | awk '{print tolower($0)}'

testandolo si ha

OK! perfetto 😀 O no?

Si può fare di meglio: non c’è bisogno di AKW, basta bash (b.sh)

#!/bin/bash
tr '[A-Z]' '[a-z]' < $1

verifica


Volendo, si può essere ancora più eleganti (b1.sh)

#!/bin/bash
tr '[:upper:]' '[:lower:]' < $1

OOOK! 😀

Ci sarebbero moltissimi altri modi per ottenere lo stesso risultato, per esempio in Python c’è

str.lower()
Return a copy of the string converted to lowercase.

esattamente come in newLISP. Chi ha copiato?
Ma lo sapevamo di già

tutte le strade portano a Ankh-Morpork

E poi, a dirla proprio tutta-tutta, non sono nemmeno originale. Tempo fa avevo segnalato il link a “trying to use Unix tools“: dovrei fare più attenzione a quello che leggo e riporto.

________________
Poi per chi volesse approfondire sul 伟大舵手 può partire da qui, sì c’è anche in italiano.

Ancora sui numeri grossi, ma anche piccoli

A volte ritornano! Chi? Cosa? Quello che volete, quello che non vi aspettate; per esempio oggi torna l’argomento già trattato nel post “Numeri grossi“.

Anche se, pare, non sia un argomento interessante. Ma interessa me a allora… 8)
Ci metto anche una dritta su Unix/Linux che tanti giudicheranno banale e elementare ma metti che uno inizi adesso –come me 8). (Sì a volte dico bugie ma mi hanno insegnato che le bugie si possono dire a fin di bene 😉 ).

Il post precedente finiva con la constatazione che per numeri davvero grandi la rappresentazione normale è insufficiente, così

Propongo di fare come fanno i matematici e gli scienziati (e anche gli ing.): ricorriamo alla rappresentazione esponenziale: il numero mille viene scritto come 1e3, cioè 1*103; il numero un miliardo diventa 1e9.

Facile e efficace vero? C’è da dire che non a tutti piace e c’è un’alternativa, più usata dalle persone sane di mente e normali, talmente comune che non ci accorgiamo nemmeno di usarla. Sto parlando dei prefissi di SI (Sistema internazionale di unità di misura).
Quando diciamo kilometro, milligrammo, ettolitro, nanometro e simili stiamo usando SI.
E quando diciamo che il disco fisso (hard disk) del nostro computer è di 200 gigabytes usiamo ‘quasi’ SI. Sì perché in questo caso il fattore di moltiplicazione non è 1000 ma 210 = 1024, vedi qui.

Tornando al nostro problema vediamo di riciclare gli script Python e bash aggiornandoli a rappresentare i numeri anche in formato esponenziale.

Ormai siamo abituati a scrivere j1 3^50 e deve essere possibile continuare a farlo ma se scriviamo j1 -e 3^50 vogliamo la rappresentazione esponenziale.

Vediamo intanto come dobbiamo modificare lo script bash, propongo di chiamarlo jp1, eccolo

#!/bin/sh
par="calc "
xp=""

for c in $*
do
    if [ "$c" = "-e" ]; then
        xp="E"
    else
        par=$par\ $c
    fi
done

#echo $xp $par
./j30.py $xp `$par`

Semplice vero? Esegue un ciclo for per i parametri passati nella riga di comando ($*) accumulandoli nella variabile par ad eccezione di -e che viene memorizzato in xp.

Lo script di Python (adesso j30.py) viene anch’esso modificatto, così

#!/usr/bin/env python

import sys

#print sys.argv
if len(sys.argv) == 0:
    print 0
else:
    if sys.argv[1] == 'E':
        arg = sys.argv[2]
        xp = True
        fmt = '{:,e}'
    else:
        arg = sys.argv[1]
        xp = False
        fmt = '{:,}'
    try:
        if arg[0] == '~': arg = arg[1:]
        d = arg.find('.')
        if d >= 0:
            st = fmt.format(float(arg))
        else:
            st = fmt.format(long(arg))
    except:
        print 'error'
        sys.exit(1)

    if xp: d = st.find('.')
    p = st.find('.')
    if d >= 0:
        st = st[:p] + '@' + st[p+1:]
    q = st.find(',')
    while q > 0:
        st = st[:q] + '.' + st[q+1:]
        q = st.find(',')
    if d >= 0:
        st = st[:p] + ',' + st[p+1:]
    print st

Il formato di formattazione dell’istruzione format lo prendiamo sempre dalla documentazione online.

Entrambi gli script hanno un’istruzione commentata, (righe 14 e 5) molto utile in fase di debug. Per questo le ho lasciate, non si sa mai.

Notare come adesso la rappresentazione esponenziale sia utile anche per la rappresentazione di numeri molto piccoli, prossimi a zero, così

Ma non troppo piccoli


E abbiamo ancora un problema con i numeri negativi

perché il segno “” viene interpretato come introduzione di un’opzione. Sarebbe da correggere, lasciato come compito per il lettore (compito delle vacanze). A meno che … No per adesso un altro post non è previsto 8)

Resta ancora un passo da fare: rendere il comando jp eseguibile indipendentemente dalla directory in cui ci troviamo, come i comandi seri ls, echo, cat

Come qualcuno sa c’è una directory speciale nella nostra home, è la directory ~/bin. Il carattere “~” si ottiene con AltGr+ì con la tastiera italiana. Per vedere se c’è basta fare così


OK, io ho ~/bin e non ~/bon.

Se ~/bin è presente viene automaticamente inserita nella PATH, si può verificare con


Nel caso in cui non esista si può creare, così (N.B.: io creo ~/bon, per quando detto sopra)

A questo punto copiamo il file j30.py in ~/bin


Lo script jp1 dev’essere leggermente modificato, inoltre lo salvo come jp

#!/bin/sh
par="calc "
xp=""

for c in $*
do
    if [ "$c" = "-e" ]; then
        xp="E"
    else
        par=$par\ $c
    fi
done

#echo $xp $par
~/bin/j30.py $xp `$par`

e lo copio in ~/bin


D’ora in poi il comando sarà eseguibile da ogni directory


Attenzione: se avete creato la directory ~/bin questa sarà inserita nella PATH al prossimo avvio o reset. OK, ci sarebbe ancora qualcosa da dire ma per iniziare credo sia sufficiente.

_____________
Un piccolo aneddoto: mentre stavo preparando il post (in particolare lo script bash) sono incappato in uno di quegli errori banalissimi quando li fa un altro ma se lo fai tu e sei solo e ti intestardisci non lo trovi e dai di matto brutto.
Potenza di Google+: ho postato il problema e la soluzione è arrivata in pochi minuti, qui 8)

Un amico vale un tesoro, io ne avevo due online, di quelli tosti 8)

Numeri grossi

Quando i numeri superano un certo limite diventano difficili da comprendere, e anche da leggere.
Mi spiego: tutto è nato da una discussione sul Totocalcio (se ne parla anche quando non ci sono le partite, ah l’astinenza!). Abbiamo 13 pronostici ognuno con 3 opzioni quindi le combinazioni possibili sono 3 ^ 13, ossia

1594323, un milionecinquecentonovantaquattromilatrecentoventitrè.
Ecco scritto così è difficile da leggere, il secondo modo andrebbe bene, forse, per i tedeschi. Facciamo come i ragionieri: 1.594.323, OK 😀

E se poi mettessimo nella schedina più partite (in Brasile sono 15 (mi dicono)), per esempio anche tutta la serie B, diciamo 20 partite, allora abbiamo

no! illeggibile, dobbiamo fare qualcosa.

OK! in Unix (e nel suo successore Linux) c’è una grande tradizione di filtri, facciamone uno, propongo Python.

Con una googlata arriviamo a Format Specification Mini-Language

Ecco proprio quello che ci serve 8) O quasi: a differenza degli anglofoni usiamo il punto al posto della vergola e viceversa; ci serve uno scriptino.

Quello che vogliamo è un comando simile a calc ma che scriva i numeri in modo leggibile.

Dai è fattibile e semplice, qualcosa che faccia così:

Allora, secondo me dobbiamo coinvolgere calc, bash e Python. In alternativa, visto che calc deve essere installato e se non lo vogliamo potremmo sostituirlo con bc.

Questa è la componente in Python

#!/usr/bin/env python

import sys

if len(sys.argv) == 0:
	print 0
else:
	try:
		arg = sys.argv[1]
		d = arg.find('.')
		if d >= 0:
			st = '{:,}'.format(float(arg))
		else:
			st = '{:,}'.format(long(arg))
	except:
		print 'error'
		sys.exit(1)

	p = st.find('.')
	if d >= 0:
		st = st[:p] + '@' + st[p+1:]
	q = st.find(',')
	while q > 0:
		st = st[:q] + '.' + st[q+1:]
		q = st.find(',')
	if d >= 0:
		st = st[:p] + ',' + st[p+1:]
	print st

Semplice vero? Lo script si aspetta che calc (o bc) restituisca un numero (righe 5, 12 e 14). Siccome il parametro è una stringa verifica se c’è il separatore decimale (il punto); se c’è trasforma la stringa in float (il double del C) –riga 12– altrimenti in long (intero a precisione estesa) –riga 14.

A questo punto il nostro numero è rappresentato dalla stringa st.
Salva quindi la posizione del punto decimale (se c’è), riga 19. Se c’è sostituisce il punto con il carattere @ –righe 20 e 21. Esegue poi il ciclo di sostituzione delle virgole con punti –righe 22-25. E infine se c’era il punto iniziale mette una virgola in quella posizione –righe 26 e 27.
Scrive la stringa risultato –riga 28. Fatto.

Non ci resta che abilitarlo come comando, visto che abbiamo un terminale aperto lo facciamo con il comando

chmod +x j20.py

In alternativa in Nautilus click sul file j20.py con il tasto desto, selezionare Proprietà e poi Permessi e checkare (spuntare) “Consentire l’esecuzione del file come programma

E bash? Beh, questo è facile, ne abbiamo parlato in passato, c’è il corso di Bit3Lux & Lightuono (lo state seguendo vero? adesso sono in ferie ma riprenderà), eccolo

./j20.py `calc $@`

Attiviamolo e proviamolo

Per chi volesse usare bc al posto di calc ecco jbc

./j20.py `echo $@|bc -l`

e abbiamo (dopo l’attivazione)


OK! credo che per oggi basti così. Ci sarabbero ancora altre cose da fare, prossimamente, forse 8)

Inoltre –nota personale– questo era quasi pronto ieri, solo che poi c’è stato nientepopodimenoche il terremoto

Io sono nel pallino rosso. L’epicentro è sulle montagne tra la Val Chisone (quella di Pinerolo) e la Val di Susa (quella della TAV). Niente danni, le nostre montagne sono di roccia e quella è la zona dov’è nata l’espressione “bugia nen“.

Ha spaventato solo la mia amica Giulietta


coraggio Giulia è passato 8)
Non credete ai giornali: fanno quello che fa la gente, per un paio di giorni c’è qualcosa su cui chiacchierare, oltre al tempo (stasera è previsto un temporale, comunque, per chi fosse interessato) 😉

RSS – la guida a come farlo e usarlo

Questo è un post leggermente atipico anche nell’atipicità del blog. Ma c’è una ragione: serve a quelli che ancora non usano l’RSS perché nessuno gli ha detto cos’è e i geek / nerd /smanettoni / tecnologici nostrani sono troppo criptici per capirci qualcosa. Allora, con l’aiuto del dottor Dulcamara ecco la guida che spiega tutto per bene, passo passo –o almeno ci prova.

Cos’è l’RSS
Ci sono dei siti che vengono aggiornati periodicamente ma non si sa mai se c’è qualcosa di nuovo o no, sono i blog. Invece di controllare ogni tanto ogni singolo blog che seguiamo (operazione lunga e noiosa) noi creiamo un elenco dei blog da tenere sott’occhio e aprendo la pagina di quest’elenco abbiamo subito a disposizione tutte le novità. Questa meraviglia si chiama RSS (Really Simple Syndication). Approfondimenti al solito su Wikipedia, qui.

Nota #1: Diversamente dal solito le videate che illustrano il post sono screenshot presi in ambiente Windows: cosa non si fa per i proprii amici lettori potenziali 8)

Nota #2: facendo click sulle figure si apre una nuova scheda con la figura grande, quando serve, ovviamente.

Creare un account Gmail
Questo capitolo è per chi ancora non ha una mail. Verrà creata con Gmail, quella di Google, per comodità. Liberi di saltare al capitolo successivo se ne siete già provvisti, ovviamente 8)
Inoltre non è necessario che l’account email sia con Gmail, vanno bene tutte (anche yahoo! se sopportate la pubblicità strabordante).

Apriamo il nostro browser preferito (io uso Firefox, ma va bene qualunque) e accediamo all’indirizzo http://www.gmail.com. Verremo reindirizzati e otterremo qualcosa come in figura


A noi interessa il pulsante Crea un account –quello indicato dalla freccia rossa (che ho aggiunto io, non cercatela, cercate il pulsante (questa precisazione è per i leghisti e Brunetta)).

Compiliamo la scheda, come in figura, fino in fondo, non solo la parte visualizzata. Quando proponiamo il nome di accesso desiderato dobbiamo sempre clickare su verifica la dispobibilità perché Gmail ama contrattare come i venditori di tappeti. Scegliete un nome bello perché è quello che userete e distribuirete. Attenzione alla password: mettetene una significativa per voi con dentro qualche numero, segno di punteggiatura, maiuscola, minuscola, etc. Ricordatela –segnatela subito su un pezzo di carta 8)

Completata questa fase (se ci sono errori Gmail ve li indica con note in rosso e vi lascia correggere senza perdere tutto) arriviamo a

dove possiamo finalmente collegarci alla nostra nuova casella di posta elettronica –basta inserire il nome utente e la password definiti al punto precedente.

Possiamo senz’altro saltare i convenevoli

leggiamo e/o cancelliamo le mail di Gmail e chiudiamo la finestra, è tutto OK 8)
Siamo pronti a passare all’RSS. 8)

Creare e gestire una lista RSS
Proveremo prima con un metodo facile-facile, poi vedremo che si può sveltire. Ma dobbiamo imparare e ricordate: Ankh Morpork non è stata costruita in un giorno.
Apriamo un blog che ci piace, propongo http://www.tamburoriparato.blogspot.com.

Quello che ci interessa è il quadratino indicato dalla freccia, clickiamolo

e clickiamo su Abbonati adesso.
Propongo di fare la stessa cosa per https://okpanico.wordpress.com

e per il bellissimo blog della mia amica Patrizia: http://patriziamandanici.blogspot.com

OK, a questo punto abbiamo materiale sufficiente per vedere come funziona il Reader di Google. Apriamo http://www.google.it/reader/. Se eravamo usciti dal nostro collegamento (in gergo slogati) ci chiederà nome e password (di nuovo!) e avremo qualcosa come

dove troviamo, per adesso, solo ciarpame. Ma ci interessa il pulsante Aggiungi un’iscrizione (freccia rossa). Controlliamo di avere visibili anche i segnalibri dei blog appena selezionati (freccia blu).

Facciamo click su su Aggiungi un’iscrizione e abbiamo


Trasciniamo l’icona di La fumettista curiosa nel campo come indicato dalla freccia rossa; click su aggiungi e ripetere per gli altri due blog.

A questo punto la finestra dovrebbe essere quasi come quella indicata in figura.

Controllate che sia attivo Tutti gli elementi (pallino rosso); io di solito seleziono le iscrizioni nuove (pallino blu) e modifico le impostazioni feed (pallino verde) dicendo di elencare prima il più vecchio (come indicato in figura).

Facendo click sul titolo del post (linea rosa) si apre una scheda con il contenuto del post, quello per cui abbiamo fatto tutta questa roba qua. Possiamo navigare o con la solita barra di scorrimento sulla destra o con i due pulsanti Elemento precedente e Elemento successivo (pallini rosa).

Quando un post viene scorso viene considerato letto e rimosso dall’elenco.

Possiamo però dirgli di tenerlo ancora selezionando Mantieni come da leggere (pallino rosso)

OK, possiamo usare una procedura più veloce per inserire i blog nella nostra lista RSS. Ecco come si fa. Utilizzaremo il blog dell’amico Popinga –questi milanesi hanno dei nomi che non ti dico 😉 Apriamo in una scheda l’URL http://keespopinga.blogspot.com, come indicato in figura

OK, è lui, selezioniamo l’URL, copiamolo (con Ctrl-C) e torniamo alla scheda del reader (pallino rosso).

Facciamo click su (pallino rosso) Aggiungi un’iscrizione e nel campo che si apre incolliamo l’URL (Ctrl-V).
Facendo click su Aggiungi il blog verrà (indovinate) aggiunto e comparirà nella lista Iscrizioni (pallino rosso)

E se volessimo cancellare qualche iscrizione che non ci piace più? –mi sembra di aver sentito OK, panico: non ci provate che non vi faccio più ‘mico, nèh 😦
Facendo click su Gestisci iscrizioni (pallino blu) si apre questa pagina dove, tra le altre cose più da specialisti, possiamo selezionare il bidone del blog da cancellare (pallino rosso). Quando abbiamo finito possiamo tornare al reader con Torna a Google Reader (pallino blu).


Facile vero? Per domande e osservazioni ci sono i commenti. E, prossimamente, faccio un post (sul Tamburo Riparato) con l’elenco del blog che seguo. Magari interessa. In alternativa un corso di Haskell o Lisp o APL.
O peggio, non c’è mai limite al peggio 8)

L’alternativa ortodossa a calc — bc

no! non sto parlando di questo

Credevate che il post su calc della scorsa settimana fosse l’ultimo della serie? Allora credevate male perché c’è bc che, a differenza di calc, viene installato automaticamente con Linux (e con Unix, naturalmente).
L’autore di bc è Mark Hopkins (almeno secondo questa pagina), il man di Ubuntu da invece Philip A. Nelson.

bc è un vero e proprio linguaggio di programmazione. Il manuale completo al solito è disponibile con

man bc

o online, All’indirizzo http://man.cx/bc dove potete trovarne un’altra versione in inglese, spagnolo, finlandese, ungherese, giapponese, coreano, polacco e turco –no l’italiano non c’è– diversa da quella installata su Ubuntu. Inoltre le versioni nelle varie lingue sono diverse (OK, non ne conosco nessuna di quelle elencate, ho semplicemente contato le opzioni in synopsis).

L’uso più elementare di bc è un pochino quirkoso

cioè bisogna passargli l’operazione da eseguire attraverso echo, usando la pipe. E ancora


bc liscio determina la precisione (le cifre dopo il separatore decimale) in base agli operandi che riceve; è possibile modificare questo comportamento settando la variabile scale. Notare che in questo caso dobbiamo racchiudere la stringa da echoare tra doppi apici.

È naturalmente possibile salvare il risultato in una variabile, così

o, seguendo la sintassi antica


che pare quella ancora preferita da qualcuno. A proposito: state seguendo il corso di BASH degli amici Bit3Lux e Lightuono, qui o qui vero?

Naturalmente si vede subito che questo modo d’uso è scomodo se si vogliono eseguire più calcoli in sequenza, eventualmente salvando i risultati in variabili. Ecco un esempio

Ma si può fare di meglio: con l’opzione -l (o l’equivalente lunga –mathlib) scale viene automaticamente impostato a 20 e sono disponibili le funzioni standard, come a – arcotangente dell’angolo, espresso in radianti.

Copiando da man.cx ecco la definizione di una funzione, mye, valore approssimato dell’esponenziale e suo esempio d’uso. È fatta per scopi puramente didattici in quanto la funzione e – esponenziale è predefinita quando si specifica l’opzione -l. Ecco il file test_e.bc

scale = 20
define mye(x) {
	auto a, b, c, i, s
	a = 1
	b = 1
	s = 1
	for (i = 1; 1 == 1; i++) {
		a = a*x
		b = b*i
		c = a/b
		if (c == 0) {
			return(s)
		}
		s = s+c
	}
}

/* calcolo l'esponenziale dei
   primi dieci interi
*/

for (i = 0; i &lt;= 10; i++) {
   mye(i)
}

quit

eseguendola otteniamo


E con questo credo di aver illustrato cosa si può fare con bc.
Storicamente –ma non in Linux– bc si appoggia su dc.
Già resta da parlare di dc, prossimamente, forse 8)

Scorciatoie per il terminale

Non so voi ma a me capita spesso di usare il Terminale. A parte il fatto della nostàlgia –mi sembra di tornare ggiovane— in certi casi è indispensabile. Per esempio quando sto pythonando è estremamente comodo, dopo aver salvato il file in fase di sviluppo in Geany, andare sul terminale e digitare qualcosa come

pyhton t1.py uno due "tre quattro" cinque

Naturalmente il passo successivo il comando potrebbe variare e allora, dopo averlo richiamato con Up (freccia su) ci può essere l’esigenza di correggerlo. E qui entrano in gioco le scorciatoie che fanno risparmiare il numero di tasti premuti e il consumo degli stessi e dei polpastrelli 8)

Sì perché il terminale, o meglio la shell, dispone di un vero e proprio editor, con millantamila combinazioni. Ecco quelle che conosco, non le uso tutte (anzi qualcuna deriva da una sessione di googlate ad hoc per questo post).

Fondamentali
Alt Gr-ì
~ questo di sicuro la sanno tutti, altrimenti uno sarebbe costretto a scrivere continuamente /home/juhan (o peggio se non aveste avuto la fantastica idea di chiamare juhan il vostro user)

Alt Gr-‘
` backtick, usato in comandi complessi, sarebbe un discorso lungo e poi si può sostituire con $(), anzi è consigliato

Cancellazione
Crtl-U
cancella tutti i caratteri a sinistra del cursore

Ctrl-K
cancella tutti i caratteri dal cursore alla fine della riga

Ctrl-W
cancella la parola prima del cursore

Spostamenti del cursore
Ctrl-Up, Ctrl-A, Home
inizio della riga

Ctrl-Dn, Ctrl-E, Fine
fine della riga

Shift-PgUp
pagina precedente del terminale

Shift-PgDn
pagina successiva del terminale

Shift-Home
inizio del terminale –limitato dal buffer dello stesso

Shift-Fine
fine del terminale, cioè al prompt

Crtl-B
cursore a sinistra di un carattere

Crtl-F
cursore a destra di un carattere

Alt-B
cursore a sinistra di una parola

Alt-F
cursore a destra di una parola? no! menu File

Altri
Ctrl-L
clear<invio>, pulisce la finestra del terminale

Ctrl-C
chiusura (kill) del processo in corso di esecuzione

Ctrl-D
exit<invio>, termina il processo in corso nel terminale, se non ce n’è nessuno chiude il terminale (un processo in corso c’è, è sh)

Ctrl-R
richiama il comando nell’history; es.: per rifare un ping Ctrl-R e inizio a scrivere fino a quando mi propone quello giusto, ovviamente il cmd dev’essere nell’history

Ctrl-S
blocca il terminale, si sblocca con Ctrl-Q

Ctrl-T
scambia il carattere sotto il cursore con il precedente; il cursore avanza di uno

Crtl-{J, M, O}
<invio>

Alt-P
come Crtl-R ma senza msg e solo l’ultimo

Ctrl-Y
incolla il testo tagliato con Ctrl-U e Ctrl-K

Tab
completa il nome del file|directory, fin dove ci riesce

Shift-Ctrl-C
copia il testo evidenziato

Shift-Ctrl-V
pastaincolla il testo nel copiato con Shift-Ctrl-C
Da notare che il buffer di Ctrl-{U, K, Y} è diverso da quello di Ctrl-Shift-C. Quest’ultimo è quello di Ctrl-C nei programmi normali come browser, editor et similia.

E inoltre
^testo^NUOVO^ nell’ultimo comando (nell’history) sostituisce testo con NUOVO; a dire il vero non mi sembra granchè utile ma non si sa mai 😉

E per Windows?
Intanto lì il terminale si chiama Prompt dei comandi.

Ho provato con XP e la bella notizia è che potete tranquillamente dimenticare tutte queste scorciatoie: non ci sono 😀

Confessione
Tutto questo è nato dopo aver letto il post dell’amico Bit3Lux, qui.

Inizialmente pensavo di mettere solo un commento sul suo post poi ho cambiato idea e mi sento un pochino in colpa, come se mi fossi appropriato di una cosa non mia. Inoltre anche il trucchetto di ^^^ viene da lui, qui e sta ancora contnuando: sarebbe cosa buona e giusta seguire il suo blog.

Dite, se volete, che vi mando io.