rubí | |
---|---|
clase de idioma | lenguaje de programación orientado a objetos |
Apareció en | 1995 [2] |
Autor | Matsumoto, Yukihiro |
extensión de archivo | .rbo.rbw |
Liberar |
|
sistema de tipos | estricto , dinámico ( pato ) |
Implementaciones principales | Ruby MRI , JRuby , Rubinius |
sido influenciado | Ada , Dylan , Perl [3] , Python [3] , Smalltalk , C++ , Clu , Eiffel , Lisp , Basic , Lua y Emacs [4] |
influenciado | Raku , Groovy |
Licencia | Licencia Ruby [d] ,GNU GPL 2[5]ylicencia BSD de 2 cláusulas [6] |
Sitio web | ruby-lang.org _ |
sistema operativo | Microsoft Windows [7] , GNU/Linux [7] , BSD [7] y macOS [7] |
Archivos multimedia en Wikimedia Commons |
Ruby ( en inglés ruby - ruby , pronunciado ['ru:bɪ] - ruby ) es un lenguaje de programación de alto nivel dinámico , reflexivo e interpretado [8] [9] . El lenguaje tiene un sistema operativo : implementación independiente de subprocesos múltiples, escritura dinámica fuerte , un recolector de basura y muchas otras características . En términos de características de sintaxis , está cerca de Perl y Eiffel , en términos de enfoque orientado a objetos, de Smalltalk . También se toman algunas características del lenguaje de Python , Lisp , Dylan y Clu .
La implementación multiplataforma del intérprete de lenguaje es completamente gratuita [10] .
El creador de Ruby, Yukihiro Matsumoto (Matz) , se interesó por los lenguajes de programación cuando aún era estudiante, pero la idea de desarrollar un nuevo lenguaje vino después. Ruby comenzó a desarrollarse el 23 de febrero de 1993 y se lanzó en 1995.
El nombre está inspirado en el lenguaje Perl, muchas de cuyas sintaxis y semántica están tomadas de Ruby: English. perla - "perla", rubí - "rubí".
Una de las inspiraciones de Matsumoto para desarrollar Ruby fue la novela de ciencia ficción Babylon 17 , basada en la hipótesis de Sapir-Whorf [11] .
El objetivo del diseño era crear un lenguaje de programación interpretado "verdaderamente orientado a objetos ", fácil de desarrollar . De la carta del autor [12] :
Rubí nació el 24 de febrero de 1993. Ese día, estaba hablando con un colega sobre la posibilidad de un lenguaje de secuencias de comandos orientado a objetos . Conocía Perl (Perl4, no Perl5), pero no me gustaba, tenía cierto sabor a lenguaje de juguete (y todavía lo tiene). Y un lenguaje interpretado orientado a objetos parecía prometedor. En ese momento, conocía a Python. Pero no me gustó porque no lo consideré un lenguaje orientado a objetos real. Sus propiedades OO parecían un complemento para el lenguaje. Como un fanático de los lenguajes y un fanático de la programación orientada a objetos de quince años, realmente quería un lenguaje verdaderamente orientado a objetos y fácil de usar. Traté de encontrar tal lenguaje, pero no había ninguno.
Entonces decidí crearlo. Pasaron varios meses antes de que el intérprete comenzara a trabajar. Agregué lo que quería a mi lenguaje: iteradores , manejo de excepciones , recolección automática de basura. Luego refactoricé las propiedades de Perl y las implementé como una biblioteca de clases . En diciembre de 1995, publiqué Ruby 0.95 en grupos de noticias japoneses. Desde entonces ha habido sitios web, listas de correo. Hay discusiones acaloradas en las listas de correo. La lista más antigua contiene ahora 14.789 letras.
En Japón, Ruby se ha vuelto popular desde su primer lanzamiento público en 1995, pero la documentación solo en japonés ha frenado su adopción. Solo en 1997 apareció una descripción de Ruby en inglés, y en 1998 se abrió el foro ruby-talk. Esto marcó el comienzo del crecimiento de la prominencia del idioma en el resto del mundo. A principios de la década de 2000, se publicaron varios libros en inglés, lo que contribuyó a la creciente popularidad de Ruby en Europa Occidental y América. En 2003, se lanzó Ruby 1.8.0, y en 2005, apareció el marco web Ruby on Rails , escrito en Ruby e inmediatamente ganando reconocimiento debido a la facilidad de construir aplicaciones web típicas en él. Ruby en él no es solo el lenguaje de implementación del marco en sí, sino también el lenguaje para describir soluciones (en particular, se utilizan plantillas HTML con código Ruby incrustado).
El principal problema tanto para Ruby en general como para Ruby on Rails en ese momento era el rendimiento: el intérprete original perdía velocidad frente a los lenguajes de la competencia y las implementaciones alternativas, y la escalabilidad de la aplicación estaba limitada por los altos requisitos de memoria. El desarrollo del lenguaje en la segunda mitad de la década del 2000 se dividió en dos ramas: simultáneamente con el apoyo de la línea 1.8.*, se inició el desarrollo de la rama experimental 1.9.*, en la que el autor del lenguaje partía de la principios de mantener la compatibilidad con versiones anteriores e hizo cambios significativos en preparación para el lanzamiento de Ruby 2.0. Como resultado, con el lanzamiento de Ruby 1.9.1 en 2009 y Rails 3.0 en 2010, la situación ha cambiado significativamente: la velocidad del intérprete original se ha incrementado varias veces y está casi a la par con implementaciones alternativas para .NET y JVM. , las modificaciones del lenguaje han eliminado algunos puntos criticados a menudo. El interés en Ruby se triplicó con creces entre 2009 y 2012, según TIOBE y Indeed.com . En Rusia, las primeras ediciones oficiales de las traducciones rusas de libros sobre Ruby aparecieron en 2011 y se han publicado regularmente desde entonces, lo que puede considerarse como evidencia de un creciente interés en el idioma entre los especialistas de habla rusa.
La versión estable de Ruby 2.0 se lanzó en febrero de 2013. El 24 de febrero de 2014 se cumplen 21 años desde el anuncio del lenguaje de programación Ruby. Los desarrolladores decidieron marcar tal evento con el lanzamiento de un parche para Ruby 2.1, al que llamaron Ruby 2.1.1 [13] . A fines de 2018, se lanzó Ruby 2.6, que implementó la compilación JIT .
Ahora Ruby está incluido en la mayoría de las distribuciones de Linux , viene con Mac OS X y está disponible para usuarios de otros sistemas operativos . Una de las principales aplicaciones asociadas con Ruby sigue siendo Ruby on Rails, que continúa desarrollándose activamente, pero el uso de Ruby es mucho más amplio: se desarrolla una gran cantidad de aplicaciones para diversos propósitos, además, se utiliza como lenguaje de secuencias de comandos para automatizar y personalizar aplicaciones y escribir utilidades administrativas, en particular, en el sistema operativo Linux.
Matsumoto , fanático de la programación orientada a objetos, soñaba con un lenguaje más poderoso que Perl y más orientado a objetos que Python. El objetivo principal de Ruby es crear programas simples y al mismo tiempo comprensibles para resolver problemas en los que el tiempo de desarrollo, la comprensibilidad y la simplicidad son más importantes que la velocidad.
Los principios del diseño y la programación de Ruby a veces se denominan Ruby Way . En general, "la forma de Ruby" no tiene una redacción exacta, a veces el término se usa para criticar. [14] En una forma relativamente condensada, sus disposiciones se presentan en los libros "Programación en Ruby" de Hal Fulton [15] y "The Ruby Way" de Hal Fulton y André Arce [16] .
El lenguaje es para los humanos, no para las computadoras. La prioridad es la comodidad y minimización de los costes laborales del programador a la hora de desarrollar un programa, liberándolo del trabajo rutinario que el ordenador puede realizar más rápido y mejor. Se presta especial atención, en particular, a las actividades rutinarias diarias (procesamiento de textos, administración), y el idioma está configurado especialmente bien para ellas. A diferencia de los lenguajes orientados a máquinas que funcionan más rápido, Ruby es el lenguaje más cercano al humano. Cualquier trabajo con una computadora es hecho por personas y para personas, y es necesario cuidar ante todo el esfuerzo de las personas. Simple, pero no demasiado simple. La simplificación es una bendición, pero no debe traspasar ciertos límites más allá de los cuales se convierte en un fin en sí mismo y perjudica el resultado final. El principio de la menor sorpresa El programa debe comportarse como el programador espera . Pero en el contexto de Ruby, esto significa la menor sorpresa, no al conocer el idioma, sino al estudiarlo a fondo. El mismo Matsumoto afirma que el objetivo del diseño era minimizar las sorpresas al programar para él , pero después de la difusión del lenguaje, se sorprendió al saber que el pensamiento de los programadores es similar, y para muchos de ellos coincidía el principio de "menor sorpresa". con su principio. La ortogonalidad es importante, pero la naturalidad es más importante. La redundancia es aceptable si es conveniente. Ruby heredó la filosofía del lenguaje de programación Perl en términos de brindarle al programador la capacidad de lograr el mismo resultado de varias maneras diferentes. Las personas son diferentes, y para la libertad necesitan la oportunidad de elegir. “Prefiero proporcionar muchos caminos si es posible, pero animo o guío a los usuarios a elegir el mejor camino si es posible” [17] . No seas un esclavo del rendimiento. Si el desempeño para un caso particular es inaceptablemente bajo, entonces esto requiere corrección, y si se sabe de antemano que será significativo, es necesario diseñar inicialmente el programa con esto en mente. Pero uno debería preferir la elegancia de la eficiencia en los casos en que la eficiencia no es demasiado crítica. No tenga miedo de los cambios en tiempo de ejecución. La presencia en el lenguaje de medios dinámicos, hasta la automodificación del programa en tiempo de ejecución, proporciona características muy útiles para una programación eficiente. El golpe de rendimiento al que tienes que ir por ellos es, en la mayoría de los casos, bastante aceptable. Sigue reglas simples y estrictas, pero no llegues al punto de la pedantería. "Lo que vemos en Ruby no es 'coherencia pedante', sino una estricta adherencia a un conjunto de reglas simples". Se necesitan reglas y convenciones (en particular, las convenciones de nomenclatura adoptadas en el lenguaje) para que el programa sea más fácil de entender. Si la desviación de la regla en un caso particular es lógica y comprensible, está justificada. "No tienes que luchar contra eso". Ruby es lo que está diseñado para ser. Un programador no debe esperar que Ruby se comporte como otro lenguaje al que está acostumbrado. El programador puede seguir sus propias ideas y hábitos, influenciado por otros lenguajes (ver "Principio de la menor sorpresa" ), pero si las expectativas resultan ser incorrectas, esto simplemente debe aceptarse y usarse.Ruby es un lenguaje completamente orientado a objetos. En él, todos los datos son objetos , a diferencia de muchos otros lenguajes donde existen tipos primitivos . Cada función es un método .
Cada construcción en Ruby devuelve un valor. Por ejemplo:
# El operador condicional devuelve el valor de la rama seleccionada puts ( si 5 > 3 entonces "Uno" else "Otro" final ) #=> Uno # El operador de asignación devuelve el valor asignado de puts ( var = 5 ) #=> 5Ruby usa call -by-sharing , aunque a menudo se dice en la comunidad de Ruby que usa call-by-reference . Para un programador acostumbrado a los lenguajes de programación híbridos comunes, algunos de los efectos de tal decisión pueden parecer inesperados. Por ejemplo:
a = "abcdefg" # => "abcdefg" - la variable a se inicializa en una nueva cadena. b = a # => "abcdefg" - la variable b obtiene una referencia a la MISMA cadena. a [ 3 ] = 'R' # => "abcRefg" - la cadena asignada a a cambia. b # => "abcRefg" - cambiando también una b modificada implícitamente, ya que se refieren a UN objeto. # Sin embargo: x = 10 # => 10 - la variable x se inicializa con el número 10. y = x # => 10 - la variable y obtiene una referencia al mismo valor. x += 5 # => 15 - la operación += crea un NUEVO valor entero 15, que se escribe en x, y # => 10 para que cambiar x no se refleje en yEl mecanismo de asignación funciona igual para todos los objetos, a diferencia de lenguajes como Object Pascal , donde la asignación puede significar copiar un valor o copiar una referencia a un valor.
Ruby no admite la herencia múltiple , sino que tiene un poderoso mecanismo de combinación . Todas las clases (directamente oa través de otras clases) se derivan de la clase Object, por lo tanto, cualquier objeto puede usar los métodos definidos en ella (por ejemplo, class, to_s, nil?). El estilo procedimental también es compatible, pero todos los procedimientos globales son implícitamente métodos privados de Object.
Ruby es un lenguaje multiparadigma : admite estilo procedimental (definición de funciones y variables fuera de las clases), orientado a objetos (todo es un objeto), estilo funcional ( funciones anónimas , cierres , devolución de un valor por todas las instrucciones, devolución de una función de último valor calculado). Admite reflexión , metaprogramación , información de tipo variable en tiempo de ejecución (ver identificación de tipo de datos dinámico ).
Los comentarios de línea comienzan con un #. También se admiten comentarios de varias líneas:
x = 10 # Un comentario de línea comienza con # y continúa hasta el final de la línea actual =begin Cualquier cosa entre =begin y =end es un comentario. Los delimitadores de dicho comentario deben escribirse desde el principio de la línea. =finRuby es un lenguaje que distingue entre mayúsculas y minúsculas, las letras mayúsculas y minúsculas en los identificadores son diferentes. Todas las palabras clave de idioma, con dos excepciones, se escriben en minúsculas.
Antes de la versión 2.0, el lenguaje usaba muchos caracteres ASCII de 7 bits . Dado que la versión 2.0 Unicode es compatible , los archivos de código fuente predeterminados utilizan la codificación UTF-8 . Todos los caracteres alfabéticos Unicode pueden usarse en identificadores al igual que las letras en inglés. Las cadenas Unicode son totalmente compatibles.
Lista de palabras clave de Ruby:
alias y BEGIN comienzan la definición de definición de clase de caso de ruptura ? hacer otra cosa elsif END fin asegurar falso para si en el módulo siguiente nil no o rehacer rescate volver a intentar devolver auto super entonces verdadero undef a menos que hasta cuando mientras rendimientoTradicionalmente, los identificadores deben estar formados por letras, números y guiones bajos, y comenzar con una letra o un guión bajo. Ruby usa la convención de nomenclatura:
Los prefijos de nombre también se utilizan para definir el alcance del identificador:
Los nombres de los métodos usan sufijos para indicar el propósito del método:
Ruby implementa la ideología de "todo es un objeto", es decir, cualquier unidad de datos es un objeto, una instancia de cierta clase a la que se aplican todos los medios sintácticos diseñados para trabajar con objetos. En este sentido, el lenguaje no contiene tipos de datos primitivos incorporados. Convencionalmente, estos pueden considerarse tipos proporcionados por el intérprete y la biblioteca del sistema, que se usan con mayor frecuencia y no requieren una indicación especial del nombre de la clase para su uso.
Números enteros. Representado por tipos Fixnumy Bignum. El primer tipo se utiliza para números que no superan 2 30 en valor absoluto , el segundo para números superiores a 2 30 . En las operaciones aritméticas, estos tipos numéricos son totalmente compatibles y se pueden usar juntos libremente, se proporciona una conversión transparente entre ellos. El tipo Fixnumtiene un ancho de bit limitado y utiliza instrucciones aritméticas de procesador estándar; la profundidad de bits Bignumestá limitada solo por la cantidad de RAM disponible, y las operaciones con ellos se basan en algoritmos de cálculo con precisión ilimitada. Esto permite realizar cálculos precisos con cualquier número de dígitos requerido. Por ejemplo, en la mayoría de los lenguajes de programación, escribir un programa factorial exacto que funcione para un argumento del orden de cien es una tarea bastante difícil. En Ruby esto se hace de forma elemental, ya que el intérprete se encarga de los problemas de trabajar con números largos. def fact ( n ) result = 1 for i in 1 .. n do result *= i end result end puts fact ( 100 ) =begin Выведет : 93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000 =end La entrada de un número decimal (excluyendo los signos más y menos) debe comenzar con un número del 1 al 9. Un número entero que comienza con cero se considera octal. Un número entero con el prefijo "0x" es hexadecimal, "0b" es binario. Otros tipos numéricos. El tipo Float son números de punto flotante representados por un número fijo de dígitos. Los números flotantes se escriben en forma natural o exponencial. La biblioteca del sistema matemático también proporciona los tipos Rational( número racional ) y Complex( número complejo ). Ambos tipos se convierten automáticamente en números enteros y flotantes con un denominador de unidad y una parte imaginaria cero, respectivamente. Instrumentos de cuerda. String es una matriz de bytes mutable que representa caracteres codificados en UTF-8. Están implementados por la clase String, que tiene un gran conjunto de métodos que proporcionan análisis, manipulación de contenido, transformación, búsqueda. Los literales de cadena están delimitados por apóstrofes, comillas dobles o encerrados en la construcción %q[…] o %Q[…]. Los delimitadores de línea afectan el uso de caracteres especiales dentro de ella:Los rangos se utilizan ampliamente en Ruby para el muestreo y el bucle de datos.
objetos procesales.Un programa Ruby es un archivo de texto que contiene una secuencia de instrucciones: comandos y descripciones. Cuando se lanza un archivo de programa para su ejecución, el intérprete lee secuencialmente el archivo y ejecuta las instrucciones. Ruby no requiere que el cuerpo del programa principal esté organizado como una unidad de programa especial (como una función main()en C), los comandos que lo componen simplemente se escriben directamente en el texto del archivo del programa. Dado que el intérprete procesa secuencialmente el archivo del programa, todas las funciones, métodos y descripciones deben preceder a su primer uso en el texto del programa.
El programa se puede dividir en varios archivos. En este caso, el archivo del programa principal debe cargar el resto de los archivos usando la declaración requireo require_relative:
require 'module1' # carga el archivo de programa llamado 'module1.rb' o el nombre de biblioteca 'module1' require 'pkgs/package2' # carga el archivo de programa 'package2' del subdirectorio pkgsEsta instrucción busca un archivo con el nombre y la extensión especificados '.rb' y lo descarga. Si no hay un archivo de código fuente con el mismo nombre, el intérprete intenta cargar una biblioteca dinámica con el mismo nombre (las extensiones dependen del sistema operativo). Las rutas de búsqueda de archivos están determinadas por la instrucción de carga: requireutiliza un conjunto de directorios especificados por la configuración del entorno y los parámetros de inicio del intérprete para la carga, y require_relativecarga el archivo con la ruta especificada en relación con el archivo actual (es decir, en el ejemplo anterior , si el archivo que contiene las instrucciones de carga se encuentra en el directorio /home/programmer/work/ruby/testproject, entonces el archivo package2.rbse cargará desde /home/programmer/work/ruby/testproject/pkgs.Al cargar un módulo de programa, el intérprete lo procesa, es decir, todas sus instrucciones se ejecutan.Si el módulo se carga en varios archivos, luego se carga solo una vez.Ruby tiene un método loadque también carga el archivo de código fuente o la biblioteca, es una funcionalidad algo diferente y generalmente se usa para cargar módulos binarios escritos en C.
Ruby contiene un rico conjunto de construcciones de control; muchas de sus variantes son bastante raras.
El operador condicional ifparece tradicional:
si x > 0 entonces pone "x es un número positivo" si x < 0 entonces pone "x es un número negativo" si no pone "x es cero" endPuede elsifhaber cualquier número de sucursales, se permite el uso de la palabra clave , pero no es obligatorio, las thensucursales pueden estar ausentes. Además de esta forma "canónica" del operador condicional, el lenguaje admite varios otros: elsifelse
# Si no es una condición a menos que x > 3 entonces pone x . to_s # imprime el valor de x si NO es mayor que tres. otra cosa pone "demasiado para contar" al finalPuede utilizar formas abreviadas del operador condicional como modificadores de declaraciones . Se escriben después de una instrucción y se interpretan como una condición bajo la cual se debe ejecutar la instrucción dada. Las ramas elseen los modificadores no pueden ser.
pone "x es menor que cero!" si x < 0 # La impresión solo ocurrirá si x es negativo pone "x es positivo!" a menos que x <= 0 # La cadena se imprimirá si x es MAYOR que ceroPuede usar una declaración condicional como una expresión. Su valor será el valor de la sucursal que fue seleccionada de acuerdo a la condición. En este uso, se requiere la palabra clave entonces. Ruby también heredó el operador triple condicional de ?:C.
# El argumento del método puts es seleccionado por la expresión condicional. puts ( si x == 0 entonces "nulo" sino final "no nulo" ) # Un análogo de la instrucción anterior, escrito usando un operador condicional de tres lugares. pone ( x == 0 )? "nulo" : "no nulo"El operador de opción múltiple case-whenofrece una opción entre varias alternativas, cada una de las cuales se puede especificar mediante un solo valor, un conjunto de valores o un rango:
caso mes cuando 1 , 2 , 12 luego pone "invierno" # selecciona de una lista de opciones cuando 3 .. 5 luego pone "primavera" # selecciona de un rango de opciones cuando 6 .. 8 luego pone "verano" # puede reemplazar luego con dos puntos cuando 9 .. 11 # entonces se puede omitir si hay una nueva línea pone "otoño" sino pone "no pasa!!!" finalLas alternativas en el operador casese verifican secuencialmente, se selecciona la primera rama para la cual la condición coincide con la lista de valores o rango. Si no se selecciona ninguna de las ramas when, se ejecutará la rama else, si existe.
Ruby tiene siete tipos de construcciones de bucle. El ejemplo muestra opciones de bucle para atravesar una matriz liste imprimir todos sus valores.
# ciclo while con precondición i = 0 while i < lista . tamaño imprime " #{ lista [ i ] } " i + = 1 fin # Hasta bucle ("todavía no") con condición previa i = 0 hasta i == lista . tamaño imprime " #{ lista [ i ] } " i + = 1 fin # ciclo while con verificación final i = 0 comenzar imprimir " #{ lista [ i ] } " i += 1 final mientras i < lista . Talla # Hasta que el ciclo termine con verificación i = 0 comience a imprimir " #{ lista [ i ] } " i += 1 termine hasta que i == lista . Talla # Un ciclo for con un contador (i pasa por alto el rango dado) for i in 0 .. list . tamaño - 1 imprime " # { lista [ i ] } " fin # Recorre la colección para x en la lista do # x toma los valores de los elementos de la lista print " #{ x } " end # Bucle infinito bucle i = 0 n = lista . tamaño - 1 bucle do print " #{ lista [ i ] } " i += 1 interrupción si i > n # Salir si finaliza # Bucle i = 0 n = lista . tamaño - 1 ciclo do print " #{ list [ i ] } " i += 1 interrupción a menos que i <= n # Salir cuando se viola la condición finalRuby admite matrices heterogéneas dinámicas , que cambian de tamaño automáticamente y pueden contener elementos de cualquier tipo. Una matriz es una instancia de la clase Array, que proporciona herramientas poderosas para trabajar con datos almacenados.
# Una matriz se puede inicializar con una lista de valores entre corchetes. a = [ 1 , 'hola' , 3 . 14 , 1 , 2 , [ 4 , 5 ] * 3 ] a [ 2 ] # Invertir por índice # "expandir" todas las matrices internas, eliminar elementos idénticos a . aplana _ uniq # => [1, 'hola', 3.14, 2, 4, 5] # encontrar elemento por valor a . índice ( 6 ) # falla: se devuelve nil a . index ( 4 ) # => 5 # casi todas las funciones se proporcionan con # un análogo con el mismo nombre, pero que termina en "!", # que modifica el propio contenedor . aplana! # => [1, "hola", 3.14, 1, 2, 4, 5, 4, 5, 4, 5]Se proporcionan iteradores para que los tipos de contenedores iteren sobre sus elementos.
# Iterador 'cada' - sobre los elementos de la lista de colección . cada uno hace | x | imprimir " #{ x } " fin # Iterador 'veces' - por el número de elementos en la colección n = lista . tamaño nm . tiempos hacen | yo | imprimir " #{ lista [ i ] } " fin # Iterador 'hasta' - desde el número original hasta el máximo n = lista . tamaño - 1 O . hasta ( n ) hacer | yo | imprimir " #{ lista [ i ] } " fin # Lista de iteradores 'cada_índice' . cada_índice hacer | x | imprimir " #{ lista [ x ] } " finTodas las clases son descendientes de la clase predefinida Object. Los métodos de clase se describen dentro de la descripción de la propia clase. Las variables con el prefijo @@ que se encuentran en la descripción de la clase son variables de clase (análogas a los miembros de clase estáticos en C++), las variables con el prefijo @ son variables de instancia (campos de clase).
clase Persona < Objeto # clase Persona hereda de Objeto incluir Comparable # mezclar en métodos de instancia del módulo Comparable @variable # variable de instancia @@count_obj = 0 # variable de clase para contar el número de objetos creados # def inicializar ( nombre , edad ) # constructor (nombre, edad - parámetros del método) @nombre , @edad = nombre , edad # crear objetos @@ count_obj += 1 # incrementa el contador en 1 extremo def <=> ( persona ) # operator override <=> @age <=> persona . edad # la última expresión evaluada se devuelve desde el fin del método def to_s # para salida de información formateada puts " #{ @name } ( #{ @age } )" # construcción #{x} en 2 comillas se reemplaza en la cadena por el valor de texto x end def inspeccionar # método utilizado por el intérprete para la salida de diagnóstico "< #{ @@count_obj } : #{ to_s } >" end attr_reader :nombre , :edad # crear métodos de acceso de lectura para el final de los campos # Crear una matriz de instancias de clase Grupo de personas = [ Persona . nuevo ( "Juan" , 20 ), Persona . nuevo ( "Markus" , 63 ), Persona . new ( "Ash" , 16 ) ] # el método de inspección se llama automáticamente a la salida # => [<3:John (20)>, <3:Markus (63)>, <3:Ash (16)>] # ordenar y "revertir" una matriz usando métodos estándar # funciona anulando el operador <=> puts group . ordenar _ reverso # Impresiones: # Markus (63) # John (20) # Ash (16) # método entre agregado implícitamente cuando se incluye el grupo Comparable [ 0 ]. ¿Entre? ( grupo [ 2 ] , grupo [ 1 ] ) # => verdaderoUna sola clase en Ruby se puede declarar en varios archivos fuente. Como resultado, es posible, por ejemplo, agregar nuevos métodos a una clase ya existente.
Ruby solo admite herencia simple . Además, hay un mecanismo de combinación y la capacidad de declarar módulos que le permiten implementar la mayoría de las características de la herencia múltiple.
Ruby tiene muchas soluciones originales que rara vez se encuentran o no se encuentran en los principales lenguajes de programación. Puede agregar métodos no solo a cualquier clase, sino también a cualquier objeto. Por ejemplo, puede agregar un método arbitrario a alguna cadena.
# todo, desde el carácter # hasta el final de la línea - el comentario # = es un operador de asignación, # los caracteres en """ son una cadena que se puede manipular mediante el lenguaje str = "Hola" # una variable str se crea aquí, de tipo String # def es una palabra clave para declaraciones de funciones def str .bye # str especifica quién es el propietario del método (Objeto predeterminado) # bye es el nombre del método, opcionalmente seguido de una lista opcional entre paréntesis de parámetros de función "¡Adiós!" # el último valor calculado se devuelve desde el método (aquí, una cadena) end # casi todas las instrucciones de Ruby terminan con la palabra clave end # puts es un método, # str.bye es una llamada al método bye del str object # el valor obtenido del método bye se pasa al método puts, # que muestra información de puts str.bye # => ¡Adiós !Este ejemplo también demuestra cómo se puede usar un singleton en Ruby . En este ejemplo, el singleton es un str.
El lenguaje tiene 2 formas equivalentes de escribir bloques de código :
{ pone "¡Hola, mundo!" } do pone "¡Hola, mundo!" finalLas corrutinas se utilizan con la mayoría de los métodos integrados:
archivo _ abrir ( 'archivo.txt' , 'w' ) { | archivo | # abrir el archivo "archivo.txt" para escribir el archivo ("w" - escribir ) . pone 'Escribí un mensaje de texto'. } # El diseño elimina la incertidumbre al cerrar el archivo: cierra aquí para cualquier resultadoEl siguiente ejemplo muestra el uso de rutinas e iteradores para trabajar con matrices, lo que muestra la brevedad de escribir en Ruby muchas acciones bastante complejas (seleccionar aleatoriamente de una secuencia de cuadrados de números del "0" al "10" e imprimir junto con índices):
# Requiere Ruby 1.9 ( 0 .. 10 ) para funcionar . recoger { | v | v ** 2 } . seleccione { rand ( 2 ) . ¿cero? } . mapa _ con_índice { |* v | v }Las excepciones se lanzan usando la construcción raise(o ), opcionalmente, failse puede agregar texto con un mensaje, tipo de excepción e información sobre la pila de llamadas :
aumentar ArgumentError , "Argumento no válido" , llamador # llamador es un método que devuelve la pila de ejecución actualLas excepciones se manejan usando el rescue. Opcionalmente, puede especificar el tipo de excepción que se manejará (de manera predeterminada, se manejan todas) y la información que se recuperará. También puede agregar bloques else(se ejecuta si no hubo excepciones) y ensure(se ejecuta de todos modos).
comenzar # ... rescatar RuntimeError => e # manejar un tipo específico de error pone e # imprimir el mensaje de error rescate # puede escribir rescate => e para obtener el objeto de la excepción # manejar todas las excepciones más # funcionará si hay no hubo excepciones , asegúrese de que # funcionará de todos modosHay varias implementaciones para Ruby: el intérprete oficial escrito en C , JRuby es una implementación para Java , un intérprete para la plataforma .NET IronRuby , Rubinius está escrito principalmente en Ruby y se basa en las ideas de Smalltalk - 80 VM [18] , MagLev es otro basado en Smalltalk desarrollado por Gemstone [19] , Blue Ruby es una implementación de Ruby para la máquina virtual ABAP [20] , MacRuby es una implementación para Mac OS con un enfoque en la máxima integración con las capacidades del sistema operativo [21] , mruby es una implementación para incrustar en programas [22 ] .
El intérprete oficial ha sido portado a la mayoría de las plataformas, incluidas Unix , Microsoft Windows (incluido Windows CE ), DOS , Mac OS X , OS/2 , Amiga , BeOS , Syllable , Acorn RISC OS y más. Para Windows existe un RubyInstaller especializado y es posible ejecutarlo bajo Cygwin para una mayor compatibilidad con Unix [23] .
La versión oficial del intérprete de Ruby viene con un shell de comandos de Ruby ( Interactive Ruby Shell ). Lanzado por un comando irben una ventana de terminal ( interfaz de línea de comandos ), le permite probar el código del programa muy rápidamente (línea por línea):
$ irb irb ( principal ): 001 : 0 > "Hola, mundo" => "Hola, mundo" irb ( principal ): 002 : 0 > 2 ** 256 # ** - operador de exponenciación => 115792089237316195423570985008687907853269984699194056403El programa irbmuestra el resultado de cada línea después de los caracteres =>. En los ejemplos anteriores, para mayor claridad, se utiliza la anotación: los resultados de las líneas del programa se escriben en comentarios después de =>. La simulación irbse puede ejecutar directamente en el navegador .
A partir de la versión 1.8.2-15, el paquete de distribución One-Click Installer para Windows viene con una utilidad fxrique incluye un sistema de ayuda ( ri) y un intérprete interactivo ( irb).
Se agregan capacidades de edición básicas a muchos editores ( Emacs , Bred , vim , jEdit , nano , SciTE , Kate , etc.); aquí solo se enumeran los IDE que brindan un amplio conjunto de funciones.
Nombre | Licencia | Plataformas | Enlace |
---|---|---|---|
IDE de Komodo de estado activo | Propiedad | Linux, Mac OS X, Solaris, Windows | [una] |
IDE Rubí de Aracno | Propiedad | Windows 2000/XP, Linux | [2] Archivado el 25 de diciembre de 2019 en Wayback Machine . |
Aptana ( RadRails + RDT ) | GPL , APL+ CPL | Java | [3] |
EasyEclipse para Ruby y Rails | Windows 2000/XP, Linux, Mac OS X | [cuatro] | |
Eclipse + RDT | EPL + CPL | Java | [5] |
Embarcadero TurboRubí | Propiedad | Windows, OS X, Linux | [6] |
paseo libre | Licencia Rubí | Windows, OS X, POSIX | [7] |
Complemento IntelliJ IDEA + Ruby | Propietario (en IDEA ), Apache 2.0 (en el propio complemento) | Java, Rubí | Complemento de rubí |
KDevelop | GNU GPL | linux | [ocho] |
Komodo Editar | Propiedad | Windows, Mac, Linux | [9] |
Desarrollo de Mondrian Ruby IDE descontinuado, versión antigua disponible | MIT | Rubí (+ kit de herramientas FOX ) | [diez] |
NetBeans IDE (versión 6.9.1 y anteriores) | CDDL | Java | [11] Archivado el 1 de agosto de 2008 en Wayback Machine . |
RDE | Licencia Rubí | ventanas | [12] (enlace no disponible) |
rubí en acero | Propiedad | estudio visual 2005 | [13] |
RubyMine | Propietario (basado en IDEA ) | Java | [catorce] |
Visual Studio ( implementación de IronRuby ) | Propiedad | ventanas | [quince] |
Xcode 3.1 | Propiedad | Mac OS X 10.5 | [dieciséis] |
Además de las potentes funciones integradas en el lenguaje, Ruby viene con una gran biblioteca estándar . En primer lugar, estas son bibliotecas para trabajar con varios protocolos de red en el lado del servidor y del cliente , herramientas para trabajar con varios formatos de presentación de datos ( XML , XSLT , YAML , PDF , RSS , CSV , WSDL ). Además de las herramientas de depuración integradas en el lenguaje, Ruby viene con bibliotecas para pruebas unitarias , registro y creación de perfiles . También hay bibliotecas para trabajar con archivos , fechas, codificaciones , matrices , herramientas para administración de sistemas, computación distribuida, soporte multihilo, etc.
Clases básicas de Ruby integradasNombre | Descripción | Versión [24] |
---|---|---|
Parte superior de la jerarquía de clases de Ruby. | 1.0 | |
|
Matriz dinámica para almacenar objetos arbitrarios, indexados desde 0. | 1.0 |
Los objetos almacenan el contexto de ejecución de alguna pieza de código (el valor de variables, métodos, etc.). Posteriormente se puede utilizar para realizar cálculos en este contexto. | 1.2 | |
El objeto almacena la dirección de retorno y el contexto de ejecución, lo que le permite saltar al punto de creación desde cualquier parte del programa (el llamado salto no local). | 1.4 | |
Un envoltorio alrededor del puntero C , usado principalmente cuando se escriben extensiones. | 1.0 | |
Representación de directorios del sistema de archivos. Proporciona la capacidad de ver directorios y sus atributos. | 1.0 | |
La clase base de todas las excepciones (forma la parte superior de una jerarquía de más de 30 excepciones). | 1.0 | |
|
La variable global falsees la única instancia de esta clase y representa boolean false en expresiones booleanas. | 1.0 |
Colección de pares clave-valor; el orden de recorrido es independiente del orden de inserción. | 1.0 | |
Capacidades básicas de E/S. | 1.0 | |
Clase para acceder a archivos. | 1.0 | |
|
El resultado de aplicar la expresión regular. Por lo general, no se usa directamente, sino a través de variables especiales $&, $', $`, $1, $2etc. | 1.0 |
Un método asociado con un objeto específico (no una clase). Se puede usar para llamar a este método sin la presencia de un objeto. | 1.2 | |
Clase de módulo. | 1.0 | |
|
clase de clases; las clases en Ruby son objetos, y Class es la clase de esos objetos (metaclase). | 1.0 |
|
La única instancia de una clase es una variable nil. Solo representan mentiras en los programas nil. falseCualquier otro objeto es verdadero. | 1.0 |
Una clase abstracta de números. | 1.0 | |
Una clase abstracta de enteros. Se puede tratar como una cadena de bits infinita para operaciones bit a bit. | 1.0 | |
Números enteros limitados únicamente por la cantidad de memoria. Convierte a Fixnumautomáticamente si el valor se puede colocar en ellos, y viceversa. (Antes de la versión 2.4) | 1.0 | |
Números enteros que caben en una palabra de máquina (32 bits en la mayoría de las máquinas). Si el resultado de la operación está fuera del alcance, se convierte automáticamente a Bignum. (Antes de la versión 2.4) | 1.0 | |
Números de punto flotante. | 1.0 | |
|
Un bloque de código con un contexto asociado (un cierre ) que se puede ejecutar repetidamente en otros contextos. | 1.0 |
|
Intervalo: Conjunto de valores dados con elementos de inicio y final. | 1.0 |
Expresión regular. | 1.0 | |
Una cadena de bytes de longitud arbitraria. | 1.0 | |
|
Proporciona una manera fácil de vincular atributos sin escribir código de clase directamente; genera clases especiales que contienen muchas variables y métodos de acceso. | 1.0 |
Representa un nombre y se crea con la extensión :name. Todos los objetos con el nombre dado creados en el programa son referencias a un objeto. | 1.6 | |
Encapsula información sobre un subproceso, incluido el subproceso principal de un script de Ruby. | 1.0 | |
Proporciona una forma de administrar un grupo de subprocesos. Un hilo solo puede pertenecer a uno ThreadGroup. Agregar un hilo a un nuevo grupo lo elimina de cualquier anterior. | 1.6 | |
Fecha y hora. | 1.0 | |
|
La variable global truees la única variable de clase y representa la verdad lógica en expresiones booleanas. | 1.0 |
Un método que no está asociado con un objeto específico. Se puede vincular a un objeto e invocar como Method. | 1.6 |
El lenguaje Ruby proporciona un mecanismo simple y conveniente para ampliar el lenguaje con bibliotecas escritas en C , lo que facilita el desarrollo de bibliotecas adicionales [25] [26] .
Para el acceso unificado a las bases de datos, se ha desarrollado la biblioteca Ruby DBI (soporta SQLite , Oracle Database , ODBC , MySQL , DB2 , MS SQL , InterBase , ADO , etc.). También hay bibliotecas específicas de bases de datos que admiten operaciones específicas de bases de datos. Hay varias bibliotecas para la implementación de ORM , como ActiveRecord, Mongoid, DataMapper o Sequel.
Las bibliotecas gráficas incluyen FxRuby (interfaz para la biblioteca gráfica FOX ), paquete de desarrollo gráfico wxRuby (interfaz para el paquete wxWidgets multiplataforma de C++ ), QtRuby/Korundum (enlace a Qt y KDE respectivamente), bibliotecas gráficas para trabajar con Tk [27] y GTK . También se ha implementado una librería para trabajar con OpenGL , que permite programar gráficos en tres dimensiones .
Win32utils: le permite acceder a funciones específicas de la API de Win32 .
Rmagick es una biblioteca de manipulación de imágenes que admite más de 90 formatos (basada en ImageMagick y GraphicsMagick ).
La biblioteca Ruport (informes de Ruby) está diseñada para implementar fácilmente informes y crear gráficos basados en datos de una base de datos o directamente desde archivos de texto CSV . Además, los resultados se pueden guardar en formato PDF , HTML , CSV y TXT.
RuTils es un procesador de texto ruso en Ruby. Le permite implementar la cantidad en palabras y la elección del numeral. Por ejemplo, 231.propisju(2) => "doscientos treinta y uno" o 341.propisju_items(1, "maleta", "maleta", "maletas") => "trescientas cuarenta y una maleta". Así como traducción a transliteración y trabajo con fechas.
El sistema de administración de paquetes de RubyGems está diseñado para administrar bibliotecas y programas de Ruby como paquetes autónomos .
Hay un repositorio de software Ruby RAA (Ruby Application Archive) en todo el mundo. El repositorio a septiembre de 2007 contiene más de mil quinientos proyectos. Una gran cantidad de software escrito en Ruby está alojado en el proyecto RubyForge , que fue creado específicamente para este propósito. RubyForge está cerrado el 15 de mayo de 2014, mientras que el archivo del programa permanecerá disponible para su descarga.
La mayoría de las extensiones se distribuyen bajo licencias libres ( LGPL , licencia Ruby) y se pueden usar en cualquier proyecto casi sin restricciones.
El sistema RDoc está destinado a la extracción automática de documentación de códigos fuente y programas Ruby y su posterior procesamiento. Es el estándar de facto para preparar documentación para software escrito en Ruby.
Para acceder a la documentación de Ruby desde la línea de comandos de Unix, se ha desarrollado un programa ri. Con su ayuda, puede obtener información sobre los módulos, clases y métodos de Ruby.
Uno de los aspectos más criticados de Ruby es el rendimiento. El intérprete original en las primeras versiones mostró en pruebas la velocidad de trabajo de tres a cinco veces menor que los lenguajes interpretados que estaban en uso activo en ese momento (PHP, JavaScript, Python). En la actualidad, esta afirmación ha perdido en gran medida su relevancia: el desempeño de las versiones modernas de los intérpretes (tanto los originales como los alternativos) es aproximadamente del mismo orden (las estimaciones exactas varían de una prueba a otra) con idiomas interpretados que tienen un propósito cercano. , y en general es bastante alto para que en tareas típicas el intérprete no se convierta en un " cuello de botella ". La introducción de la compilación JIT en la versión 2.6 está en línea con la tendencia general de rendimiento de los intérpretes.
Ruby es significativamente más lento que los lenguajes imperativos tipificados estáticamente que se compilan en código objeto como C , Pascal o Go , pero esta desventaja es común a la mayoría de los lenguajes dinámicos. En los casos en que el rendimiento de los fragmentos de programas individuales se vuelve crítico, la única forma de lograrlo es escribir estos fragmentos en lenguajes más rápidos (generalmente en C ).
Los críticos también señalan las deficiencias en las implementaciones actuales de Ruby y en el propio proceso de desarrollo del lenguaje y el sistema.
Ruby es utilizado por la NASA , la NOAA (Administración Nacional Oceánica y Atmosférica), Motorola y otras grandes organizaciones [28] . Los siguientes programas utilizan Ruby como lenguaje de secuencias de comandos para ampliar las capacidades del programa, o están escritos en él (en parte o en su totalidad).
La siguiente lista enumera solo las principales actualizaciones [31] .
Nombre de la versión | fecha de lanzamiento | notas |
---|---|---|
0.06 | 7 de enero de 1994 | Primera versión enumerada en Changelogs |
1.0-961225 | 25 de diciembre de 1996 | Esta versión siguió inmediatamente a la versión 0.99.4-961224 lanzada el día anterior. El número después de 1.0 es la fecha de lanzamiento de la versión. Se lanzaron nuevas versiones de la línea 1.0 por un año más (hasta 1.0-971225). |
1.1 alfa0 | 13 de agosto de 1997 | Las versiones alfa se lanzaron hasta el 7 de octubre de 1997 (1.1 alpha9) |
1.1b0 | 4 de diciembre de 1997 | Próxima versión después de 1.1 alpha9. El 27 de febrero de 1998, se lanzó la versión 1.1b9, luego, hasta mediados de 1998, hubo lanzamientos experimentales con una designación como 1.1b9_31 (se lanzó la versión 1.1b9_31, pero no se menciona en la documentación). |
1.1c0 | 17 de julio de 1998 | Esta versión siguió a la versión 1.1b9_31. Se publicaron modificaciones de esta versión hasta el 26 de noviembre de 1998 (1.1c9). |
1.1d0 (anterior a 1.2) | 16 de diciembre de 1998 | Esta versión siguió a la versión 1.1c9. El 22 de diciembre de 1998 se lanzó una versión experimental 1.1d1 que completaba esta línea. |
1.2 (estable) | 25 de diciembre de 1998 | Se lanzaron más modificaciones de esta versión hasta la versión 1.2.5, lanzada el 13 de abril de 1999. El 21 de junio de 1999 se lanzó la versión 1.2.6, anunciada como la versión final 1.2 (1.2 final). El 15 de julio de 1999, se lanzó una versión 1.2.6 reempaquetada. |
1.3 (desarrollo) | 24 de diciembre de 1998 | Una rama separada de modificaciones, desarrollada independientemente de la línea 1.2 (similar al kernel de Linux). La primera versión se anunció como una versión de desarrollo y siguió a la versión 1.1d1. Siguieron muchas modificaciones intermedias: ruby-1.3.1-990215 - ruby-1.3.4-990625, después de lo cual abandonaron la fecha en el número y lanzaron 1.3.5 - 1.4 alfa (15 de julio de 1999), 1.3.6 - 1.4 alfa (28 de julio de 1999), 1.3.7 - 1.4 beta (6 de agosto de 1999). |
1.4.0 (estable) | 13 de agosto de 1999 | Esta versión apareció unos días después del lanzamiento de 1.3.7 - 1.4 beta. Posteriormente, se liberaron nuevas modificaciones hasta la versión 1.4.6, que fue liberada el 16 de agosto de 2000. |
1.5.0 (desarrollo) | 20 de noviembre de 1999 | Esta línea estaba destinada únicamente a probar varias innovaciones en desarrollo. Las modificaciones de esta línea están disponibles exclusivamente en el repositorio del proyecto y, en consecuencia, los ensamblajes de esta versión no se cargaron en el servidor oficial. |
1.6.0 (estable) | 19 de septiembre de 2000 | En el futuro, se lanzaron modificaciones de esta versión hasta la versión 1.6.8 (24 de diciembre de 2002). El 21 de septiembre de 2005, se lanzó un parche para la versión 1.6.8. |
1.7.0 (desarrollo) | 24 de febrero de 2001 | Esta línea estaba destinada únicamente a probar varias innovaciones en desarrollo. Las modificaciones de esta línea están disponibles exclusivamente en el repositorio del proyecto y, en consecuencia, los ensamblajes de esta versión no se cargaron en el servidor oficial. |
1.8.0 (estable) | 4 de agosto de 2003 | A esto le siguieron una gran cantidad de modificaciones que aún se están publicando (1 de enero de 2011), por ejemplo, se lanzó la versión intermedia 1.8.7-p330 el 24 de diciembre de 2010. |
1.9.0 (desarrollo) | 25 de diciembre de 2007 | Inicialmente una rama experimental, creada para probar una serie de innovaciones en la práctica. |
1.9.3 (estable) | 31 de octubre de 2011 | Las diferencias con 1.9.2 son significativas. |
2.0.0 (estable) | 24 de febrero de 2013 | |
2.1.0 (estable) | 25 de diciembre de 2013 | |
2.2.0 (estable) | 25 de diciembre de 2014 | Compatibilidad con Unicode 7.0, recolección de basura agregada para objetos de tipo Símbolo. |
2.3.0 (estable) | 25 de diciembre de 2015 | Se agregó el nuevo operador "&". para facilitar el manejo de valores nulos al acceder a objetos. Se ha implementado un nuevo pragma experimental de literal de cadena congelado que le permite congelar el estado de los literales de cadena en los textos de origen. |
2.4.0 (estable) | 25 de diciembre de 2016 | Unión de Fixnum y Bignum a Entero. Soporte para cambiar el caso de los caracteres Unicode por String. Mejoras en la tabla hash (st_table). Sesiones interactivas binding.irb. Se agregó el método Regexp#match?. Optimización Array#max, Array#min. |
2.5.0 (estable) | 25 de diciembre de 2017 | En bloques do/end, ahora es legal usar las secciones de rescate, si no, y asegurar directamente.
El método yield_self se define para realizar una operación de rendimiento en un bloque en su contexto. A diferencia de tap, el método devuelve el resultado de la ejecución del bloque. Soporte para medir la cobertura de código de prueba de ramas y métodos. Se agregaron nuevos métodos Hash#slice y Hash#transform_keys. Habilitó la carga automática de la biblioteca pp.rb sin necesidad de especificar 'requerir "pp"' en el código. Cambió la salida de los mensajes de seguimiento y error al orden inverso (al principio hay llamadas, comenzando con las antiguas y terminando con las nuevas, y al final se muestra un mensaje de error). [32] |
2.6.0 (estable) | 25 de diciembre de 2018 | Se agregó soporte para la compilación JIT de Vladimir Makarov;
Se agregó un nuevo módulo RubyVM::AbstractSyntaxTree; Nuevo alias en kernel, Kernel#then alias para Kernel#yield_self; Añadidos intervalos infinitos (1..); |
2.7.0 (estable) | 25 de diciembre de 2019 | Soporte experimental para la coincidencia de patrones
Agregado recolector de basura compacto GC.compact Capacidad de usar nombres de variables numerados predeterminados para parámetros de bloque. Soporte experimental para rangos sin valor final. |
3.0.0 (estable) | 25 de diciembre de 2020 | Añadida la posibilidad de análisis estático |
En formato electrónico:
En formato electrónico:
rubí | |
---|---|
Gente | |
IDE |
|
Implementaciones |
|
Aplicaciones |
|
Bibliotecas y marcos |
|
software de servidor | |
Otro |
|
|
Lenguajes de programación | |
---|---|
|