Transparency International.

Sună mişto, îţi vine în cap lenjeria cineştie cărei gagici care face furori în Playboy.

Dar nu e vorba de asta ci de o organizaţie şmeceră care măsoară diferite lucruri. Acum cică au măsurat Corupţia.

Concluzia lor e că România are 3,8 puncte, la fel ca în anul precedent.

Mai întâi ni se spune că suntem pe ultimul loc din Europa pentru că avem 3,8 puncte.

Apoi că de fapt avem acelaşi punctaj cu Grecia şi Bulgaria, da’ tot suntem pe ultimul loc deoarece Bulgaria e în creştere şi că ne-a ajuns datorită unei creşteri de 0,2 punte,  iar   Grecia în scădere cu 0,9 puncte.

Deci la egalitate cu cele două ţări, da’ tot noi suntem ultimii. Că aşa vrea Victor Alistar.

Privind atent la tv ca să văd despre ce e vorba, aflu de la o domnişoară drăguţă că de fapt ei au măsurat percepţia asupra corupţiei şi nu situaţia adevărată. „Ar fi prea greu”, conchide respectiva.

Apoi l-am văzut pe Victor Alistar făcând un fel de acrobaţii logice.

Zicea omul că acum suntem în cea mai  proastă poziţie de când ştiu muşchiu’ lui.

E drept că avem cel mai bun punctaj pe care l-am avut de când ştie el dar cu toate aste e cel mai rău, pentru că n-a mai crescut. A rămas acolo înţepenit chiar dacă trecem printr-o criză cum n-a mai fost în perioada de când muşchiul lui Alistar mănâncă degeaba banii lu’ Transparency Internaţional.

Zicea omul (?) că înainte (în perioada 2004-2008) era mai bine că aveam un plan deci punctajul ne creştea acum nu mai avem, deci stagnăm.

Foarte interesant. Ca din întâmplare e perioada când era Tăriceanu Premier. De exemplu poveştile cu caltaboşi şi pălincă erau percepute ca filme SF.

Eu stau şi tot aştept să-l văd pe Victoraş răspunzând acuzaţiilor ANI.

http://stiri.juridice.ro/40871/ani-il-ataca-pe-victor-alistar.html

http://www.hotnews.ro/stiri-esential-5841506-ani-acuza-victor-alistar-fals-legatura-declaratia-avere-transparency-international-ani-ataca-alistar-dupa-transparency-sesizat-problemele-integritate-nivelul-conducerii-ani.htm

De asemenea, i-aş aminti zglobiului personaj, că în perioada în care magistraţii făceau greva aceea ilegală el era unul din personajele extrem de vocale şi susţinea că judecătorii săracii au venituri atât de mici încât nu îşi pot cumpăra o casă şi o maşină decente. Nu îl interesa că aceiaşi colegi asi lui îngroapă dosare de corupţie precum groparii cadavrele celor morţi la vreme de ciumă.

Ba şi mai mult, nu văd nici o referire a respectivei organizaţii vreo referire la sondajele oferite pe piaţă cu generozitate de diferite organizaţii de sondare a opiniei publice, sondaje care seamănă între ele precum copii a două copluri, unul formatdintr-un pigmeu, cu o suedeză şi altul, dintr-o negresă cu  un chinez.

Poate ar fi bine să se aplece puţin şi asupra mecanismelor care au făcut ca un urma unor decizii ale PSD-ului să intre în grevă diferite organizaţii sindicale, sau de ce nu să măsoare transparenţa afacerilor domnului Patriciu şi legăturilor unor indivizi precum Sorin Roşca-Stănescu cu acestea.

Parcă tot era mai mişto dacă Transparency International era un nume de lenjerie damă …

(rieccomi dopo mesi di nulla.. a casa malato e mi do da fare )

Quest’articolo fa parte di una serie di articoli sui tool GNU (e quindi Linux) per manipolare testi.

L’esempio che si era visto in quell’articolo, con awk, è il seguente:
cat sottotitoli.srt | awk 'NR%2==1' > sottotitoli-dispari.srt

il cui scopo era rimuovere tutte le righe pari… fra poco sarà tutto più chiaro!

awk è un altro software per la manipolazione dei testi, secondo il mio parere si adatta meglio a lavorare su testi con una struttura rigida, ad esempio divisi per colonne (tipo tabella), ogni elemento di questa “tabella” è chiamato ‘campo’. Per elaborare il risultato di molti comandi Linux questo strumento è comodissimo

Per comprendere cosa intendo ecco un piccolo esempio che potete replicare facilmente aprendo un terminale:

$ cal
luglio 2009
lu ma me gi ve sa do
1  2  3  4  5
6  7  8  9 10 11 12
13 14 15 16 17 18 19
20 21 22 23 24 25 26
27 28 29 30 31

Il comando cal senza parametri stampa il calendario del mese corrente (Luglio 2009 in questo caso).
Vediamo cosa succede se diamo in pasto il risultato del comando cal ad awk.

$ cal | awk '{ print $3; }'
me
3
8
15
22
29

Quel che ho fatto qui è semplicissimo: eseguo il comando cal, quindi il risultato lo butto in pasto al comando awk (si ottiene grazie al pipe, ovvero la linea verticale ‘|’).
il “programma” che viene fatto girare da awk è semplicemente: { print $3; }. Ovvero: stampa la terza colonna (Mercoledì).

In realtà awk è un vero linguaggio di programmazione e quindi più potente, per certi versi, di sed: contiene funzioni richiamabili e permette di effettuare operazioni matematiche con i dati in elaborazione!

In questo breve tutorial impareremo il significato del comando visto qui sopra e cercherò di insegnarvi ad utilizzare awk in modo più approfondito: applicando pattern “per riga” ed effettuando operazioni su stringhe e numeri!

Prerequisiti

Per poter comprendere appieno questo tutorial è necessario che abbiate compreso e fatto un po’ di pratica con le regular expression (o regex) di cui vi ho parlato qui.
Non sono richieste particolari esperienze di programmazione ma aiutano parecchio.

il software si chiama gawk

Si.. non awk ma gawk! awk è il linguaggio, gawk è l’implementazione GNU del linguaggio!
Cioè { print $3; } è un comando nel linguaggio awk che dice di stampare la terza colonna, mentre il software che esegue codice awk si chiama gawk in sistemi GNU/* come Linux.

lanciare gawk

Il manuale di gawk è molto ben scritto, anche se in inglese, e io ho imparato ad utilizzare awk semplicemente leggendo questo manuale e provando di volta in volta.

man gawk

le opzioni principali per lanciare gawk (per le altre guardate il manuale):

• -F fs o --field-separator fs « l’opzione del comando awk vi permette di specificare quali sono i caratteri che volete siano considerati come separatori di campo (se omessa verranno usati gli spazi e le tabulazioni) e indovinate un po? si può, volendo, indicare quali sono i separatori di campo con una espressione regolare (regex)
• -f script-file o --file script-file « specifica un file di script awk invece che indicarlo dalla linea di comando tra apici

awk si lancia con questa sintassi (notate gli apici prima e dopo i comandi):

awk '<programma>' nome-file-su-cui-lavorare

oppure

cat nome-file-su-cui-lavorare | awk '<programma>'

oppure

awk -f programma-awk.awk nome-file-su-cui-lavorare

Se ad esempio vogliamo chiedere ad awk di usare la virgola come carattere di separazione dei campi (Field Separator, FS) possiamo invocare awk così:

awk -F, '<programma>'

esiste un caso particolare in cui questo non funziona: se cercate di impostare il SOLO carattere tabulazione (che si indica con ‘\t’) come FS non riuscirete a scriverlo in questo modo… dovrete usare questa scrittura:

awk -F "\t" '<programma>'

che poteva comunque essere utilizzata anche per la virgola o per passare una regex ad awk

un altro modo per fare la stessa cosa è impostare la variabile FS all’interno del programma così:

awk 'BEGIN {FS = ","} { ... }'

Questo metodo è più comodo se volete scrivere uno script invece che lanciare da linea di comando…

Inoltre con l’esempio vediamo 2 cose nuove: BEGIN e l’utilizzo di variabili (cioè contenitori di dati che possono cambiare durante l’esecuzione del codice).

Per chiarificare immaginate di avere questa riga di testo: “tizio,caio,sempronio” e di voler effettuare una separazione utilizzando la virgola anziché gli spazi… Otterreste quindi i campi “tizio”, “caio” e “sempronio”.

$ echo 'tizio,caio,sempronio' | gawk -F, '{ print "1=" $1 " - 2=" $2 " - 3=" $3; }'
1=tizio – 2=caio – 3=sempronio

Con quest’esempio abbiamo anche visto come concatenare delle stringhe (del testo): quello che vuoi volete scrivere potete metterlo tra virgolette doppie… per concatenare più stringhe (metterle una dopo l’altra) è sufficiente elencarle separate da spazio!

Struttura di base di un programma awk

Il testo è suddiviso in record e campi: possiamo pensare ai record come le “righe” di un file di testo e ai “campi” come le sue “colonne”.
Come abbiamo visto prima nell’esempio del calendario i campi sono separati automaticamente dove ci sono spazi, i record sono separati con degli “a capo”. Entrambe questi limitatori si possono cambiare modificando le variabil FS (Field separator, separatore di campo) e RS (Record Separator, separatore di record).

gawk legge un record alla volta, lo suddivide in campi e vi permette di lavorarci.

La struttura di un programma awk è la seguente:

pattern1 { azioni }
pattern2 { azioni }
function nome(parametri) { azioni }


I pattern selezionano dei record su cui verranno svolte delle azioni.
Le funzioni sono comode quando dobbiamo ripetere le stesse operazioni più volte nelle nostre azioni.

Ora vedremo come si utilizzano le variabili in un programma awk, quindi cosa sono i pattern e come sfruttarli…
Il tutto verrà supportato da esempi!

Variabili

Come in qualunque linguaggio di programmazione una variabile è un etichetta: un contenitore!
Le variabili gawk possono contenere numeri o testo e awk si occupa automaticamente di convertire dall’uno all’altro all’occorrenza.

Dichiarare una variabile è semplice:

numero = 12;
testoNumero = "4";
saluto = "ciao";
nome = "daniele";
concatenamento = testo " " nome; /* ciao daniele */
risultato = numero / testoNumero; /* 3 */

Le variabili, una volta che assumono un valore, sono utilizzabili ovunque nel programma awk: sono “globali”.

Ci sono alcune variabili “speciali” già definite da awk, ed alcune le abbiamo già usate:

• $1: primo campo del record
• $2: secondo campo del record
• $0: l’intero record
• NF: (Number of Fields) numero di campi ($1, $2, …)
• FS: (Field Separator) separatore di campo, può essere modificato durante l’esecuzione e cambia i valori delle variabili $1, $2, $3, …
• NR: (Number of Records) numero di record processati (per semplicità pensatelo come il numero di riga per ora)
• FNR: Numero del record corrente nel file (questo è effettivamente il numero di riga/record)
• RS: (Record Separator) carattere separatore tra record (predefinito è l’a-capo)

Le trovate tutte nel manuale di gawk.

Vediamo alcuni esempi:

conta il numero di righe di un file di testo. (stesso risultato del comando wc -l di Linux):

gawk '{numeroRighe = numeroRighe +1;} END { print numeroRighe; }'

inserisce i numeri di riga di un file (1. prima riga, 2. seconda riga, ecc…):

gawk '{ print FNR ". " $0;}'

Supponente poi di avere una file con una lista “nome: numero”:

primo salto: 170
secondo salto: 175
terzo salto: 180

si può facilmente calcolare e stampare una media con awk:

BEGIN {
FS = ":"; /* imposto come separatore i 2 punti */
}
{
conteggioRighe = conteggioRighe +1; /* questo può anche essere scritto conteggioRighe++; */
totale = totale + $2; /* il secondo campo è quello dopo i due punti */
print $0; /* stampo tutta la riga invariata */
}
END {
print "-----------"; /* un separatore */
print "media: " totale/conteggioRighe;
}

vettori

tra le variabili si possono anche definire vettori!

mioArray[indice] = valore;
print mioArray[indice];

l’indice e il valore possono essere qualunque variabile: un numero o una stringa.
Quindi questo è perfettamente legale:

mioArray["febbre"] = 38;
mioArray["vomito"] = "si purtroppo";
mioArray[1] = "tutto chiaro?";

pattern di riga

Vi siete chiesti il perché delle parentesi graffe? O perché BEGIN è stato scritto di fronte ad esse nell’ultimo esempio? Qui viene spiegato il perché.

Il linguaggio awk va definito in questo modo:

BEGIN { comandi da eseguire all'inizio }
PATTERN1 { comandi da eseguire per le righe che corrispondono al pattern 1 }
PATTERN2 { comandi da eseguire per le righe che corrispondono al pattern 2 }
END { comandi da eseguire alla fine}

Si ma cos’è un pattern?

Il pattern è in sostanza qualcosa che dice ad awk su quali parti del testo lavorare!
Il pattern può essere un espressione regolare, una espressione di una qualche relazione o una combinazione di queste cose!

Ad ogni pattern sono associate una o più azioni che vengono racchiuse tra parentesi graffe ‘{ }’. Se l’azione viene omessa questa corrisponde all’azione ‘{print}’ che semplicemente stampa l’intero pattern senza azioni su di esso!

Quindi un pattern può essere:

• una regex: /regex/ { fai qualcosa per le righe che soddisfano la regular expression }
• un confronto NR%2 == 1 { fai qualcosa con i numeri di riga dispari }: NR è la variabile “numero di riga”, NR%2 è il modulo 2, cioè il resto della divisione per 2.

più pattern possono essere messi in OR/AND/NOT. Cioè ad esempio si può dire che si vuole effettuare un particolare comando per le righe pari che cominciano con dei numeri mettendo in AND un confronto (righe pari) e una regolar expression (cominciano con un numero):

NR%2==0 && /^[0-9].*/ { comandi da applicare a righe pari che cominciano con un numero }

! /topo/ { fai qualcosa con le righe che NON contengono la parola "topo" }

Ci sono due pattern speciali: BEGIN e END. Questi pattern ignorano i dati d’ingresso (il testo).
Con BEGIN la parte “azione” viene eseguita tutta PRIMA di leggere un qualsiasi input.
Con END la parte “azione” viene eseguita DOPO aver finito di processare l’intero testo in input.

Nell’esempio con il file dei sottotitoli abbiamo utilizzato solamente il pattern indicando che volevamo awk lavorasse solo sulle righe dispari.

le funzioni

gawk vi mette a disposizione diverse funzioni già pronte, qui ve ne elenco qualcuna ma vi rimando al manuale di gawk per una lista completa.

• print(stringa): l’abbiamo già vista, stampa a video delle stringhe
• lenght(stringa): restituisce la lunghezza di una stringa
• tolower(stringa): restituisce la stringa in caratteri minuscoli
• toupper(stringa): restituisce la stringa in caratteri maiuscoli
• int(numero): restituisce l’intero del numero (toglie i decimali)
• cos(numero): calcola il coseno di un numero
• sqrt(numero): calcola la radice quadrata di un numero
• system(stringa di comando): esegue un comando Linux

supponiamo di voler rendere più evidenti tutte le righe di un testo con la scritta “important” all’interno.
Solo le righe che contentono la parola “important” sono state convertite in TUTTO MAIUSCOLE, le altre sono state stampate così come sono (notare il ! di NOT davanti alla seconda regex):

awk '/important/ { print toupper($0);} !/important/ { print $0; }'

nuove funzioni possono essere definite anche da voi seguendo la sintassi, vediamo una modifica del comando precedente:

awk '/important/ { print maiuscolo($0);} !/important/ { print $0; } function maiuscolo(stringa) { return toupper(stringa); }'

Cicli e condizionali

Come tutti i linguaggi di programmazione anche awk mette a disposizione dei comandi per gestire il flusso di operazioni!

• if (condizione) { azione } else { altra azione }
• while (condizione) { azione da ripetere }
• for (inizializzazione; condizione; avanzamento) { azione da ripetere }
• for (indice in array) { azioni con gli elementi di un array }

Per chi ha famigliarità con un linguaggio di programmazione non serve aggiungere altro a questa lista, per gli altri non sarà così ovvia…
Mi limiterò a fare qualche esempio per lasciar “intuire” come utilizzarli ma non è presunzione di questo tutorial insegnare a programmare a chi non lo ha mai fatto:

Riprendiamo l’esempio con i salti di prima (notate in fondo il comando if):


BEGIN {
FS = ":"; /* imposto come separatore i 2 punti */
}
{
conteggioRighe = conteggioRighe +1; /* questo può anche essere scritto conteggioRighe++; */
totale = totale + $2; /* il secondo campo è quello dopo i due punti */
print $0; /* stampo tutta la riga invariata */
}
END {
print "-----------"; /* un separatore */
calcoloMedia = totale/conteggioRighe;
if (calcoloMedia < 120) { print "media: CHE SCHIAPPA!!!"; }
else { print "media: " totale/conteggioRighe; }
}

Stavolta se la media di altezza per il salto in alto è inferiore a 120 verrà stampato CHE SCHIAPPA!!!

Come altro esempio immaginate di avere questo file:

salto in alto: 190
salto in alto: 174
salto in lungo: 5.3
100 metri: 9.5
salto in lungo: 4.8
salto in alto: 193
100 metri: 10.2

Ora vedremo, come ultimo esempio, come calcolare le medie di tutte le varie discipline in un colpo solo:


BEGIN {
FS = ":"; /* imposto come separatore i 2 punti */
}
{
conteggioRighe[$1]++;
totale[$1] = totale[$1] + $2; /* l'indice è il nome della disciplina ($1), il valore il risultato ($2) */
print $0; /* stampo tutta la riga invariata */
}
END {
print "-----------"; /* un separatore */
print "MEDIE:";
/* per ogni indice dell'array stampa una media */
for (indice in totale) { print indice ": " totale[indice]/conteggioRighe[indice]; }
}

ecco quello che si ottiene eseguendo questo programmino:

$ awk -f programmino.awk attletica.txt
salto in alto: 190
salto in alto: 174
salto in lungo: 5.3
100 metri: 9.5
salto in lungo: 4.8
salto in alto: 193
100 metri: 10.2
———–
MEDIE:
salto in alto: 185.667
100 metri: 9.85
salto in lungo: 5.05

sono disponibile per domande
se vi sembra ci siano parti poco chiare fatemelo notare e farò del mio meglio per renderle più chiare

ps: scusate ho fatto casini con il copia incolla.. ora dovrebbe essere a posto

Il comando ’sed’ permette di manipolare, filtrare, trasformare testi o flussi di testi; con flussi di testi intendo che può lavorare anche su dati che gli arrivano un po’ per volta. In modo predefinito elabora i file di testo riga per riga.

sed è tipico degli ambienti GNU/Linux e Unix in generale. Prerequisito di questa guida è la conoscienza almeno basilare delle espressioni regolari, se ancora non lo avete letto o non le conoscete leggetevi prima questo articolo. Un esempio semplice di utilizzo di sed lo trovate invece qui.

Questa introduzione è abbastanza completa ma non tratta ancora tutto perché le mie conoscenze di sed non sono ancora a livelli “guru” .

Aggiornerò la guida quando avrò più conoscenze di sed! Potete comunque trovare già moltissime spiegazioni ed esempi adesso.

|| Versione guida: 1.1 ||

############

** in preparazione: script con sed, molto più potenti del semplice utilizzo a linea di comando **

10/12/2007 – v. 1.1

• aggiunto il comando “transliterate”, per sostituire certi caratteri con altri, ai comandi spiegati ( y/prima/dopo/ )

############

le opzioni principali (per le altre guardate il manuale):

• -n o --quiet o --silent « inibisce la stampa di ciò che viene fatto (vedere gli esempi)
• -e script o --expression[=script « specifica uno script tra gli apici (opzione già vista) direttamente sulla linea di comando. Più comandi vanno separati da un punto e virgola ';'
• -i[SUFFISSO] o --in-place[=SUFFISSO] « richiede di modificare direttamente il file, se viene specificato un suffisso viene creato un file di backup. consiglio di porre attenzione quando utilizzate questa opzione
  es.
  sed -i # modifica senza creare un backup
  sed --in-place # come sopra
  sed -i.bak # creerà una copia del file aggiungendo alla fine .bak
  sed --in-place=.bak # stesso di sopra
• -f script-file o --file=script-file « specifica un file di script

queste sono le opzioni del comando, ben poca cosa! Quel che più serve sono i comandi degli script! Io ve ne mostrerò solo alcuni, i pochi già utilizzati e poco altro, come al solito per tutti i comandi consultate il manuale (man sed)

In genere i comandi si distinguono in due gruppi: quelli che selezionano delle righe su cui lavorare e quelli che eseguono qualche operazione. Sed vuole che prima si selezionino le righe su cui lavorare e quindi gli si dica come lavorare su di esse! Se non viene specificato su quali righe lavorare sed opererà su tutte.

• p « stampa ciò che stà elaborando, per comprendere il comando provate questi:
  sed -e '' vostro-file.txt # non fa nulla (ma stampa tutto il file)
  sed -n -e '' vostro-file.txt # non fa nulla e non stampa nulla (opzione -n)
  sed -e 'p' vostro-file.txt # stampa il file (ogni riga due volte come vedrete)
  sed -n -e 'p' vostro-file.txt # stampa il file una sola volta
  ora dovreste comprendere il significato dell’opzione -n, il modo migliore per capirlo è provare ad eseguire i comandi con e senza quest’opzione
• p « stampa la riga (print)
• /regex/p « elabora e stampa le sole righe corrispondenti alla regex
• d « elimina la riga (usarlo senza l’opzione -n) – (delete)
• /regex/d « elimina le righe che corrispondono alla regex
• s/regex/sostituto/ « come già visto sostituisce il testo individuato dalla regex con quello che gli viene indicato; lo fà però solo la prima volta che lo incontra per ogni riga
  dove ho scritto “sostituto” potete fare in modo che venga inserita l’espressione trovata tramite la regex utilizzando la e-commerciale (&) (substitute)
• g « “mantiene” la riga corrente, scusate se non spiego meglio ma non ho ancora usato abbastanza questo comando da capirlo a fondo
• s/regex/sostituto/g « come sopra ma non si ferma al primo testo individuato
• y/prima/dopo/ « questo sostituisce i caratteri “prima” con i corrispondenti “dopo”
  es.:
  y/abcdefghijklmnopqrstuvwxyz/ABCDEFGHIJKLMNOPQRSTUVWXYZ/ « trasforma tutti i caratteri minuscoli in caratteri maiuscoli. Il primo carattere nella prima parte (a) diventa il primo nella seconda (A)
• 4 « corrisponde alla quarta riga
• 3p « stampa la terza riga (usatelo con l’opzione -n altrimenti la terza riga verrà stampata due volte e il resto una sola volta)
• inizio,fine « corrisponde a tutte le righe da ‘inizio’ a ‘fine’ (comprese)
  es.
  1,5d « le prime cinque righe vengono eliminate
  4,12p « le righe dalla 4 alla 12 vengono stampate
• prima~passo « corrisponde a tutte le righe a partire dalla riga ‘prima’ e da quella ogni ‘passo’ righe, và usato assieme ad un comando
  es.
  1~2p « stampa tutte le righe dispari (parte dalla prima e poi ogni 2). Stesso risultato di quello che abbiamo fatto con awk
  2~2p « stampa tutte le righe pari (parte dalla seconda e poi ogni 2)
  5~3p « stampa le righe: “5, 8, 11, 14, …” (parte dalla quinta poi ogni 3)
  6~10d « elimina le righe: “6, 16, 26, …” (parte dalla sesta poi ogni 10)
• /regex-inizio/,/regex-fine/p « stampa tutte le righe comprese tra la prima che soddisfa la ‘regex-inizio’ e una che soddisfa la ‘regex-fine’
• 1~2s/Linux/GNU\/&/g « sostituisce la parola ‘Linux’ con ‘GNU/Linux’ solo nelle righe dispari (il primo comando seleziona le righe su cui agire, se ne può usare qualunque altro per questo scopo; compreso ‘/regex-inizio/,/regex-fine/’! Il secondo comando agisce su queste righe decidendo il da farsi…)
• s:regex:sostituto:g « capita a volte di avere tanti caratteri ‘/’ da sostituire, digitare tutte le volte ‘\/‘ può essere frustrante! Il comando ‘s//‘ si può modificare per accettare altri caratteri come limitatori, in questo caso abbiamo scelto i due punti.
  es.
  s:/home/daniele:/home/andrea:g « questo comando sostituisce ‘/home/daniele’ con ‘/home/andrea’ in un file di testo

NOTA: ricordatevi che se usate dei caratteri giolli (*,+) per indicare una qualunque ripetizione di qualche carattere la regex cercherà la sequenza più lunga che riesce a trovare!! Per capire cosa questo comporta facciamo un esempio suppongendo di voler rimuovere i tag da un file html:

prendiamo questa sequenza:

Sono <b>davvero</b> soddisfatto di <i>Linux</i>!!!

verrebbe naturale usare quest’espressione regolare per rimuovere i tag:

s/<.*>//g « che significa: sostituisci con ‘nulla’ le sequenze che cominciano con ‘<’, finiscono con ‘>’ e al loro interno hanno una sequenza di qualunque carattere….

Il risultato di questa espressione è il seguente:

Sono !!!

Ha tolto tutto quello che stà tra il primo ”! Evidentemente non è ciò che si voleva… per ovviare si utilizza una regex come questa:

s/<[^>]*>//g « che significa: sostituisci con ‘nulla’ le sequenze che cominciano con ‘<’, finiscono con ‘>’ e al loro interno hanno una sequenza di qualunque carattere che non sia un ‘>’…

Il risultato è:

Sono davvero soddisfatto di Linux!!!

Le potenzialità usando dei file di script sono anche maggiori! Vi lascio alcuni link di approfondimento ma sono sicuro che potete trovarne altri nel web…

Gentoo Wiki – Sed by examples

Esempi pratici sulla pagina ufficiale di sed

Tutto chiaro? Esercitatevi un po’ e sarà sempre più chiaro…