|
==Sintaxe==
A sintaxe de Ruby é moi similar á de Perl e Python. As definicións de clases e métodos son sinaladas por palabras chave. En contraste con Perl, as variables non son prefixadas obrigatoriamente con un símbolo [[símbolo (informática)|símbolo]]. Cando son empregados, os símbolos cambian a semántica do ámbito da variable. A diferenza máis grande dende C e Perl son que as palabras chave son normalmente empregadas para definir bloques de código lóxico, sen corchetes (p.e. pares de { e }). Os finais de liña son significativos e recollen o final da declaración ; un punto e coma pode ser equivalentemente empregado. Fronte a Python, a indentación non é significativa.
Unha das diferenzas de Ruby comparado con Python e Perl é que Ruby fai as variables de instancia totalmente privadas á clase e só as mostra a través de métodos accesores (attr_writer, attr_reader,etc).
Fronte ós métodos "getter" e "setter" de outras linguaxes como C++ ou Java, os métodos de acceso en Ruby poden ser escritos nunha soa liña de código. Como a invocación destes métodos non require o emprego de parénteses isto fai trivial os cambios nas variables de instancia nunha clase completa, modificando unha única liña de código e sen ter que facer unha refactorización para ter outra funcionalidade, isto é similar ás propiedades dos membros en C# e VB.NET. Os descritores de propiedades en Python son similares, pero traen un proceso de desenrrolo. Se un comeza en Python a empregar variables de instancia espostas públicamente, o código interno da clase pode precisar o axuste para empregar unha variable de privada fronte a unha propiedade pública, Ruby elimina esta decisión de deseño forzando a tódalas variables de instancia a ser privadas, pero tamén proporciona unha forma simple de declarar métodos de set e get. Isto mantén nuna idea de que en Ruby, un nunca accederá directamente ós valores internos dos membros da clase dende fora de ela. Polo tanto terá que a pasar unha mensaxe á clase e recibir unha resposta.
Vota unha ollada á sección de ''[[#Exemplos|exemplos]]'' para atopar exemplos de código demostrando a sintaxe de Ruby.
==Interacción==
A distribución oficial de Ruby inclúe "irb"(Interactive Ruby Shell), un intérprete interactivo de líña de comandos que pode ser empregado para probar código de manera rápida. O seguinte fragmento de código representa unha mostra dunha sesión empregando irb:
=> 3
</source>
==Falla==
===Características da linguaxe===
* En termos de velocidade, Ruby ten un rendemento inferior a algunhas linguaxes compiladas (xa que é unha linguaxe interpretada) e outras linguaxes maioritarias de script como [[Python]] e [[Perl]]<ref name="alioth">[http://shootout.alioth.debian.org/ The Computer Language Benchmarks Game]</ref>. Sen embargo, en futuras versións (revisión actual: 1.9), Ruby será [[bytecode|compilado bytecode]] para ser executado en [[YARV]] (''Yet Another Ruby VM''). Actualmente, o [[memory footprint]](emprego de memoria) de Ruby é superior para as mesmas operacións que as de Perl e Python.<ref name="alioth" />
* A omisión dos parénteses nos argumentos dos métodos poden lever a resultados inexperados se os métodos recollen parámetros múltiples. Nótese que os desenvolvedores de Ruby advertiron que a omisión de parénteses en métodos multi-parametrais será eliminado en futuras versións de Ruby, o intérprete de Ruby actualmente (Feb 2007) volta unha advertencia que advite ó escitor de ''non'' omitir os <code>()</code>, para evitar significados ambígüos no código. O non emprego dos <code>()</code> así e todo é tamén unha práctica moi común, e pode ser especialmente boa para empregar Ruby coma unha linguaxe de máis lexible polas persoas, ademais do método chamado <code>method_missing()</code>.
A omisión dos parénteses nos argumentos dos métodos poden lever a resultados inexperados se os métodos recollen parámetros múltiples. Nótese que os desenvolvedores de Ruby advertiron que a omisión de parénteses en métodos multi-parametrais será eliminado en futuras versións de Ruby, o intérprete de Ruby actualmente (Feb 2007) volta unha advertencia que advite ó escitor de ''non'' omitir os <code>()</code>, para evitar significados ambígüos no código. O non emprego dos <code>()</code> así e todo é tamén unha práctica moi común, e pode ser especialmente boa para empregar Ruby coma unha linguaxe de máis lexible polas persoas, ademais do método chamado <code>method_missing()</code>.
A lista de "[[gotcha|falla]]" pode ser atopado no libro de Hal Fulton ''The Ruby Way'', 2nd ed (ISBN 0-672-32884-4), Section 1.5. Unha lista similar á da 1ª edición escrita para a anterior versión da linguaxe (version 1.6), algúns problemas solucionáronse co tempo. <code>retry</code>, por exemplo, agora funciona con <code>while</code>, <code>until</code>, e <code>for</code>, así coma cos iteradores.
==Exemplos==
Os seguintes exemplos poden ser executados na liña de comandos Ruby ''irb'' [[Interactive Ruby Shell]] ou gardados nun ficheiro e correlos dende a liña de comandos escribindo '''ruby <nome de ficheiro>'''
Exemplo Clásico [[Hola Mundo]]:
<source lang="ruby">
puts "Hola Mundo!"
</source>
Algún código Básico de Ruby:
<source lang="ruby">
# Todo, incluído os literais, son obxectos, así traballa:
-199.abs # 199
"ruby mola".length # 9
"Rick".index("c") # 2
"¿Caralludo o día non?".downcase.split(//).sort.uniq.join # " '?acdelnoru"
</source>
Conversións:
<source lang="ruby">
puts '¿Cal é o teu día favorito?'
numbero = gets.chomp
numero_saida = numbero.to_i + 1
puts numero_saida.to_s + ' é un número máis grande que o meu número favorito.'
</source>
===Coleccións===
Construído e empregando un [[array]]:
<source lang="ruby">
a = [1, 'hi', 3.14, 1, 2, [4, 5]]
a[2] # 3.14
a.reverse # [[4, 5], 2, 1, 3.14, 'hi', 1]
a.flatten.uniq # [1, 'hi', 3.14, 2, 4, 5]
</source>
Construcíndo e empregando un [[hash table|hash]]:
<source lang="ruby">
hash = { :auga => 'mollada', :lume => 'quente' }
puts hash[:lume] # Prints: quente
hash.each_pair do |key, value| # ou: hash.each do |key, value|
puts "#{key} é #{value}"
end
# Imprimer: auge é mollada
# lume é quente
hash.delete_if {|key, value| key == :water} # Borra :water => 'wet'
</source>
===Bloques e iteradores===
Dúas sintaxes para crear un bloque de código:
<source lang="ruby">
{ puts "Hola Mundo!" } # Olla os { corchetes }
do puts "Hola Mundo!" end
</source>
Paso de parámetros a un bloque para ser [[Envoltura (informática)|envolto]]:
<source lang="ruby">
# Nunha variable de instancia de obxecto (denotado como '@'), lembra o bloque.
def recorda(&a_block)
@bloque = a_block
end
# Invocamos o método anterior, pasándolle un bloque que colle un nome.
recorda {|nome| puts "Hola, #{nome}!"}
# Cando é o momento (para o obxecto) -- chamamos a envoltura!
@block.call("Jon")
# => "Hola, Jon!"
</source>
Retornando envolturas dun método:
<source lang="ruby">
def crear_set_e_get(valor_inicial=0) # Nota o valor por defecto de 0
valor_envoltura = valor_inicial
return Proc.new {|x| valor_envoltura = x}, Proc.new { valor_envoltura }
end
setter, getter = crear_set_and_get # ie. volta dous valores
setter.call(21)
getter.call # => 21
</source>
Producindo o fluxo de control dun programa a un bloque que nos foi proporcionado cando se nos chamou:
<source lang="ruby">
def use_hola
yield "hola"
end
# Invocamos o método anterior, pasandolle un bloque.
use_hola {|cadea| puts cadea} # => 'hola'
</source>
Iterando sobre enumeracións e arrays empregando bloques:
<source lang="ruby">
array = [1, 'hi', 3.14]
array.each { |elemento| puts elemento }
# => 1
# => 'hi'
# => 3.14
array.each_index { |indice| puts indice.to_s + ": " + array[indice] }
# => 0: 1
# => 1: 'hi'
# => 2: 3.14
(3..6).each { |num| puts num }
# => 3
# => 4
# => 5
# => 6
</source>
Un método como é inject() pode aceptar ámbolos parámetros e un bloque. Inject itera sobre cada elemento da lista, levando a cabo algunha función mentras se obten e agrega. Isto é analogo á función [[foldl]] nos [[linguaxes de programación funcional]]. Por exemplo:
<source lang="ruby">
[1,3,5].inject(10) {|suma, elemento| suma + elemento} # => 19
</source>
Na primeira chamada, o bloque recibe 10 (o argumento a inxectar) como suma, e 1 (o primeiro elmeento do array) como elmento, Isto volta 11. 11 logo é a suma no seguinte paso, ó cal se lle engade 3 para recoller 14. a 14 logo engadeselle 5, para finalmente voltar 19.
Traballo dos bloques en algúns métodos internos da linguaxe:
<source lang="ruby">
File.open('ficheiro.txt', 'w') do |ficheiro| # 'w' denota "modo escritura".
file.puts 'Escribiu algún texto.'
end # O ficheiro é automaticamente pechado aquí
File.readlines('ficheiro.txt').each do |liña|
puts liña
end
# => Escribiru algún texto.
</source>
Empregando unha enumeración e un bloque para facer o cuadrado dos númeors 1 a 10:
<source lang="ruby">
(1..10).collect {|x| x*x} # => [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
</source>
==Repositorios e Librarías==
| 