Nueva Web de Rby

EN este enlace:http://ruby-obd.6te.net/rubi/ encontraréis la nueva página de Ruby.

.to_i

Convierte en número entero.

Ejemplo:


s = 10.5
puts s                     ---> 10.5
puts s.class             ---> Float
puts s.to_i              --- > 10
puts s.to_i+s.to_i    ---> 20
puts s+s                 ---> 21

.to_s

Utiliza el objeto como String (cadena de caracteres)

Ejemplos:
5.to_s ---> "5"
abc.to_s ---> "abc"

.length

Nos muestra la longitud del objeto. No es aplicable a los objetos de la clase Fixnum.

EJEMPLOS:
--------------------
abcd.length ---> 4  #Es un objeto string
--------------------
foo = "abc"
foo.length    ---> 3  #Es el objeto variable foo
-------------------
fuu = ["abc" , "cde"]
fuu.length ---> 2     #Es el objeto array
fuu.length[0] --->    #Es la longitud del primer elemento del array
------------------

Los objetos de Ruby

Los objetos de Ruby:

Todo en Ruby es un objeto, lo cual nos está hablando de que tiene (digámoslo así) unas características propias y algo se puede hacer con ello (mas o menos como en el mundo real)

Estos objetos estás limitados por sus métodos que son las acciones que se pueden realizar.
La manera de saber qué métodos tiene un objeto es con una orden interna: .methods
Programa:

Programa
Salida
Programa:
a=2
puts a.methods

Salida:
%
inspect
taguri
<<
singleton_method_added
&
clone
>>
round
rpower
public_methods
taguri=
display
to_r
instance_variable_defined?
divmod
equal?
freeze
integer?
chr
*
+
to_i
methods
respond_to?
-
upto
between?
numerator
prec
truncate
/
dup
instance_variables
__id__
modulo
succ
|
method
eql?
zero?
id
~
to_f
send
singleton_methods
lcm
power!
prec_i
taint
step
to_int
instance_variable_get
frozen?
instance_of?
__send__
^
remainder
to_a
+@
to_yaml_style
nonzero?
-@
type
**
floor
<
require_gem
object_id
instance_eval
protected_methods
gcdlcm
<=>
require
==
prec_f
quo
>
===
downto
id2name
size
instance_variable_set
extend
kind_of?
abs
>=
gem
to_yaml_properties
next
denominator
to_s
<=
to_yaml
coerce
class
hash
ceil
private_methods
=~
tainted?
to_bn
rdiv
div
untaint
nil?
gcd
times
to_sym
is_a?
[]
>Exit code: 0

Programa:
a="hola"
puts a.methods

Salida:
%
select
[]=
inspect
taguri
<<
each_byte
clone
gsub
casecmp
display
public_methods
to_str
partition
tr_s
taguri=
empty?
instance_variable_defined?
tr!
freeze
equal?
rstrip
*
match
grep
chomp!
+
next!
swapcase
ljust
to_i
swapcase!
respond_to?
methods
between?
upto
reject
sum
hex
dup
insert
reverse!
chop
instance_variables
delete
dump
__id__
tr_s!
concat
member?
method
succ
find
eql?
each_with_index
strip!
id
rjust
to_f
send
singleton_methods
index
collect
oct
all?
is_complex_yaml?
slice
taint
length
entries
chomp
instance_variable_get
frozen?
upcase
sub!
squeeze
include?
instance_of?
__send__
upcase!
crypt
delete!
to_yaml_style
detect
to_a
zip
lstrip!
type
center
<
require_gem
object_id
instance_eval
protected_methods
map
<=>
rindex
require
>
any?
==
is_binary_data?
split
===
strip
size
sort
instance_variable_set
gsub!
count
succ!
downcase
min
extend
kind_of?
squeeze!
downcase!
intern
>=
gem
to_yaml_properties
next
find_all
to_s
<=
each_line
to_yaml
each
rstrip!
class
slice!
hash
sub
private_methods
tainted?
replace
inject
=~
tr
reverse
untaint
nil?
sort_by
lstrip
to_sym
capitalize
max
chop!
is_a?
capitalize!
scan
[]
unpack

Todo esto es lo que tienen definidos los objetos tipo número y tipo texto (cualquier cadena de caracteres)
Como en la vida real sólo puede trabajar con objetos de la misma naturaleza, pero sus métodos pueden hacer que cambien de naturaleza, es decir, pueden convertir un número en texto y viceversa.

Para comprender mejor los métodos veremos algunos:
.capitalize ---> Convierte en mayúscula el primer carácter en una cadena de caracteres.
.to_i ---> Convierte una cadena en número entero
.to_f --->Convierte una cadena en número flotante (decimal)
.to_sym ---> Convierte una cadena en símbolo.
.upcase --->  Convierte una cadena en mayúsculas.
.downcase --->  Convierte una cadena en minúsculas.
.swapcase --->  Convierte una cadena en mayúsculas y minúsculas alternadas.

Baste esto por ahora para hacernos una idea de qué son los métodos.

Los objetos en Ruby se clasifican en clases y para saber en qué clase están se utiliza la siguiente orden: .class
Nos encontraremos con que existen estas clases: Fixnun, Float, String, Array, Hash, Class, Integer, Rational.
a=2
b=2.0
c="a"
d=[]
e={}
f=2.to_r
g= 2.to_a
puts a.class
puts b.class
puts c.class
puts d.class
puts e.class
puts f.class
puts g.class

Da:
>ruby pppp.rb
pppp.rb:7: warning: default `to_a' will be obsolete
Fixnum
Float
String
Array
Hash
Rational
Array

Como vemos Ruby lee lo que ponemos y entiende en qué clase trabajará, puesto que es en ella donde se definen los métodos con los que podrá hacer algo el objeto, así, cuando ponemos a=1 ruby entiende que 1 es el valor (variable) asignado a a (que es el objeto nuevo), ésta es de la clase Fixnum, por ser un número, y le dota de sus métodos, por ser una instancia de Fixnum, así pues a hereda todas los métodos de Fixnum.

Para entendernos, cuando ponemos a='Hola' lo que hace Ruby es:
1.- a es un objeto definido por Hola.
2.- está limitado por las comillas lo cual le convierte en String
3.- le asigna los métodos de los String para que los pueda usar.

Las clases se pueden definir con .new o con los constructores literales:
String ---> ' ó "
Símbolo ---> :
Array ---> [ ]
Hash ---> { }
Rango ---> .. ó …
Expresiones regulares ---> /

Pero, ¿ordenes como puts o print, son objetos?

Bien, para que todo sea un objeto todo debe salir de una clase general que lo contenga que se llama Class, esta clase genera un objeto que los engloba a todos y se llama main, la manera de saber en qué objeto estamos es con la orden self: puts self
Así que puts y print son objetos definidos en main y no hace falta volver a definirlos.

En fin, que todo es un objeto, todo está contenido en clases y todo tiene métodos propios para poder manejar los objetos y relacionarse entre ellos. La cuestión es ir averiguando qué hace lo que uno quiere, no a la sintaxis meramente, sino a la idea de lo que uno quiere hacer.

Un ejemplo a grosso modo, si uno quiere fabricar helados, tendrá que usar de una máquina de helados donde poder darle las características que uno quiera (esto es la clase), también el helado tendrá sabor, olor, tamaño, etc., son las variables del objeto, y los métodos serán los materiales que unidos entre sí formen la máquina de hacer helados, tornillos, tuercas, muelles, paneles, líquidos, etc. infinidad de objetos y características de todo con todo en perfecta armonía para degustar el helado.

Se que aún me quedan muchas mas cosas qué decir, pero las dejo pendientes para otras entradas.

Consideraciones en los programas de Ruby I

Consideraciones en los programas de Ruby I:

• Cuando veamos una línea que empieza con # significa que no se ejecuta, es una o varias líneas de comentario.
• Cuando vea algo que empieza con mayúscula es una constante.
• El signo = no significa igualdad, sino asignación, es decir lo de la derecha del signo se le asigna a lo de la izquierda del mismo
• Normalmente las líneas del programa se escriben de izquierda a derecha pero en algunos casos no se leen igual que se escriben. Si se leen como se escriben cuando no hay procedimiento que está simbolizado por un punto a la derecha del nombre de un objeto, ejemplos:
• #, print, puts, etc. se leen como se escriben. (Son órdenes internas)
• i.to_i, etc. hay que leerlo de derecha a izquierda. (to_i utiliza una característica del objeto i)
• El uso de dobles comillas o comillas simples se diferencia en que las dobles pueden contener ordenes y las simples sólo contienen caracteres de texto. Ejemplos:

Programa
#Hola Mundo
pp = "mundo"
pp1 = 'monda'
puts "Hola mundo"
puts 'hola mundO'
puts "Hola " + pp
puts 'Hola #{pp}'
puts "Hola #{pp}"
puts "Hola #{pp1}"
puts "Hola " + pp1
>ruby ppp.rb

Resultado:
Hola mundo
hola mundO
Hola mundo
Hola #{pp}
Hola mundo
Hola monda
Hola monda
>Exit code: 0

• Lo números son súmeros mientras no se diga otra cosa:

Programa
#Hola Mundo
pp = "1"
pp1 = '1'
pp2 = 1
pp3 = pp2.to_s
puts 'Soy pp = '+pp+' Soy un string'
puts 'Soy pp1 = '+pp1+' Soy un string'
puts "Soy pp2 = #{pp2} Soy un número"
puts "Ahora soy pp3 = string de pp2 = "+pp3
>ruby ppp.rb

Resultado
Soy pp = 1 Soy un string
Soy pp1 = 1 Soy un string
Soy pp2 = 1 Soy un número
Ahora soy pp3 = string de pp2 = 1
>Exit code: 0

• En los ejemplos anteriores hemos definido variables cuando poníamos = y la forma de leerlo es así: en el ejemplo pp = “1” ---> el string 1 se le asigna a pp

pp3 = pp2.to_s ---> la forma de string de la variable pp2 se le asigna a pp3

• Cuando hay un procedimiento hay que empezar a leer por él.
• Las constantes son aquellos caracteres que empiezan por mayúsculas: P = 1
• Las variables pueden ser de tres tipos:
• locales; empiezan por minúsculas y llevan =
• Son aquellas que utilizamos en un momento determinado en el cuerpo del programa.
• No son válidas dentro de procesos ni clases.
• Las de instancia; son las que empiezan por @ y llevan =
• Las de clase, que empiezan por @@ y llevan =   (Las veremos mas adelante)

ejemplos:
Programa
#variables y contantes
A = 1                      #Constante
a = 2                      #variable local
@a = 4                   # variable de instancia

def suma               #defino un procedimiento
  b = 10                  #variable local dentro de procedimiento
  puts "@a+b = #{@a+b}"
  @c = @a+b        #defino una variable local interna al procedimiento
  puts "b+@c = #{b+@c}"  #puedo sumarla con las variables y constantes generales
  end                        # termino el procedimiento
suma
puts "Puedo sumar lo troncal con la definición"
puts "a+@c = #{a+@c}"
puts "o también hacer A+@a+@c = #{A+@a+@c}"
puts 'pero la variable b sólo puede ser usada dentro de def'
>ruby pppp.rb

Resultado
@a+b = 14
b+@c = 24

Puedo sumar lo troncal con la definición
a+@c = 16
o también hacer A+@a+@c = 19
pero la variable b sólo puede ser usada dentro de def
>Exit code: 0

• Como se puede observar #{} permite introducir una operación dentro de una cadena de caracteres
• puts y print son los encargados de mostrar por pantalla lo que sea
• puts devuelve un retorno de carro tras mostrar su mensaje
• print lo pone todo seguido.

Programa
#print y puts
print 'hola'
puts 'hola'
print "hola\n"  #Lleva el procedimiento u orden \n = retorno de carro por esto necesita comillas
puts 'hola'

Resultado
>ruby pppp.rb
holahola
hola
hola
>Exit code: 0

• =begin

=end
es un comentario de varias líneas, todo pegadito a la izquierda.
Por ahora son unas consideraciones a tener en cuenta.

Convenciones en Ruby

Documento sacado de:

http://www.ruby-lang.org/es/documentation/ruby-from-other-languages/

Cuando te enfrentas por primera vez a código escrito en Ruby, probablemente te recuerde otros lenguajes que hayas usado. Esto es a propósito. La mayor parte de la sintaxis es familiar para los usuarios de Perl, Python, y Java (entre otros lenguajes), así que si has usado alguno de estos, aprender Ruby será muy fácil.

Este documento contiene dos secciones. La primera intenta ser un resumen de lo que puedes esperar ver al aprender Ruby viniendo de otro lenguaje. La segunda sección se enfoca en determinadas funcionalidades del lenguaje y cómo podrían compararse a lo que ya puedas estar familiarizado.

                   Qué esperar: Lenguaje X a Ruby

·      A Ruby desde Java

·       A Ruby desde PHP

Estamos en proceso de traducir todos estos artículos, pero mientras lo hacemos no queremos privarte de que los leas en inglés:

·       To Ruby From C and C++ (en inglés)

·       To Ruby From Java (en inglés)

·       To Ruby From Perl (en inglés)

·       To Ruby From PHP (en inglés)

·       To Ruby From Python (en inglés)

                   Funcionalidades importantes del lenguaje y algunas advertencias

Aquí tienes algunas referencias y consejos sobre funcionalidades de Ruby que verás mientras lo aprendes.

                        Iteración

Dos funcionalidades de Ruby que se diferencian de lo que puedes haber visto previamente, y que toma cierto tiempo acostumbrarse a ellas, son los “bloques” e iteradores. En vez de recorrer un índice (como con C, C++, o Java anterior al 1.5), o recorrer una lista (como el for (@a) {...} de Perl, o for i in aList: ... en Python, con Ruby verás muy frecuentemente código de este estilo:

una_lista.each do |este_item|

  # Estamos dentro del bloque.

  # Trabaja con este_item.

end

Para obtener más información sobre each (y sus amigos collect, find,inject, sort, etc.), ejecuta ri Enumerable (y después ri Enumerable#nombre_del_metodo).

                        Todo tiene un valor

No hay diferencia entre una expresión y un comando. Todo tiene un valor, incluso si ese valor es nil. Esto es posible:

x = 10

y = 11

z = if x < y

  true

else

  false

end

z # => true

                        Los symbols (símbolos) no son strings especiales

A muchos novatos en Ruby les cuesta entender qué son los symbols, y qué utilidad pueden tener.

Los symbols pueden ser descritos como identidades. Lo importante de un Symbol es quién es, no qué es. Arranca irb y experimenta la diferencia:

irb(main):001:0> :jorge.object_id == :jorge.object_id

=> true

irb(main):002:0> "jorge".object_id == "jorge".object_id

=> false

irb(main):003:0>

El método object_id retorna la identidad de un objeto. Si dos objetos tienen el mismo object_id, son el mismo objeto (apuntan al mismo objeto en la memoria).

Como puedes ver, una vez que has usado un Symbol, cualquier otro Symbol con los mismos caracteres referencia al mismo objeto en memoria. Para dos symbols que representan los mismos caracteres, elobject_id es el mismo.

Ahora veamos el String (“jorge”). El object_id no es el mismo. Eso significa que representan a dos objetos diferentes en memoria. Siempre que uses un nuevo String, Ruby reserva memoria para él.

Si tienes dudas sobre usar un Symbol o un String, considera qué es más importante: la identidad de un objeto (por ejemplo la Key de un Hash), o el contenido (en nuestro ejemplo, “jorge”).

                        Todo es un objeto

“Todo es un objeto” no es una exageración. Incluso las clases y los enteros son objetos, y puedes hacer con ellos las mismas cosas que con cualquier otro objeto:

# Esto es lo mismo que:

# class MiClase

#   attr_accessor :variable_de_instancia

# end

MiClase = Class.new do

  attr_accessor :variable_de_instancia

end

                        Constantes variables

Las constantes no son realmente… constantes. Si modificas una constante previamente inicializada, Ruby disparará una advertencia, pero no detendrá tu programa. De todas formas, eso no quiere decir que deberías redefinir tus constantes.

                        Convenciones de sintaxis

Ruby impone algunas convenciones de sintaxis. Si un identificador comienza con una letra mayúscula, es una constante. Si comienza con un símbolo de moneda ($), es una variable global. Si comienza con @, es una variable de instancia. Si comienza con @@, es una variable de clase.

Sin embargo, los nombres de los métodos tienen permitido comenzar con letras mayúsculas. Esto puede confundirte, como muestra el siguiente ejemplo:

Constante = 10

def Constante

  11

end

Ahora Constante vale 10, pero Constante() retorna 11.

                        Falsos parámetros nombrados

A diferencia de Python, Ruby no tiene parámetros nombrados. Sin embargo, pueden ser emulados mediante el uso de symbols y hashes. Ruby on Rails, entre otros, usa esto a discreción. Por ejemplo:

def parametros_con_nombre( params )

  params

end

parametros_con_nombre( :param_uno => 10, :param_dos => 42 )

# => {:param_uno=>10, :param_dos=>42}

                        La verdad universal

En Ruby, todo excepto nil y false es considerado true. En C, Python y muchos otros lenguajes, 0* y posiblemente otros valores, como listas vacías, son considerados *false. Examina el siguiente código Python (el ejemplo aplica también a otros lenguajes):

# en Python

if 0:

  print "0 es verdadero"

else:

  print "0 es falso"

Esto imprimirá “0 es falso”. El equivalente en Ruby:

# en Ruby

if 0

  puts "0 es verdadero"

else

  puts "0 es falso"

end

Imprime “0 es verdadero”.

                        Los modificadores de acceso aplican hasta el fin del alcance

En el siguiente código Ruby,

class MiClase

  private

  def un_metodo; true; end

  def otro_metodo; false; end

end

Puede ser que esperes que otro_metodo sea de alcance público. Esto no es así. El modificador de acceso ‘private’ continúa hasta el fin del alcance, o hasta que aparezca un nuevo modificador de acceso, lo que ocurra primero. Por defecto, los métodos son públicos:

class MiClase

  # Ahora un_metodo es público

  def un_metodo; true; end

  private

  # otro_metodo es privado

  def otro_metodo; false; end

end

public, private y protected en realidad son métodos, así que pueden recibir parámetros. Si pasas un símbolo a uno de ellos, la visibilidad de ese método es alterada.

                        Acceso a los métodos

En Java, public significa que un método puede ser accedido por cualquiera. protected significa que las instancias de la clase, instancias de sus descendientes así como también de clases en el mismo paquete, pueden accederlo, pero nadie más. Y private significa que los métodos son accesibles únicamente desde las instancias de la clase.

En Ruby esto es un poco diferente. public es, naturalmente, público.private significa que los métodos son accesibles sólo cuando pueden ser invocados sin un receptor explícito. Sólo self tiene permitido ser el receptor de la invocación a un método privado.

Al que debemos estar atentos es a protected. Un método protegido puede ser llamado desde una instancia de una clase o las instancias de sus ancestros, pero también con otra instancia como su receptor.

Ejemplo, adaptado del Ruby FAQ:

$ irb

irb(main):001:0> class Test

irb(main):002:1>   # public por defecto

irb(main):003:1*   def func

irb(main):004:2>     99

irb(main):005:2>   end

irb(main):006:1>

irb(main):007:1*   def ==(otro)

irb(main):008:2>     func == otro.func

irb(main):009:2>   end

irb(main):010:1> end

=> nil

irb(main):011:0>

irb(main):012:0* t1 = Test.new

=> #

irb(main):013:0> t2 = Test.new

=> #

irb(main):014:0> t1 == t2

=> true

irb(main):015:0> # ahora haz 'func' protected, todavía funciona

irb(main):016:0* # porque protected permite la otra referencia

irb(main):017:0* class Test

irb(main):018:1>   protected :func

irb(main):019:1> end

=> Test

irb(main):020:0> t1 == t2

=> true

irb(main):021:0> # ahora haz 'func' private

irb(main):022:0* class Test

irb(main):023:1>   private :func

irb(main):024:1> end

=> Test

irb(main):025:0> t1 == t2

NoMethodError: private method `func' called for #

        from (irb):8:in `=='

        from (irb):25

        from :0

irb(main):026:0>

                        Las clases están abiertas

Las clases de Ruby están abiertas.Puedes abrirlas, agregarles funcionalidad, y modificarlas en cualquier momento. Incluso las clases principales, como Fixnum o incluso Object, el padre de todos los objetos. Ruby on Rails define un montón de métodos para menejar el tiempo y los horarios en Fixnum. Mira:

class Fixnum

  def hours

    self * 3600 # cantidad de segundos en una hora

  end

  alias hour hours

end

  

# 14 horas desde las 00:00 del 1ro de enero del 2006

Time.mktime(2006, 01, 01) + 14.hours # => Sun Jan 01 14:00:00

                        Nombres de métodos graciosos

En Ruby, los métodos tienen permitido terminar en signos de exclamación o interrogación. Por convención, los métodos que responden preguntas (i.e. Array#empty? retorna true si el receptor está vacío) terminan con un signo de interrogación. Métodos potencialmente “peligrosos” (i.e. métodos que modifican self o sus argumentos, exit! etc.) por convención terminan en un signo de exclamación.

De todas formas, no todos los métodos que modifican sus argumentos terminan en signos de exclamación. Array#replacereemplaza el contenido de un array co nel contenido de otro array. No tiene mucho sentido tener un método como ese que no modifiqueself.

                        Los métodos Singleton

Los métodos Singleton son métodos-por-objeto. Sólo están disponibles en el objeto en el que los defines.

class Automovil

  def inspect

    "Auto barato"

  end

end

porsche = Automovil.new

porsche.inspect # => Auto barato

def porsche.inspect

  "Auto muy caro"

end

porsche.inspect # => Auto muy caro

# Otros objetos no son afectados

otro_auto = Automovil.new

otro_auto.inspect # => Auto barato

                        Métodos faltantes

Ruby no se rinde si no puede encontrar un método que responda a un mensaje en particular. Llama al método method_missing con el nómbre del método que no pudo encontrar y sus argumentos. Por defecto, method_missing lanza una excepción NameError, pero puedes redefinirlo para que se ajuste mejor a tu aplicación, y muchas bibliotecas lo hacen. Aquí tienes un ejemplo:

# id es el nombre del método invocado, la sintaxis * recolecta

# todos los argumentos en un array llamado 'argumentos'

def method_missing( id, *argumentos )

  puts "El método #{id} fue invocado, pero no existe. Tiene " +

       "estos argumentos: #{argumentos.join(", ")}"

end

__ :a, :b, 10

# => El método __ fue invocado, pero no existe. Tiene estos

# argumentos: a, b, 10

Este código sólo imprime los detalles de la invocación, pero eres libre de manejar el mensaje como te parezca más apropiado.

                        Pasaje de mensajes, no llamadas a funciones

Una invocación a un método en realidad es un mensaje a otro objeto:

# Esto

1 + 2

# Es lo mismo que esto ...

1.+(2)

# Que es lo mismo que esto:

1.send "+", 2

                        Los bloques son objetos, sólo que todavía no lo saben

Los bloques (cierres en realidad) son muy utilizados por la biblioteca estandar. Para llamar a un bloque, puedes usar yield, o transformarlo en un Proc al anexarle un parámetro especial a la lista de argumentos, así:

def block( &el_bloque )

  # Aquí dentro, el_bloque es el bloque pasado al método

  el_bloque # retornar el bloque

end

sumador = block { |a, b| a + b }

# sumador ahora es un objeto Proc

sumador.class # => Proc

También puedes crear bloques fuera de las invocaciones a métodos, utilizando Proc.new con un bloque o llamando al método lambda.

Similarmente, los métodos también pueden ser objetos:

method(:puts).call "¡puts es un objeto!"

# => ¡puts es un objeto!

                        Los operadores son comodidades sintácticas

La mayoría de los operadores en Ruby son simples simplificaciones sintácticas (con algunas reglas de precedencia) para llamar a ciertos métodos. Puedes, por ejemplo, redefinir el método Fixnum#+:

class Fixnum

  # Puedes, pero por favor no lo hagas

  def +( otro )

    self - otro

  end

end

No necesitas eloperator+ de C++, etc.

Incluso puedes tener acceso estilo array si defines los métodos [] y[]=. Para definir los métodos unarios + y – (piensa en +1 y -2), debes definir los métodos +@ and -@ respectivamente.

Sin embargo, los siguientes operadores no son simplificaciones sintácticas. No son métodos, y no pueden ser redefinidos:

=, .., ..., !, not, &&, and, ||, or, !=, !~, ::

Además, +=, *= etc. sólo son abreviaciones para var = var + otra_var,var = var * otra_var, etc. y por ende no pueden ser redefinidos.