Ruby (lenguaje de programación)

Lenguaje de programación interpretado, de alto nivel y de propósito general

Este artículo trata sobre el lenguaje de programación. Para otros usos, consulte Ruby (desambiguación) .

No confundir con Ruby on Rails .

Rubí

Paradigma	Multi-paradigma : funcional , imperativo , orientado a objetos , reflexivo
Diseñada por	Yukihiro Matsumoto
Desarrollador	Yukihiro Matsumoto y col.
Apareció por primera vez	1995 ; Hace 26 años ( 1995 )
Lanzamiento estable	3.0.1 [1]  (5 de abril de 2021 ; hace 36 días ) [±] ( 5 de abril de 2021 )
Disciplina de mecanografía	Pato , dinámico , fuerte
Alcance	Léxico, a veces dinámico
Lenguaje de implementación	C
SO	Multiplataforma
Licencia	Licencia Ruby , GPLv2 o licencia BSD de 2 cláusulas [2] [3] [4]
Extensiones de nombre de archivo	.rb
Sitio web	www .ruby-lang .org
Implementaciones importantes
Rubí MRI , YARV , Rubinius , levitación magnética , JRuby , MacRuby , RubyMotion , Mruby , IronRuby
Influenciado por
Ada , [5] Básico , [6] C ++ , [5] CLU , [7] Dylan , [7] Eiffel , [5] Lisp , [7] Lua , Perl , [7] Python , [7] Smalltalk [7 ]
Influenciado
Clojure , CoffeeScript , Crystal , D , Elixir , Groovy , Ioke , [8] Julia , [9] Mirah , Nu , [10] Ring, [11] Rust , [12] Swift [13]
Programación Ruby en Wikilibros

Ruby es un lenguaje de programación interpretado , de alto nivel y de propósito general . Fue diseñado y desarrollado a mediados de la década de 1990 por Yukihiro "Matz" Matsumoto en Japón .

Ruby se escribe dinámicamente y utiliza la recolección de basura . Admite múltiples paradigmas de programación , incluida la programación de procedimientos , orientada a objetos y funcional . Según el creador, Ruby fue influenciado por Perl , Smalltalk , Eiffel , Ada , BASIC y Lisp . ^{[14] [15]}

Historia

Concepto inicial

Matsumoto ha dicho que Ruby fue concebido en 1993. En una publicación de 1999 en la lista de correo de ruby-talk , describe algunas de sus primeras ideas sobre el idioma: ^[16]

Estaba hablando con mi colega sobre la posibilidad de un lenguaje de scripting orientado a objetos. Conocía Perl (Perl4, no Perl5), pero en realidad no me gustaba porque olía a lenguaje de juguete (todavía lo tiene). El lenguaje orientado a objetos parecía muy prometedor. Entonces conocí a Python . Pero no me gustó, porque no pensé que fuera un verdadero lenguaje orientado a objetos; las características de OO parecían ser un complemento del lenguaje. Como maníaco del lenguaje y fanático de OO durante 15 años, realmente quería un lenguaje de scripting genuino, orientado a objetos y fácil de usar. Busqué pero no pude encontrar uno. Así que decidí hacerlo.

Matsumoto describe el diseño de Ruby como un simple lenguaje Lisp en su núcleo, con un sistema de objetos como el de Smalltalk, bloques inspirados en funciones de orden superior y una utilidad práctica como la de Perl. ^[17]

El nombre "Ruby"

El nombre "Ruby" se originó durante una sesión de chat en línea entre Matsumoto y Keiju Ishitsuka el 24 de febrero de 1993, antes de que se escribiera ningún código para el idioma. ^[18] Inicialmente se propusieron dos nombres: " Coral " y " Ruby ". Matsumoto eligió este último en un correo electrónico posterior a Ishitsuka. ^[19] Matsumoto notó más tarde un factor en la elección del nombre "Ruby": era la piedra de nacimiento de uno de sus colegas. ^{[20] [21]}

Primera publicación

El primer lanzamiento público de Ruby 0.95 se anunció en los grupos de noticias nacionales japoneses el 21 de diciembre de 1995. ^{[22] [23]} Posteriormente, se lanzaron tres versiones más de Ruby en dos días. ^[18] El lanzamiento coincidió con el lanzamiento de la lista de correo ruby-list en idioma japonés , que fue la primera lista de correo para el nuevo idioma.

En esta etapa de desarrollo ya estaban presentes muchas de las características familiares en versiones posteriores de Ruby, incluido el diseño orientado a objetos , clases con herencia, mixins , iteradores , cierres , manejo de excepciones y recolección de basura . ^[24]

Lanzamientos tempranos

Tras el lanzamiento de Ruby 0.95 en 1995, se lanzaron varias versiones estables de Ruby en los años siguientes:

• Ruby 1.0: 25 de diciembre de 1996 ^[18]
• Ruby 1.2: diciembre de 1998
• Ruby 1.4: agosto de 1999
• Ruby 1.6: septiembre de 2000

En 1997, se publicó en la Web el primer artículo sobre Ruby. Ese mismo año, netlab.jp contrató a Matsumoto para trabajar en Ruby como desarrollador a tiempo completo. ^[18]

En 1998, Matsumoto lanzó Ruby Application Archive, junto con una sencilla página de inicio en inglés para Ruby. ^[18]

En 1999, comenzó la primera lista de correo en inglés ruby-talk , lo que señaló un creciente interés en el idioma fuera de Japón. ^[25] En este mismo año, Matsumoto y Keiju Ishitsuka escribieron el primer libro sobre Ruby, El lenguaje de secuencias de comandos orientado a objetos Ruby (オ ブ ジ ェ ク ト 指向 ス ク リ プ ト 言語 Ruby), que se publicó en Japón en octubre de 1999. 2000 por alrededor de 20 libros sobre Ruby publicados en japonés. ^[18]

En 2000, Ruby era más popular que Python en Japón. ^[26] En septiembre de 2000, se imprimió el primer libro en inglés Programming Ruby , que luego se lanzó gratuitamente al público, ampliando aún más la adopción de Ruby entre los angloparlantes. A principios de 2002, la lista de correo ruby-talk en inglés recibía más mensajes que la lista ruby- language en japonés , lo que demuestra la creciente popularidad de Ruby en el mundo de habla no japonesa.

Ruby 1.8

Ruby 1.8 se lanzó inicialmente en agosto de 2003, se mantuvo estable durante mucho tiempo y se retiró en junio de 2013. ^[27] Aunque está obsoleto, todavía hay código basado en él. Ruby 1.8 es solo parcialmente compatible con Ruby 1.9.

Ruby 1.8 ha sido objeto de varios estándares de la industria. Las especificaciones de idioma para Ruby fueron desarrolladas por el Centro de Promoción de Estándares Abiertos de la Agencia de Promoción de Tecnologías de la Información (una agencia del gobierno japonés ) para su presentación al Comité de Normas Industriales de Japón (JISC) y luego a la Organización Internacional de Normalización (ISO). Fue aceptado como norma industrial japonesa (JIS X 3017) en 2011 ^[28] y como norma internacional ( ISO / IEC 30170 ) en 2012. ^{[29] [30]}

Alrededor de 2005, el interés en el lenguaje Ruby surgió junto con Ruby on Rails , un marco web escrito en Ruby. Con frecuencia se atribuye a Rails el aumento de la conciencia de Ruby. ^[31]

Ruby 1.9

Ruby 1.9 fue lanzado el día de Navidad de 2007. Efectivo con Ruby 1.9.3, lanzado el 31 de octubre de 2011, ^[32] Ruby pasó de tener una licencia doble bajo la Licencia Ruby y la GPL a tener una licencia doble bajo la Licencia Ruby y la licencia BSD de dos cláusulas. ^{[33] La} adopción de 1.9 fue ralentizada por cambios de 1.8 que requirieron la reescritura de muchas gemas populares de terceros .

Ruby 1.9 introduce muchos cambios significativos sobre la serie 1.8. ^[34] Ejemplos:

• Bloquear variables locales (variables que son locales al bloque en el que se declaran)
• una sintaxis lambda adicional :f = ->(a,b) { puts a + b }
• una sintaxis literal de Hash adicional usando dos puntos para las claves de símbolo:{symbol_key: "value"} == {:symbol_key => "value"}
• se admiten codificaciones de caracteres por cadena
• nueva API de socket ( soporte IPv6 )
• require_relative seguridad de importación

Ruby 1.9 está obsoleto desde el 23 de febrero de 2015, ^[35] y ya no recibirá correcciones de errores ni de seguridad. Se recomienda a los usuarios que actualicen a una versión más reciente.

Ruby 2.0

Ruby 2.0 agregó varias características nuevas, que incluyen:

• argumentos de la palabra clave del método,
• un nuevo método, Module#prependpara extender una clase,
• un nuevo literal para crear una matriz de símbolos,
• nueva API para la evaluación diferida de Enumerables, y
• una nueva convención de usar #to_h para convertir objetos a Hashes. ^[36]

Ruby 2.0 estaba destinado a ser totalmente compatible con versiones anteriores de Ruby 1.9.3. A partir del lanzamiento oficial 2.0.0 del 24 de febrero de 2013, solo había cinco incompatibilidades conocidas (menores). ^[37]

Ruby 2.0 está obsoleto desde el 24 de febrero de 2016, ^[38] y ya no recibirá correcciones de errores ni de seguridad. Se recomienda a los usuarios que actualicen a una versión más reciente.

Ruby 2.1

Ruby 2.1.0 se lanzó el día de Navidad de 2013. ^[39] El lanzamiento incluye aceleraciones, correcciones de errores y actualizaciones de la biblioteca.

A partir de 2.1.0, la política de control de versiones de Ruby se parece más al control de versiones semántico . ^[40] Aunque similar, la política de versiones de Ruby no es compatible con las versiones semánticas:

Rubí	Control de versiones semántico
MAYOR : aumentado cuando el cambio es incompatible que no se puede lanzar en MENOR. Reservado para eventos especiales.	MAYOR : aumenta cuando realiza cambios de API incompatibles.
MENOR : aumenta cada Navidad, puede ser incompatible con API.	MENOR : aumenta cuando agrega funcionalidad de una manera compatible con versiones anteriores .
TEENY : seguridad o corrección de errores que mantiene la compatibilidad con API. Puede aumentarse más de 10 (como 2.1.11) y se publicará cada 2-3 meses.	PARCHE : aumenta cuando realiza correcciones de errores compatibles con versiones anteriores.
PARCHE : número de confirmaciones desde la última versión MINOR (se restablecerá a 0 cuando se libere MINOR).	-

El control de versiones semántico también proporciona etiquetas adicionales para la versión preliminar y los metadatos de compilación están disponibles como extensiones del formato MAJOR.MINOR.PATCH, no disponible en Ruby.

Ruby 2.1 está obsoleto desde el 1 de abril de 2017, ^[41] y ya no recibirá correcciones de errores ni de seguridad. Se recomienda a los usuarios que actualicen a una versión más reciente.

Ruby 2.2

Ruby 2.2.0 se lanzó el día de Navidad de 2014. ^[42] La versión incluye aceleraciones, correcciones de errores y actualizaciones de bibliotecas y elimina algunas API obsoletas. En particular, Ruby 2.2.0 introduce cambios en el manejo de la memoria: un recolector de basura incremental, soporte para la recolección de basura de símbolos y la opción de compilar directamente contra jemalloc. También contiene soporte experimental para usar vfork (2) con system () y spawn (), y soporte adicional para la especificación Unicode 7.0.

Las características que se volvieron obsoletas o se eliminaron incluyen callcc, la biblioteca DL, Digest :: HMAC, lib / racional.rb, lib / complex.rb, GServer, Logger :: Application, así como varias funciones API de C. ^[43]

Ruby 2.2 está obsoleto desde el 1 de abril de 2018, ^[44] y ya no recibirá correcciones de errores ni de seguridad. Se recomienda a los usuarios que actualicen a una versión más reciente.

Rendimiento de PowerPC64

Desde la versión 2.2.1, ^[45] se mejoró el rendimiento de Ruby MRI en PowerPC64 . ^{[46] [47] [48]}

Ruby 2.3

Ruby 2.3.0 se lanzó el día de Navidad de 2015. Algunos cambios notables incluyen:

• La capacidad de marcar todos los literales de cadena como congelados de forma predeterminada con un gran aumento del rendimiento en las operaciones de cadena. ^[49]
• Comparación de hash para permitir la verificación directa de pares clave / valor en lugar de solo claves.
• Un nuevo operador de navegación seguro &. que puede facilitar el manejo nulo (por ejemplo, en lugar de , podemos usar ).if obj && obj.foo && obj.foo.barif obj&.foo&.bar
• La gema did_you_mean ahora se incluye de forma predeterminada y se requiere en el inicio para sugerir automáticamente coincidencias de nombres similares en un NameError o NoMethodError .
• Hash # dig y Array # dig para extraer fácilmente valores profundamente anidados (por ejemplo , dado , el valor Foo Baz ahora se puede recuperar ).profile = { social: { wikipedia: { name: 'Foo Baz' } } }profile.dig(:social, :wikipedia, :name)
• .grep_v(regexp) que coincidirá con todos los ejemplos negativos de una expresión regular dada, además de otras características nuevas.

La rama 2.3 también incluye muchas mejoras de rendimiento, actualizaciones y correcciones de errores, incluidos cambios en la llamada Proc #, uso de Socket y IO de palabras clave de excepción, manejo de nombres de Thread #, conexiones Net :: FTP pasivas predeterminadas y eliminación de Rake de stdlib. ^[50]

Ruby 2.4

Ruby 2.4.0 se lanzó el día de Navidad de 2016. Algunos cambios notables incluyen:

• Binding # irb: Inicie una sesión REPL similar a binding.pry
• Unificar Fixnum y Bignum en Entero clase
• String admite asignaciones de mayúsculas y minúsculas Unicode, no solo ASCII
• Un nuevo método, Regexp # match ?, que es una versión booleana más rápida de Regexp # match
• La detección de interbloqueo de subprocesos ahora muestra subprocesos con su seguimiento y dependencia

La rama 2.4 también incluye mejoras de rendimiento para la tabla hash, Array # max, Array # min y el acceso a variables de instancia. ^[51]

Ruby 2.5

Ruby 2.5.0 se lanzó el día de Navidad de 2017. ^[52] Algunos cambios notables incluyen:

• Las declaraciones de rescate y aseguramiento usan automáticamente un bloque do-end circundante (menos necesidad de bloques extra de inicio y fin )
• Encadenamiento de métodos con yield_self
• Soporte de cobertura de sucursales y medición de cobertura de método
• Transformaciones Hash más fáciles con Hash # slice y Hash # transform_keys

Además de eso, vienen muchas mejoras de rendimiento, como un paso de bloques más rápido (3 veces más rápido), Mutexes más rápidos, plantillas ERB más rápidas y mejoras en algunos métodos de concatenación.

Ruby 2.6

Ruby 2.6.0 se lanzó el día de Navidad de 2018. ^[53] Algunos cambios notables incluyen:

• JIT (experimental)
• RubyVM :: AbstractSyntaxTree (experimental)

Ruby 2.7

Ruby 2.7.0 se lanzó el día de Navidad de 2019. ^[54] Algunos cambios notables incluyen:

• Coincidencia de patrones (experimental)
• Mejora de REPL
• Compactación GC
• Separación de argumentos posicionales y de palabras clave

Ruby 3.0

Ruby 3.0.0 se lanzó el día de Navidad de 2020. ^[55] Se conoce como Ruby 3x3. Uno de sus principales objetivos era cambiar el intérprete a un compilador Just-In-Time, para hacer que los programas fueran más rápidos.

Tabla de versiones

Versión	Última versión pequeñita	Fecha de lanzamiento inicial	Fin de la fase de soporte	Fin de la fase de mantenimiento de la seguridad
Versión antigua, ya no se mantiene: 1.0	N / A	1996-12-25 [56]	N / A	N / A
Versión antigua, ya no se mantiene: 1.8	1.8.7-p375 [57]	2003-08-04 [58]	2012-06 [59]	2014-07-01 [60]
Versión antigua, ya no se mantiene: 1,9	1.9.3-p551 [61]	2007-12-25 [62]	2014-02-23 [63]	2015-02-23 [64]
Versión antigua, ya no se mantiene: 2.0	2.0.0-p648 [65]	2013-02-24 [66]	2015-02-24 [65]	2016-02-24 [65]
Versión antigua, ya no se mantiene: 2.1	2.1.10 [67]	25/12/2013 [68]	2016-03-30 [69] [70]	2017-03-31 [71] [72]
Versión antigua, ya no se mantiene: 2.2	2.2.10 [73]	25/12/2014 [74]	2017-03-28 [75]	2018-03-31 [72]
Versión antigua, ya no se mantiene: 2.3	2.3.8 [76]	25/12/2015 [77]	20/06/2018 [78]	31/03/2019 [78]
Versión antigua, ya no se mantiene: 2.4	2.4.10 [79]	2016-12-25 [80]	2019-04-01 [81]	2020-04-01 [81]
Versión antigua, ya no se mantiene: 2.5	2.5.9 [82]	25/12/2017 [83]	05/04/2021 [82]	05/04/2021 [82]
Older version, yet still maintained: 2.6	2.6.7 [84]	2018-12-25 [85]	TBA	TBA
Older version, yet still maintained: 2,7	2.7.3 [86]	2019-12-25 [87]	TBA	TBA
Current stable version: 3,0	3.0.1 [88]	25/12/2020 [89]	TBA	TBA
Leyenda: Versión antigua Versión anterior, aún mantenida Ultima versión Latest preview version Lanzamiento futuro

Filosofía

Yukihiro Matsumoto , el creador de Ruby

Matsumoto ha dicho que Ruby está diseñado para la productividad y la diversión del programador, siguiendo los principios de un buen diseño de interfaz de usuario . ^[90] En una charla técnica de Google en 2008, Matsumoto declaró además: "Espero que Ruby ayude a todos los programadores del mundo a ser productivos, disfrutar de la programación y ser felices. Ese es el propósito principal del lenguaje Ruby". ^[91] Hace hincapié en que el diseño de sistemas debe enfatizar las necesidades humanas, en lugar de las informáticas: ^[92]

A menudo, las personas, especialmente los ingenieros informáticos, se centran en las máquinas. Piensan: "Al hacer esto, la máquina funcionará más rápido. Al hacer esto, la máquina funcionará de manera más efectiva. Al hacer esto, la máquina hará algo, algo, algo". Se centran en las máquinas. Pero, de hecho, debemos centrarnos en los humanos, en cómo los humanos se preocupan por programar u operar la aplicación de las máquinas. Somos los maestros. Son los esclavos.

Se dice que Ruby sigue el principio del mínimo asombro (POLA), lo que significa que el lenguaje debe comportarse de tal manera que se minimice la confusión para los usuarios experimentados. Matsumoto ha dicho que su objetivo principal de diseño era crear un lenguaje que él mismo disfrutara usando, minimizando el trabajo del programador y la posible confusión. Ha dicho que no había aplicado el principio del menor asombro al diseño de Ruby, ^[92]Sin embargo, la frase ha llegado a estar estrechamente asociada con el lenguaje de programación Ruby. La frase en sí misma ha sido una fuente de sorpresa, ya que los usuarios novatos pueden interpretarla en el sentido de que los comportamientos de Ruby intentan coincidir estrechamente con los comportamientos familiares de otros idiomas. En una discusión de mayo de 2005 en el grupo de noticias comp.lang.ruby, Matsumoto intentó distanciar a Ruby de POLA, explicando que debido a que cualquier elección de diseño sorprenderá a alguien, usa un estándar personal para evaluar la sorpresa. Si ese estándar personal sigue siendo consistente, habrá pocas sorpresas para quienes estén familiarizados con el estándar. ^[93]

Matsumoto lo definió de esta manera en una entrevista: ^[92]

Todo el mundo tiene un trasfondo individual. Alguien puede provenir de Python, alguien más puede provenir de Perl y pueden sorprenderse con diferentes aspectos del lenguaje. Luego se me acercan y me dicen: 'Me sorprendió esta característica del lenguaje, así que Ruby viola el principio de la menor sorpresa'. Esperar. Esperar. El principio de la mínima sorpresa no es solo para ti. El principio de la menor sorpresa significa el principio de la menor sorpresa mía . Y significa el principio de la mínima sorpresa después de que aprendas Ruby muy bien. Por ejemplo, yo era programador en C ++ antes de comenzar a diseñar Ruby. Programé en C ++ exclusivamente durante dos o tres años. Y después de dos años de programación en C ++, todavía me sorprende.

Funciones

• Totalmente orientado a objetos con herencia , mixins y metaclases ^[94]
• Tipeo dinámico y tipeo de pato
• Todo es una expresión (incluso declaraciones ) y todo se ejecuta imperativamente (incluso declaraciones )
• Sintaxis sucinta y flexible ^[95] que minimiza el ruido sintáctico y sirve como base para lenguajes de dominios específicos ^[96]
• Reflexión dinámica y alteración de objetos para facilitar la metaprogramación ^[97]
• Cierres léxicos , iteradores y generadores , con sintaxis de bloque ^[98]
• Notación literal para matrices , hashes , expresiones regulares y símbolos
• Insertar código en cadenas ( interpolación )
• Argumentos predeterminados
• Cuatro niveles de alcance variable ( global , clase , instancia y local ) denotados por sigilos o la falta de los mismos
• Recolección de basura
• Continuaciones de primera clase
• Reglas de coerción booleanas estrictas (todo es cierto excepto falsey nil)
• Manejo de excepciones
• Sobrecarga del operador
• Soporte integrado para números racionales , números complejos y aritmética de precisión arbitraria
• Comportamiento de envío personalizado (a través de method_missingy const_missing)
• Hilos nativos y fibras cooperativas (las fibras son una característica 1.9 / YARV )
• Soporte para Unicode y codificaciones de caracteres múltiples .
• API de complemento nativo en C
• Interactive Ruby Shell (un REPL )
• Gestión de paquetes centralizada a través de RubyGems
• Implementado en todas las plataformas principales
• Gran biblioteca estándar, que incluye módulos para YAML , JSON , XML , CGI , OpenSSL , HTTP , FTP , RSS , curses , zlib y Tk ^[99]

Semántica

Ruby está orientado a objetos : cada valor es un objeto, incluidas las clases y las instancias de tipos que muchos otros lenguajes designan como primitivos (como enteros , booleanos y " nulos "). Las variables siempre tienen referencias a objetos. Cada función es un método y los métodos siempre se llaman en un objeto. Los métodos definidos en el ámbito de nivel superior se convierten en métodos de la clase Object. Dado que esta clase es un antepasado de todas las demás clases, estos métodos pueden invocarse en cualquier objeto. También son visibles en todos los ámbitos, sirviendo efectivamente como procedimientos "globales". Ruby admite herencia con envío dinámico , mixinsy métodos singleton (pertenecientes a, y definidos para, una sola instancia en lugar de estar definidos en la clase). Aunque Ruby no admite herencia múltiple , las clases pueden importar módulos como mixins.

Ruby ha sido descrito como un lenguaje de programación multi-paradigma : permite la programación procedimental (definir funciones / variables fuera de las clases las hace parte de la raíz, 'self' Object), con orientación a objeto (todo es un objeto) o programación funcional (it tiene funciones anónimas , cierres y continuaciones ; todas las declaraciones tienen valores y las funciones devuelven la última evaluación). Tiene soporte para introspección , reflexión y metaprogramación , así como soporte para hilos basados ​​en intérpretes ^[100] . Ruby presenta escritura dinámica y admitepolimorfismo paramétrico .

Según las preguntas frecuentes de Ruby, la sintaxis es similar a Perl y la semántica es similar a Smalltalk , pero difiere mucho de Python . ^[101]

Sintaxis

La sintaxis de Ruby es muy similar a la de Perl y Python . Las definiciones de clases y métodos se indican mediante palabras clave, mientras que los bloques de código se pueden definir mediante palabras clave o llaves. A diferencia de Perl, las variables no tienen un prefijo obligatorio con un sigilo . Cuando se usa, el sigilo cambia la semántica del alcance de la variable. A efectos prácticos, no hay distinción entre expresiones y declaraciones . ^{[102] [103]} Los saltos de línea son importantes y se toman como el final de una declaración; se puede utilizar de forma equivalente un punto y coma. A diferencia de Python, la sangría no es significativa.

Una de las diferencias de Python y Perl es que Ruby mantiene todas sus variables de instancia completamente privadas a la clase y sólo los expone a través de métodos de acceso ( attr_writer, attr_reader, etc.). A diferencia de los métodos "getter" y "setter" de otros lenguajes como C ++ o Java , los métodos de acceso en Ruby se pueden crear con una sola línea de código mediante metaprogramación ; sin embargo, los métodos de acceso también se pueden crear de la manera tradicional de C ++ y Java. Como la invocación de estos métodos no requiere el uso de paréntesis, es trivial cambiar una variable de instancia a una función completa, sin modificar una sola línea de código de llamada o tener que hacer una refactorización para lograr una funcionalidad similar a C # yMiembros de propiedad de VB.NET .

Los descriptores de propiedad de Python son similares, pero vienen con una compensación en el proceso de desarrollo. Si uno comienza en Python usando una variable de instancia expuesta públicamente, y luego cambia la implementación para usar una variable de instancia privada expuesta a través de un descriptor de propiedad, es posible que el código interno de la clase deba ajustarse para usar la variable privada en lugar de la propiedad pública. . El diseño de Ruby obliga a que todas las variables de instancia sean privadas, pero también proporciona una forma sencilla de declarar sety getmétodos. Esto está de acuerdo con la idea de que en Ruby, uno nunca accede directamente a los miembros internos de una clase desde fuera de la clase; más bien, uno pasa un mensaje a la clase y recibe una respuesta.

Consulte la sección de Ejemplos a continuación para ver ejemplos de código que demuestran la sintaxis de Ruby.

Interacción

Ver también: Shell Ruby interactivo

La distribución oficial de Ruby también incluye irbun intérprete de línea de comandos interactivo que se puede utilizar para probar el código rápidamente. El siguiente fragmento de código representa una sesión de muestra usando irb:

$ irb irb (principal): 001: 0> pone  'Hola, mundo' Hola, mundo => nil irb (principal): 002: 0> 1 + 2 => 3

Ejemplos

Esta sección no cita ninguna fuente . Por favor, ayuda a mejorar esta sección mediante la adición de citas de fuentes confiables . El material no obtenido puede ser cuestionado y eliminado . ( Enero de 2014 ) ( Obtenga información sobre cómo y cuándo eliminar este mensaje de plantilla )

Los siguientes ejemplos se pueden ejecutar en un shell Ruby como Interactive Ruby Shell , o se pueden guardar en un archivo y ejecutar desde la línea de comandos escribiendo .ruby <filename>

Ejemplo clásico de Hello world :

pone  "¡Hola mundo!"

Un poco de código Ruby básico:

# Todo, incluido un literal, es un objeto, así que esto funciona: - 199 . abs  # => 199 'el hielo es bueno' . length  # => 11 'ruby is cool.' . index ( 'u' )  # => 1 "Buen día, ¿no?" . downcase . dividir ( '' ) . uniq . ordenar . unirse  # => "'? acdeinsty"

Aporte:

print  'Por favor escriba nombre>' name  =  gets . chomp pone  "Hola # { nombre } ".

Conversiones:

pone  'Dame un número' número  =  obtiene . chomp pone  número . to_i número_salida  =  número . to_i  +  1 pone  output_number . to_s  +  'es un número mayor'.

Cadenas

Hay una variedad de formas de definir cadenas en Ruby.

Las siguientes asignaciones son equivalentes:

a  =  " \ n Esta es una cadena entre comillas dobles \ n " a  =  % Q { \ n Esta es una cadena entre comillas dobles \ n } a  =  % { \ n Esta es una cadena entre comillas dobles \ n } a  =  % / \ nEsta es una cadena entre comillas dobles \ n / a  =  << - BLOQUEEste es un BLOQUE de cadena entre comillas dobles

Las cadenas admiten interpolación variable :

var  =  3 . 14159 "pi es # { var } " =>  "pi es 3.14159"

Las siguientes asignaciones son equivalentes y producen cadenas sin procesar :

a  =  'Esta es una cadena entre comillas simples' a  =  % q {Esta es una cadena entre comillas simples}

Colecciones

Construyendo y usando una matriz :

a  =  [ 3 ,  'hola' ,  14 . 5 ,  1 ,  2 ,  [ 6 ,  15 ]]a [ 2 ]  # => 14,5 a . [] ( 2 )  # => 14,5 a . reverso  # => [[6, 15], 2, 1, 14.5, 'hola', 3] a . aplanar . uniq  # => [3, 'hola', 14.5, 1, 2, 6, 15]

Construyendo y usando una matriz asociativa (en Ruby, llamada hash ):

hash  =  hash . new  # equivalente a hash = {} hash  =  {  water :  'wet' ,  fire :  'hot'  }  # hace que la línea anterior sea redundante ya que ahora  # estamos asignando hash a un nuevo objeto hash separado pone  hash [ : fire ]  # imprime "caliente"hash . each_pair  hacer  | clave ,  valor |  # o: hash.each do | clave, valor |  pone  " # { clave } es # { valor } " end # devuelve {: agua => "mojado",: fuego => "caliente"} e imprime: # el agua está mojada # el fuego está calientehash . delete  : water  # elimina el par: water => 'mojado' y devuelve hash "mojado" . delete_if  { | clave , valor |  valor  ==  'caliente' }  # elimina el par: fuego => 'caliente' y devuelve {}

Estructuras de control

Si declaración:

# Genere un número aleatorio e imprima si es par o impar. si  rand ( 100 ) . ¿incluso?  pone  "Es par"; de lo contrario,  pone  "Es extraño" al final

Bloques e iteradores

Las dos sintaxis para crear un bloque de código:

{  pone  "¡Hola, mundo!"  }  # Señalan los tirantes # o: do  pone  '¡Hola, mundo!' final

Un bloque de código se puede pasar a un método como un argumento de bloque opcional. Muchos métodos incorporados tienen tales argumentos:

Archivo . open ( 'file.txt' ,  'w' )  do  | archivo |  # 'w' denota  archivo en "modo de escritura" . pone  "Escribí un texto". end  # archivo se cierra automáticamente aquíArchivo . readlines ( 'archivo.txt' ) . cada uno  hace  | línea |  pone  fin de línea # => Escribió un texto.

Parámetro-pasar un bloque para ser un cierre :

# En una variable de instancia de objeto (indicada con '@'), recuerde un bloque. def  recordar ( & a_block )  @block  =  a_block end# Invocar el método anterior, dándole un bloque que tome un nombre. recuerda  { | nombre |  pone  "¡Hola, # { nombre } !" }# Llame al cierre (tenga en cuenta que esto sucede para no cerrar sobre ninguna variable libre): @block . call ( 'Jon' )  # => "¡Hola, Jon!"

Creando una función anónima :

proc  { | arg |  pone  arg } Proc . nuevo  { | arg |  pone  arg } lambda  { | arg |  pone  arg } -> ( arg )  { pone  arg }  # introducido en Ruby 1.9

Devolución de cierres de un método:

def  create_set_and_get ( valor_inicial = 0 )  # tenga en cuenta el valor predeterminado de 0  valor_cierre  =  valor_inicial  [  Proc . nuevo  { | x |  valor_cierre  =  x },  Proc . final de nuevo  {  valor_de_clave  }  ]setter ,  getter  =  create_set_and_get  # devuelve dos valores setter . llamar ( 21 ) getter . # de llamada  => 21# Las variables de parámetro también se pueden usar como un enlace para el cierre, # por lo que lo anterior se puede reescribir como:def  create_set_and_get ( valor_cierre = 0 )  [  proc  { | x |  cierre_valor  =  x  }  ,  proc  {  cierre_valor  }  ] final

Ceder el flujo de control del programa a un bloque que se proporcionó en el momento de la llamada:

def  use_hello  rendimiento  "hola" final# Invocar el método anterior, pasándole un bloque. use_hello  { | cadena |  pone  cadena }  # => 'hola'

Iterando sobre enumeraciones y matrices usando bloques:

matriz  =  [ 1 ,  'hola' ,  3 . 14 ] matriz . cada  { | artículo |  pone  artículo  } # impresiones: # 1 # 'hola' # 3.14matriz . each_index  { | índice |  pone  " # { index } : # { array [ index ] } "  } # imprime: # 0: 1 # 1: 'hola' # 2: 3.14# Lo siguiente usa un rango (a..b) ( 3 .. 6 ) . cada  { | num |  pone  num  } # impresiones: # 3 # 4 # 5 # 6# Lo siguiente usa un (a ... b) Rango ( 3 ... 6 ) . cada  { | num |  pone  num  } # impresiones: # 3 # 4 # 5

Un método como injectpuede aceptar tanto un parámetro como un bloque. El injectmétodo itera sobre cada miembro de una lista, realizando alguna función en él mientras retiene un agregado. Esto es análogo a la foldlfunción en los lenguajes de programación funcionales . Por ejemplo:

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

En la primera pasada, el bloque recibe 10 (el argumento a inyectar) como sumy 1 (el primer elemento de la matriz) como element. Esto devuelve 11, que luego se convierte sumen la siguiente pasada. Se suma a 3 para obtener 14, que luego se suma a 5 en la tercera pasada, para finalmente devolver 19.

Usando una enumeración y un bloque para elevar al cuadrado los números del 1 al 10 (usando un rango ):

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

O invoque un método en cada elemento ( mapes un sinónimo de collect):

( 1 .. 5 ) . map ( & : to_f )  # => [1.0, 2.0, 3.0, 4.0, 5.0]

Clases

El siguiente código define una clase llamada Person. Además initializedel constructor habitual para crear nuevos objetos, tiene dos métodos: uno para anular el <=>operador de comparación (por lo que Array#sortpuede ordenar por edad) y el otro para anular el to_smétodo (por lo que Kernel#putspuede formatear su salida). Aquí, attr_readerhay un ejemplo de metaprogramación en Ruby: attr_accessordefine métodos getter y setter de variables de instancia, pero attr_readersolo métodos getter. La última declaración evaluada en un método es su valor de retorno, lo que permite la omisión de una returndeclaración explícita .

clase de  persona  attr_reader  : nombre ,  : edad  def  initialize ( nombre ,  edad )  @Name ,  @age  =  nombre ,  edad  extremo  def  <=> ( persona )  # el operador de comparación para clasificar  @age  <=>  persona . age  end  def  to_s  " # { @name } ( # { @age } )"  end endgrupo  =  [  Persona . nuevo ( "Bob" ,  33 ),  Persona . nuevo ( "Chris" ,  16 ),  Persona . nuevo ( "Ash" ,  23 ) ]pone  grupo . ordenar . contrarrestar

El código anterior imprime tres nombres en orden inverso de edad:

Bob (33)Fresno (23)Chris (16)

Persones una constante y es una referencia a un Classobjeto.

Clases abiertas

En Ruby, las clases nunca se cierran: los métodos siempre se pueden agregar a una clase existente. Esto se aplica a todas las clases, incluidas las estándar integradas. Todo lo que se necesita hacer es abrir una definición de clase para una clase existente, y los nuevos contenidos especificados se agregarán a los contenidos existentes. Un ejemplo simple de agregar un nuevo método a la Timeclase de la biblioteca estándar :

# reabrir Ruby's Time class class  Time  def  ayer  self  -  86400  end endhoy  =  Hora . ahora  # => 2013-09-03 16:09:37 +0300 ayer  =  hoy . ayer  # => 2013-09-02 16:09:37 +0300

Agregar métodos a clases previamente definidas a menudo se denomina parcheado de mono . Si se realiza de forma imprudente, la práctica puede conducir tanto a colisiones de comportamiento con resultados inesperados posteriores como a problemas de escalabilidad del código.

Desde Ruby 2.0, ha sido posible usar mejoras para reducir las consecuencias potencialmente negativas del parche de mono, al limitar el alcance del parche a áreas particulares de la base del código.

# reabrir el módulo de  clase de Ruby's Time RelativeTimeExtensions  refine  Time  do  def  half_a_day_ago  self  -  43200  end  end endmodule  MyModule  class  MyClass  # Permitir que el refinamiento se use  usando  RelativeTimeExtensions def  window  Time . ahora . half_a_day_ago  end  end end

Excepciones

Se genera una excepción con una raisellamada:

aumentar

Se puede agregar un mensaje opcional a la excepción:

plantear  "Este es un mensaje"

El programador también puede especificar excepciones:

plantear  ArgumentError ,  "¡ Argumentos ilegales!"

Alternativamente, se puede pasar una instancia de excepción al raisemétodo:

plantear  ArgumentError . nuevo ( "¡Argumentos ilegales!" )

Esta última construcción es útil cuando se genera una instancia de una clase de excepción personalizada que presenta un constructor que toma más de un argumento:

class  ParseError  <  Exception  def  initialize ( input ,  line ,  pos )  super  "No se pudo analizar ' # { input } ' en la línea # { line } , posición # { pos } "  end endgenerar  ParseError . nuevo ( "Foo" ,  3 ,  9 )

Las excepciones son manejadas por la rescuecláusula. Dicha cláusula puede detectar excepciones heredadas de StandardError. Otras palabras clave de control de flujo que se pueden usar al manejar excepciones son elsey ensure:

comenzar  # hacer algo rescatar  # manejar la excepción de lo contrario  # hacer esto si no se generó ninguna excepción asegurarse  # hacer esto si se generó una excepción o no end

Es un error común intentar capturar todas las excepciones con una simple cláusula de rescate. Para detectar todas las excepciones, uno debe escribir:

comenzar  # hacer algo rescate  Excepción  # Código de manejo de excepciones aquí.  # No escriba solo "rescate"; que solo detecta StandardError, una subclase de Exception. final

O detecta excepciones particulares:

comenzar  # hacer algo rescate  RuntimeError  # manejar solo RuntimeError y sus subclases end

También es posible especificar que el objeto de excepción esté disponible para la cláusula del controlador:

begin  # do something rescue  RuntimeError  =>  e  # manejo, posiblemente involucrando e, como "pone e.to_s" end

Alternativamente, la excepción más reciente se almacena en el magic global $!.

También se pueden detectar varias excepciones:

comenzar  # hacer algo rescate  RuntimeError ,  Timeout :: Error  =>  e  # manejo, posiblemente involucrando e end

Metaprogramación

Esta sección necesita citas adicionales para su verificación . Por favor, ayuda a mejorar este artículo mediante la adición de citas de fuentes confiables . El material no obtenido puede ser cuestionado y eliminado. ( Enero de 2014 ) ( Obtenga información sobre cómo y cuándo eliminar este mensaje de plantilla )

El código Ruby puede modificar programáticamente, en tiempo de ejecución , aspectos de su propia estructura que se arreglarían en lenguajes más rígidos, como las definiciones de clases y métodos. Este tipo de metaprogramación se puede utilizar para escribir código más conciso y extender el lenguaje de manera efectiva.

Por ejemplo, el siguiente código Ruby genera nuevos métodos para la Stringclase incorporada , basados ​​en una lista de colores. Los métodos envuelven el contenido de la cadena con una etiqueta HTML diseñada con el color respectivo.

COLORES  =  {  negro :  "000" ,  rojo :  "f00" ,  verde :  "0f0" ,  amarillo :  "ff0" ,  azul :  "00f" ,  magenta :  "f0f" ,  cian :  "0ff" ,  blanco :  "fff"  }clase  String  COLORS . cada uno  hace  | color , código |  define_method  "in_ # { color } "  do  "<span style = \" color: # # { code } \ " > # { self } </span>"  end  end end

Los métodos generados podrían usarse así:

"¡Hola Mundo!" . in_blue  =>  "<span style = \" color: # 00f \ " > ¡Hola, mundo! </span>"

Para implementar el equivalente en muchos otros idiomas, el programador tendría que escribir cada método ( in_black, in_red, in_green, etc.) por separado.

Algunos otros usos posibles de la metaprogramación de Ruby incluyen:

• interceptar y modificar llamadas a métodos
• implementar nuevos modelos de herencia
• generar clases dinámicamente a partir de parámetros
• serialización automática de objetos
• ayuda interactiva y depuración

Implementaciones

Ver también: Ruby MRI § Sistemas operativos

Intérprete Ruby de Matz

El intérprete Ruby original a menudo se conoce como el intérprete Ruby de Matz o MRI. Esta implementación está escrita en C y usa su propia máquina virtual específica de Ruby .

La implementación de Ruby 1.8 estandarizada y retirada se escribió en C , como un lenguaje interpretado de una sola pasada . ^[27]

Comenzando con Ruby 1.9 y continuando con Ruby 2.xy superior, el intérprete oficial de Ruby ha sido YARV ("Yet Another Ruby VM"), y esta implementación ha reemplazado a la máquina virtual más lenta utilizada en versiones anteriores de MRI.

Implementaciones alternativas

A partir de 2018 ^[update], hay una serie de implementaciones alternativas de Ruby, incluidas JRuby , Rubinius y mruby . Cada uno adopta un enfoque diferente, con JRuby y Rubinius proporcionando compilación justo a tiempo y mruby también proporcionando compilación anticipada .

Ruby tiene tres implementaciones alternativas principales:

• JRuby , una implementación mixta de Java y Ruby que se ejecuta en la máquina virtual Java . Actualmente, JRuby apunta a Ruby 2.5.
• TruffleRuby , una implementación de Java que utiliza el marco de implementación del lenguaje Truffle con GraalVM
• Rubinius , una máquina virtual de código de bytes C ++ que usa LLVM para compilar en código de máquina en tiempo de ejecución. El compilador de código de bytes y la mayoría de las clases principales están escritas en Ruby puro. Rubinius apunta actualmente a Ruby 2.3.1.

Otras implementaciones de Ruby incluyen:

• Levitación magnética , un Smalltalk aplicación que se ejecuta en GemTalk Sistemas ' GemStone / S VM
• mruby , una implementación diseñada para integrarse en el código C, de manera similar a Lua . Actualmente está siendo desarrollado por Yukihiro Matsumoto y otros.
• RGSS, o Ruby Game Scripting System, una implementación patentada que utiliza la serie de software RPG Maker para el diseño de juegos y la modificación del motor RPG Maker.
• Un transpilador (parcial) de Ruby a Julia , julializer está disponible. Puede usarse para una gran aceleración sobre, por ejemplo, implementaciones de Ruby o JRuby (puede que solo sea útil para código numérico). ^[104]
• Topaz , una implementación de Ruby escrita en Python
• Opal , un intérprete basado en web que compila Ruby en JavaScript

Otras implementaciones de Ruby ahora desaparecidas fueron:

• MacRuby , una implementación de Mac OS X en el tiempo de ejecución de Objective-C . Su contraparte de iOS se llama RubyMotion
• IronRuby una implementación en .NET Framework
• Cardinal, una implementación para la máquina virtual Parrot
• Rubí Enterprise Edition , a menudo abreviado como ree , una implementación optimizada para manejar a gran escala de Ruby on Rails proyectos
• HotRuby , una implementación de JavaScript y ActionScript del lenguaje de programación Ruby

La madurez de las implementaciones de Ruby tiende a medirse por su capacidad para ejecutar el marco Ruby on Rails (Rails), porque es complejo de implementar y utiliza muchas características específicas de Ruby. El punto en el que una implementación particular logra este objetivo se denomina "la singularidad de Rails". La implementación de referencia, JRuby y Rubinius ^[105] pueden ejecutar Rails sin modificaciones en un entorno de producción.

Soporte de plataforma

Matsumoto originalmente desarrolló Ruby en Sony NEWS-OS 3.x basado en 4.3BSD , pero luego migró su trabajo a SunOS 4.xy finalmente a Linux . ^{[106] [107]}

En 1999, se sabía que Ruby funcionaba en muchos sistemas operativos diferentes , incluidos NEWS-OS, SunOS, AIX , SVR4 , Solaris , NEC UP-UX , NeXTSTEP , BSD, Linux, Mac OS , DOS , Windows y BeOS . ^[108]

Las versiones e implementaciones modernas de Ruby están disponibles en muchos sistemas operativos, como Linux, BSD, Solaris, AIX, macOS , Windows, Windows Phone , ^[109] Windows CE , Symbian OS , BeOS e IBM i .

El lenguaje de programación Ruby es compatible con varias plataformas de alojamiento en la nube como Jelastic , Heroku , Google Cloud Platform y otras.

Repositorios y bibliotecas

RubyGems es el administrador de paquetes de Ruby. Un paquete de Ruby se denomina "gema" y se puede instalar fácilmente a través de la línea de comandos. La mayoría de las gemas son bibliotecas, aunque existen algunas que son aplicaciones, como IDE . ^[110] Hay más de 10,000 gemas Ruby alojadas en RubyGems.org .

Muchas bibliotecas Ruby nuevas y existentes están alojadas en GitHub , un servicio que ofrece alojamiento de repositorio de control de versiones para Git .

El archivo de aplicaciones de Ruby, que albergaba aplicaciones, documentación y bibliotecas para la programación de Ruby, se mantuvo hasta 2013, cuando su función se transfirió a RubyGems. ^[111]

Ver también

• Comparación de lenguajes de programación
• Proyecto Metasploit  : el proyecto Ruby más grande del mundo, con más de 700.000 líneas de código
• Guía (conmovedora) por qué de Ruby  : un libro de texto de Ruby en línea en formato de novela gráfica
• XRuby  : un compilador estático de Ruby a Java
• Crystal  : un lenguaje de programación inspirado en Ruby

Referencias

1. https://www.ruby-lang.org/en/news/2021/04/05/ruby-3-0-1-released/ .
2. "[ruby] Contenido de / trunk / COPYING" . Consultado el 2 de mayo de 2015 .
3. "[ruby] Contenido de / trunk / GPL" . Consultado el 2 de mayo de 2015 .
4. "[ruby] Contenido de / trunk / BSDL" . Consultado el 2 de mayo de 2015 .
5. Cooper, Peter (2009). Beginning Ruby: de principiante a profesional . De principiante a profesional (2ª ed.). Berkeley: APulse. pag. 101. ISBN 978-1-4302-2363-4. En menor medida, Python, LISP, Eiffel, Ada y C ++ también han influido en Ruby.
6. "Confreaks TV | Razones detrás de Ruby - Ruby Conference 2008" . confreaks.tv . Consultado el 25 de junio de 2019 .
7. Bini, Ola (2007). Proyectos prácticos de JRuby on Rails Web 2.0: Llevando Ruby on Rails a Java . Berkeley: APulse. pag. 3 . ISBN 978-1-59059-881-8. Se basa principalmente en características de Perl, Smalltalk, Python, Lisp, Dylan y CLU.
8. Bini, Ola. "Ioke" . Ioke.org . Archivado desde el original el 21 de julio de 2011 . Consultado el 21 de julio de 2011 . inspirado en Io, Smalltalk, Lisp y Ruby
9. "Documentación de Julia 1.0: Introducción" . Consultado el 6 de octubre de 2018 .
10. Burks, Tim. "Acerca de Nu ™" . Programación de Nu ™ . Diseño de neón Technology, Inc . Consultado el 21 de julio de 2011 .
11. Ring Team (3 de diciembre de 2017). "Ring y otros idiomas" . ring-lang.net . ring-lang .
12. "La referencia de óxido" . Consultado el 16 de noviembre de 2019 .
13. Lattner, Chris (3 de junio de 2014). "Página de inicio de Chris Lattner" . Chris Lattner . Consultado el 3 de junio de 2014 . El lenguaje Swift es el producto del esfuerzo incansable de un equipo de expertos en lenguaje, gurús de la documentación, ninjas de optimización de compiladores y un grupo interno de prueba interna increíblemente importante que brindó comentarios para ayudar a refinar y probar ideas. Por supuesto, también se benefició enormemente de las experiencias ganadas con esfuerzo por muchos otros lenguajes en el campo, extrayendo ideas de Objective-C, Rust, Haskell, Ruby, Python, C #, CLU y demasiados otros para enumerarlos.
14. "Acerca de Ruby" . Consultado el 15 de febrero de 2020 .
15. "Confreaks TV | Razones detrás de Ruby - Ruby Conference 2008" . confreaks.tv . Consultado el 25 de junio de 2019 .
16. Shugo Maeda (17 de diciembre de 2002). "Preguntas frecuentes sobre el lenguaje Ruby" . Consultado el 2 de marzo de 2014 .
17. Matsumoto, Yukihiro (13 de febrero de 2006). "Re: características lisp de Ruby" . Consultado el 15 de febrero de 2020 .
18. "Historia de Ruby" .
19. "[FYI: histórico] El momento decisivo del nombre del idioma Ruby. (Re: [ANN] ruby ​​1.8.1)" (Correo electrónico de Hiroshi Sugihara a ruby-talk).
20. "Preguntas frecuentes sobre el lenguaje Ruby - 1.3 ¿Por qué el nombre 'Ruby'?" . Ruby-Doc.org . Consultado el 10 de abril de 2012 .
21. Yukihiro Matsumoto (11 de junio de 1999). "Re: ¿el nombre de Ruby?" . Ruby-Talk (lista de correo) . Consultado el 10 de abril de 2012 .
22. "Más arqueolingüística: desenterrando proto-Ruby" . Archivado desde el original el 6 de noviembre de 2015 . Consultado el 2 de mayo de 2015 .
23. "[ruby-talk: 00382] Re: historia de ruby" . Consultado el 2 de mayo de 2015 .
24. "[ruby-list: 124] TUTORIAL - características de ruby" . Consultado el 2 de mayo de 2015 .
25. "Una entrevista con el creador de Ruby" .
26. Yukihiro Matsumoto (octubre de 2000). "Programación de Ruby: Adelante" . Consultado el 5 de marzo de 2014 .
27. "Retiramos Ruby 1.8.7" . Consultado el 2 de mayo de 2015 .
28. "IPA 独立 行政 法人 情報 処理 推進 機構 ： プ レ ス 発 表 プ ロ グ ラ ム 言語 Ruby の JIS 規格 （JIS X 3017） 制定 に つ い て" . Consultado el 2 de mayo de 2015 .
29. "IPA 独立 行政 法人 情報 処理 推進 機構 ： プ レ ス 発 表 プ ロ グ ラ ム 言語 Ruby 、 国際 規格 と し て 承認" . Consultado el 2 de mayo de 2015 .
30. "ISO / IEC 30170: 2012" . Consultado el 10 de marzo de 2017 .
31. Desarrollo web: Ruby on Rails . Devarticles.com (22 de marzo de 2007). Consultado el 17 de julio de 2013.
32. "Se lanza Ruby 1.9.3 p0" . ruby-lang.org. 31 de octubre de 2011 . Consultado el 20 de febrero de 2013 .
33. "v1_9_3_0 / NOTICIAS" . Repositorio de fuentes de Ruby Subversion . ruby-lang.org. 17 de septiembre de 2011 . Consultado el 20 de febrero de 2013 .
34. Ruby 1.9: Qué esperar . slideshow.rubyforge.org. Consultado el 17 de julio de 2013.
35. "El soporte para Ruby 1.9.3 ha finalizado" . Consultado el 2 de mayo de 2015 .
36. Endoh, Yusuke. (2013-02-24) Lanzamiento de Ruby 2.0.0-p0 . Ruby-lang.org. Consultado el 17 de julio de 2013.
37. Endoh, Yusuke. (2013-02-24) Lanzamiento de Ruby 2.0.0-p0 . Ruby-lang.org. Consultado el 17 de julio de 2013.
38. Unidos (24 de febrero de 2016). "Planes de soporte para Ruby 2.0.0 y Ruby 2.1" . Ruby-lang.org . Consultado el 18 de abril de 2017 .
39. "Ruby 2.1.0 es lanzado" . 25 de diciembre de 2013 . Consultado el 26 de diciembre de 2013 .
40. "Control de versiones semántico a partir de Ruby 2.1.0" . 21 de diciembre de 2013 . Consultado el 27 de diciembre de 2013 .
41. "El soporte para Ruby 2.1 ha finalizado" . Consultado el 4 de abril de 2017 .
42. "Ruby 2.2.0 lanzado" . 25 de diciembre de 2014 . Consultado el 4 de enero de 2015 .
43. "ruby / NOTICIAS en v2_2_0 · ruby ​​/ ruby ​​· GitHub" . GitHub . Consultado el 2 de mayo de 2015 .
44. "El soporte de Ruby 2.2 ha terminado" . Consultado el 29 de diciembre de 2019 .
45. Gustavo Frederico Temple Pedrosa, Vitor de Lima, Leonardo Bianconi (2015). "Ruby 2.2.1 lanzado" . Consultado el 12 de julio de 2016 .
46. Gustavo Frederico Temple Pedrosa, Vitor de Lima, Leonardo Bianconi (2015). "v2.2.1 ChangeLog" . Consultado el 12 de julio de 2016 .
47. Gustavo Frederico Temple Pedrosa, Vitor de Lima, Leonardo Bianconi (2014). "Especificación de registros no volátiles para aumentar el rendimiento en ppc64" . Consultado el 12 de julio de 2016 .
48. Gustavo Frederico Temple Pedrosa, Vitor de Lima, Leonardo Bianconi (2014). "Especificación de MACRO para aumentar el rendimiento en ppc64" . Consultado el 12 de julio de 2016 .
49. "Ruby 2.3.0 cambios y características - Ejecutando con Ruby" . dev.mensfeld.pl .
50. "Ruby / NOTICIAS en v.2_3_0 - ruby ​​/ ruby ​​- Github" . GitHub . Consultado el 25 de diciembre de 2015 .
51. "Ruby 2.4.0 lanzado" . www.ruby-lang.org . Consultado el 30 de diciembre de 2016 .
52. "Ruby 2.5.0 lanzado" . Consultado el 2 de mayo de 2018 .
53. "Ruby 2.6.0 lanzado" . Lenguaje de programación Ruby . 2018-12-25 . Consultado el 25 de diciembre de 2018 .
54. "Ruby 2.7.0 lanzado" . Lenguaje de programación Ruby . 2019-12-25 . Consultado el 25 de diciembre de 2019 .
55. "Ruby 3.0.0 lanzado" . Lenguaje de programación Ruby . 2020-12-25 . Consultado el 25 de diciembre de 2020 .
56. "Lanzamientos de Navidad de la comunidad Ruby" . www.rubyinside.com .
57. "Un parche en el tiempo: asegurar Ruby" .
58. "ruby-1.8.0 lanzado!" . www.ruby-lang.org .
59. "Planes para 1.8.7" . www.ruby-lang.org .
60. "EOL para Ruby 1.8.7 y 1.9.2" . www.ruby-lang.org .
61. "Ruby 1.9.3-p551 lanzado" . www.ruby-lang.org .
62. "Ruby 1.9.0 lanzado" . www.ruby-lang.org .
63. "El soporte para Ruby versión 1.9.3 finalizará el 23 de febrero de 2015" . www.ruby-lang.org .
64. "El soporte para Ruby 1.9.3 ha finalizado" . www.ruby-lang.org .
65. "Lanzamiento de Ruby 2.0.0-p648" . www.ruby-lang.org .
66. "Se lanza Ruby 2.0.0-p0" . www.ruby-lang.org .
67. "Ruby 2.1.10 lanzado" . www.ruby-lang.org .
68. "Ruby 2.1.0 es lanzado" . www.ruby-lang.org .
69. "Planes de soporte para Ruby 2.0.0 y Ruby 2.1" . www.ruby-lang.org .
70. "Ruby 2.1.9 lanzado" . www.ruby-lang.org .
71. "ReleaseEngineering - Ruby - Ruby Issue Tracking System" . bugs.ruby-lang.org .
72. "Ha finalizado el soporte de Ruby 2.1" . www.ruby-lang.org .
73. "Ruby 2.2.10 lanzado" . www.ruby-lang.org .
74. "Ruby 2.2.0 lanzado" . www.ruby-lang.org .
75. "Ruby 2.2.7 lanzado" . www.ruby-lang.org .
76. "Ruby 2.3.8 lanzado" . www.ruby-lang.org .
77. "Ruby 2.3.0 lanzado" . www.ruby-lang.org .
78. "Ha finalizado el soporte de Ruby 2.2" . www.ruby-lang.org .
79. "Ruby 2.4.10 lanzado" . Lenguaje de programación Ruby . 2020-03-31 . Consultado el 1 de abril de 2020 .
80. "Ruby 2.4.0 lanzado" . www.ruby-lang.org .
81. "Ha finalizado el soporte de Ruby 2.4" . www.ruby-lang.org .
82. "Ruby 2.5.9 lanzado" . Lenguaje de programación Ruby . 2021-04-05 . Consultado el 5 de abril de 2021 .
83. "Ruby 2.5.0 lanzado" . www.ruby-lang.org .
84. "Ruby 2.6.7 lanzado" . Lenguaje de programación Ruby . 2021-04-05 . Consultado el 5 de abril de 2021 .
85. "Ruby 2.6.0 lanzado" . www.ruby-lang.org .
86. "Ruby 2.7.3 lanzado" . Lenguaje de programación Ruby . 2021-04-05 . Consultado el 5 de abril de 2021 .
87. "Ruby 2.7.0 lanzado" . www.ruby-lang.org .
88. "Ruby 3.0.1 lanzado" . Lenguaje de programación Ruby . 2021-04-05 . Consultado el 5 de abril de 2021 .
89. "Ruby 3.0.0 lanzado" . www.ruby-lang.org .
90. "El lenguaje de programación Ruby" . Consultado el 2 de mayo de 2015 .
91. Google Tech Talks - Ruby 1.9 en YouTube
92. Bill Venners. "La filosofía de Ruby" . Consultado el 2 de mayo de 2015 .
93. "Bienvenido a RUBYWEEKLYNEWS.ORG" . 4 de julio de 2017. Archivado desde el original el 4 de julio de 2017.
94. Bruce Stewart (29 de noviembre de 2001). "Una entrevista con el creador de Ruby - O'Reilly Media" . Consultado el 2 de mayo de 2015 .
95. Bill Venners. "Productividad dinámica con Ruby" . Consultado el 2 de mayo de 2015 .
96. "Bancos de trabajo de idiomas: ¿la aplicación asesina para idiomas específicos de dominio?" . martinfowler.com . Consultado el 2 de mayo de 2015 .
97. "Ruby - Agregar métodos de clase en tiempo de ejecución" .
98. Bill Venners. "Bloques y cierres en Ruby" . Consultado el 2 de mayo de 2015 .
99. Britt, James. "Documentación de la biblioteca estándar de Ruby 2.0.0" . Consultado el 9 de diciembre de 2013 .
100. Hilos verdes
101. "Preguntas frecuentes sobre el lenguaje Ruby: ¿Cómo se compara Ruby con ...?" . Consultado el 2 de mayo de 2015 .
102. "[ruby-talk: 01120] Re: El valor de while ..." En la sintaxis de Ruby, la instrucción es solo un caso especial de una expresión que no puede aparecer como un argumento (por ejemplo, asignación múltiple).
103. "[ruby-talk: 02460] Re: Pregunta de precedencia" . La declaración [...] no puede ser parte de una expresión a menos que esté agrupada entre paréntesis.
104. "GitHub - remove / virtual_module: Nacido para hacer que su código Ruby sea más de 3 veces más rápido. Con suerte" .
105. Peter Cooper (18 de mayo de 2010). "El por qué, qué y cómo de la versión de Rubinius 1.0" .
106. Maya Stodte (febrero de 2000). "IBM developerWorks - Ruby: un nuevo lenguaje" . Archivado desde el original el 18 de agosto de 2000 . Consultado el 3 de marzo de 2014 .
107. Yukihiro Matsumoto (agosto de 2002). "lang-ruby-general: Re: pregunta sobre el desarrollo inicial de Ruby" . Consultado el 3 de marzo de 2014 .
108. Yukihiro Matsumoto (5 de enero de 1999). "ruby-talk: Re: ja, revisa estos errores" . Consultado el 3 de marzo de 2014 .
109. "Iron Ruby en Windows Phone 7" .
110. "La caja de herramientas de Ruby" . Consultado el 4 de abril de 2015 .
111. "Retiramos raa.ruby-lang.org" . 2013-08-08 . Consultado el 3 de enero de 2016 .

Lectura adicional

• Black, David; Leo, Joseph (15 de marzo de 2019), The Well-Grounded Rubyist (Tercera ed.), Publicaciones Manning , p. 584, ISBN 978-1617295218
• Metz, Sandi (22 de agosto de 2018), Diseño práctico orientado a objetos: un manual ágil con Ruby (segunda edición), Addison-Wesley Professional , p. 288, ISBN 978-0-13-445647-8
• Cooper, Peter (12 de julio de 2016), Beginning Ruby: From Novice to Professional (Tercera ed.), Apress , p. 492, ISBN 978-1484212790
• Carlson, Lucas; Richardson, Leonard (3 de abril de 2015), Ruby Cookbook: Recipes for Object-Oriented Scripting (Segunda edición), O'Reilly Media , p. 963, ISBN 978-1449373719
• Fulton, Hal; Arko, André (2 de marzo de 2015), The Ruby Way: Solutions and Techniques in Ruby Programming (tercera edición), Addison-Wesley Professional , p. 816, ISBN 978-0-321-71463-3
• Thomas, Dave; Fowler, Chad; Hunt, Andy (7 de julio de 2013), Programming Ruby 1.9 & 2.0: The Pragmatic Programmers 'Guide (Cuarta ed.), Pragmatic Bookshelf , p. 888, ISBN 978-1937785499
• McAnally, Jeremy; Arkin, Assaf (28 de marzo de 2009), Ruby in Practice (Primera ed.), Manning Publications , p. 360, ISBN 978-1933988474
• Flanagan, David; Matsumoto, Yukihiro (25 de enero de 2008), The Ruby Programming Language (Primera ed.), O'Reilly Media , p. 446 , ISBN 978-0-596-51617-8
• Baird, Kevin (8 de junio de 2007), Ruby by Example: Concepts and Code (Primera edición), No Starch Press , p. 326, ISBN 978-1593271480
• Fitzgerald, Michael (14 de mayo de 2007), Learning Ruby (Primera ed.), O'Reilly Media , p. 255 , ISBN 978-0-596-52986-4

Enlaces externos

Wikiquote tiene citas relacionadas con: Ruby (lenguaje de programación)

Wikimedia Commons tiene medios relacionados con el lenguaje de programación Ruby .

Wikiversity tiene recursos de aprendizaje sobre el tema: Ruby

• Página web oficial
• Documentación de Ruby
• Ruby en Curlie