Programming Ruby

The Pragmatic Programmer's Guide

Previous < Contents ^
Next >
class Object
Parent:
Version: 1.6

Index:

== === =~ __id__ __send__ class clone display dup eql? equal? extend freeze frozen? hash id inspect instance_eval instance_of? instance_variables is_a? kind_of? method method_missing methods nil? private_methods protected_methods public_methods respond_to? send singleton_methods taint tainted? to_a to_s type untaint



Subclasses: Array, Binding, Continuation, Data, Dir, Exception, FalseClass, File::Stat, Hash, IO, MatchingData, Method, Module, NilClass, Numeric, Proc, Range, Regexp, String, Struct, Symbol, Thread, Time, TrueClass

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 that follow, the parameter aSymbol refers to a symbol, which is either a quoted string or a Symbol (such as :name).

instance methods
== obj == anObject -> true or false

Equality---At the Object level, == returns true only if obj and anObject are the same object. Typically, this method is overridden in descendent classes to provide class-specific meaning.

=== obj === anObject -> true or false

Case Equality---A synonym for Object#== , but typically overridden by descendents to provide meaningful semantics in case statements.

=~ obj =~ anObject -> false

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

__id__ obj.__id__ -> aFixnum

Synonym for Object#id .

__send__ obj.__send__( aSymbol [, args ]+ ) -> anObject

Synonym for Object#send .

class obj.class -> aClass

Returns the class of obj (synonym for Object#type ).

clone obj.clone -> anObject

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:0x401b5478>
s1.str = "Hello" "Hello"
s2 = s1.clone #<Klass:0x401b5194 @str="Hello">
s2.str[1,4] = "i" "i"
s1.inspect "#<Klass:0x401b5478 @str=\"Hi\">"
s2.inspect "#<Klass:0x401b5194 @str=\"Hi\">"

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

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

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

dup obj.dup -> anObject

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.

eql? obj.eql?( anObject ) -> true or false

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

equal? obj.equal?( anObject ) -> true or false

Returns true if obj and anObject have the same object ID. This method should not be overridden by subclasses.

a = [ 'cat', 'dog' ]
b = [ 'cat', 'dog' ]
a == b true
a.id == b.id false
a.eql?(b) true
a.equal?(b) false

extend obj.extend( [ aModule ]+ ) -> 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:0x401b598c>
k.hello "Hello from Mod.\n"

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

frozen? obj.frozen? -> true or false

Returns the freeze status of obj.

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

hash obj.hash -> aFixnum

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.

id obj.id -> aFixnum

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#id is a different concept from the :name notation, which returns the symbol id of name.

inspect obj.inspect -> aString

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 "Sun Jun 09 00:18:15 CDT 2002"

instance_eval obj.instance_eval(aString [, file [ line ] ] ) -> anObject
obj.instance_eval {| | block } -> anObject

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

instance_of? obj.instance_of?( aClass ) -> true or false

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

instance_variables obj.instance_variables -> anArray

Returns an array of instance variable names for the receiver.

is_a? obj.is_a?( aClass ) -> true or false

Synonym for Object#kind_of? .

kind_of? obj.kind_of?( aClass ) -> true or false
Returns true if aClass is the class of obj, or if aClass is one of the superclasses of obj or modules included in obj.

a = 1
a.instance_of? Numeric false
a.instance_of? Integer false
a.instance_of? Fixnum true
a.instance_of? Comparable false
a.kind_of? Numeric true
a.kind_of? Integer true
a.kind_of? Fixnum true
a.kind_of? Comparable true

method obj.method( aSymbol ) -> aMethod

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"

method_missing obj.method_missing( aSymbol [, *args ] ) -> anObject
Invoked by Ruby when obj is sent a message it cannot handle. aSymbol is the symbol for the method called, and args are any arguments that were passed to it. The example below creates a class Roman, which responds to methods with names consisting of roman numerals, returning the corresponding integer values.

class Roman
  def romanToInt(str)
    # ...
  end
  def method_missing(methId)
    str = methId.id2name
    romanToInt(str)
  end
end

r = Roman.new
r.iv 4
r.xxiii 23
r.mm 2000

methods obj.methods -> anArray

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", "dup", "eql?", "protected_methods", "==", "frozen?", "===", "respond_to?", "class", "kind_of?"]
k.methods.length 38

nil? obj.nil? -> true or false

All objects except nil return false.

private_methods obj.private_methods -> anArray

Returns a list of private methods accessible within obj. This will include the private methods in obj's ancestors, along with any mixed-in module functions.

protected_methods obj.protected_methods -> anArray

Returns the list of protected methods accessible to obj.

public_methods obj.public_methods -> anArray

Synonym for Object#methods .

respond_to? obj.respond_to?( aSymbol, includePriv=false ) -> true or false

Returns true if obj responds to the given method. Private methods are included in the search only if the optional second parameter evaluates to true.

send obj.send( aSymbol [, args ]* ) -> anObject

Invokes the method identified by aSymbol, 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"

singleton_methods obj.singleton_methods -> anArray

Returns an array of the names of singleton methods for obj.

class Klass
  def Klass.classMethod
  end
end
k = Klass.new
def k.sm()
end
Klass.singleton_methods ["classMethod"]
k.singleton_methods ["sm"]

taint obj.taint -> obj

Marks obj as tainted (see Chapter 20, which begins on page 253).

tainted? obj.tainted? -> true or false

Returns true if the object is tainted.

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.

self.to_a [main]
"hello".to_a ["hello"]
Time.new.to_a [15, 18, 0, 9, 6, 2002, 0, 160, true, "CDT"]

to_s obj.to_s -> aString

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.''

type obj.type -> aClass

Returns the class of obj.

untaint obj.untaint -> obj

Removes the taint from obj.


Previous < Contents ^
Next >

Extracted from the book "Programming Ruby - The Pragmatic Programmer's Guide"
Copyright © 2001 by Addison Wesley Longman, Inc. This material may be distributed only subject to the terms and conditions set forth in the Open Publication License, v1.0 or later (the latest version is presently available at http://www.opencontent.org/openpub/)).

Distribution of substantively modified versions of this document is prohibited without the explicit permission of the copyright holder.

Distribution of the work or derivative of the work in any standard (paper) book form is prohibited unless prior permission is obtained from the copyright holder.