Re: who can eplain deeply the ruby's methods?

To see what methods are associated with what class which is not
inherited use this syntax:

object.public_methods(false)

examples:

>> BasicObject.public_methods(false)
 =3D> [:allocate, :new, :superclass, :to_yaml]

>> class MyClass; def hello; "world"; end; end
>> x =3D MyClass.new
 =3D> #<MyClass:0x00000002d55618>
ruby-1.9.2-head :085 > x.public_method(false)
>> x.public_methods(false)
 =3D> [:hello]

 >> {}.public_methods(false)
 =3D> [:rehash, :to_hash, :to_a, :inspect, :to_s, :=3D=3D, :[], :hash,
:eql?, :fetch, :[]=3D, :store, :default, :default=3D, :default_proc,
:default_proc=3D, :key, :index, :size, :length, :empty?, :each_value,
:each_key, :each_pair, :each, :keys, :values, :values_at, :shift,
:delete, :delete_if, :keep_if, :select, :select!, :reject, :reject!,
:clear, :invert, :update, :replace, :merge!, :merge, :assoc, :rassoc,
:flatten, :include?, :member?, :has_key?, :has_value?, :key?, :value?,
:compare_by_identity, :compare_by_identity?, :taguri=3D, :taguri,
:yaml_initialize, :to_yaml]

and so one.

On Sun, Apr 24, 2011 at 3:46 AM, Stu <[e-mail]> wrote:
> It's an object oriented inheritance hierarchy of abstract data types.
>
> For example run this in irb:
>
> String.new.class
>
> then
>
> String.class.ancestors
>
>
> This will give you an array which is the inheritance chain all the way
> down to BasicObject which for most abstract data types is the root
> with the exceptions of NilClass, TrueClass, and FalseClass.
>
> The function *_methods are to aid in reflective programming and keep
> track of specific function types to that class( or object for
> singletons). Grep can be used to search the object path in the case of
> function overloading one can call super which may open up alternative
> ways to deal with message passing, signals and polymorphism.
>
> The simplest way to "see" this is to start with your base class. In
> this case BasicObject and see what methods are in there. From there
> move up the line. Some of the data types break off in a tree like
> structure but share the common functions as you move up the tree.
>
> In when the same functions are needed they are overwritten in a top
> level class to deal with the data types special need. This can be seen
> more simply by looking at Float and Integer:
>
> =C2=A0>> 3.14.class.ancestors
> =C2=A0=3D> [Float, Numeric, Comparable, Object, Kernel, BasicObject]
>
>>> 42.class.ancestors
> =C2=A0=3D> [Fixnum, Integer, Numeric, Comparable, Object, Kernel, BasicOb=
ject]
>
> Fixnum is ruby's way of dealing with small numbers( Bignum is it's
> analogue) but ignore that for now as they are both branch off the same
> concept of integers. Notice both Float and Integer classes share
> Numeric and Comparable. Both inherit from the same common set of
> rules. Then somewhere in each respective top level class they overide
> those rules as needed to provide common syntax and function they
> share. In object oriented speak this is polymorphism.
>
> Another great example would be Array and Hash. Both share Enumerable
> and I'm sure both override the .each method to deal with the
> abstraction of an indexed array is an associative one. In the end they
> are just containers data structures that are pure abstracted and
> feature endowed linked lists.
>
> This saves us calls to self and dealing with reverse Hungarian
> notation styled function names since ruby's methods and aliases are
> well thought out and can be used as a template or standard to follow
> in your own classes you create with them.
>
> Hope that helps you a bit
>
> ~Stu
>
>
>
> On Sun, Apr 24, 2011 at 12:57 AM, savin max <[e-mail]> wrote:
>> I wants to know the ruby's methods' describe,the relationship between
>> them,also the mechanism(most wants to know).
>>
>> what are
>>
>> methods:
>> public_methods:
>> protected_methods:
>> private_methods:
>> ------------------------------------------------------------------------=
-----
>> #e.g(from ruby API 1.9.2)
>>
>> mod.instance_methods(include_super=3Dtrue) =E2=86=92 array
>> =C2=A0 =C2=A0Returns an array containing the names of the public and pro=
tected
>> instance methods in the receiver. For a module, these are the public and
>> protected methods; for a class, they are the instance (not singleton)
>> methods. With no argument, or with an argument that is false, the
>> instance methods in mod are returned, otherwise the methods in mod and
>> mod=E2=80=98s superclasses are returned.
>>
>> mod.public_instance_methods(include_super=3Dtrue) =E2=86=92 array
>> Returns a list of the public instance methods defined in mod. If the
>> optional parameter is not false, the methods of any ancestors are
>> included.
>>
>> mod.protected_instance_methods(include_super=3Dtrue) =E2=86=92 array
>> Returns a list of the protected instance methods defined in mod. If the
>> optional parameter is not false, the methods of any ancestors are
>> included.
>>
>> mod.private_instance_methods(include_super=3Dtrue) =E2=86=92 array
>> Returns a list of the private instance methods defined in mod. If the
>> optional parameter is not false, the methods of any ancestors are
>> included.
>>
>>
>> ------------------------------------------------------------------------=
-----
>>
>> obj.singleton_methods(all=3Dtrue) =E2=86=92 array
>> Returns an array of the names of singleton methods for obj. If the
>> optional all parameter is true, the list will include methods in modules
>> included in obj. Only public and protected singleton methods are
>> returned.
>>
>>
>> what's the relationship between these methods?
>> #e.g.
>> =C2=A0 =C2=A0String.instance_methods =3D=3D "str".methods #true
>> =C2=A0 =C2=A0String.methods(false) =3D=3D String.singleton_methods(false=
) =C2=A0#true
>> =C2=A0 =C2=A0class method is the singleton method?
>> .....
>> ......
>> .......
>>
>> I wants to know the ruby's methods' describe,the relationship between
>> them,also the mechanism(most wants to know).
>>
>> who can Explain=EF=BC=9F
>> thanks...
>>
>> --
>> Posted via http://www.ruby-forum.com/.
>>
>