Class: Object
Relationships & Source Files | |
Super Chains via Extension / Inclusion / Inheritance | |
Instance Chain:
self,
::Kernel
|
|
Inherits: | BasicObject |
Defined in: | class.c, enumerator.c, eval.c, gc.c, io.c, object.c, proc.c, variable.c, vm_eval.c, vm_method.c |
Overview
Object
is the default root of all Ruby objects. Object
inherits from ::BasicObject which allows creating alternate object hierarchies. Methods on Object
are available to all classes 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.
When referencing constants in classes inheriting from Object
you do not need to use the full namespace. For example, referencing ::File inside YourClass
will find the top-level ::File class.
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
).
Instance Attribute Summary
-
#frozen? ⇒ Boolean
readonly
Returns the freeze status of obj.
-
#nil? ⇒ Boolean
readonly
Only the object nil responds
true
tonil?
. -
#tainted? ⇒ Boolean
readonly
Returns true if the object is tainted.
-
#untrusted? ⇒ Boolean
readonly
Deprecated method that is equivalent to #tainted?.
Instance Method Summary
-
#!~(other) ⇒ Boolean
Returns true if two objects do not match (using the =~ method), otherwise false.
-
#<=>(other) ⇒ 0?
Returns 0 if
obj
andother
are the same object orobj == other
, otherwise nil. -
#===(other) ⇒ Boolean
Case Equality – For class
Object
, effectively the same as calling#==
, but typically overridden by descendants to provide meaningful semantics incase
statements. - #=~(other) ⇒ nil
-
#class ⇒ class
Returns the class of obj.
-
#clone ⇒ Object
Produces a shallow copy of obj—the instance variables of obj are copied, but not the objects they reference.
-
#define_singleton_method(symbol, method) ⇒ new_method
Defines a singleton method in the receiver.
-
#display(port = $>) ⇒ nil
Prints obj on the given port (default
$>
). -
#dup ⇒ Object
Produces a shallow copy of obj—the instance variables of obj are copied, but not the objects they reference.
-
#enum_for(method = :each, *args) ⇒ Enumerator
Alias for #to_enum.
-
#eql?(other) ⇒ Boolean
Alias for BasicObject#==.
-
#extend(module, ...) ⇒ Object
Adds to obj the instance methods from each module given as a parameter.
-
#freeze ⇒ Object
Prevents further modifications to obj.
-
#hash ⇒ Fixnum
Generates a ::Fixnum hash value for this object.
-
#inspect ⇒ String
Returns a string containing a human-readable representation of obj.
-
#instance_of?(class) ⇒ Boolean
Returns
true
if obj is an instance of the given class. -
#instance_variable_defined?(symbol) ⇒ Boolean
Returns
true
if the given instance variable is defined in obj. -
#instance_variable_get(symbol) ⇒ Object
Returns the value of the given instance variable, or nil if the instance variable is not set.
-
#instance_variable_set(symbol, obj) ⇒ Object
Sets the instance variable named by symbol to the given object, thereby frustrating the efforts of the class's author to attempt to provide proper encapsulation.
-
#instance_variables ⇒ Array
Returns an array of instance variable names for the receiver.
-
#is_a?(class) ⇒ Boolean
(also: #kind_of?)
Returns
true
if class is the class of obj, or if class is one of the superclasses of obj or modules included in obj. -
#itself ⇒ Object
Returns obj.
-
#kind_of?(class) ⇒ Boolean
Alias for #is_a?.
-
#method(sym) ⇒ method
Looks up the named method as a receiver in obj, returning a ::Method object (or raising ::NameError).
-
#methods(regular = true) ⇒ Array
Returns a list of the names of public and protected methods of obj.
-
#object_id ⇒ Integer
Alias for BasicObject#__id__.
-
#private_methods(all = true) ⇒ Array
Returns the list of private methods accessible to obj.
-
#protected_methods(all = true) ⇒ Array
Returns the list of protected methods accessible to obj.
-
#public_method(sym) ⇒ method
Similar to method, searches public method only.
-
#public_methods(all = true) ⇒ Array
Returns the list of public methods accessible to obj.
-
#public_send(symbol [, args...]) ⇒ Object
Invokes the method identified by symbol, passing it any arguments specified.
-
#remove_instance_variable(symbol) ⇒ Object
Removes the named instance variable from obj, returning that variable's value.
-
#respond_to?(symbol, include_all = false) ⇒ Boolean
Returns
true
if obj responds to the given method. -
#respond_to_missing?(symbol, include_all) ⇒ Boolean
DO NOT USE THIS DIRECTLY.
-
#send(symbol [, args...]) ⇒ Object
Alias for BasicObject#__send__.
-
#singleton_class ⇒ class
Returns the singleton class of obj.
-
#singleton_method(sym) ⇒ method
Similar to method, searches singleton method only.
-
#singleton_methods(all = true) ⇒ Array
Returns an array of the names of singleton methods for obj.
-
#taint ⇒ Object
Mark the object as tainted.
-
#tap {|x| ... } ⇒ Object
Yields self to the block, and then returns self.
-
#to_enum(method = :each, *args) ⇒ Enumerator
(also: #enum_for)
Creates a new ::Enumerator which will enumerate by calling #method on
obj
, passingargs
if any. -
#to_s ⇒ String
Returns a string representing obj.
-
#trust ⇒ Object
Deprecated method that is equivalent to #untaint.
-
#untaint ⇒ Object
Removes the tainted mark from the object.
-
#untrust ⇒ Object
Deprecated method that is equivalent to #taint.
Instance Attribute Details
#frozen? ⇒ Boolean
(readonly)
Returns the freeze status of obj.
a = [ "a", "b", "c" ]
a.freeze #=> ["a", "b", "c"]
a.frozen? #=> true
#nil? ⇒ Boolean
(readonly)
Only the object nil responds true
to nil?
.
Object.new.nil? #=> false
nil.nil? #=> true
#tainted? ⇒ Boolean
(readonly)
Returns true if the object is tainted.
See #taint for more information.
#untrusted? ⇒ Boolean
(readonly)
Deprecated method that is equivalent to #tainted?.
Instance Method Details
#!~(other) ⇒ Boolean
Returns true if two objects do not match (using the =~ method), otherwise false.
#<=>(other) ⇒ 0
?
Returns 0 if obj
and other
are the same object or obj == other
, otherwise nil.
The <=>
is used by various methods to compare objects, for example Enumerable#sort, Enumerable#max etc.
Your implementation of <=>
should return one of the following values: -1, 0, 1 or nil. -1 means self is smaller than other. 0 means self is equal to other. 1 means self is bigger than other. Nil means the two values could not be compared.
When you define <=>
, you can include ::Comparable to gain the methods <=
, <
, ==
, >=
, >
and between?
.
#===(other) ⇒ Boolean
Case Equality – For class Object
, effectively the same as calling #==
, but typically overridden by descendants to provide meaningful semantics in case
statements.
#=~(other) ⇒ nil
#class ⇒ class
Returns the class of obj. 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
#clone ⇒ Object
Produces a shallow copy of obj—the instance variables of obj are copied, but not the objects they reference. clone
copies the frozen and tainted state of obj. See also the discussion under #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.
#define_singleton_method(symbol, method) ⇒ new_method
#define_singleton_method(symbol) ⇒ Proc
new_method
#define_singleton_method(symbol) ⇒ Proc
Defines a singleton method in the receiver. The method parameter can be a ::Proc, a ::Method or an ::UnboundMethod object. If a block is specified, it is used as the method body.
class A
class << self
def class_name
to_s
end
end
end
A.define_singleton_method(:who_am_i) do
"I am: #{class_name}"
end
A.who_am_i # ==> "I am: A"
guy = "Bob"
guy.define_singleton_method(:hello) { "#{self}: Hello there!" }
guy.hello #=> "Bob: Hello there!"
#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
#dup ⇒ 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.
This method may have class-specific behavior. If so, that behavior will be documented under the #initialize_copy
method of the class.
on dup vs clone
In general, #clone and dup
may have different semantics in descendant classes. While #clone is used to duplicate an object, including its internal state, dup
typically uses the class of the descendant object to create the new instance.
When using #dup
, any modules that the object has been extended with will not be copied.
class Klass
attr_accessor :str
end
module Foo
def foo; 'foo'; end
end
s1 = Klass.new #=> #<Klass:0x401b3a38>
s1.extend(Foo) #=> #<Klass:0x401b3a38>
s1.foo #=> "foo"
s2 = s1.clone #=> #<Klass:0x401b3a38>
s2.foo #=> "foo"
s3 = s1.dup #=> #<Klass:0x401b3a38>
s3.foo #=> NoMethodError: undefined method `foo' for #<Klass:0x401b3a38>
#to_enum(method = :each, *args) ⇒ Enumerator
#enum_for(method = :each, *args) ⇒ Enumerator
#to_enum(method = :each, *args) {|*args| ... } ⇒ Enumerator
#enum_for(method = :each, *args) {|*args| ... } ⇒ Enumerator
Alias for #to_enum.
#eql?(other) ⇒ Boolean
Alias for BasicObject#==. Equality — At the Object
level, ==
returns true
only if obj
and other
are the same object. Typically, this method is overridden in descendant classes to provide class-specific meaning.
Unlike ==
, the equal?
method should never be overridden by subclasses as it is used to determine object identity (that is, a.equal?(b)
if and only if a
is the same object as b
):
obj = "a"
other = obj.dup
obj == other #=> true
obj.equal? other #=> false
obj.equal? obj #=> true
The eql?
method returns true
if obj
and other
refer to the same hash key. This is used by ::Hash to test members for equality. For objects of class Object
, eql?
is synonymous with ==
. Subclasses normally continue this tradition by aliasing eql?
to their overridden ==
method, 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
#extend(module, ...) ⇒ Object
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"
#freeze ⇒ Object
Prevents further modifications to obj. A ::RuntimeError will be raised if modification is attempted. There is no way to unfreeze a frozen object. See also #frozen?.
This method returns self.
a = [ "a", "b", "c" ]
a.freeze
a << "z"
produces:
prog.rb:3:in `<<': can't modify frozen Array (RuntimeError)
from prog.rb:3
Objects of the following classes are always frozen: ::Fixnum, ::Bignum, ::Float, ::Symbol.
#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 along with #eql? by the ::Hash class to determine if two objects reference the same hash key. Any hash value that exceeds the capacity of a ::Fixnum will be truncated before being used.
The hash value for an object may not be identical across invocations or implementations of Ruby. If you need a stable identifier across Ruby invocations and implementations you will need to generate one with a custom method.
#inspect ⇒ String
Returns a string containing a human-readable representation of obj. The default inspect
shows the object's class name, an encoding of the object id, and a list of the instance variables and their values (by calling #inspect
on each of them). User defined classes should override this method to provide a better representation of obj. When overriding this method, it should return a string whose encoding is compatible with the default external encoding.
[ 1, 2, 3..4, 'five' ].inspect #=> "[1, 2, 3..4, \"five\"]"
Time.new.inspect #=> "2008-03-08 19:43:39 +0900"
class Foo
end
Foo.new.inspect #=> "#<Foo:0x0300c868>"
class Bar
def initialize
@bar = 1
end
end
Bar.new.inspect #=> "#<Bar:0x0300c868 @bar=1>"
#instance_of?(class) ⇒ Boolean
Returns true
if obj is an instance of the given class. See also #kind_of?.
class A; 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
#instance_variable_defined?(symbol) ⇒ Boolean
#instance_variable_defined?(string) ⇒ Boolean
Boolean
#instance_variable_defined?(string) ⇒ Boolean
Returns true
if the given instance variable is defined in obj. ::String arguments are converted to symbols.
class Fred
def initialize(p1, p2)
@a, @b = p1, p2
end
end
fred = Fred.new('cat', 99)
fred.instance_variable_defined?(:@a) #=> true
fred.instance_variable_defined?("@b") #=> true
fred.instance_variable_defined?("@c") #=> false
#instance_variable_get(symbol) ⇒ Object
#instance_variable_get(string) ⇒ Object
Object
#instance_variable_get(string) ⇒ Object
Returns the value of the given instance variable, or nil if the instance variable is not set. The @
part of the variable name should be included for regular instance variables. Throws a ::NameError exception if the supplied symbol is not valid as an instance variable name. ::String arguments are converted to symbols.
class Fred
def initialize(p1, p2)
@a, @b = p1, p2
end
end
fred = Fred.new('cat', 99)
fred.instance_variable_get(:@a) #=> "cat"
fred.instance_variable_get("@b") #=> 99
#instance_variable_set(symbol, obj) ⇒ Object
#instance_variable_set(string, obj) ⇒ Object
Object
#instance_variable_set(string, obj) ⇒ Object
Sets the instance variable named by symbol to the given object, thereby frustrating the efforts of the class's author to attempt to provide proper encapsulation. The variable does not have to exist prior to this call. If the instance variable name is passed as a string, that string is converted to a symbol.
class Fred
def initialize(p1, p2)
@a, @b = p1, p2
end
end
fred = Fred.new('cat', 99)
fred.instance_variable_set(:@a, 'dog') #=> "dog"
fred.instance_variable_set(:@c, 'cat') #=> "cat"
fred.inspect #=> "#<Fred:0x401b3da8 @a=\"dog\", @b=99, @c=\"cat\">"
#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]
#is_a?(class) ⇒ Boolean
#kind_of?(class) ⇒ Boolean
Also known as: #kind_of?
Boolean
#kind_of?(class) ⇒ Boolean
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.is_a? A #=> true
b.is_a? B #=> true
b.is_a? C #=> false
b.is_a? M #=> true
b.kind_of? A #=> true
b.kind_of? B #=> true
b.kind_of? C #=> false
b.kind_of? M #=> true
#itself ⇒ Object
#is_a?(class) ⇒ Boolean
#kind_of?(class) ⇒ Boolean
Boolean
#kind_of?(class) ⇒ Boolean
Alias for #is_a?.
#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"
#methods(regular = true) ⇒ Array
Returns a list of the names of public and protected methods of obj. This will include all the methods accessible in obj's ancestors. If the optional parameter is false
, it returns an array of obj<i>'s public and protected singleton methods, the array will not include methods in modules included in <i>obj.
class Klass
def klass_method()
end
end
k = Klass.new
k.methods[0..9] #=> [:klass_method, :nil?, :===,
# :==~, :!, :eql?
# :hash, :<=>, :class, :singleton_class]
k.methods.length #=> 56
k.methods(false) #=> []
def k.singleton_method; end
k.methods(false) #=> [:singleton_method]
module M123; def m123; end end
k.extend M123
k.methods(false) #=> [:singleton_method]
#object_id ⇒ Integer
Alias for BasicObject#__id__. Returns an integer identifier for obj
.
The same number will be returned on all calls to object_id
for a given object, and no two active objects will share an id.
Note: that some objects of builtin classes are reused for optimization. This is the case for immediate values and frozen string literals.
Immediate values are not passed by reference but are passed by value: nil
, true
, false
, Fixnums, Symbols, and some Floats.
Object.new.object_id == Object.new.object_id # => false
(21 * 2).object_id == (21 * 2).object_id # => true
"hello".object_id == "hello".object_id # => false
"hi".freeze.object_id == "hi".freeze.object_id # => true
#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.
#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.
#public_method(sym) ⇒ method
Similar to method, searches public method only.
#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.
#public_send(symbol [, args...]) ⇒ Object
#public_send(string [, args...]) ⇒ Object
Object
#public_send(string [, args...]) ⇒ Object
Invokes the method identified by symbol, passing it any arguments specified. Unlike send, public_send calls public methods only. When the method is identified by a string, the string is converted to a symbol.
1.public_send(:puts, "hello") # causes NoMethodError
#remove_instance_variable(symbol) ⇒ Object
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
#respond_to?(symbol, include_all = false) ⇒ Boolean
#respond_to?(string, include_all = false) ⇒ Boolean
Boolean
#respond_to?(string, include_all = false) ⇒ Boolean
Returns true
if obj responds to the given method. Private and protected methods are included in the search only if the optional second parameter evaluates to true
.
If the method is not implemented, as Process.fork on Windows, File.lchmod on GNU/Linux, etc., false is returned.
If the method is not defined, #respond_to_missing? method is called and the result is returned.
When the method name parameter is given as a string, the string is converted to a symbol.
#respond_to_missing?(symbol, include_all) ⇒ Boolean
#respond_to_missing?(string, include_all) ⇒ Boolean
Boolean
#respond_to_missing?(string, include_all) ⇒ Boolean
DO NOT USE THIS DIRECTLY.
Hook method to return whether the obj can respond to id method or not.
When the method name parameter is given as a string, the string is converted to a symbol.
See #respond_to?, and the example of ::BasicObject.
#send(symbol [, args...]) ⇒ Object
#send(string [, args...]) ⇒ Object
Object
#send(string [, args...]) ⇒ Object
Alias for BasicObject#__send__. 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. When the method is identified by a string, the string is converted to a symbol.
class Klass
def hello(*args)
"Hello " + args.join(' ')
end
end
k = Klass.new
k.send :hello, "gentle", "readers" #=> "Hello gentle readers"
#singleton_class ⇒ class
Returns the singleton class of obj. This method creates a new singleton class if obj does not have one.
If obj is nil
, true
, or false
, it returns ::NilClass, ::TrueClass, or ::FalseClass, respectively. If obj is a ::Fixnum or a ::Symbol, it raises a ::TypeError.
Object.new.singleton_class #=> #<Class:#<Object:0xb7ce1e24>>
String.singleton_class #=> #<Class:String>
nil.singleton_class #=> NilClass
#singleton_method(sym) ⇒ method
Similar to method, searches singleton method only.
class Demo
def initialize(n)
@iv = n
end
def hello()
"Hello, @iv = #{@iv}"
end
end
k = Demo.new(99)
def k.hi
"Hi, @iv = #{@iv}"
end
m = k.singleton_method(:hi)
m.call #=> "Hi, @iv = 99"
m = k.singleton_method(:hello) #=> NameError
#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. Only public and protected singleton methods are returned.
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]
#taint ⇒ Object
Mark the object as tainted.
Objects that are marked as tainted will be restricted from various built-in methods. This is to prevent insecure data, such as command-line arguments or strings read from Kernel.gets, from inadvertently compromising the user's system.
To check whether an object is tainted, use #tainted?.
You should only untaint a tainted object if your code has inspected it and determined that it is safe. To do so use #untaint.
#tap {|x| ... } ⇒ Object
Yields self to the block, and then returns self. The primary purpose of this method is to “tap into” a method chain, in order to perform operations on intermediate results within the chain.
(1..10) .tap {|x| puts "original: #{x.inspect}"}
.to_a .tap {|x| puts "array: #{x.inspect}"}
.select {|x| x%2==0} .tap {|x| puts "evens: #{x.inspect}"}
.map {|x| x*x} .tap {|x| puts "squares: #{x.inspect}"}
#to_enum(method = :each, *args) ⇒ Enumerator
#enum_for(method = :each, *args) ⇒ Enumerator
#to_enum(method = :each, *args) {|*args| ... } ⇒ Enumerator
#enum_for(method = :each, *args) {|*args| ... } ⇒ Enumerator
Also known as: #enum_for
Creates a new ::Enumerator which will enumerate by calling #method on obj
, passing args
if any.
If a block is given, it will be used to calculate the size of the enumerator without the need to iterate it (see Enumerator#size).
Examples
str = "xyz"
enum = str.enum_for(:each_byte)
enum.each { |b| puts b }
# => 120
# => 121
# => 122
# protect an array from being modified by some_method
a = [1, 2, 3]
some_method(a.to_enum)
It is typical to call to_enum when defining methods for a generic ::Enumerable, in case no block is passed.
Here is such an example, with parameter passing and a sizing block:
module Enumerable
# a generic method to repeat the values of any enumerable
def repeat(n)
raise ArgumentError, "#{n} is negative!" if n < 0
unless block_given?
return to_enum(__method__, n) do # __method__ is :repeat here
sz = size # Call size and multiply by n...
sz * n if sz # but return nil if size itself is nil
end
end
each do |*val|
n.times { yield *val }
end
end
end
%i[hello world].repeat(2) { |w| puts w }
# => Prints 'hello', 'hello', 'world', 'world'
enum = (1..14).repeat(3)
# => returns an Enumerator when called without a block
enum.first(4) # => [1, 1, 1, 2]
enum.size # => 42
#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''.
#trust ⇒ Object
Deprecated method that is equivalent to #untaint.
#untaint ⇒ Object
Removes the tainted mark from the object.
See #taint for more information.
#untrust ⇒ Object
Deprecated method that is equivalent to #taint.