Fechas

Qué sería de un lenguaje moderno sin fecha?
Ruby tiene todo un set de clases basados en C, que fueron heredados cómo clases de fechas. De cualquier forma, estas clases ya tienen mucha lógica Ruby, qué es lo que nos interesa.
Por ejemplo, empezemos las pruebas:

irb(main):002:0> Time.now
=> Tue Apr 17 10:05:42 -0300 2007
irb(main):003:0>

Podemos tener una representación desde 1969

irb(main):004:0* Time.at(1)
=> Wed Dec 31 21:00:01 -0300 1969
irb(main):005:0> Time.at(300)
=> Wed Dec 31 21:05:00 -0300 1969
irb(main):006:0>


O toda una variación de ejemplos:

irb(main):009:0> t.sec
=> 0
irb(main):010:0> t.min
=> 0
irb(main):011:0> t.hour
=> 21
irb(main):012:0> t.day
=> 31
irb(main):013:0> t.month
=> 12
irb(main):014:0> t.year
=> 1969
irb(main):015:0> t.wday
=> 3
irb(main):016:0> t.yday
=> 365
irb(main):017:0> t.zone
=> "ART"
irb(main):018:0>

En la próxima entrega, veremos más variaciones de los objetos Time.

Números

Cómo están?
Ahora vamos a empezar a trabajar sobre los números, una parte importante de cualquier lenguaje de programación. En Ruby tenemos montones de tipos: de 32 Bits, enteros largos, enteros cortos, etc. Cómo Ruby intenta resolverlo todo por su cuenta, muchas veces no aparecen (es decir, se asignan automáticamente). Por eso es necesario conocer un poco cómo funciona esa asignación, para no generar gastos de memoria innecesarios.

Para este fin, podemos aplicar el método .class (qué devuelve la clase "natural" del objeto):

irb(main):001:0> 1000.class
=> Fixnum
irb(main):002:0> 100000000000000000.class
=> Fixnum
irb(main):003:0> 1000000000000000000000000000000000000000000000000000000000000.class
=> Bignum
irb(main):004:0> (2**30).class
=> Fixnum
irb(main):005:0> (2**300).class
=> Bignum
irb(main):006:0> 0.01.class
=> Float
irb(main):007:0> 1.class
=> Fixnum
irb(main):008:0> 1.0.class
=> Float
irb(main):009:0>

De esta forma podemos ver cómo la clase natural varía según el tamaño. Es importante notar que Ruby toma la convención del punto para saber si un número es Float o nó. Esto es: si el número 1 se escribe sin punto, es un entero, pero si se escribe 1.0 es un decimal, aunque el número se redondeé.

Seguimos jugando con los string

Ahora que podemos acceder a la documentación, podemos seguir jugando con nuestras strings. Por ejemplo, imaginemos que querémos poner un salto de línea en nuestra string.
Teníamos nuestra string:

irb(main):001:0> string = "Nuestro primer string"
=> "Nuestro primer string"
irb(main):002:0>

Pero queremos adjuntarle un pequeño salto de línea. Esto lo podemos hacer de la siguiente forma:

irb(main):002:0> string = "Nuestro \n primer salto"
=> "Nuestro \n primer salto"

Pero cómo podemos ver, no nos muestra el string con el formato que veríamos, sinó cómo lo ingresamos. Por lo que tenemos que usar el puts (Put String):

irb(main):003:0> puts string
Nuestro
primer salto
=> nil
irb(main):004:0>

De esta forma, podemos ver a nuestro string en toda su gloria! :D
Si en vez de utilizar comillas utilizamos una sola coma, lo único que podemos utilizar, cómo caractér diferente, es el "\" para usar una comilla y "\\" para usar un backlash:

irb(main):006:0* puts 'Aca esta \' una nueva prueba \' \\ '
Aca esta ' una nueva prueba ' \
=> nil
irb(main):007:0>

(cómo pueden ver, ruby entiende que el contenido es automáticamente un string).
Otra forma de escribir strings largas es la siguiente:

irb(main):009:0> string_larga = <irb(main):010:0" esta string
irb(main):011:0" tiene varios
irb(main):012:0" parrafos
irb(main):013:0" EOF
=> "esta string\ntiene varios\nparrafos\n"
irb(main):015:0> puts string_larga
esta string
tiene varios
parrafos
=> nil
irb(main):016:0>

Otro método útil es buscar parte de un string:

irb(main):016:0> puts string
Nuestro
primer salto
=> nil
irb(main):017:0> puts string[3,5]
stro
=> nil
irb(main):018:0>

Siempre podemos necesitar pasar el string de minúsculas a mayúsculas. Pero el ruby es mutable, y toma diferentes expresiones. Veámoslas:
irb(main):020:0* puts string

Nuestro
primer salto
=> nil
irb(main):021:0> puts string.upcase
NUESTRO
PRIMER SALTO
=> nil
irb(main):022:0> puts string
Nuestro
primer salto
=> nil
irb(main):023:0> puts string.upcase!
NUESTRO
PRIMER SALTO
=> nil
irb(main):024:0> puts string
NUESTRO
PRIMER SALTO
=> nil
irb(main):025:0>

Cómo podemos ver, el string mutó luego de utilizar el signo de admiración.

Finalmente, y para terminar este tour de ruby, les vamos a dejar un pequeño testeo, que luego veremos en mayor detalle. Podemos aplicar un método a cualquier objeto para saber si está vacío, llamado empty. Y la forma de testearlo es con un signo de interrogación. O ver si un string incluye un caractér...veámos:

irb(main):026:0* string.empty?
=> false
irb(main):027:0> string.include? 'NUESTRO'
=> true
irb(main):028:0>

Espero que les haya gustado! en la próxima entrega, veremos un pequeño problema a tratar, para que se ejerciten en esto.

Un apartado para el sistema de documentación

Quizás este sea un buen momento para hablar del ri. El comando "ri" es un comando que nos permite tener información sobre un objeto, o sus métodos. Por ejemplo, si hacemos un ri del objeto String (pronto veremos el significado de mayúsculas:

[fecho@sigil ~]$ ri String

Nos dará lo siguiente:
---------------------------------------------------------- Class: String
A +String+ object holds and manipulates an arbitrary sequence of
bytes, typically representing characters. String objects may be
created using +String::new+ or as literals.

Because of aliasing issues, users of strings should be aware of the
methods that modify the contents of a +String+ object. Typically,
methods with names ending in ``!'' modify their receiver, while
those without a ``!'' return a new +String+. However, there are
exceptions, such as +String#[]=+.

------------------------------------------------------------------------
Enhance the String class with a XML escaped character version of
to_s.

------------------------------------------------------------------------
User defined methods to be added to String.

------------------------------------------------------------------------


Includes:
---------
Comparable(<, <=, ==, >, >=, between?), Enumerable(all?, any?,
collect, detect, each_cons, each_slice, each_with_index, entries,
enum_cons, enum_slice, enum_with_index, find, find_all, grep,
group_by, include?, index_by, inject, map, max, member?, min,
partition, reject, select, sort, sort_by, sum, to_a, to_set, zip)


Constants:
----------
DeletePatternCache: {}
HashCache: {}
PATTERN_EUC: '[\xa1-\xfe][\xa1-\xfe]'Constants:
----------
DeletePatternCache: {}
HashCache: {}
PATTERN_EUC: '[\xa1-\xfe][\xa1-\xfe]'
PATTERN_SJIS: '[\x81-\x9f\xe0-\xef][\x40-\x7e\x80-\xfc]'
PATTERN_UTF8: '[\xc0-\xdf][\x80-\xbf]|[\xe0-\xef][\x80-\xbf]
[\x80-\xbf]'
RE_EUC: Regexp.new(PATTERN_EUC, 0, 'n')
RE_SJIS: Regexp.new(PATTERN_SJIS, 0, 'n')
RE_UTF8: Regexp.new(PATTERN_UTF8, 0, 'n')
SUCC: {}
SqueezePatternCache: {}
TrPatternCache: {}


Class methods:
--------------
new, yaml_new


Instance methods:
-----------------
%, *, +, <<, <=>, ==, =~, [], []=, _expand_ch, _regex_quote,
block_scanf, capitalize, capitalize!, casecmp, center, chomp,
chomp!, chop, chop!, concat, count, crypt, delete, delete!,
downcase, downcase!, dump, each, each_byte, each_char, each_line,
empty?, end_regexp, eql?, expand_ch_hash, ext, gsub, gsub!, hash,
hex, include?, index, initialize_copy, insert, inspect, intern,
is_binary_data?, is_complex_yaml?, iseuc, issjis, isutf8, jcount,
jlength, jsize, kconv, length, ljust, lstrip, lstrip!, match,
mbchar?, next, next!, oct, original_succ, original_succ!, pathmap,
pathmap_explode, pathmap_partial, pathmap_replace, quote, replace,
reverse, reverse!, rindex, rjust, rstrip, rstrip!, scan, scanf,
size, slice, slice!, split, squeeze, squeeze!, strip, strip!, sub,
sub!, succ, succ!, sum, swapcase, swapcase!, to_f, to_i, to_s,
to_str, to_sym, to_yaml, toeuc, tojis, tosjis, toutf16, toutf8, tr,
tr!, tr_s, tr_s!, unpack, upcase, upcase!, upto
(END)

Cómo podemos ver, esto es todas las características del objeto, mientras que si buscamos por ejemplo las características del método length, aplicado al string mediante el siguiente comando:

[fecho@sigil ~]$ ri String#length---------------------------------------------------------- String#length
str.length => integer
------------------------------------------------------------------------
Returns the length of _str_.

(END)

Esto es, lo que el comando hace.

De esta forma podemos obtener información de cualquier objeto y/o método.

En la próxima entrega seguiremos jugando con los strings.

Pruebas de expresiones

Ahora que ya tenemos Ruby instalado, podemos empezar a probar algunas de sus expresiones. Hoy veremos dos cosas: el irb, y las cadenas de caracteres, de aquí en más llamadas string(1). Usaremos los strings para ver algunas características de la sintáxis del lenguaje.

(1) Dado que la sintáxis de Ruby está atada al inglés, voy a usar los términos en ese idioma, si son necesarios para poder programar en el lenguaje.

Empezemos con el irb. Qué es el irb? Es un programa que Ruby instala por defecto, llamado Interactive Ruby. Nos permite probar expresiones, sin necesidad de estar creando un programa para poder probarlas.
Veamos cómo funciona. Abriendo un terminal (desde linux) o un command prompt (desde Windows) tipeamos irb:

[fecho@sigil ~]$ irb
irb(main):001:0>

Este es el prompt del irb. En él podremos probar expresiones fácilmente, cómo 1 + 1:

irb(main):001:0> 1+1
=> 2
irb(main):002:0>

Veamos de usar el irb en conjunto con los strings.

Los strings de Ruby no son muy diferentes de los strings de la mayor parte de los lenguajes, cómo Python, Java o C/C++. Son objetos dinámicos y mutables. Comenzemos por nuestro primer string:

irb(main):002:0> string = "Nuestro primer string"
=> "Nuestro primer string"
irb(main):003:0>

Creamos una expresión de caracteres, "Nuestro primer string" y se la asignamos a la variable string. Las variables en Ruby son de asignación dinámica, con lo cuál no debemos estar declarándolas siempre (recuerden, facilidad de programación! :D).
Cómo cualquier lenguaje orientado a objetos, podemos aplicarle un método a un objeto. Probemos con el método length, que nos devuelve la longitud de la cadena:

irb(main):003:0> string.length
=> 21
irb(main):004:0>

Cómo podemos ver, este método (luego veremos la documentación de los mismos) es aplicado al objeto string. En el caso de ruby, se pueden poner o nó paréntesis luego del método. Es decir, un .length es lo mismo que un length(). Veámoslo con un método para contar el número de veces que un caractér aparece en el string:

irb(main):006:0> string.count 'i'
=> 2
irb(main):007:0> string.count('i')
=> 2
irb(main):008:0>


Cómo podemos ver, ruby acepta la forma más cómoda de trabajar. :D
La próxima seguiremos con los strings, y empezaremos a ver la documentación. Suerte!!

Bienvenidos!

Hola a todos! Me llamo DingirFecho, y les doy la bienvenida.
Este es un blog para escribir sobre el lenguaje de programación Ruby. Si bien es el lenguaje que, al parecer, será el próximo Java en un par de años, hay poca información sobre él. Mi idea es, todos los días, escribir una pequeña introducción al lenguaje, y con el tiempo, ir sumándo nó sólo el Ruby, sino el Rails, el framework de programación del mismo.

Antes que empezemos, tenemos que hablar un poco sobre el Ruby cómo lenguaje. Fue creado por Yukihiro "Matz" Matsumoto en 1995, tomando muchos conceptos de Perl y Python. Es un lenguaje interpretado, orientado a objetos, dinámico y reflexivo. Si estas características suenan extrañas, no se hagan problema, que las trataremos individualmente. Es un lenguaje muy fácil de escribir y de leer, porque toma un paradigma nuevo, qué estoy seguro que les va a gustar: el lenguaje tiene que hacerle la vida fácil al programador. :D Con este criterio, Ruby hace que sea un placer programar, cosa que verán próximamente.


Pero por hoy, y para ir cerrando, les dejo las direcciones de dónde pueden bajarse el Ruby, junto con un par de aplicaciones interesantes:
Para el lenguaje, tienen que ir a su pagina
Para el gems, un package manager, pueden ir a esta página
Y finalmente, un buen IDE (y gratis!) es el Freeride, en esta página

Espero que les sirva, y nos vemos mañana!

Fecho