Ruby

Da Wikipedia, l'enciclopedia libera.
bussola Disambiguazione – Se stai cercando altri significati, vedi Ruby (disambigua).
Ruby
Ruby logo.svg
Autore Yukihiro Matsumoto
Data di origine 1995; 19 anni fa[1]
Ultima versione 2.1.5 / 13 novembre 2014; 38 giorni fa[2]
Utilizzo scripting
Paradigmi a oggetti
Tipizzazione duck, dynamic
Influenzato da Lisp Smalltalk Perl
Implementazione di riferimento
Implementazione interprete
Sistema operativo Multipiattaforma
Lingua en
Licenza GNU General Public License
Sito web www.ruby-lang.org

Ruby è un linguaggio di scripting completamente a oggetti. Nato nel 1993 come progetto personale del giapponese Yukihiro Matsumoto (spesso chiamato semplicemente Matz), Ruby è stato il primo linguaggio di programmazione sviluppato in Oriente a guadagnare abbastanza popolarità da superare la barriera linguistica che separa l'informatica nipponica da quella internazionale e ad essere usato anche in Occidente in progetti di rilievo.

Il linguaggio che ha maggiormente ispirato l'autore è lo Smalltalk[3], da cui Ruby ha tratto la maggior parte delle sue caratteristiche. A seguire ci sono il Lisp (ed in generale i linguaggi funzionali), da cui provengono le chiusure (blocchi o proc, in Ruby), e il Perl, per la sintassi e l'espressività.

Negli ultimi anni la popolarità di Ruby ha subito una forte impennata, dovuta alla comparsa di framework di successo per lo sviluppo di applicazioni web, come Nitro e Ruby on Rails, nonché del Metasploit Framework, ambiente per la creazione e l’esecuzione facilitata di exploit.

Sistemi operativi[modifica | modifica wikitesto]

L'interprete di Ruby è disponibile per i seguenti sistemi operativi:

Potrebbero esistere port per altri sistemi operativi. Esiste inoltre JRuby, un'implementazione Java dell'interprete.

Caratteristiche principali[modifica | modifica wikitesto]

Ruby, pur essendo un linguaggio ad oggetti, presenta alcune caratteristiche tipiche dei paradigmi imperativo e funzionale.

Il paradigma ad oggetti di Ruby è puro, come quello di Smalltalk, ossia ogni componente del linguaggio, dalle costanti numeriche alle classi, è un oggetto, e come tale può possedere metodi; a differenza dei linguaggi come C++ e derivati, tuttavia, gli oggetti in Ruby sono qualcosa di molto più dinamico, in quanto è possibile aggiungere o modificare metodi a run-time. Il tipo di un oggetto, perciò, non è definito tanto dalla classe che lo ha istanziato, quanto dall'insieme dei metodi che possiede, o, secondo la terminologia abitualmente utilizzata per i linguaggi stile Smalltalk, dei messaggi a cui sa rispondere.

In Ruby, dunque, è fondamentale il duck typing (dall'inglese if it looks like a duck, and quacks like a duck, it must be a duck), ovvero il principio secondo il quale il comportamento di una funzione sui suoi argomenti non deve essere determinato dal tipo di questi (come accade in C++ e altri linguaggi staticamente tipizzati), bensì da quali messaggi essi sono in grado di gestire.

Un'altra caratteristica fondamentale di Ruby è costituita dai cosiddetti blocchi, che sono sostanzialmente delle chiusure (ovvero funzioni dotate di ambiente), e che consentono di sostituire i cicli espliciti, frequenti nei linguaggi a basso livello, con l'utilizzo di iteratori, nascondendo così al chiamante i meccanismi interni del ciclo in questione.

Esempi[modifica | modifica wikitesto]

Hello world[modifica | modifica wikitesto]

Il seguente esempio stampa il testo "Hello world".

puts "Hello World"

Classi e metodi[modifica | modifica wikitesto]

Ecco un programma semanticamente identico al precedente, ma che si avvale del paradigma ad oggetti di Ruby.

class Greeter
  attr_reader :recipient
  def initialize(recipient)
    @recipient = recipient
  end
  def greet
    puts "Hello #{recipient}"
  end
end 
 
greeter = Greeter.new("world")
greeter.greet

Duck typing[modifica | modifica wikitesto]

La funzione definita qui di seguito agisce diversamente a seconda dei messaggi a cui il suo argomento risponde.

def text_of(widget)
  if widget.respond_to? :caption
    widget.caption
  elsif widget.respond_to? :text
    widget.text
  else
    raise "no text associated to widget #{widget}"
  end
end

Blocchi e iteratori[modifica | modifica wikitesto]

I cicli in Ruby sono generalmente eseguiti mediante iteratori, a cui viene passato un blocco, sotto forma di codice compreso fra le parole chiave do e end, come illustrato nel seguente esempio,

5.times do
  puts "Hello world"
end

in cui il metodo times dell'oggetto "numero 5" si preoccupa di eseguire il giusto numero di volte (5, per l'appunto) il codice indicato.

Nella definizione di un iteratore, si usa la parola chiave yield.

class Integer
  def times_header_and_footer
    puts "-- BEGIN --"
    times do
      yield
    end
    puts "-- END --"
  end
end
 
 
5.times_header_and_footer do
  puts "Hello world"
end

Si noti come la classe Integer (una classe predefinita) sia stata riaperta per l'aggiunta di un metodo. L'output dello script è

-- BEGIN -— 
Hello world
Hello world
Hello world
Hello world
Hello world
-— END --

Commenti[modifica | modifica wikitesto]

Commenti su riga singola o su più righe

# Questo è un commento
 
=begin
   Questo è
   un commento
   su più righe
=end

Notare che nei commenti disposti su più righe, =begin ed =end devono trovarsi all'inizio della riga, senza alcuna indentazione.

Note[modifica | modifica wikitesto]

  1. ^ Template:Cita web!https://www.ruby-lang.org/en/about/
  2. ^ https://www.ruby-lang.org/en/news/2014/11/13/ruby-2-1-5-is-released/.
  3. ^ Fonte: «Smalltalk was one big influence on Ruby, and it continues to do so. […]»

Voci correlate[modifica | modifica wikitesto]

Altri progetti[modifica | modifica wikitesto]

Collegamenti esterni[modifica | modifica wikitesto]