Czym jest attr accessor w Ruby?

Attr_accessor jest tylko metodą. (Link powinien zapewnić więcej wglądu w to, jak to działa-spójrz na pary wygenerowanych metod, a samouczek powinien pokazać, jak z niego korzystać.)

Sztuczka polega na tym, że class jest nie definicją W Rubim (jest "tylko definicją" w językach takich jak C++ i Java), ale jest wyrażeniem , które ocenia. Podczas tej oceny jest wywoływana metoda attr_accessor, która z kolei modyfikuje bieżącą klasę - remember the implicit receiver: self.attr_accessor, Gdzie self jest obiektem klasy "open" w tym punkcie.

Potrzeba attr_accessor i przyjaciół, jest, cóż:

1. Ruby, podobnie jak Smalltalk, nie pozwala na dostęp do zmiennych instancji poza metodami¹ za ten przedmiot. Oznacza to, że zmienne instancji nie mogą być dostępne w formie x.y, Jak to jest powszechne w say, Java lub nawet Python. W Ruby {[6] } jest zawsze traktowana jako wiadomość do wysłania (lub"metoda do wywołania"). Zatem metody {[7] } tworzy wrappery, które zastępują instancję @variable dostęp za pomocą dynamicznie tworzonych metod.

2. Boilerplate sucks

Mam nadzieję, że to wyjaśnia niektóre szczegóły. Szczęśliwego kodowania.

¹ nie jest to ściśle prawda i istnieją pewne "techniki" wokół tego , ale nie ma wsparcia składni dla dostępu do "zmiennej instancji publicznej".

attr_accessor jest (jak stwierdził @pst) tylko metodą. To, co robi, to tworzenie więcej metod dla Ciebie.

Więc ten kod tutaj:

class Foo
  attr_accessor :bar
end

Jest odpowiednikiem tego kodu:

class Foo
  def bar
    @bar
  end
  def bar=( new_value )
    @bar = new_value
  end
end

Możesz napisać ten rodzaj metody samodzielnie w Ruby:

class Module
  def var( method_name )
    inst_variable_name = "@#{method_name}".to_sym
    define_method method_name do
      instance_variable_get inst_variable_name
    end
    define_method "#{method_name}=" do |new_value|
      instance_variable_set inst_variable_name, new_value
    end
  end
end

class Foo
  var :bar
end

f = Foo.new
p f.bar     #=> nil
f.bar = 42
p f.bar     #=> 42

attr_accessor jest bardzo proste:

attr_accessor :foo

Jest skrótem od:

def foo=(val)
  @foo = val
end

def foo
  @foo
end

Jest to nic innego jak getter / setter dla obiektu

Zasadniczo fałszują publicznie dostępne atrybuty danych, których Ruby nie ma.

Jest to po prostu metoda, która definiuje metody getter i setter na przykład zmienne. Przykładowa implementacja to:

def self.attr_accessor(*names)
  names.each do |name|
    define_method(name) {instance_variable_get("@#{name}")} # This is the getter
    define_method("#{name}=") {|arg| instance_variable_set("@#{name}", arg)} # This is the setter
  end
end

Ja również zmierzyłem się z tym problemem i napisałem dość długą odpowiedź na to pytanie. Istnieje już kilka świetnych odpowiedzi na ten temat, ale każdy, kto szuka więcej wyjaśnień, mam nadzieję, że moja odpowiedź może pomóc

Initialize Method

Initialize pozwala na ustawienie danych do instancji obiektu po utworzeniu instancji, zamiast ustawiać je w osobnej linii kodu za każdym razem, gdy tworzysz nową instancję klasy.

class Person
  attr_accessor :name

  def initialize(name)
    @name = name
  end


  def greeting
    "Hello #{@name}"
  end
end

person = Person.new("Denis")
puts person.greeting

W powyższym kodzie jesteśmy ustawianie nazwy "Denis" za pomocą metody initialize poprzez przekazanie Dennisa przez parametr w Initialize. Jeśli chcemy ustawić nazwę Bez metody initialize, możemy zrobić to w następujący sposób:

class Person
  attr_accessor :name

  # def initialize(name)
  #     @name = name
  # end

  def greeting
    "Hello #{name}"
  end
end

person = Person.new
person.name = "Dennis"
puts person.greeting

W powyższym kodzie ustawiamy nazwę wywołując metodę attr_accessor setter używając person.name, zamiast ustawiać wartości przy inicjalizacji obiektu.

Obie "metody" wykonywania tej pracy, ale initialize oszczędza nam czas i linie kodu.

To jest tylko zadanie inicjalizacji. Nie można wywołać initialize jako metody. Aby uzyskać wartości obiektu instancji, należy użyć getterów i setterów (attr_reader( get), attr_writer (set) i attr_accessor (both)). Więcej szczegółów na ten temat można znaleźć poniżej.

Getters, Setters (attr_reader, attr_writer, attr_accessor)

Getters, attr_reader: celem gettera jest zwrócenie wartości konkretnej zmiennej instancji. Odwiedź poniższy przykładowy kod, aby uzyskać informacje na ten temat.

class Item

  def initialize(item_name, quantity)
    @item_name = item_name
    @quantity = quantity
  end

  def item_name
    @item_name
  end

  def quantity
     @quantity
  end
end

example = Item.new("TV",2)
puts example.item_name
puts example.quantity

W powyższym kodzie wywołujesz metody "item_name" i " quantity "na instancji elementu"example". Przykład " puts.item_name " i " przykład.quantity "zwróci (lub" get") wartość parametrów, które zostały przekazane do "przykładu"i wyświetli je na ekranie.

Na szczęście w Rubim istnieje nieodłączna metoda, która pozwala nam pisać ten kod bardziej zwięźle; metoda attr_reader. Zobacz poniższy kod;

class Item

attr_reader :item_name, :quantity

  def initialize(item_name, quantity)
    @item_name = item_name
    @quantity = quantity
  end

end

item = Item.new("TV",2)
puts item.item_name
puts item.quantity

Ta składnia działa dokładnie tak w ten sam sposób, tylko to oszczędza nam sześć linijek kodu. Wyobraź sobie, że masz jeszcze 5 Stanów przypisanych do klasy przedmiotów? Kod szybko się wydłuży.

Setters, attr_writer: to, co na początku skrzyżowało mnie z metodami setter, to to, że w moich oczach wydawało mi się, że spełnia ona identyczną funkcję jak metoda initialize. Poniżej wyjaśniam różnicę na podstawie mojego zrozumienia;

Jak podano wcześniej, metoda initialize pozwala ustawić wartości dla instancji obiektu po obiekcie stworzenie.

Ale co zrobić, jeśli chcesz ustawić wartości później, po utworzeniu instancji, lub zmienić je po ich zainicjowaniu? Byłby to scenariusz, w którym można by użyć metody settera. NA TYM POLEGA RÓŻNICA. Nie musisz "ustawiać" określonego stanu, gdy używasz początkowo metody attr_writer.

Poniższy kod jest przykładem użycia metody setter do zadeklarowania wartości item_name dla tej instancji klasy Item. Zauważ, że w dalszym ciągu użyj metody getter attr_reader, abyśmy mogli pobrać wartości i wydrukować je na ekranie, na wszelki wypadek, gdybyś chciał przetestować kod samodzielnie.

class Item

attr_reader :item_name

  def item_name=(str)
    @item_name = (str)
  end

end

Poniższy kod jest przykładem użycia attr_writer, aby ponownie skrócić nasz kod i zaoszczędzić nam czasu.

class Item

attr_reader :item_name
attr_writer :item_name

end

item = Item.new
puts item.item_name = "TV"

Poniższy kod jest powtórzeniem powyższego przykładu initialize, gdzie używamy initialize, aby ustawić wartość obiektów item_name podczas tworzenia.

class Item

attr_reader :item_name

  def initialize(item_name)
    @item_name = item_name
  end

end

item = Item.new("TV")
puts item.item_name

Attr_accessor: wykonuje funkcje obu attr_reader i attr_writer, zapisując Ci jeszcze jedną linię kodu.

Myślę, że część tego, co myli nowych Rubyistów / programistów (jak ja), to:

"Dlaczego nie mogę po prostu powiedzieć instancji, która ma dany atrybut (np. nazwa) i nadać temu atrybutowi wartość za jednym zamachem?"

Trochę bardziej uogólnione, ale tak mi się urwało:

Podane:

class Person
end

Nie zdefiniowaliśmy osobyjako czegoś, co może mieć nazwę lub jakiekolwiek inne atrybuty w tym zakresie.

Więc jeśli wtedy:

baby = Person.new

...i spróbuj podaj im nazwisko...

baby.name = "Ruth"

Otrzymujemy błąd ponieważ w Rubyland Klasa obiektu osoby nie jest czymś, co jest związane lub zdolne do posiadania "nazwy"... jeszcze!

Ale możemy użyć dowolnej z podanych metod (Zobacz poprzednie odpowiedzi) jako sposób na powiedzenie: "instancja klasy Person (baby) możemy teraz mieć atrybut o nazwie 'name' , dlatego nie tylko mamy składniowy sposób uzyskiwania i ustawiania tej nazwy, ale ma to dla nas sens więc."

Ponownie, uderzając w to pytanie z nieco innej i bardziej ogólnej perspektywy, ale mam nadzieję, że pomoże to następnej instancji klasy, która znajdzie drogę do tego wątku.

Jeśli znasz pojęcie OOP, musisz znać metodę getter i setter. attr_accessor robi to samo w Rubim.

Getter i Setter w sposób ogólny

class Person
  def name
    @name
  end

  def name=(str)
    @name = str
  end
end

person = Person.new
person.name = 'Eshaan'
person.name # => "Eshaan"

Metoda Settera

def name=(val)
  @name = val
end

Metoda Getter

def name
  @name
end

Metoda Getter i Setter w Ruby

class Person
  attr_accessor :name
end

person = Person.new
person.name = "Eshaan"
person.name # => "Eshaan"

Większość powyższych odpowiedzi używa kodu. To Wyjaśnienie próbuje na nie odpowiedzieć bez użycia żadnego kodu:

Wyjaśnienie przez analogię

Strony zewnętrzne nie mogą uzyskać dostępu do wewnętrznych tajemnic CIA

• Wyobraźmy sobie naprawdę tajne miejsce: CIA. Nikt nie wie, co się dzieje w CIA, poza ludźmi wewnątrz CIA. Innymi słowy, ludzie zewnętrzni nie mogą uzyskać dostępu do żadnych informacji w CIA. Ale ponieważ nie jest dobrze mieć organizację, która jest całkowicie tajne, pewne informacje są udostępniane światu zewnętrznemu - tylko rzeczy, o których CIA chce, aby wszyscy wiedzieli, oczywiście: np. dyrektor CIA, jak przyjazny dla środowiska ten dział jest porównywany do wszystkich innych departamentów rządowych itp. Inne informacje: np. kim są jego tajni agenci w Iraku lub Afganistanie - tego typu rzeczy prawdopodobnie pozostaną tajemnicą przez następne 150 lat.

• Jeśli jesteś poza CIA masz dostęp tylko informacje, które udostępnił publicznie. Lub użyć języka CIA można uzyskać dostęp tylko do informacji, które są "wyczyszczone".

• Informacje, które CIA chce udostępnić opinii publicznej poza CIA są nazywane: atrybuty.

Znaczenie atrybutów odczytu i zapisu:

• W przypadku CIA większość atrybutów to "tylko do odczytu". Oznacza to, że jeśli jesteś stroną zewnętrzną do CIA, możesz zapytać: "kto jest dyrektorem CIA?"i otrzymasz prostą odpowiedź. Ale to, czego nie możesz zrobić z atrybutami "tylko do odczytu", to wprowadzić zmiany w CIA. na przykład nie możesz zadzwonić i nagle zdecydować , że chcesz, aby Kim Kardashian był dyrektorem, lub że chcesz, aby Paris Hilton był głównodowodzącym.

• Jeśli atrybuty dały ci dostęp do "zapisu", to możesz wprowadzać zmiany, jeśli chcesz, nawet jeśli Na Zewnątrz. W przeciwnym razie możesz tylko czytać.

  Innymi słowy accessory pozwalają na zadawanie pytań lub wprowadzanie zmian w organizacjach, które w przeciwnym razie nie wpuszczają osób zewnętrznych, w zależności od tego, czy accessory są accessorami do odczytu czy zapisu.

Obiekty wewnątrz klasy mogą łatwo uzyskać dostęp do siebie

Z drugiej strony, gdybyś był już w CIA, mógłbyś zadzwonić do swojego agenta CIA w Kabulu. i spytaj go, czy chce po pracy napić się piwa z lokalnym informatorem z Kabulu. Ale jeśli jesteś poza CIA, po prostu nie otrzymasz dostępu: nie będziesz w stanie wiedzieć, kim są (dostęp do odczytu) i nie będziesz w stanie zmienić ich misji (dostęp do zapisu).

Dokładnie to samo z klasami i możliwością dostępu do zmiennych, właściwości i metod wewnątrz nich. HTH! Wszelkie pytania, proszę pytać i mam nadzieję, że mogę wyjaśnić.

Po prostu zdefiniuje setter i getter dla klasy.

Zauważ, że

attr_reader :v is equivalant to 
def v
  @v
end

attr_writer :v is equivalant to
def v=(value)
  @v=value
end

Więc

attr_accessor :v which means 
attr_reader :v; attr_writer :v 

Są równoważne do zdefiniowania settera i gettera dla klasy.

Po prostu attr-accessor tworzy metody getter i setter dla określonych atrybutów

Innym sposobem, aby to zrozumieć, jest ustalenie, jaki kod błędu eliminuje poprzez attr_accessor.

Przykład:

class BankAccount    
  def initialize( account_owner )
    @owner = account_owner
    @balance = 0
  end

  def deposit( amount )
    @balance = @balance + amount
  end

  def withdraw( amount )
    @balance = @balance - amount
  end
end

Dostępne są następujące metody:

$ bankie = BankAccout.new("Iggy")
$ bankie 
$ bankie.deposit(100)
$ bankie.withdraw(5)

Następujące metody powodują błąd:

$ bankie.owner     #undefined method `owner'... 
$ bankie.balance   #undefined method `balance'...

owner i balance nie są, technicznie, metodą, ale atrybutem. Klasa BankAccount nie posiada def owner i def balance. Jeśli tak, możesz użyć dwóch poniższych poleceń. Ale tych dwóch metod nie ma. Jednak można access atrybuty tak, jakbyś miał dostęp do metody poprzez attr_accessor!! stąd słowo attr_accessor. Atrybut. / Align = "left" / Uzyskuje dostęp do atrybutów tak, jak można uzyskać dostęp do metody.

Dodanie attr_accessor :balance, :owner pozwala na odczyt i zapis balance oraz owner "metoda". Teraz możesz użyć ostatnich 2 metod.

$ bankie.balance
$ bankie.owner

Definiuje nazwany atrybut dla tego modułu, gdzie nazwa to symbol. id2name, tworząc zmienną instancji (@name) I odpowiadającą jej metodę dostępu do jej odczytu. Tworzy również metodę nazwaną name=, aby ustawić atrybut.

module Mod
  attr_accessor(:one, :two)
end
Mod.instance_methods.sort   #=> [:one, :one=, :two, :two=]

Podsumowując atrybut accessor aka attr_accessor daje dwie darmowe metody.

Tak jak w Javie nazywają się getters i setters.

Wiele odpowiedzi pokazało dobre przykłady, więc powiem krótko.

#the_attribute

I

#the_attribute=

W starym Ruby docs tag hash # oznacza metodę. Może również zawierać przedrostek nazwy klasy... MyClass # my_method

Atrybuty i metody dostępu

Atrybuty są składnikami klas, do których dostęp można uzyskać spoza obiektu. Są one znane jako właściwości w wielu innych językach programowania. Ich wartości są dostępne za pomocą "notacji kropkowej", jak w object_name.attribute_name. W przeciwieństwie do Pythona i kilku innych języków, Ruby nie pozwala na dostęp do zmiennych instancji bezpośrednio spoza obiektu.

class Car
  def initialize
    @wheels = 4  # This is an instance variable
  end
end

c = Car.new
c.wheels     # Output: NoMethodError: undefined method `wheels' for #<Car:0x00000000d43500>

W powyższym przykładzie c jest instancją (obiektem) klasy samochodów. Bezskutecznie próbowaliśmy odczytać wartość zmiennej instancji wheels spoza obiektu. Stało się tak, że Ruby próbował wywołać metodę o nazwie wheels wewnątrz obiektu c, ale żadna taka metoda nie została zdefiniowana. Krótko mówiąc, object_name.attribute_name próbuje wywołać metodę o nazwie attribute_name wewnątrz obiektu. Aby uzyskać dostęp do wartości zmiennej wheels z zewnątrz, musimy zaimplementować metodę instancji o tej nazwie, która zwróci wartość tej zmiennej po wywołaniu. To nazywana metodą accessor. W ogólnym kontekście programowania, typowym sposobem dostępu do zmiennej instancji spoza obiektu jest implementacja metod accessora, znanych również jako metody getter i setter. Getter pozwala na odczyt wartości zmiennej zdefiniowanej w klasie z zewnątrz, a setter pozwala na zapisanie jej z zewnątrz.

W poniższym przykładzie dodaliśmy metody getter i setter do klasy samochodu, aby uzyskać dostęp do zmiennych kół z zewnątrz obiekt. Nie jest to "Ruby sposób" definiowania getterów i setterów; służy tylko do zilustrowania tego, co robią metody getter i setter.

class Car
  def wheels  # getter method
    @wheels
  end

  def wheels=(val)  # setter method
    @wheels = val
  end
end

f = Car.new
f.wheels = 4  # The setter method was invoked
f.wheels  # The getter method was invoked
# Output: => 4

Powyższy przykład działa i podobny kod jest powszechnie używany do tworzenia metod getter i setter w innych językach. Jednak Ruby zapewnia prostszy sposób: trzy wbudowane metody o nazwie attr_reader, attr_writer i attr_acessor. Metoda attr_reader sprawia, że zmienna instancji jest czytelna z zewnątrz, attr_writer sprawia, że można ją zapisać, a attr_acessor czyni go czytelnym i możliwym do zapisu.

Powyższy przykład można przepisać w ten sposób.

class Car
  attr_accessor :wheels
end

f = Car.new
f.wheels = 4
f.wheels  # Output: => 4

W powyższym przykładzie atrybut wheels będzie czytelny i możliwy do zapisania spoza obiektu. Jeśli zamiast attr_accessor użyjemy attr_reader, będzie to tylko do odczytu. Jeśli użyjemy attr_writer, będzie to tylko do zapisu. Te trzy metody nie są same w sobie getterami i setterami, ale kiedy są wywoływane, tworzą dla nas metody getter i setter. Są to metody, które dynamicznie (programowo) generować inne metody; to się nazywa metaprogramowanie.

Pierwszy (dłuższy) przykład, który nie wykorzystuje wbudowanych metod Ruby, powinien być używany tylko wtedy, gdy wymagany jest dodatkowy kod w metodach getter i setter. Na przykład metoda setter może wymagać walidacji danych lub wykonania obliczeń przed przypisaniem wartości do zmiennej instancji.

Możliwy jest dostęp (odczyt i zapis) zmiennych instancji spoza obiektu, za pomocą wbudowane metody instance_variable_get i instance_variable_set. Jest to jednak rzadko uzasadnione i zazwyczaj jest to zły pomysł, ponieważ ominięcie hermetyzacji ma tendencję do siania wszelkiego rodzaju spustoszeń.

Hmmm. Wiele dobrych odpowiedzi. Oto moje kilka centów.

• attr_accessor jest prostą metodą, która pomaga nam w czyszczeniu (na sucho ) w górę powtarzanie getter and setter metody.

• Abyśmy mogli skupić się bardziej na pisaniu logiki biznesowej i nie martwić się o setterów i getterów.

Główną funkcjonalnością attr_accessor nad innymi jest możliwość dostępu do danych z innych plików.
Więc zwykle masz attr_reader lub attr_writer, ale dobrą wiadomością jest to, że Ruby pozwala Ci połączyć te dwie rzeczy razem z attr_accessor. Myślę o tym jak moja metoda to go ponieważ jest bardziej zaokrąglony lub wszechstronny. Pamiętaj też, że w Rails jest to eliminowane, ponieważ robi to za Ciebie z tyłu. Innymi słowy: jesteś lepiej używać attr_acessor nad pozostałymi dwoma, ponieważ nie musisz się martwić o to, że jesteś konkretny, accessor Pokrywa to wszystko. Wiem, że jest to bardziej ogólne wyjaśnienie, ale pomogło mi jako początkującemu.

Mam nadzieję, że to pomogło!