Varie ed Eventuali

Questo capitolo si indirizza ad alcuni problemi pratici.

Delimitatori di Istruzione

Alcuni linguaggi richiedono una qualche forma di punteggiatura, spesso un punto e virgola (;), per terminare ogni istruzione in un programma. Ruby invece segue lòa convenzione usata nelle shell come sh e csh. Istruzioni multiple su una sola linea evono essere separate da punto e virgola , ma non ce n'è bisogno alla fine della linea stessa ; un a capo viene trattato come un punto e virgola. Se una linea termina con un controslash (), il carattere di a capo (linefeed ) seguente viene ignorato; ciò permette di avere una sola linea logica divisa su varie linee effettive.

Commenti

Perchè scrivere commenti ? Anche se il codice ben scritto tende ad essere autodocumentante , spesso è utile fare aggiunte a margine, e può essere un errore credere che altri siano in grado di comprendere immediatamente il vostro codice come voi stessi. Inoltre, per scopi pratici, voi stessi siete persone differenti dopo qualche giorno; chi di noi non è mai tornato per correggere o migliorare un programma dopo qualche tempo dicendo, so che l'ho scritto io, ma che diavolo significa 'sta roba ?

Alcuni programmatori esperti faranno notare , abbastanza correttamente, che commenti contraddittori o vecchi possono essere ancora peggio che nessun commento. Certamente, i commenti non dovrebbero essere un sostituto per il codice leggibile ; se il tuo codice non è chiaro, probabilmnente è anche pieno di bug. Potreste accorgervi che avete bisogno di commentare di più mentre imparate ruby , e poi sempre meno mentre imparate ad esprimere le vostre idee con del codice semplice, elegante e leggibile.

Ruby segue una convenzione comune nei linguaggi di scripting, che è quella di usare il simbolo del diesis, o canccelletto (#) per indicare l'inizio di un commento. Tutto ciò che segue un # non quotato, fino alla fine della linea su cui appare, viene ignorato dall'interprete.

Inoltre, per semplificare la creazione di grossi blocchi di commento, l'interprete ruby ignora qualunque cosa tra una linea che cominci per "=begin" ed un altra che cominci con "=end".

#!/usr/bin/env ruby

=begin
**********************************************************************
  questo è un blocco di commento, qualcosa che scriverete per il beneficio
  di lettori umani (inclusi voi stessi).  L'interprete le ignora.
  Non c'è bisogno di un '#' all'inizio di ogni linea.
**********************************************************************
=end

Organizzare il proprio codice

L'interprete ruby analizza il codice man mano che lo legge. Non esiste niente come una fase di compilazione ; se qualcosa non è ancora stato letto, semplicemente quel qualcosa non è definito .

# questo causa un errore "undefined method" :

print successor(3),""

def successor(x)
  x + 1
end

Questo non forza, come potrebbe sembrare a primo impatto, a organizzare il proprio codice in stile completamente bottom up. Quando l'interprete incontra una definizione di metodo,esso può tranquillamente includere riferimenti indefiniti , purchè possiate assicurarvi che essi siano poi definiti prima di essere effettivamente invocati:

# Conversione da fahrenheit a celsius, spezzata
# in due parti.

def f_to_c(f)
  scale(f - 32.0)  # riferimento in avanti, ma e' okay.
end

def scale(x)
  x * 5.0 / 9.0
end

printf "%.1f e' una temperatura confortevole." , f_to_c(72.3)

Dunque mentre potra sembrare meno conveniente di quello a cui potreste essere abituati in Perl o Java, è molto meno restrittivo dello scrivere codice in C senza prototipi (il che richiederebbe che manteniate sempre un ordinamento parziale di cosa utilizza qualcosaltro). Mettere il codice del livello più esterno alla fine del file sorgente funziona sempre. Ed anche questa è una cosa molto meno noiosa di quel che sembra all'inizio. Un modo sensibile ed indolore per forzare questo comportamento è creare una funzione main all'inizio del file, e chiamarla alla fine .

#!/usr/bin/env ruby

def main
  # Esprimete la logica del livello più alto qui...
end

# ... ponete il codice di supporto qui, organizzato come preferite...

main # ... ed avviate l'esecuzione qui .

Spesso è d'aiuto anche fornire strumenti per spezzare programmi complessi in spezzoni leggibili, riusabili, e collegati logicamente. Abbiamo già visto l'uso di include per accedere ai moduli. Troverete utili anche load e require . load funziona come se il file a cui ci si riferisce venisse copiato ed incollato (in modo simile alla direttiva #include al preprocessore C). require è leggermente più complessa , poiché fa si che il codice venga caricato soltanto una volta e solo quando necessario. Ci sono altre differenze tra load e require; fate riferimento al manuale del linguaggio o alle FAQ per maggiori informazioni .

Tutto qui...

Questo tutorial dovrebbe essere abbastanza per farvi cominciare a scrivere programmi in Ruby. Se vi sorgessero altre domande, potete frugfare nel manuale di riferimento per imparare ruby più approfonditamente. LeFAQ e lespecifiche della liibreria sono risorse importanti.

Auguri, e felice programmazione!