Ruby

Ruby
Paradigma	multiparadigma: orientado a obxectos.
Data	1995
Deseñador	Yukihiro Matsumoto
Desenvolvedor	Yukihiro Matsumoto (e outros)
Última versión	1.9.0
Tipo de dato	forte, dinámico
Influído por	Smalltalk, Perl, Lisp, Scheme, Python, CLU, Eiffel, Ada, Dylan
Influíu	Groovy
Sistema operativo	Cross-platform
Licenza	Ruby License GNU General Public License
Web	[1]

Ruby é unha linguaxe de programación reflexivo e orientado a obxetos (linguaxe interpretada), creado polo programador xaponés Yukihiro "Matz" Matsumoto en 1993. Combina unha sintaxe inspirada en Python, Perl con características de programación orientada a obxetos similares a Smalltalk. Comparte tamén funcionalidade con outras linguaxes de programación como Lisp, Lua (linguaxe de programación), Dylan e CLU. Ruby é unha linguaxe de programación interpretada nunha soa pasada e a súa implementación oficial é distribuida baixo unha licencia de software libre.

Historia

Yukihiro Matsumoto, creador de Ruby.

A linguaxe foi creado por Yukihiro "Matz" Matsumoto, quen comezou a traballar o Ruby en 24 de febrero de 1993, e lanzóuno ó público no año 1995. O nome "Ruby" foi ideado en base á pedra correspondente ó mes de nacemento dun colega. Á data de Decembro de 2007,a última versión estable é a 1.8.6; o 26 de Decembro de 2007 foi publicado Ruby 1.9.0: unha versión de desenrrolo que incorpora melloras sustanciaies no rendimiento da linguaxe, que se espera queden reflexadas na próxima versión estable de produción da linguaxe, Ruby 2.0. Diferenzas en rendemento entre a actual implementación de Ruby (1.8.6) e outras linguaxes de programación más arraigados levaron ó desarrollo de varias máquinas virtuales para Ruby. Entre ésas atópanse JRuby, un intento de levar Ruby á plataforma Java, e Rubinius, un intérprete modelado en base ás máquinas virtuales de Smalltalk.

.

Filosofía

O creador da linguaxe, Yukihiro "Matz" Matsumoto, dixo que Ruby foi deseñado para a productividade e divertimento do desenvolvedor, seguindo os principios dun bo deseño de interface de usuario. El afirma que os deseños de sistemas precisan ser deseñados para os humáns, fronte ás computadoras: :

A maioría da xente, especialmente os enxeñeiros informáticos, centranse nas máquinas. Pensan, "Facendo isto, a máquina correrá máis rápido. Facendo isto, a máquina será máis eficiente. Facendo isto, a máquina ..." Centranse nas máquinas. Pero de feito precisamos centrarnos nos humanos, en como os humanos levan a cabo a programación ou traballan cos ordenadores. Nos somos os maestros. Eles os escravos.

Ruby segue o principio da menor sorpresa (POLS), que significa que a linguaxe debería comportarse da forma que leve á minima confusión á experiencia do usuario. Matz ten dito que a súa primeira finalidade do deseño é facer unha linguaxe que el mesmo se divirpregando, minimizando o traballo do programador e a posible confusión. El non empregou o priniciop da menor sorpresa ó deseño de Ruby pero de todolos xeitos a frase xa está ben ligada á linguaxe de programación Ruby.

En mayo de 2005 nunha discusión na grupo de novas comp.lang.ruby, Matz tentaba distanciar Ruby de POLS, explicando que dende calquera elección de deseño que sexa sorprendente para alguen, el emprega un estándar persoal na avaliación da sorpresa. Se o estándar persoal segue sendo consistente terá poucas sorpresas para aqueles que estexan acostumados ós estándares.[2]

Matz definiuno desta forma nunha entrevista [3]: Todos teñen un transfondo individual. Algúns poden vir dende Python, outros dende Perl, e poden estar sorprendidos por diferentes aspectos da linguaxe. Eles poden vir e dicirme, 'Estou sorprendido por esta carcterística da linguaxe, porque Ruby viola o principio da menor sorpresa.' Espera. Espera. O principio da menor sorpresa non é só para ti. O principio da menor sorpresa significa principio da miña menor sorpresa. E isto significa a menor sorpresa despois de que aprendas Ruby bastante ben. Por exemplo, Eu fun un programador de C++ antes de comezar a deseñar Ruby. Programei en C++ exclusivamente durante dous ou tres anos. E despois de dous anos de programación con C++, incluso me sorprendeu.

Semántica

Ruby é orientado a objetos: tódolos tipos de datos son un obxeto, incluídas as clases e tipos que outras linguaxes definen como primitivas, (como enteiros, booleanos, e "nil"). Toda función é un método. As variables sempre son referencias a obxetos, non os obxetos mismos. Ruby soporta herdanza con enlace dinámico, mixins e patróns singleton (pertencentes e definidos por unha soa instancia máis que definidos poa clase). A pesar de que Ruby non soporta herdanza múltiple, as clases poden importar módulos como mixins. A sintáxis procedural esta soportada, pero tódolos métodos definidos fora do ámbito dun objeto son realmente métodos da clase Object. Como esta clase é pai de tódalas demáis, os cambios son visibles para tódalas clases e obxetos.

Ruby descibíuse coma unha linguaxe de programación multiparadigma: permite programación procedural (definindo funcións e variables fora das clases facéndoas parte do obxeto raiz Object), con orientación a obxetos, (todo é un obxeto) ou funcionalmente (ten funcións anónimas, clausuras ou closures, e continuations; tódalas sentencias teñen valores, e as funcións devolven a última avaliación). Soporta introspección, reflexión e metaprogramación, ademáis de soporte para fios de execución xestionados polo intérprete . Ruby tentipado dinámico, e soporta polimorfismo.

De acordo coas preguntas frecuentes de Ruby , "Se che gusta Perl, gustarache Ruby e a súa sintaxe. Se che Smalltalk, gustarache Ruby e a súa semántica. Se che gusta Python, a enorme diferencia de diseño entre Python y Ruby/Perl pode que che convenza ou pode que non."

Características

• orientado a obxetos
• catro niveles de ámbito de variable: global, clase, instancia y local.
• manexo de excepcións
• iteradores e clausuras o closures (pasando bloques de código)
• expresións regulares nativas similares ás de Perl a nivel de linguaxe
• posibilidad de redefinir los operadores (sobrecarga de operadores)
• recolección de basura automática
• altamente portable
• Fíos de execución simultáneos en tódalas plataformas empregando green threads
• Carga dinámica de DLL/librerías compartidas na maioría das plataformas
• introspección, reflexión e metaprogramación
• amplia librería estándar
• soporta inxección de dependencias
• soporta alteración de obxetos en tempo de execución
• continuacións e xeneradores

Ruby actualmente non tiene soporte completo de Unicode, a pesar de tener soporte parcial para UTF-8.

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. 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 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:

$ irb
irb(main):001:0> puts "Hola Galiza"
Hola Galiza
=> nil
irb(main):002:0> 1+2
=> 3

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. Sen embargo, en futuras versións (revisión actual: 1.9), Ruby será 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.
• 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 (), para evitar significados ambígüos no código. O non emprego dos () 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 method_missing().

A lista de "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. retry, por exemplo, agora funciona con while, until, e for, 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:

puts "Hola Mundo!"

Algún código Básico de Ruby:

# Todo, incluído os literais, son obxetos, así traballa:
-199.abs                                                # 199
"ruby mola".length                                   # 9
"Rick".index("c")                                       # 2
"¿Caralludo o día non?".downcase.split(//).sort.uniq.join  # " '?acdelnoru"

Conversións:

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.'

Coleccións

Construído e empregando un array:

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]

Construcíndo e empregando un hash:

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'

Bloques e iteradores

Dúas sintaxes para crear un bloque de código:

{ puts "Hola Mundo!" } # Olla os { corchetes }

do puts "Hola Mundo!" end

Paso de parámetros a un bloque para ser envolto:

# Nunha variable de instancia de obxeto (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 obxeto) -- chamamos a envoltura!
@block.call("Jon")
# => "Hola, Jon!"

Retornando envolturas dun método:

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

Producindo o fluxo de control dun programa a un bloque que nos foi proporcionado cando se nos chamou:

 
def use_hola
	yield "hola"
end
 
# Invocamos o método anterior, pasandolle un bloque.
use_hola {|cadea| puts cadea} # => 'hola'

Iterando sobre enumeracións e arrays empregando bloques:

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

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:

[1,3,5].inject(10) {|suma, elemento| suma + elemento} # => 19

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:

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.

Empregando unha enumeración e un bloque para facer o cuadrado dos númeors 1 a 10:

(1..10).collect {|x| x*x} # => [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

Repositorios e Librarías

O Ruby Application Archive (RAA), tamén coñecido coma RubyForge, serve como repositorio para un amplo rango de aplicazóns Ruby e librarías, contendo máis de dous centos de elementos. Aínda que o número de aplicacións non coinccide moito co volume de material dispoñíbel na comunidade Perl ou Python, hai un amplo rango de ferramentas e utilidades as cales seven para impulsar o desenvolvemento da linguaxe.

RubyGems chegou a ser o mantedor de paquetes estándar para as librarías Ruby. É moi similar en propositos ó de Perl CPAN, aínda que o seu uso é moi parecido a apt-get.

Implementacións

Ruby ten dúas grandes implementacións: O Ruby oficial intérprete tamén chamando como o Matz's Ruby Interpreter(Intérprete de Ruby de Matz) (MRI), o máis extendido, e JRuby, a implementación baseada en Java.

Hai outras implementacións como son IronRuby (pre-alpha fontes dispoñibles dende o 31 de agosto de 2007), Rubinius, Ruby.NET, XRuby e YARV. YARV é a nova máquina virtual oficial de Ruby 1.9 non estará dispoñíble como un proxecto separado dende a devandita versión.

Sistemas operativos

Están dispoñibles versións do interprete de Ruby para os seguintes sistemas operativoss:

• Acorn RISC OS
• Amiga
• BeOS
• DOS
• Linux
• Mac OS X
• Maemo
• Microsoft Windows 95/98/2000/2003/NT/XP/Vista
• Microsoft Windows CE
• MorphOS
• OS/2
• OpenVMS
• Syllable
• Symbian OS
• Blue Gene/L nodo de computo do kernel
• A maioría dos sabores de Unix

Existen outros portes que non se listaron aquí.

Críticas

A versión 1.8, a actual versión estable do interprete, ten algunhas limitacións, que inclúen:

• Rendemento -- o rendemento do interprete de Ruby está por detras das linguaxes comparables coma Perl, PHP, and Python [4] [5], principalmente debido ó deseño do interprete: para executar código Ruby, o interprete construe un arbore de sintaxe do código fonte e logo avalia o arbore de sintaxe directamente, no canto de compilalo directamente nunha forma executable máis eficiente.
• Threading -- o modelo de fios de ruby emprega fios verdes [6], e este modelo ten algunhas limitacións inherentes que acarrexan a dificultade de empregalo ou de non ter seguranza en escenarios específicos.[7].
• Unicode -- Ruby non ten aínda soporte nativo para Unicode ou cadeas multibyte [8].
• Compatibilidade cara atrás -- Ruby sofre de problemas de compatibilidade cara atrás con versións novas e vellas [9].

Ruby 2.0 é o obxetivo para eliminar estes problemas mencionados:

• Rendemento -- un novo e máis rápido intérprete, YARV, unha máquina virtual que executa instruccións, que son compiladas en instrucción nativas do procesador empregando o compilador JIT.
• Threading -- os fíos nativos empregaránse no canto de fíos verdes.[10]
• Unicode -- suporte compreto para cadeas Unicode.

A version 1.9, o código base que é considerado a versión de desenrrolo de 2.0 2.0, foi liberdada [11] o 26 de Decembro de 2007.

Algúns problemas aínda non foron solventados, polo que na versión 2.0 serán incluídos:

• Ruby aínda falla na especificación, a actual implementación C é a especificación referenza de facto [12] [13] .

Licenza

O intérprete e as bibliotecas están licenciadas de forma dual (inseparable) baixo as licencias libres e de código aberto GPL e Licenza Ruby.

Vexase tamén

• RubyGems (xestor de paquetes para Ruby)
• Ruby on Rails (framework orientado a aplicacións web en Ruby)
• JRuby (implementación en Java do intérprete de Ruby)
• Orientado a obxetos (Programación orientada a obxetos)

Ligazóns externas

• Ruby Sitio principal de Ruby en Internet.
• Ruby central Recursos sobre Ruby en Inglés.
• Rubíes Comunidad hispana de usuarios de Ruby.
• Ruby Tutorial tutorial en castelán de Ruby.
• Programming Ruby, David Thomas e Andrew Hunt. Libro libre
• Ruby Argentina Comunidad Arxentina de Ruby
• Ruby Venezuela Ruby de Venezuela
• Full Ruby on Rails Tutorial
• Inline::Ruby módulo Perl en CPAN para programar Ruby dentro de Perl (en inglés)
• rubyisms módulo Perl en CPAN que incorpora algunhas ideas de Ruby para Perl (en inglés)
• HTML::ERuby módulo Perl en CPAN que procesa linguaxe ERuby (en inglés)
• Syntax::Highlight::Engine::Kate::Ruby módulo Perl en CPAN para o coloreado sintáctico de Ruby dentro de Kate (en inglés)
• Inline::Ruby::dRuby::Client módulo Perl en CPAN, delegador de obxetos dRuby (en inglés)