CARRERA COMPUTACIN

SEMESTRE: QUINTO

PERODO: MAY. - AGO. / 2016

PROYECTO DE INVESTIGACIN
LENGUAJE DE PROGRAMACIN
TEMA:
MANUAL DE USO DE RUBY
AUTORES:
FROWEN A. LPEZ LAVA
JORGE M. VERA ZAMBRANO
JUAN C. RIVAS PARRAGA

FACILITADOR:
ING. FERNANDO R. MOREIRA MOREIRA, MGS

CALCETA AGOSTO, 2016

INTRODUCCIN
Cuando programas en una computadora, es necesario tener en cuenta lo que
quieres desarrollar y que es lo que se puede desarrollar dentro del lenguaje de
programacin que se va a utilizar. Existen muchos lenguajes y muchos de ellos
son excelentes.
Ruby es un lenguaje de programacin dinmico y de cdigo abierto orientado
en la simplicidad y rendimiento. Su selecta sintaxis se siente natural al leerla y
fcil al escribirla.
Adems de ser un lenguaje de programacin multiplataforma, interpretado y
orientado a objetos, libre de formato es decir que una cosa se puede hacer de
distintas maneras a lo que el programador mejor se adapte a su forma de
trabajo.

TABLA DE CONTENIDOS
INTRODUCCIN..................................................................................................ii
CAPITULO I. MARCO TERICO.........................................................................2
1.1.

QUE ES RUBY?....................................................................................2

1.1.2.

HISTORIA.........................................................................................2

1.1.2.

RUBY RPIDO Y SENCILLO...........................................................2

1.1.3.

RUBY COMO PROGRAMACIN ORIENTADA A OBJETOS..........2

1.1.4.

SINTAXIS..........................................................................................2

CAPITULO II. DESARROLLO..............................................................................2

2.1. SALIDAD DE DATOS.................................................................................2
2.2. COMENTARIOS.........................................................................................2
2.3. VARIABLES................................................................................................2
2.4.

CONVERTIR TIPOS................................................................................2

2.5. ALCANCE DE VARIABLES.......................................................................2

2.6. OPERADORES ARITMTICOS................................................................2
2.7. SENTENCIA IF Y ELSE.............................................................................2
2.8. SENTENCIA UNLESS...............................................................................2
2.9. SENTENCIA CASE....................................................................................2
2.10. CICLO FOR..............................................................................................2
2.11. CICLO WHILE..........................................................................................2
2.12. ENTRADA DE DATOS.............................................................................2
2.13. ARREGLOS.............................................................................................2
2.14. PROGRAMACIN ORIENTADO A OBJETOS RUBY.............................2
2.15. MTODOS ACCESORES.......................................................................2
2.16. HERENCIA...............................................................................................2
2.17. ALCANCE DE LOS MTODOS...............................................................2
2.18. MTODOS DE INSTANCIA Y CLASE.....................................................2

4
CONCLUSIN......................................................................................................2
BIBLIOGRAFA.....................................................................................................2

CAPITULO I. MARCO TERICO

1.1.

QUE ES RUBY?

Segn Hellmanss, (2012) Ruby es un lenguaje de scripts para una

programacin orientada a objetos rpida y sencilla. Combina una sintaxis
inspirada en Python y Perl con caractersticas de programacin orientada a
objetos similares a Smalltalk. Comparte tambin funcionalidad con otros
lenguajes de programacin como Lisp, Lua, Dylan y CLU. Ruby es un lenguaje
de programacin interpretado en una sola pasada y su implementacin oficial
es distribuida bajo una licencia de software libre. Adems se un lenguaje de
guiones interpretado:

Posibilidad de realizar directamente llamadas al sistema operativo.

Potentes operaciones sobre cadenas de caracteres y expresiones

regulares
Retroalimentacin inmediata durante el proceso de desarrollo.

1.1.2. HISTORIA
El lenguaje fue creado por Yukihiro "Matz" Matsumoto, quien empez a trabajar
en Ruby el 24 de febrero de 1993, y lo present al pblico en el ao 1995. En el
crculo de amigos de Matsumoto se le puso el nombre de "Ruby" (en espaol
rub) como broma aludiendo al lenguaje de programacin "Perl" (perla).
(Yulgrecia, 2011)

1.1.2. RUBY RPIDO Y SENCILLO

Segn Vera, (2015) Ruby es un lenguaje rpido y sencillo debido a que:

Son innecesarias las declaraciones de variables

Las variables son de tipo dinmico.
La sintaxis es simple y consistente La gestin de la memoria es
automtica

1.1.3. RUBY COMO PROGRAMACIN ORIENTADA A OBJETOS

Ruby es orientado a objetos de debido a que todos los tipos de datos son un
objeto, incluidas las clases y tipos que otros lenguajes definen como primitivas,
(como enteros, booleanos, y "nil"). Toda funcin es un mtodo. Las variables
siempre son referencias a objetos, no los objetos mismos. Ruby soporta
herencia con enlace dinmico, mixins y mtodos singleton (pertenecientes y
definidos por una sola instancia ms que definidos por la clase). A pesar de que
Ruby no soporta herencia mltiple, las clases pueden importar mdulos como
mixins. La sintaxis procedural est soportada, pero todos los mtodos definidos
fuera del mbito de un objeto son realmente mtodos de la clase Object. Como
esta clase es padre de todas las dems, los cambios son visibles para todas
las clases y objetos. (Yulgrecia, 2011)
Ruby ha sido descrito como un lenguaje de programacin multiparadigma:
permite programacin procedural (definiendo funciones y variables fuera de las
clases hacindolas parte del objeto raz Object), con orientacin a objetos,
(todo es un objeto) o funcionalmente (tiene funciones annimas, clausuras o
closures, y continuations; todas las sentencias tiene valores, y las funciones
devuelven la ltima evaluacin). Soporta introspeccin, reflexin y meta
programacin, adems de soporte para hilos de ejecucin gestionados por el
intrprete. Ruby tiene tipificado dinmico, y soporta polimorfismo de tipos
(permite tratar a subclases utilizando la interfaz de la clase padre). Ruby no
requiere de polimorfismo de funciones (sobrecarga de funciones) al no ser
fuertemente tipado (los parmetros pasados a un mtodo pueden ser de
distinta clase en cada llamada a dicho mtodo). (Yulgrecia, 2011)
De acuerdo con las preguntas frecuentes de Ruby, "Si te gusta Perl, te gustar
Ruby y su sintaxis. Si te gusta Smalltalk, te gustar Ruby y su semntica. Si te
gusta Python, la enorme diferencia de diseo entre Python y Ruby/Perl puede
que te convenza o puede que no."

1.1.4. SINTAXIS
La sintaxis de Ruby es similar a la de Perl o Python. La definicin de clases y
mtodos est definida por palabras clave. Sin embargo, en Perl, las variables
no llevan prefijos. Cuando se usa, un prefijo indica el mbito de las variables.

6
La mayor diferencia con C y Perl es que las palabras clave son usadas para
definir bloques de cdigo sin llaves. Los saltos de lnea son significativos y son
interpretados como el final de una sentencia; el punto y coma tiene el mismo
uso. De forma diferente que Python, la indentacin no es significativa. (Vera,
2015)
Una de las diferencias entre Ruby y Python y Perl es que Ruby mantiene todas
sus variables de instancia privadas dentro de las clases y solo la expone a
travs de mtodos de acceso (attr_writer, attr_reader, etc). (Vera, 2015)

CAPITULO II. DESARROLLO

2.1. SALIDAD DE DATOS
Para mostrar un cadena por pantalla se hace uso de los comandos PRINTF y
PUTS y entre

comillas el mensaje como se muestra en la figura 1, la

diferencia entre PRINTF y PUTS es que el PRINTF si hay muchas

cadenas que se quieran imprimir lo va hacer todo en una sola lnea mientras
que el PUTS es ms ordenado imprime lnea a lnea cada cadena.
(Hernndez, et al., s/f)

Figura 1. Primer hola mundo

2.2. COMENTARIOS
Segn Hernndez, et al., (s/f), en Ruby existen dos maneras de ubicar
comentarios, en el desarrollo de una aplicacin:

Comentarios de una sola lnea

Este tipo comentario se da usando al principio de un mensaje el smbolo #

como se muestra en la figura 2

Figura 2. Comentario de una sola lnea

Comentarios de varias lneas

8
Este tipo de comentario se lo realiza usando el comando =begin al principio
de todas las lneas que se van a tener el mensaje y el comando end al
finalizar el mensaje o comentario. (Hernndez, et al., s/f)

Figura 3. Comentario de varias lneas

2.3. VARIABLES
Una variable es un espacio de memoria en la computadora en donde se
almacena datos, en Ruby existen diferente tipos de variables a pesar de que no
se especifique el tipo de variable que se utilice. (Hernndez, et al., s/f)

Variables enteras

Figura 4. Uso de variables de tipo enteras

Variables de cadena de texto

Figura 5. Uso de variables de cadena de texto

En este caso en la figura 5 se puede observar que se crea dos variables de

cadena de texto una llamada nombre y la otra llamada saludo con sus
respectivas cadenas las mismas que se imprimen por medio del comando

9
PUTS y por medio de operador + se unen ambas cadena. (Hernndez, et
al., s/f)

Variables flotantes

Figura 6. Uso de variables de tipo flotantes

2.4.

CONVERTIR TIPOS

Segn Hernndez, et al., (s/f), existen maneras de convertir los tipos de

variables a otras:

De cadena de carcter a entera

Para este tipo de conversin se hace uso de mtodo.to.i como se muestra

en la figura 7.

Figura 7. Conversin de cadena a entera

De cadena de carcter a flotante

Para este tipo de conversin se hace uso del mtodo .to.f como se
muestra en la figura 8.

10

Figura 8. Conversin de cadena a flotante

De entera a cadena de carcter

Para este tipo de conversin se hace uso del mtodo .to.s como se
muestra en la figura 9.

Figura 9. Conversin de entero a cadena

2.5. ALCANCE DE VARIABLES

Segn Hernndez, et al., (s/f), existen tres tipos de variables segn su alcance.

Las globales

Son el tipo de variables que se utilizan en cualquier parte del cdigo sin
importan en la clase en que se est codificando, este tipo de variables de la
representa de la siguiente manera como se muestra en la figura10.

Figura 10. Uso de variables globales

Variables de instancia

Estas variables solo son visibles en la clase que se creen ejemplo figura 11.

11

Figura 11. Uso de variables de instancia.

Variables locales

Ejemplo figura 12.

Figura 12. Uso de variables locales.

2.6. OPERADORES ARITMTICOS

Los operados lgicos ms utilizados son la suma, resta multiplicacin y
exponente para ello a continuacin se ver en la figura 13 su definicin.

Figura 13. Operadores lgicos

2.7. SENTENCIA IF Y ELSE

La sentencia IF permite evaluar una operacin lgica y dependiendo si esta es
verdadera o falsa permite ejecutar instrucciones diferentes. (Hernndez, et al.,
s/f)
Ejemplo:

12

Figura 14. Uso de la sentencia IF y ELSE

2.8. SENTENCIA UNLESS

Segn Hernndez, et al., (s/f), Unless en Ruby es el inverso de la sentencia IF
es decir que si la condicin no se cumple ejecuta el conjunto de instruciones.
Ejemplo como se muestra en la figura 15.

Figura 15. Uso de la sentencia UNLESS

2.9. SENTENCIA CASE

Segn Hernndez, et al., (s/f), se utiliza cuando para los distintos valores de
una variable o expresin existen distintos conjuntos de sentencias a ejecutar,
por eso recibe el nombre de Sentencia Alternativa Mltiple.
En Ruby para trabajar con esta sintaxis es como se muestra en la figura 16.,
en donde en la instruccin CASE se ubica variable a avaluar y en el WHEN el
rango que desea evaluar y dependiendo ejecuta intrusiones.

13

Figura 16. Sentencia case

2.10. CICLO FOR

Segn Hernndez, et al., (s/f), la sentencia FOR proporciona una forma
compacta de recorrer un rango de valores, es decir, que es capaz de repetir un
grupo de sentencias un nmero determinado de veces.
En Ruby al igual que otros lenguajes se necesita una variable la cual va a tener
un rango de inicio y uno de finalizacin que el FOR va a repetir un grupo de
sentencias ejemplo figura 17.

Figura 17. Sentencia FOR

2.11. CICLO WHILE

Segn Hernndez,

et al.,

(s/f), la sentencia while permite

ejecutar

repetidamente un bloque mientras la condicin sea verdadera. Una sentencia

while es un ejemplo de lo que denominamos declaracin repetitiva,
adicionalmente.
En la figura 18 el ejemplo indica que tenemos una variable inicializada en 0 y
tenemos la concisin en el WHILE que mientras se menor que 5 va imprimir
cuando la condicin se cumpla este va a dejar de imprimir.

14

Figura 18. Ciclo While

2.12. ENTRADA DE DATOS

Segn Hernndez, et al., (s/f), Para permitir la entrada por pantalla de un dato
en Ruby primeramente debemos que crear una variable e igualarla a la funcin
GETS ejemplo figura 19.

Figura 19. Entrada de un dato mediante la funcion gets

2.13. ARREGLOS
Un arreglo puede definirse como un grupo o una coleccin finita, homognea y
ordenada de elementos.
Segn Hernndez, et al., (s/f), En Ruby se puede recorrer el arreglo mediante
un FOR al igual que en otros lenguajes de programacin.

Figura 20. Cuando el arreglo se le realiza entrada de datos

15

Figura 20. Cuando el arreglo viene con datos

2.14. PROGRAMACIN ORIENTADO A OBJETOS RUBY

Segn Hernndez, et al., (s/f), Ruby es fiel a las buenas costumbres de la
programacin orientada a objetos manteniendo los datos lo ms privados
posible.
Programacin orientada a objetos:
Todo es un objeto
Clases, herencia, mtodos.

2.15. MTODOS ACCESORES

Segn Hernndez, et al., (s/f), Estos son muy importantes porque nos permite
manejar o acceder los atributos, mtodos que tengamos en nuestras clases.

De esta manera creamos nuestras clases y mtodos.

16

Figura 21. Creacin de clase y mtodo

Aqu ya hacemos usos de nuestros atributos y nuestros mtodos de la clase

Figura 22. Uso de mtodos y atributos

2.16. HERENCIA
Segn Hernndez, et al., (s/f), Es poder adquirir los atributos y mtodos de una
clase mayor es decir que si tuviramos una clase inferior en el cual hubiera dos
mtodos y hereda de una clase mayor que tuviera 4 mtodos entonces mi
clase inferior va poder acceder a esos seis mtodos.
Ejemplo en la figura 23:

17

Figura 23. Mtodos y atributos de la clase mayor

Figura 24. Herencia simple de la clase mayor

18

2.17. ALCANCE DE LOS MTODOS

Segn Hernndez, et al., (s/f), un alcance en programacin, es hasta donde es
visible dicha propiedad, en este caso un mtodo en Ruby existen tres tipos de
alcance:

Pblicos

El alcance pblico tiene un mbito global es decir que puede ser accedido
desde la misma clase o fuera de ella.

Figura 25. Sintaxis de un mtodo publico

Privados

En este tipo de alcance los mtodos solo pueden ser accedidos dentro de
la misma clase.

Figura 25. Sintaxis de un mtodo privado

Protegidos

Este es muy similar al prvate con la diferencia que este aprovecha el tema de
la herencia, es decir que este mtodo solo puede ser accedido en dicha clase o
en algunos de los objetos que hereden esta clase.

Figura 25. Sintaxis de un mtodo protected

19

2.18. MTODOS DE INSTANCIA Y CLASE

Segn Hernndez, et al., (s/f), En Ruby para poder acceder a un mtodo de
instancia primeramente tenemos crear un nuevo objeto del tipo de la clase en
donde fue creado, e instanciar el mtodo para poder acceder a l, en un
mtodo de clase eso no pasa ya que podemos acceder al directamente
haciendo uso de la clase, gracias al comando SELF que se implementa al inicio
del mtodo como se muestra la sintaxis en la figura 26.

Figura 25. Sintaxis de los mtodos de clase y de instancia

20

CONCLUSIN
Ruby es un lenguaje de programacin orientado objeto; principalmente creado
para llamar la atraccin de los programadores ya que es un lenguaje sencillo y
flexible, adems de ofrecer potentes operaciones sobre cadenas de caracteres
y expresiones regulares, son innecesaria las declaraciones de variables es
decir que no tienen tipos y la gestin de memoria es automtica.

21

BIBLIOGRAFA
CodigoFacilito, 2014. Curso de Ruby. (En lnea). Formato HTML. Consultado el
1 de Agos 2016. Disponible en: https://codigofacilito.com/courses/Ruby
Hellmanss, C. 2012. Lenguaje de programacin Ruby. Manual ingeniera en
Sistemas. EC, p1-3
Hernndez, R; Oshee, V; Duque, J; Forero, D. s/f Curso de Ruby bsico. (En
lnea). Formato HTML. Consultado el 1 de Agos 2016.Disponible en:
https://platzi.com/cursos/ruby-basico/
Vera, A. 2015. Ruby presentacin. Informe Ruby. EC, p4
Yulgrecia, D. 2011.Ruby es un
Manual. EC, p4-8

Lenguaje de programacin interpretado.

Sanchez, A. s/f. El lenguaje Ruby. Libro para aprendiz. Colombia. Cap. 1, p1920