Showing posts with label basico. Show all posts
Showing posts with label basico. Show all posts

Tuesday, February 9, 2010

Ruby Básico - Manejo de Cadenas

En el anterior post sobre Ruby Básico se hablo de una muy breve introducción a Ruby.

En este post profundizaré en el manejo de cadenas con Ruby.

Como se comento antes se puede crear una cadena en Ruby con comillas simples o comillas dobles. Por ejemplo si creamos un archivo llamado "cadenas00.rb" con el siguiente código:

cadena1 = "Esta es una cadena con comillas dobles"
cadena2 = 'Esta es una cadena con comillas simples'
puts cadena1
puts cadena2

y si lo corremos con Ruby:

$ ruby cadenas00.rb
Esta es una cadena con comillas dobles
Esta es una cadena con comillas simples

Sin embargo, también es posible crear cadenas que este delimitadas por un par de caracteres iguales (que no sean letras) que estén precedidos por el símbolo %. Por ejemplo, si creamos un archivo llamado "cadenas01.rb" con el siguiente código:

puts %!Esta es una cadena!
puts %{Esta es otra cadena}
puts %[Esta también es una cadena]
puts %-Esta sera una cadena?-
puts %!Esta es una cadena como el primer ejemplo pero usando el caracter \! con secuencia de escape!

tenemos como salida:

$ ruby cadenas01.rb
Esta es una cadena
Esta es otra cadena
Esta también es una cadena
Esta sera una cadena?
Esta es una cadena como el primer ejemplo pero usando el caracter ! con secuencia de escape

Este estilo para crear cadenas en Ruby es muy útil para cuando se crean cadenas con mucho texto.

Uno de los muchos usos que les damos a las cadenas en nuestros programas es para imprimir valores de variables. Ruby nos permite hacer sustitucion de expresiones dentro de una cadena simplemente encerrando nuestra expresión entre #{ y } dentro de la cadena misma. Por ejemplo, si creamos un archivo llamado "cadenas02.rb" con el siguiente código:

x = 2
y = "expresión"
z = 2.3

puts "El valor de x es #{x}"
puts "El valor de y es #{y}"
puts "El valor de z es #{z}"

# Sera lo mismo que lo siguiente?

puts "El valor de x es " + x
puts "El valor de y es " + y
puts "El valor de z es " + z

tenemos como salida:

$ ruby cadenas02.rb
El valor de x es 2
El valor de y es expresión
El valor de z es 2.3
cadenas02.rb:11:in `+': can't convert Fixnum into String (TypeError)
from cadenas02.rb:11:in `
'

Notaran que Ruby con el uso de #{} hace automáticamente la transformación adecuada de las variables para poder meterlas a las cadenas.

Como ya había comentado Ruby es un lenguaje orientado a objetos puro de tal forma que una cadena entre comillas es un objeto y se pueden llamar métodos de la clase String. Por ejemplo, si creamos un archivo llamado "cadenas03.rb" con el siguiente código:

cadena1 = "MAYUSCULAS".downcase
cadena2 = String.new("minusculas").upcase

puts "#{cadena1}"
puts "#{cadena2}"

tenemos como salida:

$ ruby cadenas03.rb
mayusculas
MINUSCULAS

Los metodos de la clase String downcase y upcase regresan una copia de la cadena en minúsculas y mayúsculas respectivamente. El método new crea una nueva instancia de la cadena que se le pasa como argumento.

El siguiente código (que sera guardado en un archivo llamado "cadenas04.rb") muestra el uso de algunos de los métodos de la clase String.

str1 = String.new("Mensaje 1")
str2 = String.new("Mensaje 2")
str3 = String.new("MeNSajE 2")
str4 = String.new(" Cadena con espacios ")

puts "Las cadenas son iguales? #{str1 == str2}"
puts "Las cadenas son diferentes? #{str1 != str2}"
puts "Que pasa si multiplico la cadena? #{str1 * 2}"
puts "Comparacion de cadenas case-sensitive #{str2.eql?(str3)}"
puts "Comparacion de cadenas case-insensitive #{str2.casecmp(str3)}"
puts "Mi cadena esta vacia? #{str2.empty?}"
puts "Donde esta el '2' en mi cadena? #{str2.index("2")}"
puts "Si le quito los espacios a la derecha? [#{str4.rstrip}]"
puts "Si le quito los espacios a la izquierda? [#{str4.lstrip}]"
puts "Si le quito los espacios? [#{str4.strip}]"
puts "Mi cadena a la inversa! #{str2.reverse}"
puts "Substring! [#{str4.slice(4..22)}]"
puts "Substring! [#{str4.slice(4..-5)}]"

entonces al correr el código se tiene como salida:

$ ruby cadenas04.rb
Las cadenas son iguales? false
Las cadenas son diferentes? true
Que pasa si multiplico la cadena? Mensaje 1Mensaje 1
Comparacion de cadenas case-sensitive false
Comparacion de cadenas case-insensitive 0
Mi cadena esta vacia? false
Donde esta el '2' en mi cadena? 8
Si le quito los espacios a la derecha? [ Cadena con espacios]
Si le quito los espacios a la izquierda? [Cadena con espacios ]
Si le quito los espacios? [Cadena con espacios]
Mi cadena a la inversa! 2 ejasneM
Substring! [Cadena con espacios]
Substring! [Cadena con espacios]

¿Notan como el uso del un numero negativo en el método slice de la clase String cuenta los indices de cada carácter en la cadena de derecha a izquierda?.

Como mencione, el código anterior solo muestra algunos de los métodos de String así que si se requiere de hacer algo con una cadena primero hay que verificar si existe algún método ya en la clase String que lo haga.

Friday, February 5, 2010

Ruby Básico (IRb, Comentarios, Enteros y Cadenas)

Dicen que "Ruby es el mejor amigo del programador" y la verdad no entendía porque hasta que empece a usar un poco Ruby primero para aprender y luego para hacer pequeños programas que utilizo como herramientas en mi labor diaria.

Estos pequeños programas van desde analizadores de logs hasta programas que me ayudar a generar paquetes de instalación de una forma personalizada.

Ruby es un lenguaje orientado a objetos y fue creado en 1993 por Yukihiro Matsumoto. Es muy popular en estos tiempos y existe muchas librerías de apoyo que van desde acceder a base de datos hasta manejar XML.

Ruby viene con una consola interactiva llamada IRb (Interactive Ruby) que sirve de mucho para poder experimentar con el lenguaje. Para correr la consola interactiva simplemente hay que teclear el comando "irb".


irb(main):006:0* mensaje = "Hola Mundo!"
=> "Hola Mundo!"
irb(main):007:0> puts mensaje
Hola Mundo!
=> nil
irb(main):008:0> print mensaje
Hola Mundo!=> nil
irb(main):009:0>


Los identificadores en Ruby son aquellos nombres que les damos a las variables, nombres de métodos, clases, constantes, etc. Estos nombres si hacen distinción entre mayúsculas y minúsculas y pueden ser creados usando caracteres alfanuméricos y el guion bajo '_'.

Como todo lenguaje Ruby tiene palabras reservadas que no pueden ser usadas al nombrar nuestras variables, métodos, clases, etc., no listare las palabras reservadas aquí pero las pueden encontrar en cualquier sitio en internet.

Hay dos tipos de comentarios en Ruby: para comentar una sola linea y para comentar muchas lineas.


# Este es un comentario de una sola linea

=begin
Este es un comentario
para muchas
lineas
=end


Hay 5 tipos de variables en Ruby: globales, de instancia, locales, de clase y constantes. En este post hablare de las globales y constantes, en futuros posts donde les hable de como usar Ruby con clases y objetos ya hablaremos de los otros tipos de variables.

Las variables globales en Ruby se declaran colocando el símbolo $ al inicio del nombre de la variable


$variable_global = 3.1416


Y las constantes simplemente se declaran usando puras mayúsculas en el nombre, y cualquier intento de modificar una constante resulta en un error.


PI = 3.1416
RUTA_DESTION=/tmp/



irb(main):010:0> CONSTANTE = 3.1416
=> 3.1416
irb(main):011:0> CONSTANTE = 2
(irb):11: warning: already initialized constant CONSTANTE
=> 2
irb(main):012:0>


Los enteros en Ruby se pueden escribir con un signo al inicio y también se les puede indicar el tipo de base que se desee para el numero: 0b para binarios, 0x para hexadecimal y 0 para octal.


irb(main):012:0> numero1 = 12354
=> 12354
irb(main):013:0> numero2 = 1
=> 1
irb(main):014:0> numero1 + numero2
=> 12355
irb(main):015:0> numero3 = 0b0010
=> 2
irb(main):016:0> numero2 + numero3
=> 3
irb(main):017:0> numero4 = 0x0F
=> 15
irb(main):018:0> numero3 + numero4
=> 17
irb(main):019:0> numero5 = 1_000_000
=> 1000000
irb(main):020:0>


Como notaran el guion bajo '_' es ignorado al declaran enteros.

Ruby maneja dos clases para los enteros: Fixnum y Bignum. La diferencia entre estas clases es que Fixnum esta hecho para manejar enteros en el rango de -230 to 230-1 or -262 to 262-1 (depende de la computadora donde este corriendo Ruby) y el Bignum se usa para cuando los rangos son mayores a los anteriores.

Para los números flotantes Ruby usa la clase: Float. Los números flotantes puede ser declarados usando notación científica.


irb(main):022:0* flotante = 1.2345
=> 1.2345
irb(main):023:0> flotante2 = 1.34e4
=> 13400.0
irb(main):024:0>


La clase de Ruby String es la que maneja las cadenas. Las cadenas puede ser declaradas usando comillas simples o comillas dobles.


irb(main):026:0* cadena = 'Esta es una cadena'
=> "Esta es una cadena"
irb(main):027:0> cadena2 = "Esta es otra cadena pero con comillas dobles"
=> "Esta es otra cadena pero con comillas dobles"
irb(main):028:0>