Eine Methode namens ** attr_accessor **, die häufig angezeigt wird, wenn die grundlegende Grammatik von Ruby betrachtet wird.
Als ich es zum ersten Mal sah, wusste ich nicht, wofür es verwendet wurde, als ich von Ruby on Rails eintrat.
Ich werde es von dort nachschlagen
Um ehrlich zu sein, kann ich nicht verstehen ...
Für diejenigen, die es wissen, mag es zu genau sein, um zu sagen, was es ist, aber wenn jemand an der gleichen Stelle wie ich stolpert, würde ich es begrüßen, wenn Sie sich darauf beziehen könnten.
Zunächst die fragliche Methode ** attr_accessor **, aber kurz gesagt, es handelt sich um eine Methode **, die einer Instanz ein Attribut gibt, auf das von außen verwiesen und aktualisiert werden kann.
Ich werde eins nach dem anderen erklären.
Es ist leicht zu vergessen, wenn Sie Rails verwenden, aber die Hauptvoraussetzung ist, dass Sie keinen direkten Zugriff auf ** Instanzwerte haben. ** ** **
Als Beispiel haben wir die folgende ** Hoge ** -Klasse vorbereitet. Es gibt zwei Instanzvariablen, ** Name ** und ** Alter **.
attr_accessor.rb
class Hoge
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",12)
hoge.hello
p hoge.name
Wenn ich in diesem Zustand versuche, den Namen auszugeben, der eine Variable von hoge ist, die eine Instanz von Hoge ist ...
"Hello! I'm hogehoge "
"I'm 12 old"
Traceback (most recent call last):
attr_accessor.rb:33:in `<main>': undefined method `name' for #<Hoge:0x0000000004e68eb8 @name="hogehoge", @age=12> (NoMethodError)
Und NoMethodError tritt auf.
Das sollte es sein. Dies liegt daran, dass es in der Hoge-Klasse keine Methode namens name gibt.
Die Methoden ** setter ** und ** getter ** lösen das Problem, dass sie nicht auf die Werte dieser Instanzen zugreifen können.
Der Getter wird verwendet, wenn Sie wie zuvor auf den Wert der Instanz verweisen möchten. Es gibt zwei Möglichkeiten, den Getter festzulegen: ** Definieren einer Methode ** und ** Verwenden einer Zugriffsmethode **.
Die Definition einer Methode ist sehr einfach
python
class Hoge
def initialize(name, age)
@name = name
@age = age
end
#Realisieren Sie die Wertreferenz mit demselben Namen wie die Instanzvariable
def name
name = @name
end
def hello
p "Hello! I'm #{@name} "
p "I'm #{@age} old"
end
end
Definieren Sie eine Methode, die die Instanzvariable bei der Ausführung abruft.
Dies ist jedoch etwas unkühl, daher ist es besser, die Zugriffsmethode zu verwenden.
python
class Hoge
attr_reader :name
def initialize(name, age)
@name = name
@age = age
end
def hello
p "Hello! I'm #{@name} "
p "I'm #{@age} old"
end
end
Sie können auf den Wert der Instanzvariablen wie oben mit der Methode ** attr_reader ** verweisen. Der zu diesem Zeitpunkt definierte Wert muss ** mit dem in der Instanzvariablen ** definierten Wert übereinstimmen.
Dies ist die Rolle des Getters, um sich auf den Wert zu beziehen.
Nachdem Sie sich jetzt auf den Wert beziehen können, versuchen Sie, den Instanzwert auf dieselbe Weise wie Rails durch einen anderen Wert zu ersetzen ...
python
class Hoge
attr_reader :name
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",12)
hoge.hello
p hoge.name
hoge.name = "fugafuga"
--------------------------------------------------------------------------------
"Hello! I'm hogehoge "
"I'm 12 old"
"hogehoge"
Traceback (most recent call last):
attr_accessor.rb:37:in `<main>': undefined method `name=' for #<Hoge:0x0000000004fbb040 @name="hogehoge", @age=12> (NoMethodError)
Did you mean? name
Ich werde wieder wütend werden.
Dies liegt daran, dass ** Getter Werte sehen können, aber keine neuen Werte zuweisen können, da sie nicht die Möglichkeit zum Aktualisieren enthalten **.
Was zur Lösung dieses Problems verwendet wird, heißt ** Setter **.
Es gibt zwei Arten von Setzern: Der eine besteht darin, die Methode so zu definieren, wie sie ist, und der andere darin, die Accessor-Methode zu verwenden.
python
def name=(name)
@name = name
end
Wenn Sie nach der Methode ** = ** hinzufügen, wird sie zum Setter. Der Inhalt ist einfach, spiegeln Sie nur das empfangene Argument in der Instanzvariablen wider.
Verwendung der Accessor-Methode.
python
class Hoge
attr_reader :name
attr_writer :name
def initialize(name, age)
@name = name
@age = age
end
def hello
p "Hello! I'm #{@name} "
p "I'm #{@age} old"
end
end
Die Accessor-Methode verwendet ** attr_writer **.
python
hoge = Hoge.new("hogehoge",12)
hoge.hello
p hoge.name
hoge.name = "fugafuga"
hoge.hello
------------------------------------------------------
"Hello! I'm hogehoge "
"I'm 12 old"
"hogehoge"
"Hello! I'm fugafuga "
"I'm 12 old"
Und sicherlich wurde der Wert des Namens aktualisiert.
attr_accessor
Es ist schließlich die Erklärung von attr_accessor, aber die Rolle dieser Methode besteht darin, ** sowohl für den Getter als auch für den Setter oben verantwortlich zu sein.
Mit anderen Worten, Sie müssen nicht zwei Typen schreiben, attr_reader und attr_writer
python
class Hoge
#Diese Partei spielt die Rolle von Getter und Setter
attr_accessor :name
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",12)
hoge.hello
p hoge.name
hoge.name = "fugafuga"
hoge.hello
----------------------------------------------------------
Hello! I'm hogehoge "
"I'm 12 old"
"hogehoge"
"Hello! I'm fugafuga "
"I'm 12 old"
Kann ziemlich einfach geschrieben werden.
Sie haben sich vielleicht gefragt, ob Sie so weit gelesen haben, aber Rails zeigt diese Accessor-Methode normalerweise nicht an.
Der Grund, warum der Tabellenwert wie eine Methode referenziert und aktualisiert werden kann, liegt darin, dass er automatisch von ** ActiveRecord :: Base ** festgelegt wird.
Wenn Sie möchten, habe ich auch einen Artikel darüber geschrieben. Schauen Sie also bitte vorbei. >> Schienen db: migrieren und die Existenz von Modellen
Dies ist die Erklärung von attr_accessor.
| Methode | Funktion | Rolle |
|---|---|---|
| attr_reader | Getter | Sie können auf den Wert der Instanzvariablen verweisen |
| attr_writer | Setter | Sie können den Wert der Instanzvariablen aktualisieren |
| attr_accessor | Getter Setter | Sie können die Werte von Instanzvariablen anzeigen und aktualisieren |
Ruby on Rails ist ein sehr nützliches Framework, aber ich hatte das starke Gefühl, dass ich manchmal die Grundlagen von Ruby neu lernen musste ...
Wir empfehlen Ihnen, Ihren eigenen Code über den Inhalt dieses Bereichs zu schreiben!
Na dann
Recommended Posts