Использование «Я», подмешать методами и доступными методами

Question

Это код, который я использую в классе под названием Game:

def play 
    puts "There are #{@players.length} players in #{@title}." 

    @players.each do |n| 
    puts n 
    end 

    @players.each do |o| 
    GameTurn.take_turn(o) 
    puts o 
    end 
end 

Он использует строку кода, который ссылается на модуль под названием GameTurn. В GameTurn, у меня есть метод, называемый self.take_turn:

require_relative "die" 
require_relative "Player" 

module GameTurn 

    def self.take_turn(o) 
    die = Die.new 

    case die.roll 
    when 1..2 
     o.blam 
     puts "#{o.name} was blammed homie." 
    when 3..4 
     puts "#{o.name} was skipped." 
    else 
     o.w00t 
    end 
    end 
end 

Я немного запутался, почему мы используем «я», а разницу между доступными методами и подмешать методы в модулях. Я спросил об этом «instance methods of classes vs module methods»

Является ли take_turn действительно выставленным методом? Даже если мы используем метод take_turn объекта из класса игрока, этот метод по-прежнему считается модульным методом, который мы используем напрямую? Разве это не считается методом mixin? Мы вводим в метод take_turn объект из другого класса, так что он не смешивается с другими классами?

Кроме того, я все еще пытаюсь выяснить, когда/почему мы используем термин «я»? Просто странно, что нам нужно определить метод take_turn в модуле GameTurn, используя термин «я». Кажется, он должен быть определен без «я»?

Answer 1

Хорошо, с самого начала:

self всегда возвращает объект, в каком контексте она выполняется. Так вот:

class A 
    self  #=> A 
end 

В рубин, вы можете определить методы объектов в полете, вы можете, например, сделать:

o = Object.new 

o.foo #=> NameError 

def o.foo 
    :foo 
end 

o.foo #=> :foo 

Классы и модули только объекты, как все остальное, следовательно, вы можете определить методы на них, а также:

def A.method 
    'class method' 
end 

A.method #=> 'class_method' 

Однако гораздо проще и более удобно, чтобы определить его в теле класса - из-за себя, которая всегда возвращает себя классу:

class A 
    def self.foo 
    :foo 
    end 
end 

self возвращает, так что это может быть прочитана как:

class A 
    def A.foo 
    :foo 
    end 
end 

Хорошая вещь о том, что если вы решите изменить имя класса, вам нужно только сделать это на вершине, рядом до class - сам позаботится обо всем остальном.

В способе self всегда используется приемник. Итак:

o = Object.new 
def o.method 
    self 
end 
o.method == o  #=> true 

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

class A 
    def get_class 
    self.class 
    end 
end 

class B < A 
end 

b = B.new 
b.get_class  #=> B 

даже если get_class определяются по классу А, сам относится к приемнику методы, а не владелец метод. Следовательно, имеет значение:

b.class   #=> B 

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