Ruby/Справочник/Object

Материал из Викиучебника — открытых книг для открытого мира
Перейти к навигации Перейти к поиску

Класс Object[править]

Object is the parent class of all classes in Ruby. Its methods are therefore available to all objects unless explicitly overridden. Object mixes in the Kernel module, making the built-in kernel functions globally accessible. Although the instance methods of Object are defined by the Kernel module, we have chosen to document them here for clarity. In the descriptions of Object's methods, the parameter symbol refers to a symbol, which is either a quoted string or a Symbol (such as :name).


Same as above, except in Object.


metaprogramming assistant -- metaid.rb


Примеси

Kernel (Array, Float, Integer, Pathname, String, URI, `, abort, at_exit, autoload, autoload?, binding, block_given?, callcc, caller, catch, chomp, chomp!, chop, chop!, eval, exec, exit, exit!, fail, fork, format, gem, getc, gets, global_variables, gsub, gsub!, iterator?, lambda, load, local_variables, loop, method_missing, open, open_uri_original_open, p, pp, pretty_inspect, print, printf, proc, putc, puts, raise, rake_dup, rand, readline, readlines, require, require_gem, scan, scanf, select, set_trace_func, sleep, split, sprintf, srand, sub, sub!, syscall, system, test, throw, to_ptr, trace_var, trap, untrace_var, warn, y),

PP::ObjectMixin (pretty_print, pretty_print_cycle, pretty_print_inspect, pretty_print_instance_variables)

Константы

ARGF, ARGV, DATA, ENV, FALSE, IPsocket, MatchingData, NIL, PLATFORM, RELEASE_DATE, RUBY_PATCHLEVEL, RUBY_PLATFORM, RUBY_RELEASE_DATE, RUBY_VERSION, SOCKSsocket, STDERR, STDIN, STDOUT, TCPserver, TCPsocket, TOPLEVEL_BINDING, TRUE, UDPsocket, UNIXserver, UNIXsocket, VERSION

Методы класса

find_hidden_method, method_added, new

Методы объекта

===, ==, =~, __id__, __send__, class_def, class, clone, dclone, display, dup, enum_for, eql?, equal?, extend, freeze, frozen?, hash, id, inspect, instance_eval, instance_of?, instance_variable_get, instance_variable_set, instance_variables, is_a?, kind_of?, meta_def, meta_eval, metaclass, methods, method, nil?, object_id, private_methods, protected_methods, public_methods, remove_instance_variable, respond_to?, send, singleton_method_added, singleton_method_removed, singleton_method_undefined, singleton_methods, tainted?, taint, to_a, to_enum, to_s, to_yaml_properties, to_yaml_style, to_yaml, type, untaint

Object::find_hidden_method[править]


 Object::find_hidden_method(name)

(нет описания...)

Object::method_added[править]


 Object::method_added(name)

Detect method additions to Object and remove them in the BlankSlate class.

Object::new[править]


 Object::new()

Not documented

Object#==[править]


 obj == other        => true or false
 obj.equal?(other)   => true or false
 obj.eql?(other)     => true or false

Equality---At the Object level, == returns true only if obj and other are the same object. Typically, this method is overridden in descendent classes to provide class-specific meaning. Unlike ==, the equal? method should never be overridden by subclasses: it is used to determine object identity (that is, a.equal?(b) iff a is the same object as b). The eql? method returns true if obj and anObject have the same value. Used by Hash to test members for equality. For objects of class Object, eql? is synonymous with ==. Subclasses normally continue this tradition, but there are exceptions. Numeric types, for example, perform type conversion across ==, but not across eql?, so:

  1 == 1.0     #=> true
  1.eql? 1.0   #=> false

Object#===[править]


 obj === other   => true or false

Case Equality---For class Object, effectively the same as calling #==, but typically overridden by descendents to provide meaningful semantics in case statements.

Object#=~[править]


 obj =~ other  => false

Pattern Match---Overridden by descendents (notably Regexp and String) to provide meaningful pattern-match semantics.

Object#__id__[править]


 obj.__id__       => fixnum
 obj.object_id    => fixnum

Document-method: object_id Returns an integer identifier for obj. The same number will be returned on all calls to id for a given object, and no two active objects will share an id. Object#object_id is a different concept from the :name notation, which returns the symbol id of name. Replaces the deprecated Object#id.

Object#__send__[править]


 obj.send(symbol [, args...])        => obj
 obj.__send__(symbol [, args...])    => obj

Invokes the method identified by symbol, passing it any arguments specified. You can use __send__ if the name send clashes with an existing method in obj.

  class Klass
    def hello(*args)
      "Hello " + args.join(' ')
    end
  end
  k = Klass.new
  k.send :hello, "gentle", "readers"   #=> "Hello gentle readers"

Object#class[править]


 obj.class    => class

Returns the class of obj, now preferred over Object#type, as an object's type in Ruby is only loosely tied to that object's class. This method must always be called with an explicit receiver, as class is also a reserved word in Ruby.

  1.class      #=> Fixnum
  self.class   #=> Object

Object#class_def[править]


 class_def(name, &blk)

Defines an instance method within a class

Object#clone[править]


 obj.clone -> an_object

Produces a shallow copy of obj---the instance variables of obj are copied, but not the objects they reference. Copies the frozen and tainted state of obj. See also the discussion under Object#dup.

  class Klass
     attr_accessor :str
  end
  s1 = Klass.new      #=> #<Klass:0x401b3a38>
  s1.str = "Hello"    #=> "Hello"
  s2 = s1.clone       #=> #<Klass:0x401b3998 @str="Hello">
  s2.str[1,4] = "i"   #=> "i"
  s1.inspect          #=> "#<Klass:0x401b3a38 @str=\"Hi\">"
  s2.inspect          #=> "#<Klass:0x401b3998 @str=\"Hi\">"

This method may have class-specific behavior. If so, that behavior will be documented under the #initialize_copy method of the class.

Object#dclone[править]


 dclone()

(нет описания...)

Object#display[править]


 obj.display(port=$>)    => nil

Prints obj on the given port (default $>). Equivalent to:

  def display(port=$>)
    port.write self
  end

For example:

  1.display
  "cat".display
  [ 4, 5, 6 ].display
  puts

produces:

  1cat456

Object#dup[править]


 obj.dup -> an_object

Produces a shallow copy of obj---the instance variables of obj are copied, but not the objects they reference. dup copies the tainted state of obj. See also the discussion under Object#clone. In general, clone and dup may have different semantics in descendent classes. While clone is used to duplicate an object, including its internal state, dup typically uses the class of the descendent object to create the new instance. This method may have class-specific behavior. If so, that behavior will be documented under the #initialize_copy method of the class.

Object#enum_for[править]


 obj.to_enum(method = :each, *args)
 obj.enum_for(method = :each, *args)

Returns Enumerable::Enumerator.new(self, method, *args). e.g.:

  str = "xyz"
  enum = str.enum_for(:each_byte)
  a = enum.map {|b| '%02x' % b } #=> ["78", "79", "7a"]
  # protects an array from being modified
  a = [1, 2, 3]
  some_method(a.to_enum)

Object#eql?[править]


 obj == other        => true or false
 obj.equal?(other)   => true or false
 obj.eql?(other)     => true or false

Equality---At the Object level, == returns true only if obj and other are the same object. Typically, this method is overridden in descendent classes to provide class-specific meaning. Unlike ==, the equal? method should never be overridden by subclasses: it is used to determine object identity (that is, a.equal?(b) iff a is the same object as b). The eql? method returns true if obj and anObject have the same value. Used by Hash to test members for equality. For objects of class Object, eql? is synonymous with ==. Subclasses normally continue this tradition, but there are exceptions. Numeric types, for example, perform type conversion across ==, but not across eql?, so:

  1 == 1.0     #=> true
  1.eql? 1.0   #=> false

Object#equal?[править]


 obj == other        => true or false
 obj.equal?(other)   => true or false
 obj.eql?(other)     => true or false

Equality---At the Object level, == returns true only if obj and other are the same object. Typically, this method is overridden in descendent classes to provide class-specific meaning. Unlike ==, the equal? method should never be overridden by subclasses: it is used to determine object identity (that is, a.equal?(b) iff a is the same object as b). The eql? method returns true if obj and anObject have the same value. Used by Hash to test members for equality. For objects of class Object, eql? is synonymous with ==. Subclasses normally continue this tradition, but there are exceptions. Numeric types, for example, perform type conversion across ==, but not across eql?, so:

  1 == 1.0     #=> true
  1.eql? 1.0   #=> false

Object#extend[править]


 obj.extend(module, ...)    => obj

Adds to obj the instance methods from each module given as a parameter.

  module Mod
    def hello
      "Hello from Mod.\n"
    end
  end
  class Klass
    def hello
      "Hello from Klass.\n"
    end
  end
  k = Klass.new
  k.hello         #=> "Hello from Klass.\n"
  k.extend(Mod)   #=> #<Klass:0x401b3bc8>
  k.hello         #=> "Hello from Mod.\n"

Object#freeze[править]


 obj.freeze    => obj

Prevents further modifications to obj. A TypeError will be raised if modification is attempted. There is no way to unfreeze a frozen object. See also Object#frozen?.

  a = [ "a", "b", "c" ]
  a.freeze
  a << "z"

produces:

  prog.rb:3:in `<<': can't modify frozen array (TypeError)
   from prog.rb:3

Object#frozen?[править]


 obj.frozen?    => true or false

Returns the freeze status of obj.

  a = [ "a", "b", "c" ]
  a.freeze    #=> ["a", "b", "c"]
  a.frozen?   #=> true

Object#hash[править]


 obj.hash    => fixnum

Generates a Fixnum hash value for this object. This function must have the property that a.eql?(b) implies a.hash == b.hash. The hash value is used by class Hash. Any hash value that exceeds the capacity of a Fixnum will be truncated before being used.

Object#id[править]


 obj.id    => fixnum

Soon-to-be deprecated version of Object#object_id.

Object#inspect[править]


 obj.inspect   => string

Returns a string containing a human-readable representation of obj. If not overridden, uses the to_s method to generate the string.

  [ 1, 2, 3..4, 'five' ].inspect   #=> "[1, 2, 3..4, \"five\"]"
  Time.new.inspect                 #=> "Wed Apr 09 08:54:39 CDT 2003"

Object#instance_eval[править]


 obj.instance_eval(string [, filename [, lineno]] )   => obj
 obj.instance_eval {| | block }                       => obj

Evaluates a string containing Ruby source code, or the given block, within the context of the receiver (obj). In order to set the context, the variable self is set to obj while the code is executing, giving the code access to obj's instance variables. In the version of instance_eval that takes a String, the optional second and third parameters supply a filename and starting line number that are used when reporting compilation errors.

  class Klass
    def initialize
      @secret = 99
    end
  end
  k = Klass.new
  k.instance_eval { @secret }   #=> 99

Object#instance_of?[править]


 obj.instance_of?(class)    => true or false

Returns true if obj is an instance of the given class. See also Object#kind_of?.

Object#instance_variable_get[править]


 instance_variable_get(ivarname)

(нет описания...)

Object#instance_variable_set[править]


 instance_variable_set(ivarname, value)

(нет описания...)

Object#instance_variables[править]


 obj.instance_variables    => array

Returns an array of instance variable names for the receiver. Note that simply defining an accessor does not create the corresponding instance variable.

  class Fred
    attr_accessor :a1
    def initialize
      @iv = 3
    end
  end
  Fred.new.instance_variables   #=> ["@iv"]

Object#is_a?[править]


 obj.is_a?(class)       => true or false
 obj.kind_of?(class)    => true or false

Returns true if class is the class of obj, or if class is one of the superclasses of obj or modules included in obj.

  module M;    end
  class A
    include M
  end
  class B < A; end
  class C < B; end
  b = B.new
  b.instance_of? A   #=> false
  b.instance_of? B   #=> true
  b.instance_of? C   #=> false
  b.instance_of? M   #=> false
  b.kind_of? A       #=> true
  b.kind_of? B       #=> true
  b.kind_of? C       #=> false
  b.kind_of? M       #=> true

Object#kind_of?[править]


 obj.is_a?(class)       => true or false
 obj.kind_of?(class)    => true or false

Returns true if class is the class of obj, or if class is one of the superclasses of obj or modules included in obj.

  module M;    end
  class A
    include M
  end
  class B < A; end
  class C < B; end
  b = B.new
  b.instance_of? A   #=> false
  b.instance_of? B   #=> true
  b.instance_of? C   #=> false
  b.instance_of? M   #=> false
  b.kind_of? A       #=> true
  b.kind_of? B       #=> true
  b.kind_of? C       #=> false
  b.kind_of? M       #=> true

Object#meta_def[править]


 meta_def(name, &blk)

Adds methods to a metaclass

Object#meta_eval[править]


 meta_eval(&blk;)

(нет описания...)

Object#metaclass[править]


 metaclass()

The hidden singleton lurks behind everyone

Object#method[править]


 obj.method(sym)    => method

Looks up the named method as a receiver in obj, returning a Method object (or raising NameError). The Method object acts as a closure in obj's object instance, so instance variables and the value of self remain available.

  class Demo
    def initialize(n)
      @iv = n
    end
    def hello()
      "Hello, @iv = #{@iv}"
    end
  end
  k = Demo.new(99)
  m = k.method(:hello)
  m.call   #=> "Hello, @iv = 99"
  l = Demo.new('Fred')
  m = l.method("hello")
  m.call   #=> "Hello, @iv = Fred"

Object#methods[править]


 obj.methods    => array

Returns a list of the names of methods publicly accessible in obj. This will include all the methods accessible in obj's ancestors.

  class Klass
    def kMethod()
    end
  end
  k = Klass.new
  k.methods[0..9]    #=> ["kMethod", "freeze", "nil?", "is_a?",
                          "class", "instance_variable_set",
                           "methods", "extend", "send", "instance_eval"]
  k.methods.length   #=> 42

Object#nil?[править]


 nil?()

call_seq:

 nil.nil?               => true
 <anything_else>.nil?   => false

Only the object nil responds true to nil?.

Object#object_id[править]


 obj.__id__       => fixnum
 obj.object_id    => fixnum

Returns an integer identifier for obj. The same number will be returned on all calls to id for a given object, and no two active objects will share an id. Object#object_id is a different concept from the :name notation, which returns the symbol id of name. Replaces the deprecated Object#id.

Object#private_methods[править]


 obj.private_methods(all=true)   => array

Returns the list of private methods accessible to obj. If the all parameter is set to false, only those methods in the receiver will be listed.

Object#protected_methods[править]


 obj.protected_methods(all=true)   => array

Returns the list of protected methods accessible to obj. If the all parameter is set to false, only those methods in the receiver will be listed.

Object#public_methods[править]


 obj.public_methods(all=true)   => array

Returns the list of public methods accessible to obj. If the all parameter is set to false, only those methods in the receiver will be listed.

Object#remove_instance_variable[править]


 obj.remove_instance_variable(symbol)    => obj

Removes the named instance variable from obj, returning that variable's value.

  class Dummy
    attr_reader :var
    def initialize
      @var = 99
    end
    def remove
      remove_instance_variable(:@var)
    end
  end
  d = Dummy.new
  d.var      #=> 99
  d.remove   #=> 99
  d.var      #=> nil

Object#respond_to?[править]


 obj.respond_to?(symbol, include_private=false) => true or false

Возвращает значение true, если объект отвечает на данный метод. Частные методы включены в поиск только тогда, когда необязательный второй параметр вычисляется как true.

Object#send[править]


 obj.send(symbol [, args...])        => obj
 obj.__send__(symbol [, args...])    => obj

Invokes the method identified by symbol, passing it any arguments specified. You can use __send__ if the name send clashes with an existing method in obj.

  class Klass
    def hello(*args)
      "Hello " + args.join(' ')
    end
  end
  k = Klass.new
  k.send :hello, "gentle", "readers"   #=> "Hello gentle readers"

Object#singleton_method_added[править]


 singleton_method_added(symbol)

Invoked as a callback whenever a singleton method is added to the receiver.

  module Chatty
    def Chatty.singleton_method_added(id)
      puts "Adding #{id.id2name}"
    end
    def self.one()     end
    def two()          end
    def Chatty.three() end
  end

produces:

  Adding singleton_method_added
  Adding one
  Adding three

Object#singleton_method_removed[править]


 singleton_method_removed(symbol)

Invoked as a callback whenever a singleton method is removed from the receiver.

  module Chatty
    def Chatty.singleton_method_removed(id)
      puts "Removing #{id.id2name}"
    end
    def self.one()     end
    def two()          end
    def Chatty.three() end
    class <<self
      remove_method :three
      remove_method :one
    end
  end

produces:

  Removing three
  Removing one

Object#singleton_method_undefined[править]


 singleton_method_undefined(symbol)

Invoked as a callback whenever a singleton method is undefined in the receiver.

  module Chatty
    def Chatty.singleton_method_undefined(id)
      puts "Undefining #{id.id2name}"
    end
    def Chatty.one()   end
    class << self
       undef_method(:one)
    end
  end

produces:

  Undefining one

Object#singleton_methods[править]


 obj.singleton_methods(all=true)    => 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.

  module Other
    def three() end
  end
  class Single
    def Single.four() end
  end
  a = Single.new
  def a.one()
  end
  class << a
    include Other
    def two()
    end
  end
  Single.singleton_methods    #=> ["four"]
  a.singleton_methods(false)  #=> ["two", "one"]
  a.singleton_methods         #=> ["two", "one", "three"]

Object#taint[править]


 obj.taint -> obj

Marks obj as tainted---if the $SAFE level is set appropriately, many method calls which might alter the running programs environment will refuse to accept tainted strings.

Object#tainted?[править]


 obj.tainted?    => true or false

Returns true if the object is tainted.

Object#to_a[править]


 obj.to_a -> anArray

Returns an array representation of obj. For objects of class Object and others that don't explicitly override the method, the return value is an array containing self. However, this latter behavior will soon be obsolete.

  self.to_a       #=> -:1: warning: default `to_a' will be obsolete
  "hello".to_a    #=> ["hello"]
  Time.new.to_a   #=> [39, 54, 8, 9, 4, 2003, 3, 99, true, "CDT"]

Object#to_enum[править]


 obj.to_enum(method = :each, *args)
 obj.enum_for(method = :each, *args)

Returns Enumerable::Enumerator.new(self, method, *args). e.g.:

  str = "xyz"
  enum = str.enum_for(:each_byte)
  a = enum.map {|b| '%02x' % b } #=> ["78", "79", "7a"]
  # protects an array from being modified
  a = [1, 2, 3]
  some_method(a.to_enum)

Object#to_s[править]


 obj.to_s    => string

Returns a string representing obj. The default to_s prints the object's class and an encoding of the object id. As a special case, the top-level object that is the initial execution context of Ruby programs returns ``main.

Object#type[править]


 obj.type   => class

Deprecated synonym for Object#class.

Object#untaint[править]


 obj.untaint    => obj

Removes the taint from obj.