Bonjour Ichihara.
Avant
"Je l'utilise souvent dans des applications créées avec Rails ** Je souhaite mettre mes propres méthodes dans un fichier séparé et les utiliser si nécessaire **, mais je ne sais pas comment faire ..."
Il y avait une telle chose. Je n'ai pas compris ** classe et module **, qui semblaient étonnamment connus, alors je les ai résumés dans un article.
En gros, ça ressemble à ça.
| Fonctionnalité | comment utiliser | Héritage | exemple | Supériorité | |
|---|---|---|---|---|---|
| class | Une collection de données et de méthodes | Lisez le fichier avec require, puis héritez et utilisez-le comme méthode d'instance | 〇 | 〇 | Étant donné que plusieurs classes sont regroupées à l'aide de l'héritage, il peut être utilisé comme un framework. |
| module | Une collection de méthodes et de valeurs uniquement | Lisez le fichier avec reequire puis incluez,Utilisé en extension | ✖ | ✖ | Collectez des données et utilisez-les si nécessaire, utilisez-les en tant que partie |
class
La classe affecte une plus large gamme d'objets par héritage et instanciation.
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
#Lisez d'abord le fichier en utilisant require
require "calc/formulas"
#Hériter des classes et hériter des méthodes et des données
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"
Dans le cas d'une classe, commencez par lire le fichier en utilisant ** require **, laissez la classe que vous souhaitez utiliser ** inherit **, puis ** créez une instance **.
Par conséquent, il convient ** pour hériter de nombreuses données telles que la construction de modèles et de frameworks MVC et de se lier les uns aux autres **, mais si vous souhaitez l'utiliser lorsque vous souhaitez utiliser les données ensemble, cela sera décrit plus tard. On peut dire que ** module ** est plus adapté.
module
Les modules ont également le rôle de regrouper les mêmes valeurs et méthodes que la classe, mais ** ne peuvent pas créer et hériter d'instances **.
Par conséquent, le module est plus facile à utiliser que la classe en termes de simple collecte d'informations et de les appeler là où c'est nécessaire.
Il existe deux types de modules d'appel dans la classe, ** include et extend **.
En un mot, incluez le module embeds comme ** méthode d'instance ** et étendez le module embeds comme ** méthode de classe **.
Ci-dessous, ** les formules mathématiques sont résumées sous forme de module et appelées comme méthode d'instance. ** **
calc/formulas.rb
module Formula
#Théorème des trois carrés
def pythagorean_theorem(a, b)
p "c = #{Math::sqrt(a**2+ b**2)}"
end
#Formule de la solution
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
#Lis
require "calc/formulas"
class Hoge
attr_accessor :name
#Utiliser inclure en classe
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"
De cette manière, l'instance générée à partir de la classe Hoge peut utiliser pythagorean_theorem, qui est le théorème de Pitagoras, comme une ** méthode d'instance **.
Ensuite, quand je l'ai lu de la même manière avec extension ...
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)
Et vous pouvez voir que l'instance générée ne peut pas utiliser la méthode du module.
python
Hoge.pythagorean_theorem(3, 4)
#----------------------------------------------------------------
"c = 5.0"
Vous pouvez l'utiliser en l'appelant comme une ** méthode de classe **.
À propos, puisque le module est développé dans la classe, la méthode d'instance et la méthode de classe peuvent être utilisées dans la classe qui en hérite **, respectivement.
Les éléments suivants ont hérité de la classe utilisant include.
python
class Fuga < Hoge
end
fuga = Fuga.new("fugafuga",20)
fuga.quadratic_formula(1, 3, 2)
#----------------------------------------------------------------
"x is -1.0 and -2.0"
Si vous souhaitez utiliser uniquement la méthode ** directement sans l'incorporer dans la classe, vous pouvez utiliser la ** méthode module **.
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 +Définir la méthode du module par le nom de la méthode
module_function :quadratic_formula
end
python
#Peut être appelé de la même manière qu'une méthode de classe
Formula.quadratic_formula(1, 8, 12)
#---------------------------------------------------
"x is -2.0 and -6.0"
Comme vous pouvez le voir, le module n'est pas nécessaire tant que la ** classe n'est pas créée, mais il peut être utilisé si vous souhaitez ajouter une petite fonction **.
Il est préférable d'utiliser le module si vous souhaitez simplement organiser les données et la classe si vous souhaitez incorporer les données dans une partie de l'application à l'aide de l'héritage.
Recommended Posts