класс Object

Возвращает true, если два объекта не совпадают (с использованием метода =~), иначе false.

Сравнивает self и other.

Возвращает:

• 0, если self и other — один и тот же объект или если self == other.

• nil в противном случае.

Примеры:

o = Object.new
o <=> o     # => 0
o <=> o.dup # => nil

Класс, подключающий модуль Comparable, должен переопределить этот метод, определив метод экземпляра, который:

• Принимает один аргумент, other.

• Возвращает:

  • -1, если self меньше other.

  • 0, если self равно other.

  • 1, если self больше other.

  • nil, если эти два значения несопоставимы.

Возвращает true или false.

Подобно Object#==, если object является экземпляром Object (а не экземпляром одного из многочисленных подклассов этого класса).

Этот метод обычно переопределяется подклассами, чтобы обеспечить осмысленную семантику в инструкциях case.

Основной интерфейс этой библиотеки. Используйте его для настройки делегирования при определении класса.

class MyClass < DelegateClass(ClassToDelegateTo) # Step 1
  def initialize
    super(obj_of_ClassToDelegateTo)              # Step 2
  end
end

или:

MyClass = DelegateClass(ClassToDelegateTo) do    # Step 1
  def initialize
    super(obj_of_ClassToDelegateTo)              # Step 2
  end
end

Вот пример использования из Tempfile, который на самом деле представляет собой объект File с несколькими особыми правилами о месте хранения и о том, когда следует удалять File. Это почти идеальный учебный пример использования делегирования.

class Tempfile < DelegateClass(File)
  # constant and class member data initialization...

  def initialize(basename, tmpdir=Dir::tmpdir)
    # build up file path/name in var tmpname...

    @tmpfile = File.open(tmpname, File::RDWR|File::CREAT|File::EXCL, 0600)

    # ...

    super(@tmpfile)

    # below this point, all methods of File are supported...
  end

  # ...
end

Возвращает подкласс Digest по name потокобезопасным способом, даже если используется загрузка по требованию.

require 'digest'

Digest("MD5")
# => Digest::MD5

Digest(:SHA256)
# => Digest::SHA256

Digest(:Foo)
# => LoadError: library not found for class Digest::Foo -- digest/foo

Определяет публичный метод singleton для получателя. Параметр method может быть объектом Proc, Method или UnboundMethod. Если указан блок, он используется в качестве тела метода. Если у блока или метода есть параметры, они используются в качестве параметров метода.

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!"

chris = "Chris"
chris.define_singleton_method(:greet) {|greeting| "#{greeting}, I'm Chris!" }
chris.greet("Hi") #=> "Hi, I'm Chris!"

Записывает self в указанный поток:

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

Вывод:

1cat[4, 5, 6]

Создает поверхностную копию obj — копируются переменные экземпляра obj, но не объекты, на которые они ссылаются.

Этот метод может иметь поведение, специфичное для класса. Если это так, оно описано в разделе #initialize_copy класса.

о dup и clone

В целом clone и dup могут иметь разную семантику в классах-потомках. В то время как clone используется для дублирования объекта вместе с его внутренним состоянием, dup обычно использует класс объекта-потомка для создания нового экземпляра.

При использовании dup не копируются модули, которыми был расширен объект.

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:0x401be280>
s2.foo #=> "foo"

s3 = s1.dup #=> #<Klass:0x401c1084>
s3.foo #=> NoMethodError: undefined method `foo' for #<Klass:0x401c1084>

Равенство — на уровне Object метод == возвращает true, только если obj и other — один и тот же объект. Обычно этот метод переопределяют в классах-потомках, чтобы задать значение, специфичное для класса.

В отличие от ==, метод equal? никогда не следует переопределять в подклассах, поскольку он используется для определения идентичности объектов (то есть a.equal?(b) тогда и только тогда, когда a — тот же объект, что и b):

obj = "a"
other = obj.dup

obj == other      #=> true
obj.equal? other  #=> false
obj.equal? obj    #=> true

Метод eql? возвращает true, если obj и other ссылаются на один и тот же ключ хеша. Метод используется классом Hash для проверки равенства элементов. Для любой пары объектов, для которых eql? возвращает true, значения hash обоих объектов должны быть равны. Поэтому любой подкласс, переопределяющий eql?, должен также соответствующим образом переопределить hash.

Для объектов класса Object метод eql? является синонимом ==. Подклассы обычно сохраняют эту традицию, назначая eql? псевдонимом переопределенного метода ==, но есть исключения. Например, типы Numeric выполняют преобразование типов при использовании ==, но не при использовании eql?, поэтому:

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

Добавляет к obj методы экземпляра из каждого переданного в качестве параметра модуля.

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"

Запрещает дальнейшее изменение obj. Если будет предпринята попытка изменить объект, возникнет исключение FrozenError. Разморозить замороженный объект невозможно. См. также Object#frozen?.

Этот метод возвращает self.

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

выводит:

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

Объекты следующих классов всегда заморожены: Integer, Float, Symbol.

Возвращает целочисленное хеш-значение для self; выполняется условие: если foo.eql?(bar), то foo.hash == bar.hash.

Класс Hash использует методы hash и eql?, чтобы определить, следует ли считать два объекта, используемые в качестве ключей хеша, одним и тем же ключом. Хеш-значение, превышающее емкость Integer, усекается перед использованием.

Многие основные классы переопределяют метод Object#hash; другие основные классы (например, Integer) вычисляют хеш внутри себя и не вызывают метод hash при использовании в качестве ключа хеша.

При реализации hash для пользовательского класса рекомендуется использовать Array#hash с именем класса и значениями, важными для экземпляра; это позволяет воспользоваться логикой данного метода для безопасного и эффективного вычисления хеш-значения:

def hash
  [self.class, a, b, c].hash
end

Хеш-значение может отличаться при разных вызовах и реализациях Ruby. Если вам нужны стабильные идентификаторы, подобные хешам, для разных запусков и реализаций Ruby, используйте специальный метод для их генерации.

Возвращает строку, содержащую удобное для чтения представление obj. По умолчанию inspect показывает имя класса объекта, закодированный адрес в памяти и список переменных экземпляра с их значениями (вызывая inspect для каждой из них). Пользовательские классы должны переопределять этот метод, чтобы обеспечить более подходящее представление obj. При переопределении метод должен возвращать строку с кодировкой, совместимой с используемой по умолчанию внешней кодировкой.

[ 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>"

Если объект obj отвечает на instance_variables_to_inspect, в строку inspect будут включены только переменные экземпляра, перечисленные в возвращаемом массиве.

class DatabaseConfig
  def initialize(host, user, password)
    @host = host
    @user = user
    @password = password
  end

private
  def instance_variables_to_inspect = [:@host, :@user]
end

conf = DatabaseConfig.new("localhost", "root", "hunter2")
conf.inspect #=> #<DatabaseConfig:0x0000000104def350 @host="localhost", @user="root">

Возвращает true, если obj является экземпляром указанного класса. См. также Object#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

Возвращает true, если указанная переменная экземпляра определена в obj. Аргументы типа String преобразуются в символы.

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

Возвращает значение указанной переменной экземпляра или nil, если переменная экземпляра не задана. Для обычных переменных экземпляра в имени переменной следует указывать часть @. Если переданный символ недопустим в качестве имени переменной экземпляра, возникает исключение NameError. Аргументы типа String преобразуются в символы.

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

Устанавливает для переменной экземпляра с именем 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\">"

Возвращает массив имен переменных экземпляра получателя. Обратите внимание: простое определение метода доступа не создает соответствующую переменную экземпляра.

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

Возвращает получателя.

string = "my string"
string.itself.object_id == string.object_id   #=> true

Возвращает true, если class является классом obj, одним из суперклассов obj или модулем, подключенным к 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

Ищет в obj метод с указанным именем, используя объект в качестве получателя, и возвращает объект Method (или вызывает исключение NameError). Объект Method действует как замыкание в экземпляре объекта obj, поэтому переменные экземпляра и значение self остаются доступными.

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 реализует метод to_proc, а значит, его можно использовать с итераторами.

[ 1, 2, 3 ].each(&method(:puts)) # => prints 3 lines to stdout

out = File.open('test.txt', 'w')
[ 1, 2, 3 ].each(&out.method(:puts)) # => prints 3 lines to file

require 'date'
%w[2017-03-01 2017-03-02].collect(&Date.method(:parse))
#=> [#<Date: 2017-03-01 ((2457814j,0s,0n),+0s,2299161j)>, #<Date: 2017-03-02 ((2457815j,0s,0n),+0s,2299161j)>]

Возвращает список имен публичных и защищенных методов объекта obj. В список входят все методы, доступные в предках obj. Если необязательный параметр равен false, возвращается массив публичных и защищенных методов singleton объекта obj; методы из модулей, подключенных к 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]

Только объект nil отвечает true на nil?.

Object.new.nil?   #=> false
nil.nil?          #=> true

Возвращает целочисленный идентификатор для obj.

При каждом вызове object_id для заданного объекта возвращается одно и то же число, и ни у каких двух существующих объектов идентификаторы не совпадают.

Примечание: некоторые объекты встроенных классов повторно используются для оптимизации. Это относится к непосредственным значениям и замороженным строковым литералам.

BasicObject реализует __id__, а Kernel реализует object_id.

Непосредственные значения передаются не по ссылке, а по значению: nil, true, false, Fixnum, символы и некоторые значения Float.

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

Возвращает список закрытых методов, доступных объекту obj. Если параметр all установлен в false, будут перечислены только методы самого получателя.

Возвращает список защищенных методов, доступных объекту obj. Если параметр all установлен в false, будут перечислены только методы самого получателя.

Подобно method, ищет только публичные методы.

Возвращает список публичных методов, доступных объекту obj. Если параметр all установлен в false, будут перечислены только методы самого получателя.

Вызывает метод, указанный в symbol, передавая ему заданные аргументы. В отличие от send, public_send вызывает только публичные методы. Если метод указан строкой, она преобразуется в символ.

1.public_send(:puts, "hello")  # causes NoMethodError

Удаляет из obj указанную переменную экземпляра и возвращает её значение. Имя можно передать в виде символа или строки.

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

Возвращает true, если obj поддерживает указанный метод. Закрытые и защищённые методы включаются в поиск, только если необязательный второй параметр имеет значение true.

Если метод не реализован, например Process.fork в Windows, File.lchmod в GNU/Linux и т. д., возвращается false.

Если метод не определён, вызывается метод respond_to_missing? и возвращается его результат.

Если имя метода задано строкой, она преобразуется в символ.

НЕ ВЫЗЫВАЙТЕ ЭТОТ МЕТОД НАПРЯМУЮ.

Метод-перехватчик, возвращающий информацию о том, может ли obj отвечать на вызов метода id.

Если имя метода задано строкой, она преобразуется в символ.

См. respond_to? и пример для BasicObject.

Вызывает метод, указанный в symbol, передавая ему заданные аргументы. Если метод указан строкой, она преобразуется в символ.

BasicObject реализует __send__, а Kernel реализует send. __send__ безопаснее, чем send, если у obj есть метод с тем же именем, что и у Socket. См. также public_send.

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

Возвращает класс-синглтон объекта obj. Если у obj нет класса-синглтона, этот метод создаёт его.

Если obj — nil, true или false, метод возвращает соответственно NilClass, TrueClass или FalseClass. Если obj — Integer, Float или Symbol, возникает исключение TypeError.

Object.new.singleton_class  #=> #<Class:#<Object:0xb7ce1e24>>
String.singleton_class      #=> #<Class:String>
nil.singleton_class         #=> NilClass

Подобно method, выполняет поиск только методов-синглтонов.

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

Возвращает массив имён методов-синглтонов объекта obj. Если необязательный параметр all имеет значение true, в список включаются методы модулей, подключённых к 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]

Создаёт новый Enumerator, который выполняет перечисление, вызывая method для obj и передавая ему args, если они заданы. Значения перечислителя — это значения, возвращённые блоком метода.

Если передан блок, он используется для вычисления размера перечислителя без необходимости его обхода (см. Enumerator#size).

Примеры

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)

# String#split in block form is more memory-effective:
very_large_string.split("|") { |chunk| return chunk if chunk.include?('DATE') }
# This could be rewritten more idiomatically with to_enum:
very_large_string.to_enum(:split, "|").lazy.grep(/DATE/).first

При определении методов для универсального Enumerable принято вызывать to_enum на случай, если блок не передан.

Ниже приведён пример с передачей параметров и блоком для вычисления размера:

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

Возвращает строковое представление объекта obj. Реализация to_s по умолчанию выводит класс объекта и закодированное представление его идентификатора. Особый случай — объект верхнего уровня, являющийся начальным контекстом выполнения программ Ruby: он возвращает «main».

Преобразует объект в YAML. Дополнительные сведения о доступных options см. в описании Psych.dump.