Omitir navegación.
Inicio

Métodos

Los métodos representan las acciones posibles de los objetos, así, un objeto puede ser texto, número, etc., pues con el método decimos qué es lo que queremos que haga el objeto, es como el verbo en una oración cualquiera, en la oración: Pedro come mucho, el método sería come, el objeto sería Pedro y la función sería mucho.

El método es un punto y un nombre detrás del objeto, así:

puts "hola".length, en este caso queremos saber la longitud del objeto y nos da 4, porque es un string y tiene 4 caracteres, si ponemos

puts [7,9,"hola"].length nos dará 3, porque es un Array de tres elementos.

Hay infinidad de métodos, relamente más de 3.000 y no es cuestión de aprenderlos todos, realmente se aprenden los que más se utilizan según surjan las necesidades, pero si es conveniente saber cómo saber de ellos y saber qué métodos tiene asociado cada objeto.

La palabra clave es .methods, que es un método en sí mismo, así si en la consola irb ponemos un objeto.methods nos dará los métodos que tiene, pero también es conveniente saber sobre qué clase estamos trabajando.

las clases son los moldes de donde salen los objetos, es un poco lioso, pero al final es comprensible.

En la entrada "Los objetos de Ruby" explicaba el tema de las clases y los objetos, así que no me voy a explicar mas, tan sólo dejar clara la idea de que todo es un objeto, de ahí sale todo, incluso las clases.

Bien, el alcance de los métodos es indiscutible, puesto ellos son los que le dan vida al objeto, asi, aunque Ruby está pensado para facilitar la programación, nada cuesta decir una camisa que una camisa de manga corta, pues más o menos es esto.

Si queremos saber qué es el objeto con el que terabajamos ponemos self:

ejemplo: puts self ---> main

Si queremos saber la clase del objeto ponemos .class:

ejemplos:

a = "Hola"
a.class --->  String
a= 1
puts a.class ---> Fixnum
a= [1]
puts a.class ---> Array

Si lo que queremos es saber los métodos utilizaremos el método .methods:

 

ejemplos:

 

a= 1
puts self
puts a.class
puts a.methods

Salida:

main

Fixnum
            %
            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?
            []
            Complete(0)

 

a= [1]
puts self
puts a.class
puts a.methods

Salida:

main
Array
uniq
select
[]=
inspect
taguri
map!
<<
fetch
&
clone
values_at
partition
public_methods
taguri=
display
empty?
instance_variable_defined?
shift
equal?
freeze
clear
*
grep
+
indices
respond_to?
methods
-
reject
first
flatten!
dup
delete_at
insert
reverse!
instance_variables
delete
nitems
__id__
unshift
concat
member?
method
fill
|
find
eql?
join
uniq!
each_with_index
yaml_initialize
id
send
singleton_methods
compact
index
collect
all?
slice
last
taint
delete_if
length
entries
instance_variable_get
frozen?
include?
instance_of?
__send__
each_index
detect
to_a
to_yaml_style
sort!
assoc
zip
to_ary
type
require_gem
object_id
instance_eval
protected_methods
map
<=>
rindex
require
any?
==
push
===
size
sort
instance_variable_set
min
extend
kind_of?
pack
reverse_each
gem
to_yaml_properties
collect!
rassoc
find_all
to_s
at
to_yaml
compact!
each
class
slice!
hash
private_methods
=~
tainted?
reject!
flatten
replace
inject
pop
reverse
untaint
nil?
transpose
sort_by
max
is_a?
[]
indexes
Complete(0)
a= "a"
puts self
puts a.class
puts a.methods
Salida:

main
String
%
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
Complete(0)

Como ves salen muchos métodos, si quieres saber qué hace cada uno de ellos pulsa en el enlace de la cabecera de esta página y búscalo, aviso que tardaré en completarlo, pero mi intención es ponerlos todos, aunque algunos los ponga en inglés de la página de la documentación de Ruby:

http://ruby-doc.org/core/