Wann soll Self in Model verwendet werden?

Frage: Wann muss ich mich in meinen Modellen in Rails selbst verwenden?

Ich habe eine setMethode in einem meiner Modelle.

class SomeData < ActiveRecord::Base
  def set_active_flag(val)
    self.active_flag = val
    self.save!
  end
end

Wenn ich das mache, funktioniert alles gut. Wenn ich dies jedoch tue:

class SomeData < ActiveRecord::Base
  def set_active_flag(val)
    active_flag = val
    save!
  end
end

Der Wert für active_flag ändert sich nicht, sondern schlägt stillschweigend fehl. Kann jemand erklären?

Ich kann keine Duplikate finden, aber wenn jemand eines findet, ist das auch in Ordnung.

Wenn Sie eine Aktion für die Instanz ausführen, die die Methode aufruft, verwenden Sie self.

Mit diesem Code

class SocialData < ActiveRecord::Base
  def set_active_flag(val)
    active_flag = val
    save!
  end
end

Sie definieren eine brandneue lokale Variable mit Gültigkeitsbereich namens active_flag und setzen sie auf den übergebenen Wert. Sie ist mit nichts verknüpft. Sie wird daher sofort weggeworfen, wenn die Methode endet, als ob sie nie existiert hätte.

self.active_flag = val

Weist die Instanz jedoch an, anstelle einer brandneuen Variablen ein eigenes Attribut namens active_flag zu ändern. Deshalb funktioniert es.

Dies geschieht aufgrund von Scoping. Wenn Sie in einer Methode, und Sie versuchen, setzen Sie eine neue Variable wie folgt aus :

class SomeData < ActiveRecord::Base
  def set_active_flag(val)
    active_flag = val
  end
end

Sie erstellen eine brandneue Variable, die sich in set_active_flag befindet. Sobald die Ausführung abgeschlossen ist, verschwindet sie und ändert sich self.active_flagin keiner Weise (die eigentliche Instanzvariable).

JEDOCH (dies war eine Quelle der Verwirrung für mich): Wenn Sie versuchen, eine Instanzvariable in Ruby wie folgt zu lesen :

class SomeData < ActiveRecord::Base
  def whats_my_active_flag
    puts active_flag
  end
end

Sie erhalten tatsächlich self.active_flag(die eigentliche Instanzvariable) zurückgegeben.

Hier ist der Grund:

Ruby wird alles tun, um eine Rückkehr zu vermeiden nil.

1. Zunächst wird gefragt, ob active_flages im Rahmen von whats_my_active_flag?
2. Es sucht und erkennt die Antwort „nein“, so springt er auf eine Ebene, auf die Instanz von some
3. Es fragt noch einmal dasselbe: "Existiert active_flages in diesem Bereich?
4. Die Antwort ist "yup" und so heißt es "Ich habe etwas für dich" und es gibt das zurück!

Wenn Sie jedoch active_flaginnerhalb von definieren whats_my_active_flagund dann danach fragen, werden die folgenden Schritte erneut ausgeführt:

1. Es fragt " active_flagexistiert im Rahmen von whats_my_active_flag?
2. Die Antwort lautet "yup", daher wird dieser Wert zurückgegeben

In beiden Fällen wird der Wert von nicht geändert , es self.active_flagsei denn, Sie teilen dies ausdrücklich mit.

Eine einfache Möglichkeit, dieses Verhalten zu beschreiben, besteht darin, "Sie nicht enttäuschen zu wollen" und zurückzukehren. nilDaher bemüht es sich, alles zu finden, was es kann.

Gleichzeitig "möchte es keine Daten durcheinander bringen, die Sie nicht ändern wollten", sodass die Instanzvariable selbst nicht geändert wird.

Hoffe das hilft!

Damit stellen Sie sicher, dass Sie die Setter-Methode verwenden und keine neue Variable festlegen. Es handelt sich um ein Ruby- und AR-Verwendungsdetail, das häufig Personen auslöst (das andere ist die (falsche) Verwendung einer Instanzvariablen).

Beachten Sie, dass es bereits update_attributes gibt! obwohl ich den Wunsch zu abstrahieren verstehe.

Es gibt auch umschalten! , was je nach Schnittstelle zur Flagge noch schöner sein könnte.

Wenn Sie active_flag = valRuby verwenden, um eine lokale Variable zu definieren, ist der beste Weg self.active_flag = val, wenn Sie sie haben, zu hoffen, dass Sie wissen, dass dies send(:active_flag=, val)auch funktioniert.