Dott. Giovanni Nigita
Panoramica !
Introduzione
!
Gli strumenti in Ruby
!
Convenzioni e programmazione ad oggetti
!
Tipi di dati
!
Strutture di controllo
!
Ereditarietà ?!?
!
Gestione file e directory
!
Espressioni regolari
!
Altre cose…
!
Pacchetti di Ruby
!
Il pacchetto “HPRICOT”
Panoramica !
Introduzione
!
Gli strumenti in Ruby
!
Convenzioni e programmazione ad oggetti
!
Tipi di dati
!
Strutture di controllo
!
Ereditarietà ?!?
!
Gestione file e directory
!
Espressioni regolari
!
Altre cose…
!
Pacchetti di Ruby
!
Il pacchetto “HPRICOT”
Introduzione Introduzione – La storia (I) •
Il linguaggio di programmazione programmazione Ruby è stato progettato nel 1993 dal giapponese
•
Ma inizialmente non ebbe molto successo!
Introduzione – La storia (II) •
Per più di un decennio non prese mai il decollo
•
Inizialmente la documentazione era esclusivamente in giapponese!!!
Introduzione – La storia (III) •
L’anno di svolta fu il 2006!
•
Anno in cui si affermarono i framework
http://rubyonrails.org/
.
Introduzione – La storia (IV) •
Adesso abbiamo veramente tanta documentazione, sia in inglese http://www.ruby-lang.org/en/
•
che in italiano! http://www.ruby-lang.org/it/
Introduzione – Alcune caratteristiche (I) •
•
Ruby è un linguaggio: •
open source
•
general purpose
•
interpretato
•
orientato agli oggetti
Possiamo definirlo come un linguaggio che ha acquisito tanto da parte di altri linguaggi come: Smalltalk, Perl, Python, C, C++, PHP, Phyton …
http://www.ruby-lang.org/en/documentation/ruby-from-other-languages/ •
Infatti uno dei primi slogan era il seguente: (Smalltalk + Perl) / 2
Introduzione – Alcune caratteristiche (II) •
Per cui avendo preso qualcosa da altri linguaggi di certo molti aspetti sintattici ritorneranno familiari.
•
Per cui dovrebbe essere relativamente semplice la comprensione di tale linguaggio!
Gli strumenti in Ruby – Interprete di Ruby (I) •
Quello di cui abbiamo bisogno è di un editor di teso e di un interprete.
•
Per vedere le varie opzioni dell’interprete lanciamo dalla shell il comando - -help
ruby --help
Gli strumenti in Ruby – Interprete di Ruby (II) •
-c: avviene un controllo della sintassi del codice, e se tutto corretto ritorna “Syntax OK ”. In questo caso il codice non viene eseguito.
•
-d, -debug: se si vuole effettuare un debug
•
-e ‘command’: avviene l’esecuzione del comando passato come argomento
•
-v, --verbose: vengono mostrate in output delle informazioni addizionali quali la versione dell’interprete, warning in fase di compilazione,
•
!
Gli strumenti in Ruby – Interactive Ruby •
Oltre all’interprete troviamo pure una shell interattiva!
•
Permette di sperimentare in real time le potenzialità di questo linguaggio ed è molto utile in fasi di sperimentazione.
•
Tra le funzionalità di questa shell abbiamo la “ Tab Completation”!
•
Per sfruttare questo utile strumento, basta eseguire da terminare il comando “irb”
•
In particolare con il comando “ irb -- help”, è possibile avere una lista di opzioni che si possono affiancare al comando irb.
Gli strumenti in Ruby – RDoc and Ri (I) •
) si Tramite lo strumento RDoc ( può avere la documentazione completa completa estratta dai file sorgenti
•
Tale documentazione viene fornita sia in formato html sia formattata per l’utility “ri”, quest’ultimo è un tool che permette di visualizzare di visualizzare la documetazione da linea di comando
•
Potete scaricare l’ultima versione andando nel seguente link: http://rdoc.rubyforge.org/
Gli strumenti in Ruby – RDoc and Ri (II) •
Esempio, eseguendo dal terminale il comando:
ri String.chomp •
otterremo otterremo la documentazione relativa alla funzione chomp:
Gli strumenti in Ruby – eRuby (I) •
Tramite lo strumento (embedded Ruby) è possibile inserire codice Ruby all’interno di pagine HTML. Per cui, come nel caso di PHP, si possono creare delle pagine dinamiche.
•
Il codice Ruby viene incorporato all’interno dei delimitatori <% e %>
•
Ovviamente, i blocchi di codici inseriti vengono valutati sul posto e vengono sostituiti dal risultato della loro valutazione.
Gli strumenti in Ruby – eRuby (II) •
Una linea di Ruby: <% ruby code %>
•
Linee multiple:
<% 2.times do %> - Hello guys
<% end %>
Output: • Hello guys • Hello guys
Gli strumenti in Ruby – eRuby (III) •
Se si incontra la linea di codice: <%= expression %>
•
allora viene valutata l’espressione e ne restituisce il valore, inoltre ogni linea di questo tipo <# ! %>
•
rappresenta un commento.
Gli strumenti in Ruby – eRuby (IV) •
Abbiamo diverse implementazioni di eRuby : • eruby: è un implementazione di eRuby scritta in C • erb: è una implementazione di eRuby scritto puramente Ruby ed include le sue librerie standard • erubis: è una implementazione di eRuby in Ruby e in Java
•
Queste implementazioni rappresenta una buona alternativi agli altri linguaggi come PHP, Perl, ASP…
Gli strumenti in Ruby – Le librerie di base •
In ambiente Unix le librerie di base si troveranno nel seguente percorso:
/usr/lib/ruby •
mentre in ambiente Windows risiedono nella directory
c:\ruby\lib\ruby\ •
In entrambi i percorsi possiamo trovare le seguenti cartelle: •
1.8: (attualmente siamo alla versione 1.9, anche se vi ritroverete sicuramente pre-installata la 1.8) contiene i moduli e le estensioni standard
•
gems: contiene le librerie e le applicazioni installate con l’utility RubyGems
•
site_ruby: contiene i moduli e le estensioni aggiunte dal programmatore e che non sono incluse nella distribuzione di base
Gli strumenti in Ruby – RubyGems •
RubyGems è un framework che gestisce le applicazioni e le librerie sotto forma di pacchetti chiamati “ gems”.
•
Esso permette di cercare, installare, disinstallare e aggiornare le librerie.
•
Nel link sottostante si possono trovare le librerie dalla allo http://rubygems.org/
Convenzioni e programmazione OO – I nomi(I) •
I nomi in Ruby fanno riferimento a costanti, variabili, metodi, classsi e moduli, nonostante alcune parole sono riservate:
•
Tramite il primo carattere del nome, Ruby distingue il modo in cui viene utilizzato.
•
Un nome può essere una lettera minuscola , maiuscola o un underscore, seguito da qualsiasi altro carattere che sia una combinazione dei simboli appartenenti alle tre precedenti categorie.
Convenzioni e programmazione OO – I nomi(II) •
Le variabili non sono tipizzate, per cui possono contenere qualsiasi tipo di dato.
•
Dal nome della variabile viene dedotto il suo scopo, ossia se essa stessa sia locale, globale, istanza , ecc…: • • • • •
il nome di variabili locali devono essere dichiarate con un lettera minuscola o con un carattere underscore le variabili globali iniziano con il simbolo $ le variabili di istanza con il simbolo @ quelle di classe con due simboli @ se si vuole specificare una costante il nome deve iniziare con una lettera maiuscola
Convenzioni e programmazione OO – I nomi(III) •
Il nome di classe e di modulo sono costanti, e seguono la convenzione utilizzata per le variabili costanti.
•
Il nome del metodo inizia con un lettera minuscola seguita da altri caratteri. Come caratteri speciali possono contenere, come suffisso, solo il simbolo “!” e quello “?”.
Convenzioni e programmazione OO – I commenti •
I commenti all’interno di un codice vengono inseriti attraverso il carattere “#”. Tutto quello che seguirà tale carattere non verrà considerato.
•
Inoltre, è possibile fare un commento multiriga , e questo è possibile farlo mettendo il testo che si vuole commentare tra i tag =begin e =end:
Convenzioni e programmazione OO – Qualche nozione non guasta mai! (I) In Ruby ogni cosa è un oggetto!!!
Convenzioni e programmazione OO – Qualche nozione non guasta mai! (II) •
Questo paradigma di programmazione prevede di raggruppare in un porzione circoscritta ( classe) del codice sorgente la dichiarazione delle strutture dati e delle procedure che operano su di esse.
•
Nella programmazione orientata agli oggetti (OOP, Object Oriented rogramming ) un oggetto può essere visto come un contenitore di dati dotato di attributi (dati) dotato di una serie di metodi (procedure) secondo quanto dichiarato dalle rispettive classi.
•
Un linguaggio è definito ad oggetti quando permette di implementare tre meccanismi chiamati incapsulamento, ereditarietà e polimorfismo.
Convenzioni e programmazione OO – Qualche nozione non guasta mai! (III) •
L’oggetto è una istanza di una classe!
•
Esso è dotato di tutti gli attributi e i metodi definiti dalla classe.
•
Dal lato del calcolatore, ogni oggetto è rappresentato da un certa locazione di memoria, nella quale si trovano memorizzati gli attributi, il valore di questi determinano lo stato interno di una dell’oggetto.
•
Istanziare un oggetto vuol dire allocare memoria ed
inizializzarla in base alle specifiche della classe definisce.
Convenzioni e programmazione OO – Gli oggetti in Ruby (I) •
Riportiamo un semplice esempio…
Convenzioni e programmazione programmazione OO – Gli oggetti in Ruby (II) • Ancora un altro esempio…
Convenzioni e programmazione programmazione OO – Gli oggetti in Ruby (III) Gestione degli attributi
•
Ruby fornisce delle scorciatoie per la gestione degli attributi: , e .
•
Il valore true che segue il nome dell’attributo indica che la variabile è pure scrivibile, in modo analogo avremmo potuto utilizzare
,
Tipi di dati – I numeri (I) Le classi che definiscono i numeri •
Nel linguaggio Ruby abbiamo la presenza di numeri interi e in virgola in virgola mobile.
•
I numeri interi sono oggetti o della classe Fixnum o della classe Bignum •
•
i numeri che possono essere rappresentati da una word sono oggetti della classe Fixnum, altrimenti appartengono alla classe Bignum.
I numeri in virgola mobile sono oggetti della classe Float.
Tipi di dati – I numeri (II) Rappresentazione di numeri non decimali •
Affinché si abbia una rappresentazione non decimale di un numero, a quest’ultimo bisogna far precedere un indicatore di base, in particolare: •
0b per i binari;
•
0 per gli ottali;
•
0d per i decimali;
•
0x per gli esadecimali
Tipi di dati – I numeri (III) Alcuni metodi per le classi Fixnum e Bignum •
Operazioni aritmetiche (+,-,*,/,div,%,modulo,** )
•
Operazioni bitwise (~,|,&,^,<<,>>)
•
Altre operazione: •
dimensione in byte (size): 1.size => 4
•
operazioni di conversione (to_f , to_s)
•
valore assoluto (abs)
Tipi di dati – I numeri (IV) La classe Float •
I numeri in virgola mobile appartengono alla classe Float
•
Questa classe, oltre ad avere i metodi poc’anzi visto, ha: •
infinite? : tale metodo restituisce • • •
•
-1 se il numero è meno infinito, +1 se il numero è più infinito, nil se il numero è finito.
nan? : ritorna • •
true se il valore è un numero non valido, false altrimenti
Tipi di dati – Le stringhe (I) •
Le stringhe sono delle istanze della classe String, e sono rappresentate da un successione di caratteri racchiusi tra singoli apici (‘) o tra le virgolette (“)
•
Si può accedere ad ogni singolo carattere della stringa []:
Tipi di dati – Le stringhe (II) •
Esempio:
•
Per visualizzare un carattere invece del codice ASCII, possiamo utilizzare il metodo chr:
Tipi di dati – Le stringhe (III) Accedere a
(I)
•
Per questo utilizziamo le []:
•
Se utilizziamo i “…” escludiamo il secondo estremo:
•
Possiamo pure specificare il range tramite un qualsiasi numero intero:
Tipi di dati – Le stringhe (IV) Accedere a
(II)
•
Può essere specificata all’interno delle [] la sottostringa da ricercare:
•
Inoltre, possono essere specificate delle espressioni regolari "!
•
Ci ritorneremo!!
Tipi di dati – Le stringhe (V) •
L’assegnazione viene effettuata attraverso il metodo []=, abbiamo una situazione analoga a metodo [] visto prima…
•
Giusto qualche esempio…
Tipi di dati – Le stringhe (VI) Alcuni importanti metodi applicabili alle stringhe (I)
•
*
•
+
•
<<
•
capitalize
Tipi di dati – Le stringhe (VI) Alcuni importanti metodi applicabili alle stringhe (II) •
downcase
•
swapcase
•
chop
•
chomp
Tipi di dati – Le stringhe (VI) Alcuni importanti metodi applicabili alle stringhe (III) •
sub e gsub
•
split
•
tr
Tipi di dati – Le stringhe (VII) Alcuni importanti metodi applicabili alle stringhe (IV) •
strip
•
lstrip
•
rstrip
•
ljust
•
rjust
•
center
Tipi di dati – Blocchi e iteratori (I) •
I blocchi sono delle regioni di codice racchiuse tra due parole do e end oppure tra due parentesi { }.
•
Un iteratore è un un metodo che prende come argomento un blocco.
•
Esempio…
•
Possiamo inoltre passare dei parametri all’iteratore. Ad esempio, l’iteratore each della classe String prende come parametro il separatore, che di default è il carattere \n. Riprendendo l’esempio avremo:
Tipi di dati – Blocchi e iteratori (II) •
Vediamo adesso un esempio in cui possiamo richiamare un blocco all’interno di un metodo, attraverso l’istruzione yield:
Tipi di dati – Array (I) •
Gli array sono istanze della classe Array e vengono creati in questo modo:
•
o in alternativa:
•
In questi due casi creeremo un array vuoto, per la creazione di un array non vuoto basta semplicemente passare i valori separati da virgole:
•
N.B. Un array è una lista di oggetti non necessariamente dello stesso tipo
Tipi di dati – Array (II) •
Al comando new è possibile passare due parametri, il primo indica la dimensione dell’array mentre il secondo il valore con il quale verrà inizializzato:
•
Attraverso il metodo []= è possibile inserire nell’array nuovi elementi o modificare quelli già presenti:
Tipi di dati – Array (III) •
E’ possibile indicare come indice due interi che rappresentano rispettivamente l’inizio e il numero di elementi da sostituire con il valore passato:
•
Allo stesso modo può essere usato il range:
Tipi di dati – Array (IV) •
Un metodo alternativo per inserire elementi in un array è dato dai metodi << e push e il loro comportamento è simile ad uno stack:
•
Attraverso il metodo pop è possibile invece eliminare l’ultimo elemento di un array:
Tipi di dati – Array (V) •
Adesso vediamo un ultima tecnica per l’inserimento di elementi all’interno di un array . Per fare questo, utilizziamo il metodo insert:
•
inoltre è possibile inserire più elementi a partire dall’indice specificato come primo parametro:
Tipi di dati – Array (VI) Operazioni sugli array (I) •
“+” concatenazione:
•
“-” differenza :
Tipi di dati – Array (VII) Operazioni sugli array (II) •
“&” intersezione:
•
“*”: questo metodo si comporta modo differente in base al parametro che gli si viene passato.
Tipi di dati – Array (VIII) Alcuni importanti metodi applicabili alle stringhe (I)
•
clear
•
compact
•
delete
•
empty?
•
include?
Tipi di dati – Array (IX) Alcuni importanti metodi applicabili alle stringhe (II)
•
index
•
join
•
lenght, nitems
•
reverse
•
sort
Tipi di dati – Array (IX) Altri metodi…
•
each
•
reverse_each
•
each_index
•
collect!
•
delete_if
Tipi di dati – Hash (I) •
Sono liste di coppie di chiavi e valori e sono istanze della classe Hash
•
Ogni coppia è separata dall’altra tramite una virgola, inoltre tra le chiavi e il valore deve esserci il simbolo “ =>”
•
A differenza degli array gli indici possono essere di qualsiasi tipo
•
Gli hash in Ruby sono racchiusi tra le parentesi { e }
•
Come creare un array :
Tipi di dati – Hash (II) •
Per popolare un hash basta utilizzare il metodo []=, visto nel caso degli array con la differenza che al posto dell’indice bisogna specificare la chiave:
•
Per accedere ad un specifico valore si utilizza il metodo []:
•
Tramite il metodo keys e values possibile elencare rispettivamente tutti le chiavi e tutti i valori:
Tipi di dati – Hash (III) •
Diversi metodi visti in precedenza per gli array sono presenti anche negli hash!
•
Uno in particolare che possiamo vedere, molto utile, è il metodo each che passa al blocco come parametri sia la chiave che il valore dell’hash. Inoltre, esistono i metodi each_key e each_value che passano rispettivamente al blocco la chiave e il valore.
Strutture di controllo – if e unless (I) If (I) •
Ovviamente chiunque il significato di tale costrutto, per cui evitiamo di parlarne e la sua sintassi:
Strutture di controllo – if e unless (II) If (II) •
Osserviamo un rapido esempio ":
Strutture di controllo – if e unless (III) If (III) •
Se il nostro if si trova in più linee allora si può anche omettere a per cui il nostro esempio diventa:
•
Inoltre, è possibile inserire un’espressione if anche in coda ad una istruzione:
Strutture di controllo – if e unless (IV) Unless (I) •
L’opposto dell’if esiste il costrutto unless che esegue le istruzioni associati all’espressione booleana che risulta falsa :
Strutture di controllo – if e unless (V) Unless (II) •
Vediamo un piccolo esempio…
•
Anche in questo caso possiamo mettere il costrutto unless alla fine dell’istruzione:
Strutture di controllo – if e unless (VI) •
Vediamo adesso un’altra forma più particolare che richiede l’uso dell’operatore “?”:
•
In questo caso assegneremo alla variabile segno la stringa “negativo” se la variabile numero è negativa , altrimenti assegneremo la stringa “positivo”.
Strutture di controllo – case (I) •
A volte per una questione di comodità e di chiarezza nel codice si preferisce utilizzare l’istruzione case in alternativa a if e unless. Il costrutto case ha la seguente sintassi:
Strutture di controllo – case (II) •
Vediamo subito un esempio…
•
L’istruzione che si trova dopo la parola else è quella che viene eseguita di default nel momento in cui falliscono tutte le altre istruzioni.
Strutture di controllo – case (III) •
E’ possibile fare uso della parola chiave then e dei due punti qualora la condizione si trovi nella stessa linea dell’istruzione:
Strutture di controllo – case (IV) •
In ultima analisi, considerando che il costrutto case restituisce il valore dell’ultima espressione valutata allora è possibile assegnare tale risultato ad un variabile:
Strutture di controllo – while, until e for (I) While
•
Esempio:
Strutture di controllo – while, until e for (II) Until
•
Esempio:
•
In questo caso viene eseguita l’espressione finché è falsa
Strutture di controllo – while, until e for (III) For
•
Esempio:
Strutture di controllo – while, until e for (IV) Come uscire dai cicli – break •
Il comando break fa terminare il ciclo e l’esecuzione del programma riparte dall’istruzione che segue il ciclo:
Strutture di controllo – while, until e for (V) Come saltare una iterazione – next • Attraverso il comando next è possibile saltare una
iterazione del ciclo e il programma riprenderà dall’iterazione successiva:
Gestione File – Apertura e chiusura (I) •
File è la classe che contiene i metodi per la gestione dei file (apertura, chiusura, lettura, scrittura…)
•
Abbiamo a disposizione due metodi per aprire un file:
Metodo classico – File.new
•
A questo punto tutto le operazioni vanno eseguite sull’oggetto my_file di tipo File.
•
Una volta concluse le operazioni, per chiudere il file basta semplicemente il seguente comando
Gestione File – Apertura e chiusura (II) •
Il metodo File.new ha la seguente sintassi:
•
Tale metodo può prendere da uno a tre parametri: • • •
•
il primo rappresenta il nome del file da aprire, il secondo la modalità di apertura, il terzo i permessi che verranno associati al file.
Di default il file viene aperto in solo lettura .
Gestione File – Apertura e chiusura (III) •
La modalità di apertura può essere espressa sia come stringa : • • • • • •
•
r: apertura a solo lettura r+: apertura per lettura e scrittura dall’inizio del file w : apertura a solo scrittura, in particolare se il file non esiste ne viene creato uno nuovo, altrimenti viene azzerato w+: apertura per lettura e scrittura, se il file non esiste ne viene creato uno nuovo, altrimenti viene azzerato a : apertura a solo scrittura dalla fine del file, inoltre se il file non esiste allora viene creato a+: apertura
sia come “or” di flag (sono costanti della classe File) • • • • • •
APPEND: apertura in modalità append; CREAT: viene creato il file se non esiste; RDONLY : apertura a solo lettura; RDWR : apertura per lettura e scrittura; TRUNC: apre il file e se già esiste lo azzera; WRONLY : apertura a solo scrittura.
Gestione File – Apertura e chiusura (IV) •
Per quanto riguarda il terzo argomento, i permessi vengono indicati, nei sistemi Unix-like, nella forma Owner-Group-Other.
•
Vediamo subito un piccolo esempio…
•
In questo caso, il file se non esiste viene creato, se esiste lo apre e lo azzera , ed inoltre viene aperto in lettura e scrittura.
•
Per quanto riguarda i permessi, possiamo leggere e scrivere nel file, mentre il nostro gruppo e chiunque altro può solamente leggerlo.
Gestione File – Apertura e chiusura (V) Apertura tramite il metodo open •
Al metodo open può essere associato un blocco al quale viene passato il file appena aperto. Senza il blocco associato open è sinonimo di File.new .
•
Quando viene utilizzato open non è richiesta la chiamata di close al termine delle operazioni, in quanto esso verrà chiuso automaticamente all’uscita del blocco.
Gestione File – Lettura e scrittura (I) •
Le operazioni base sui file appena aperto sono la lettura e la scrittura .
•
Per la lettura possiamo utilizzare il metodo gets che viene ereditato dalla classe IO (precisiamo che la classe File è un sottoclasse della classe IO).
•
Altrimenti possiamo fare ricorso agli iteratori nel momento in cui utilizziamo il metodo open per aprire il file: •
each_byte: chiama il blocco per ogni byte
•
each_line (anche each): chiama il blocco per ogni riga
Gestione File – Lettura e scrittura (II) •
Attraverso gli iteratori each_line e each possiamo iterare su ogni linea del file:
•
risparmiamo qualche riga di codice " …
Gestione File – Lettura e scrittura (III) •
Un ulteriore modo al quanto elegante per aprire un file è dato dal metodo foreach della classe IO. Ad esso viene passato come argomento un file, il metodo apre tale file, chiama il blocco per ogni linea e alla fine chiude automaticamente il file:
•
Per la scrittura su un file viene utilizzato il metodo write il quale prende come argomento la stringa da scrivere sul file:
Gestione File – Lettura e scrittura (IV) •
In alternativa a write possiamo utilizzare: •
l’operatore <<
• oppure •
il metodo puts
Gestione File – Alcuni metodi utili (I) •
Vediamo alcuni metodi utili per la gestione di file:
•
atime, ctime, mtime: rispettivamente restituisco la data di ultimo accesso, di creazione e di modifica .
•
chmod, chown: modificano i permessi di proprietariorename:
•
delete: cancella il file
•
rename: rinomina il file
•
size: restituisce la dimensione del file in byte
•
read: restituisce il contenuto del file in un’unica stringa
•
readlines: restituisce in un array le linee del file
Gestione File – Alcuni metodi utili (II) •
Vi sono alcuni metodi interrogativi come:
•
exist? : restituisce true se il file esiste
•
executable? : restituisce true se il file è eseguibile
•
readable? : restituisce true se il file è leggibile
•
writable? : restituisce true se il file è scrivibile
•
file? : restituisce true se il file è regolare, ossia se non è una directory, ecc.
•
owned? : restituisce true se l’user ID del processo è lo stesso del file.
Gestione directory •
La classe della gestione delle directory è Dir.
•
Per questa classe esistono pure i metodi new , open e close visti in precedenza per la classe File:
•
Anche in questo caso si può utilizzare il metodo open senza ricorrere successivamente a close per chiudere la directory una volta concluse le operazioni
Espressioni Regolari (I) •
Le espressioni regolari sono uno strumento molto potente per la gestione del testo. Esse forniscono dei modelli per ricercare all’interno di un testo espressioni letterali.
•
Come nel caso degli array e degli hash, gli oggetti della classe Regexp possono essere creati in diversi modi: •
utilizzando il metodo new nel quale viene passata l’espressione regolare:
•
oppure tra i doppi slash //:
Espressioni Regolari (II) •
Nel momento in cui viene creata un’espressione regolare possiamo confrontarla con una stringa. Questo lo possiamo fare attraverso l’operatore =~ o il suo negato !~
•
L’operatore =~ restituisce la posizione del primo carattere che fa match con l’espressione regolare
Espressioni Regolari (III) •
Nelle espressioni oltre ai normali caratteri possono essere usate delle sequenze di simboli che indicano determinate categorie di caratteri .
un carattere qualsiasi
\w
lettera o numero
\W
il contrario di \W , né lettera né cifra
\s
spazio, come \t \n \r, ecc..
\S
carattere non spazio
\d
cifra numerica
\D
carattere non numerico
\A
match con l’inizio della stringa
\Z
match con la fine della stringa
Espressioni Regolari (IV) •
Come nel caso di \A e \Z, esistono due particolari elementi ^ e $ che vengono usati rispettivamente per cercare l’espressione regolare all’inizio della stringa o alla fine.+
•
Esistono anche dei simboli di quantità *
zero o più ripetizioni del carattere precedente
+
una o più ripetizioni del carattere precedente
{m,n} ?
almeno m e massimo n ripetizioni del carattere precedente al massimo una ripetizione del carattere precedente
Espressioni Regolari (V) •
Possiamo indicare la classe di caratteri all’interno di un espressione regolare nel seguente modo: /[Rr]uby/
“Ruby” o “ruby”
/rub[ye]/
“ruby” o “rube”
/[aeiou]/
una qualsiasi vocale minuscola
/[0-9]/
un qualsiasi numero compreso fra 0 e 9
/[a-z]/
una qualsiasi lettera minuscola
/[A-Z]/
una qualsiasi lettera maiuscola
/[a-zA-Z0-9]/
la qualunque cosa
/[^aeiou]/
qualcos’altro rispetto ad una vocale minuscola
/[^0-9]/
qualcos’altro rispetto ad un numero compreso fra 0 e 9
Espressioni Regolari (VI) La classe String (I) •
Vediamo adesso come possiamo utilizzare le espressioni regolare per le stringhe
•
In questo caso index restituisce l’indice della prima occorrenza della sottostringa che verifica il pattern, in modo analogo il metodo rindex restituisce l’ultima occorrenza:
Espressioni Regolari (VI) La classe String (II) •
E’ possibile utilizzare le espressioni regolari anche con il metodo split:
•
Infine, possiamo sfruttare le potenzialità delle regexp con il metodo scan, in questo caso tale metodo scansiona tutta la stringa presa in esame e inserisce in un array tutti i risultati che verificano il pattern:
Pacchetti in Ruby – Introduzione a RubyGems (I)
•
RubyGems è un framework per la gestione in modo automatica dei pacchetti.
•
Esso si occupa dell’installazione, dell’aggiornamento e della distruzione…
•
Esso va installato a parte in quanto non fa parte dei programmi distribuiti direttamente da Ruby
•
Nel seguente link trovate i sorgenti attualmente disponibili: http://docs.rubygems.org/
Pacchetti in Ruby – Introduzione a RubyGems (II) •
Per l’installazione di RubyGems basta eseguire il seguente comando:
•
Se eseguiamo dal terminale in comando gem senza alcuna opzione figurerà lista di informazioni per l’uso di RubyGems
•
Per avere una lista completa dei comandi basta lanciare il seguente comando
Pacchetti in Ruby – Comandi per RubyGems (I) •
Per installare una nuova gemma basta utilizzare il comando install:
•
Per avere una lista completa delle opzioni che si possono utilizzare con il comando install basta lanciare il seguente comando:
Pacchetti in Ruby – Comandi per RubyGems (II) •
Per poter utilizzare le librerie nel codice sorgente occorre caricare la gemma, per fare ciò si utilizza il comando require:
•
Per disinstallare un pacchetto attraverso RubyGems basta utilizzare il comando unistall
•
Attraverso il comando list invece è possibile vedere le gemme installate attualmente nella propria macchina.
•
Indicando l’opzione –remote è possibile avere una lista completa dei pacchetti presenti nel repository. Di default quello ufficiale è rubyforge.org
•
Infine, attraverso il comando update possiamo aggiornare la versione di un pacchetto se viene specificato il suo nome, altrimenti vengono aggiornati tutti quelli presenti nella propria macchina.
Pacchetto “HPRICOT” (I) •
Hpricot (v 0.8.6) è una gemma che può essere scaricata dal sito: http://rubygems.org/
•
Al link http://rubygems.org/gems/hpricot
•
In alternativa può essere installato dalla shell di ruby con il seguente comando: gem install hpricot
Pacchetto “HPRICOT” (II) •
Hpricot è un parser HTML, scritto in C, veloce e flessibile.
•
Le ricerche possono basarsi su diversi elementi: •
ID degli elementi
•
Selettori CSS
•
Tag
•
Ed in generale tutti gli elementi che compongono una pagina html
Pacchetto “HPRICOT” (III) •
Documentazione •
•
Demo on line •
•
http://rubydoc.info/gems/hpricot/0.8.6/frames
http://hpricot.com/
Competitor, sempre una ruby gems: •
Nokogiri (http://nokogiri.org/)
Pacchetto “HPRICOT” (IV) •
Input: •
Dal www require 'open-uri' doc = open("http://www.sdai.unict.it/") { |f| Hpricot(f) }
•
Da file locali doc = open("index.html") { |f| Hpricot(f) }
•
Oppure una generica stringa doc = Hpricot("
A simple test string.
“)
