Hallo Ichihara.
Vor
"Ich verwende es oft in Apps, die mit Rails erstellt wurden. ** Ich möchte meine eigenen Methoden in eine separate Datei einfügen und sie bei Bedarf verwenden **, aber ich weiß nicht, wie ich das machen soll ..."
Da war so etwas. Ich habe ** Klasse und Modul ** nicht verstanden, was überraschend bekannt zu sein schien, also habe ich sie in einem Artikel zusammengefasst.
Grob zusammengefasst sieht es so aus.
| Charakteristisch | wie benutzt man | Erbe | Beispiel | Überlegenheit | |
|---|---|---|---|---|---|
| class | Eine Sammlung von Daten und Methoden | Lesen Sie die Datei mit require, erben Sie sie und verwenden Sie sie als Instanzmethode | 〇 | 〇 | Da mehrere Klassen mithilfe der Vererbung zusammengefasst werden, kann sie wie ein Framework verwendet werden. |
| module | Eine Sammlung nur von Methoden und Werten | Lesen Sie die Datei mit reequire und fügen Sie sie dann hinzu,Wird in großem Umfang verwendet | ✖ | ✖ | Sammeln Sie Daten und verwenden Sie sie gegebenenfalls als Teil |
class
Klasse wirkt sich durch Vererbung und Instanziierung auf einen größeren Bereich von Objekten aus.
python
class Formula
def pythagorean_theorem(a, b)
p "c = #{Math::sqrt(a**2+ b**2)}"
end
def self.quadratic_formula(a, b, c)
x1 = (- b +Math::sqrt(b*b -4*a*c))/ 2 * a
x2 = (- b -Math::sqrt(b*b -4*a*c))/ 2 * a
p "x is #{x1} and #{x2}"
end
end
calc/calculate.rb
#Lesen Sie zuerst die Datei mit require
require "calc/formulas"
#Erben Sie Klassen und erben Sie Methoden und Daten
class Hoge < Formula
attr_accessor :name
def initialize(name, age)
@name = name
@age = age
end
end
hoge = Hoge.new("hogehoge",22)
hoge.pythagorean_theorem(3, 4)
#-----------------------------------------------------------
"c = 5.0"
Lesen Sie im Fall einer Klasse zuerst die Datei mit ** require **, lassen Sie die Klasse, die Sie verwenden möchten, erben und erstellen Sie dann eine Instanz.
Daher eignet es sich zum ** Erben vieler Daten, z. B. zum Erstellen von MVC-Modellen und Frameworks und zum Verknüpfen **. Wenn Sie es jedoch verwenden möchten, wenn Sie die Daten zusammen verwenden möchten, wird es später beschrieben. Man kann sagen, dass ** Modul ** besser geeignet ist.
module
Module haben auch die Rolle, dieselben Werte und Methoden wie Klassen zu gruppieren, können jedoch keine Instanzen erstellen und erben.
Daher ist das Modul einfacher zu verwenden als die Klasse, da Informationen einfach gesammelt und dort aufgerufen werden, wo sie benötigt werden.
Innerhalb der Klasse gibt es zwei Arten von aufrufenden Modulen: ** einschließen und erweitern **.
Kurz gesagt, schließen Sie das Einbettungsmodul als ** Instanzmethode ** ein und erweitern Sie das Einbettungsmodul als ** Klassenmethode **.
Im Folgenden ** werden die mathematischen Formeln als Modul zusammengefasst und als Instanzmethode aufgerufen. ** ** **
calc/formulas.rb
module Formula
#Satz von drei Quadraten
def pythagorean_theorem(a, b)
p "c = #{Math::sqrt(a**2+ b**2)}"
end
#Lösungsformel
def quadratic_formula(a, b, c)
x1 = (- b +Math::sqrt(b*b -4*a*c))/ 2 * a
x2 = (- b -Math::sqrt(b*b -4*a*c))/ 2 * a
p "x is #{x1} and #{x2}"
end
end
calc/calculate.rb
#Lesen
require "calc/formulas"
class Hoge
attr_accessor :name
#Verwenden Sie include in class
include Formula
def initialize(name, age)
@name = name
@age = age
end
end
hoge = Hoge.new("hogehoge",22)
hoge.pythagorean_theorem(3, 4)
#---------------------------------------------------
"c = 5.0"
Auf diese Weise kann die aus der Hoge-Klasse generierte Instanz pythagorean_theorem, das Pitagoras-Theorem, als ** Instanzmethode ** verwenden.
Dann, wenn ich es auf die gleiche Weise mit verlängern lese ...
python
require "calc/formulas"
class Hoge
attr_accessor :name
extend Formula
def initialize(name, age)
@name = name
@age = age
end
def hello
p "Hello! I'm #{@name} "
p "I'm #{@age} old"
end
end
hoge = Hoge.new("hogehoge",22)
hoge.pythagorean_theorem(3, 4)
#--------------------------------------------------------------------
calculate.rb:26:in `<main>': undefined method `pythagorean_theorem' for #<Hoge:0x000000000504a3a8 @name="hogehoge", @age=22> (NoMethodError)
Und Sie können sehen, dass die generierte Instanz die Methode des Moduls nicht verwenden kann.
python
Hoge.pythagorean_theorem(3, 4)
#----------------------------------------------------------------
"c = 5.0"
Sie können es verwenden, indem Sie es als ** Klassenmethode ** aufrufen.
Übrigens, da das Modul in der Klasse erweitert ist, können die Instanzmethode und die Klassenmethode in der Klasse verwendet werden, die es erbt **.
Im Folgenden wurde die Klasse mit include geerbt.
python
class Fuga < Hoge
end
fuga = Fuga.new("fugafuga",20)
fuga.quadratic_formula(1, 3, 2)
#----------------------------------------------------------------
"x is -1.0 and -2.0"
Wenn Sie nur die ** Methode direkt verwenden möchten, ohne sie in die Klasse aufzunehmen, können Sie die ** Modulmethode ** verwenden.
python
module Formula
def pythagorean_theorem(a, b)
p "c = #{Math::sqrt(a**2+ b**2)}"
end
def quadratic_formula(a, b, c)
x1 = (- b +Math::sqrt(b*b -4*a*c))/ 2 * a
x2 = (- b -Math::sqrt(b*b -4*a*c))/ 2 * a
p "x is #{x1} and #{x2}"
end
# module_function +Definieren Sie die Modulmethode anhand des Methodennamens
module_function :quadratic_formula
end
python
#Kann wie eine Klassenmethode aufgerufen werden
Formula.quadratic_formula(1, 8, 12)
#---------------------------------------------------
"x is -2.0 and -6.0"
Wie Sie sehen, ist das Modul erst erforderlich, wenn die Klasse ** erstellt wurde. Es kann jedoch verwendet werden, wenn Sie eine kleine Funktion hinzufügen möchten **.
Es ist vorzuziehen, das Modul zu verwenden, wenn Sie nur die Daten organisieren möchten, und die Klasse, wenn Sie die Daten mithilfe der Vererbung in einen Teil der App einbetten möchten.
Recommended Posts