iskm/learnxinyminutes-docs
1
0
Fork 0
mirror of https://github.com/adambard/learnxinyminutes-docs.git synced 2024-12-24 18:11:38 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
f4d4fb76ba
learnxinyminutes-docs/it-it/ruby-it.html.markdown
Boris Verkhovskiy f4d4fb76ba
Fix language names (#5148)
2024-10-20 14:46:35 -07:00

654 lines
16 KiB
Markdown
Raw Blame History

---
language: Ruby
filename: learnruby-it.rb
contributors:
- ["David Underwood", "http://theflyingdeveloper.com"]
- ["Joel Walden", "http://joelwalden.net"]
- ["Luke Holder", "http://twitter.com/lukeholder"]
- ["Tristan Hume", "http://thume.ca/"]
- ["Nick LaMuro", "https://github.com/NickLaMuro"]
- ["Marcos Brizeno", "http://www.about.me/marcosbrizeno"]
- ["Ariel Krakowski", "http://www.learneroo.com"]
- ["Dzianis Dashkevich", "https://github.com/dskecse"]
- ["Levi Bostian", "https://github.com/levibostian"]
- ["Rahil Momin", "https://github.com/iamrahil"]
- ["Gabriel Halley", "https://github.com/ghalley"]
- ["Persa Zula", "http://persazula.com"]
- ["Jake Faris", "https://github.com/farisj"]
- ["Corey Ward", "https://github.com/coreyward"]
translators:
- ["abonte", "https://github.com/abonte"]
lang: it-it
---
```ruby
# Questo è un commento
# In Ruby, (quasi) tutto è un oggetto.
# Questo include i numeri...
3.class #=> Integer
# ...stringhe...
"Hello".class #=> String
# ...e anche i metodi!
"Hello".method(:class).class #=> Method
# Qualche operazione aritmetica di base
1 + 1 #=> 2
8 - 1 #=> 7
10 * 2 #=> 20
35 / 5 #=> 7
2 ** 5 #=> 32
5 % 3 #=> 2
# Bitwise operators
3 & 5 #=> 1
3 | 5 #=> 7
3 ^ 5 #=> 6
# L'aritmetica è solo zucchero sintattico
# per chiamare il metodo di un oggetto
1.+(3) #=> 4
10.* 5 #=> 50
100.methods.include?(:/) #=> true
# I valori speciali sono oggetti
nil # equivalente a null in altri linguaggi
true # vero
false # falso
nil.class #=> NilClass
true.class #=> TrueClass
false.class #=> FalseClass
# Uguaglianza
1 == 1 #=> true
2 == 1 #=> false
# Disuguaglianza
1 != 1 #=> false
2 != 1 #=> true
# nil è l'unico valore, oltre a false, che è considerato 'falso'
!!nil #=> false
!!false #=> false
!!0 #=> true
!!"" #=> true
# Altri confronti
1 < 10 #=> true
1 > 10 #=> false
2 <= 2 #=> true
2 >= 2 #=> true
# Operatori di confronto combinati (ritorna '1' quando il primo argomento è più
# grande, '-1' quando il secondo argomento è più grande, altrimenti '0')
1 <=> 10 #=> -1
10 <=> 1 #=> 1
1 <=> 1 #=> 0
# Operatori logici
true && false #=> false
true || false #=> true
# Ci sono versioni alternative degli operatori logici con meno precedenza.
# Sono usati come costrutti per il controllo di flusso per concatenare
# insieme statement finché uno di essi ritorna true o false.
# `do_something_else` chiamato solo se `do_something` ha successo.
do_something() and do_something_else()
# `log_error` è chiamato solo se `do_something` fallisce.
do_something() or log_error()
# Interpolazione di stringhe
placeholder = 'usare l\'interpolazione di stringhe'
"Per #{placeholder} si usano stringhe con i doppi apici"
#=> "Per usare l'interpolazione di stringhe si usano stringhe con i doppi apici"
# E' possibile combinare le stringhe usando `+`, ma non con gli altri tipi
'hello ' + 'world' #=> "hello world"
'hello ' + 3 #=> TypeError: can't convert Fixnum into String
'hello ' + 3.to_s #=> "hello 3"
"hello #{3}" #=> "hello 3"
# ...oppure combinare stringhe e operatori
'ciao ' * 3 #=> "ciao ciao ciao "
# ...oppure aggiungere alla stringa
'ciao' << ' mondo' #=> "ciao mondo"
# Per stampare a schermo e andare a capo
puts "Sto stampando!"
#=> Sto stampando!
#=> nil
# Per stampare a schermo senza andare a capo
print "Sto stampando!"
#=> Sto stampando! => nil
# Variabili
x = 25 #=> 25
x #=> 25
# Notare che l'assegnamento ritorna il valore assegnato.
# Questo significa che è possibile effettuare assegnamenti multipli:
x = y = 10 #=> 10
x #=> 10
y #=> 10
# Per convenzione si usa lo snake_case per i nomi delle variabili
snake_case = true
# Usare nomi delle variabili descrittivi
path_to_project_root = '/buon/nome/'
m = '/nome/scadente/'
# I simboli sono immutabili, costanti riusabili rappresentati internamente da
# un valore intero. Sono spesso usati al posto delle stringhe per comunicare
# specifici e significativi valori.
:pendente.class #=> Symbol
stato = :pendente
stato == :pendente #=> true
stato == 'pendente' #=> false
stato == :approvato #=> false
# Le stringhe possono essere convertite in simboli e viceversa:
status.to_s #=> "pendente"
"argon".to_sym #=> :argon
# Arrays
# Questo è un array
array = [1, 2, 3, 4, 5] #=> [1, 2, 3, 4, 5]
# Gli array possono contenere diversi tipi di elementi
[1, 'hello', false] #=> [1, "hello", false]
# Gli array possono essere indicizzati
# Dall'inizio...
array[0] #=> 1
array.first #=> 1
array[12] #=> nil
# ...o dalla fine...
array[-1] #=> 5
array.last #=> 5
# With a start index and length
# ...o con un indice di inzio e la lunghezza...
array[2, 3] #=> [3, 4, 5]
# ...oppure con un intervallo.
array[1..3] #=> [2, 3, 4]
# Invertire l'ordine degli elementi di un array
a = [1,2,3]
a.reverse! #=> [3,2,1]
# Come per l'aritmetica, l'accesso tramite [var]
# è solo zucchero sintattico
# per chiamare il metodo '[]'' di un oggetto
array.[] 0 #=> 1
array.[] 12 #=> nil
# Si può aggiungere un elemento all'array così
array << 6 #=> [1, 2, 3, 4, 5, 6]
# oppure così
array.push(6) #=> [1, 2, 3, 4, 5, 6]
# Controllare se un elemento esiste in un array
array.include?(1) #=> true
# Hash è un dizionario con coppie di chiave e valore
# Un hash è denotato da parentesi graffe:
hash = { 'colore' => 'verde', 'numero' => 5 }
hash.keys #=> ['colore', 'numero']
# E' possibile accedere all'hash tramite chiave:
hash['colore'] #=> 'verde'
hash['numero'] #=> 5
# Accedere all'hash con una chiave che non esiste ritorna nil:
hash['nothing here'] #=> nil
# Quando si usano simboli come chiavi di un hash, si possono utilizzare
# queste sintassi:
hash = { :defcon => 3, :action => true }
hash.keys #=> [:defcon, :action]
# oppure
hash = { defcon: 3, action: true }
hash.keys #=> [:defcon, :action]
# Controllare l'esistenza di una chiave o di un valore in un hash
new_hash.key?(:defcon) #=> true
new_hash.value?(3) #=> true
# Suggerimento: sia gli array che gli hash sono enumerabili!
# Entrambi possiedono metodi utili come each, map, count e altri.
# Strutture di controllo
#Condizionali
if true
'if statement'
elsif false
'else if, opzionale'
else
'else, opzionale'
end
#Cicli
# In Ruby, i tradizionali cicli `for` non sono molto comuni. Questi semplici
# cicli, invece, sono implementati con un enumerable, usando `each`:
(1..5).each do |contatore|
puts "iterazione #{contatore}"
end
# Esso è equivalente a questo ciclo, il quale è inusuale da vedere in Ruby:
for contatore in 1..5
puts "iterazione #{contatore}"
end
# Il costrutto `do |variable| ... end` è chiamato 'blocco'. I blocchi
# sono simili alle lambda, funzioni anonime o closure che si trovano in altri
# linguaggi di programmazione. Essi possono essere passati come oggetti,
# chiamati o allegati come metodi.
#
# Il metodo 'each' di un intervallo (range) esegue il blocco una volta
# per ogni elemento dell'intervallo.
# Al blocco è passato un contatore come parametro.
# E' possibile inglobare il blocco fra le parentesi graffe
(1..5).each { |contatore| puts "iterazione #{contatore}" }
# Il contenuto delle strutture dati può essere iterato usando "each".
array.each do |elemento|
puts "#{elemento} è parte dell'array"
end
hash.each do |chiave, valore|
puts "#{chiave} è #{valore}"
end
# If you still need an index you can use 'each_with_index' and define an index
# variable
# Se comunque si vuole un indice, si può usare "each_with_index" e definire
# una variabile che contiene l'indice
array.each_with_index do |elemento, indice|
puts "#{elemento} è il numero #{index} nell'array"
end
contatore = 1
while contatore <= 5 do
puts "iterazione #{contatore}"
contatore += 1
end
#=> iterazione 1
#=> iterazione 2
#=> iterazione 3
#=> iterazione 4
#=> iterazione 5
# Esistono in Ruby ulteriori funzioni per fare i cicli,
# come per esempio 'map', 'reduce', 'inject' e altri.
# Nel caso di 'map', esso prende l'array sul quale si sta iterando, esegue
# le istruzioni definite nel blocco, e ritorna un array completamente nuovo.
array = [1,2,3,4,5]
doubled = array.map do |elemento|
elemento * 2
end
puts doubled
#=> [2,4,6,8,10]
puts array
#=> [1,2,3,4,5]
# Costrutto "case"
grade = 'B'
case grade
when 'A'
puts 'Way to go kiddo'
when 'B'
puts 'Better luck next time'
when 'C'
puts 'You can do better'
when 'D'
puts 'Scraping through'
when 'F'
puts 'You failed!'
else
puts 'Alternative grading system, eh?'
end
#=> "Better luck next time"
# 'case' può usare anche gli intervalli
grade = 82
case grade
when 90..100
puts 'Hooray!'
when 80...90
puts 'OK job'
else
puts 'You failed!'
end
#=> "OK job"
# Gestione delle eccezioni
begin
# codice che può sollevare un eccezione
raise NoMemoryError, 'Esaurita la memoria.'
rescue NoMemoryError => exception_variable
puts 'NoMemoryError è stato sollevato.', exception_variable
rescue RuntimeError => other_exception_variable
puts 'RuntimeError è stato sollvato.'
else
puts 'Questo viene eseguito se nessuna eccezione è stata sollevata.'
ensure
puts 'Questo codice viene sempre eseguito a prescindere.'
end
# Metodi
def double(x)
x * 2
end
# Metodi (e blocchi) ritornano implicitamente il valore dell'ultima istruzione
double(2) #=> 4
# Le parentesi sono opzionali dove l'interpolazione è inequivocabile
double 3 #=> 6
double double 3 #=> 12
def sum(x, y)
x + y
end
# Gli argomenit dei metodi sono separati dalla virgola
sum 3, 4 #=> 7
sum sum(3, 4), 5 #=> 12
# yield
# Tutti i metodi hanno un implicito e opzionale parametro del blocco.
# Esso può essere chiamato con la parola chiave 'yield'.
def surround
puts '{'
yield
puts '}'
end
surround { puts 'hello world' }
# {
# hello world
# }
# I blocchi possono essere convertiti in 'proc', il quale racchiude il blocco
# e gli permette di essere passato ad un altro metodo, legato ad uno scope
# differente o modificato. Questo è molto comune nella lista parametri del
# metodo, dove è frequente vedere il parametro '&block' in coda. Esso accetta
# il blocco, se ne è stato passato uno, e lo converte in un 'Proc'.
# Qui la denominazione è una convenzione; funzionerebbe anche con '&ananas'.
def guests(&block)
block.class #=> Proc
block.call(4)
end
# Il metodo 'call' del Proc è simile allo 'yield' quando è presente un blocco.
# Gli argomenti passati a 'call' sono inoltrati al blocco come argomenti:
guests { |n| "You have #{n} guests." }
# => "You have 4 guests."
# L'operatore splat ("*") converte una lista di argomenti in un array
def guests(*array)
array.each { |guest| puts guest }
end
# Destrutturazione
# Ruby destruttura automaticamente gli array in assegnamento
# a variabili multiple:
a, b, c = [1, 2, 3]
a #=> 1
b #=> 2
c #=> 3
# In alcuni casi si usa l'operatore splat ("*") per destrutturare
# un array in una lista.
classifica_concorrenti = ["John", "Sally", "Dingus", "Moe", "Marcy"]
def migliore(primo, secondo, terzo)
puts "I vincitori sono #{primo}, #{secondo}, e #{terzo}."
end
migliore *classifica_concorrenti.first(3)
#=> I vincitori sono John, Sally, e Dingus.
# The splat operator can also be used in parameters:
def migliore(primo, secondo, terzo, *altri)
puts "I vincitori sono #{primo}, #{secondo}, e #{terzo}."
puts "C'erano altri #{altri.count} partecipanti."
end
migliore *classifica_concorrenti
#=> I vincitori sono John, Sally, e Dingus.
#=> C'erano altri 2 partecipanti.
# Per convenzione, tutti i metodi che ritornano un booleano terminano
# con un punto interrogativo
5.even? #=> false
5.odd? #=> true
# Per convenzione, se il nome di un metodo termina con un punto esclamativo,
# esso esegue qualcosa di distruttivo. Molti metodi hanno una versione con '!'
# per effettuare una modifiche, e una versione senza '!' che ritorna
# una versione modificata.
nome_azienda = "Dunder Mifflin"
nome_azienda.upcase #=> "DUNDER MIFFLIN"
nome_azienda #=> "Dunder Mifflin"
# Questa volta modifichiamo nome_azienda
nome_azienda.upcase! #=> "DUNDER MIFFLIN"
nome_azienda #=> "DUNDER MIFFLIN"
# Classi
# Definire una classe con la parola chiave class
class Umano
# Una variabile di classe. E' condivisa da tutte le istance di questa classe.
@@specie = 'H. sapiens'
# Inizializzatore di base
def initialize(nome, eta = 0)
# Assegna il valore dell'argomento alla variabile dell'istanza "nome"
@nome = nome
# Se l'età non è fornita, verrà assegnato il valore di default indicato
# nella lista degli argomenti
@eta = eta
end
# Metodo setter di base
def nome=(nome)
@nome = nome
end
# Metodo getter di base
def nome
@nome
end
# Le funzionalità di cui sopra posso essere incapsulate usando
# il metodo attr_accessor come segue
attr_accessor :nome
# Getter/setter possono anche essere creati individualmente
attr_reader :nome
attr_writer :nome
# Un metodo della classe usa 'self' per distinguersi dai metodi dell'istanza.
# Può essere richimato solo dalla classe, non dall'istanza.
def self.say(msg)
puts msg
end
def specie
@@specie
end
end
# Instanziare una classe
jim = Umano.new('Jim Halpert')
dwight = Umano.new('Dwight K. Schrute')
# Chiamiamo qualche metodo
jim.specie #=> "H. sapiens"
jim.nome #=> "Jim Halpert"
jim.nome = "Jim Halpert II" #=> "Jim Halpert II"
jim.nome #=> "Jim Halpert II"
dwight.specie #=> "H. sapiens"
dwight.nome #=> "Dwight K. Schrute"
# Chiamare un metodo della classe
Umano.say('Ciao') #=> "Ciao"
# La visibilità della variabile (variable's scope) è determinata dal modo
# in cui le viene assegnato il nome.
# Variabili che iniziano con $ hanno uno scope globale
$var = "Sono una variabile globale"
defined? $var #=> "global-variable"
# Variabili che inziano con @ hanno a livello dell'istanza
@var = "Sono una variabile dell'istanza"
defined? @var #=> "instance-variable"
# Variabili che iniziano con @@ hanno una visibilità a livello della classe
@@var = "Sono una variabile della classe"
defined? @@var #=> "class variable"
# Variabili che iniziano con una lettera maiuscola sono costanti
Var = "Sono una costante"
defined? Var #=> "constant"
# Anche una classe è un oggetto in ruby. Quindi la classe può avere
# una variabile dell'istanza. Le variabili della classe sono condivise
# fra la classe e tutti i suoi discendenti.
# Classe base
class Umano
@@foo = 0
def self.foo
@@foo
end
def self.foo=(value)
@@foo = value
end
end
# Classe derivata
class Lavoratore < Umano
end
Umano.foo #=> 0
Lavoratore.foo #=> 0
Umano.foo = 2 #=> 2
Lavoratore.foo #=> 2
# La variabile dell'istanza della classe non è condivisa dai discendenti.
class Umano
@bar = 0
def self.bar
@bar
end
def self.bar=(value)
@bar = value
end
end
class Dottore < Umano
end
Umano.bar #=> 0
Dottore.bar #=> nil
module EsempioModulo
def foo
'foo'
end
end
# Includere moduli vincola i suoi metodi all'istanza della classe.
# Estendere moduli vincola i suoi metodi alla classe stessa.
class Persona
include EsempioModulo
end
class Libro
extend EsempioModulo
end
Persona.foo #=> NoMethodError: undefined method `foo' for Person:Class
Persona.new.foo #=> 'foo'
Libro.foo #=> 'foo'
Libro.new.foo #=> NoMethodError: undefined method `foo'
# Callbacks sono eseguiti quand si include o estende un modulo
module ConcernExample
def self.included(base)
base.extend(ClassMethods)
base.send(:include, InstanceMethods)
end
module ClassMethods
def bar
'bar'
end
end
module InstanceMethods
def qux
'qux'
end
end
end
class Something
include ConcernExample
end
Something.bar #=> 'bar'
Something.qux #=> NoMethodError: undefined method `qux'
Something.new.bar #=> NoMethodError: undefined method `bar'
Something.new.qux #=> 'qux'
```
## Ulteriori risorse
- [Learn Ruby by Example with Challenges](http://www.learneroo.com/modules/61/nodes/338) - Una variante di questa guida con esercizi nel browser.
- [An Interactive Tutorial for Ruby](https://rubymonk.com/) - Imparare Ruby attraverso una serie di tutorial interattivi.
- [Official Documentation](http://ruby-doc.org/core)
- [Ruby from other languages](https://www.ruby-lang.org/en/documentation/ruby-from-other-languages/)
- [Programming Ruby](http://www.amazon.com/Programming-Ruby-1-9-2-0-Programmers/dp/1937785491/) - Una passata [edizione libera](http://ruby-doc.com/docs/ProgrammingRuby/) è disponibile online.
- [Ruby Style Guide](https://github.com/bbatsov/ruby-style-guide) - A community-driven Ruby coding style guide.
- [Try Ruby](https://try.ruby-lang.org/) - Imparare le basi del linguaggio di programmazion Ruby, interattivamente nel browser.
Reference in New Issue View Git Blame Copy Permalink