Najlepsza praktyka: PHP magiczne metody set and get [duplicate]

Musisz używać magii tylko wtedy, gdy obiekt jest rzeczywiście "magiczny". Jeśli masz klasyczny obiekt o stałych właściwościach, użyj setterów i getterów, działają dobrze.

Jeśli twój obiekt ma właściwości dynamiczne na przykład jest częścią warstwy abstrakcji bazy danych, a jego parametry są ustawiane w czasie wykonywania, to rzeczywiście potrzebujesz magicznych metod dla wygody.

Używam __get (i public properties) w miarę możliwości, ponieważ sprawiają, że kod jest o wiele bardziej czytelny. Porównaj:

Ten kod jednoznacznie mówi, co robię:

echo $user->name;

Ten kod sprawia, że czuję się głupio, czego nie lubię:

function getName() { return $this->_name; }
....

echo $user->getName();

Różnica między nimi jest szczególnie oczywista, gdy uzyskujesz dostęp do wielu właściwości jednocześnie.

echo "
    Dear $user->firstName $user->lastName!
    Your purchase:
        $product->name  $product->count x $product->price
"

I

echo "
    Dear " . $user->getFirstName() . " " . $user->getLastName() . "
    Your purchase: 
        " . $product->getName() . " " . $product->getCount() . "  x " . $product->getPrice() . " ";

Czy $a->b naprawdę powinno zrobić coś lub po prostu zwrócić wartość jest odpowiedzialność kallee. Dla wywołującego, $user->name i $user->accountBalance powinny wyglądać tak samo, chociaż te ostatnie mogą wiązać się ze skomplikowanymi obliczeniami. W moich klasach danych używam następującej małej metody:

 function __get($p) { 
      $m = "get_$p";
      if(method_exists($this, $m)) return $this->$m();
      user_error("undefined property $p");
 }

Gdy ktoś wywoła $obj->xxx i klasa ma zdefiniowaną get_xxx, ta metoda zostanie wywołana domyślnie. Możesz więc zdefiniować getter, jeśli tego potrzebujesz, zachowując jednolity i przejrzysty interfejs. Jako dodatkowy bonus zapewnia elegancki sposób zapamiętywania obliczenia:

  function get_accountBalance() {
      $result = <...complex stuff...>
      // since we cache the result in a public property, the getter will be called only once
      $this->accountBalance = $result;
  }

  ....


   echo $user->accountBalance; // calculate the value
   ....
   echo $user->accountBalance; // use the cached value

Podsumowując: php jest dynamicznym językiem skryptowym, używaj go w ten sposób, nie udawaj, że robisz Javę lub C#.

Robię mieszankę odpowiedzi edema i Twojego drugiego kodu. W ten sposób, mam korzyści z common getter / setters(uzupełnianie kodu w IDE), łatwość kodowania, jeśli chcę, wyjątki ze względu na nieistniejące właściwości (świetne do odkrywania literówek: $foo->naem zamiast $foo->name), właściwości tylko do odczytu i Właściwości złożone.

class Foo
{
    private $_bar;
    private $_baz;

    public function getBar()
    {
        return $this->_bar;
    }

    public function setBar($value)
    {
        $this->_bar = $value;
    }

    public function getBaz()
    {
        return $this->_baz;
    }

    public function getBarBaz()
    {
        return $this->_bar . ' ' . $this->_baz;
    }

    public function __get($var)
    {
        $func = 'get'.$var;
        if (method_exists($this, $func))
        {
            return $this->$func();
        } else {
            throw new InexistentPropertyException("Inexistent property: $var");
        }
    }

    public function __set($var, $value)
    {
        $func = 'set'.$var;
        if (method_exists($this, $func))
        {
            $this->$func($value);
        } else {
            if (method_exists($this, 'get'.$var))
            {
                throw new ReadOnlyException("property $var is read-only");
            } else {
                throw new InexistentPropertyException("Inexistent property: $var");
            }
        }
    }
}

Głosuję za trzecim rozwiązaniem. Używam tego w moich projektach i Symfony też używa czegoś takiego:

public function __call($val, $x) {
    if(substr($val, 0, 3) == 'get') {
        $varname = strtolower(substr($val, 3));
    }
    else {
        throw new Exception('Bad method.', 500);
    }
    if(property_exists('Yourclass', $varname)) {
        return $this->$varname;
    } else {
        throw new Exception('Property does not exist: '.$varname, 500);
    }
}

W ten sposób Masz automatyczne gettery (możesz też pisać settery) i musisz pisać nowe metody tylko wtedy, gdy istnieje specjalny przypadek dla zmiennej członkowskiej.

Powinieneś użyć stdClass jeśli chcesz mieć członków magic, jeśli napiszesz klasę-określ, co ona zawiera.

Najlepszą praktyką byłoby stosowanie tradycyjnych getterów i seterów, ze względu na introspekcję lub refleksję. W PHP (podobnie jak w Javie) istnieje sposób na uzyskanie nazwy metody lub wszystkich metod. Takie coś zwróci "_ _ get "w pierwszym przypadku i "getFirstField", "getSecondField" w drugim (Plus setery).

Więcej na ten temat: http://php.net/manual/en/book.reflection.php

Teraz wracam do setterów i getterów, ale umieszczam również getterów i seterów w magicznym methos _ _ get I _ _ set. W ten sposób mam domyślne zachowanie, gdy to robię

$class - > var;

To po prostu wywoła getter, który ustawiłem w _ _ get. Normalnie po prostu użyję gettera bezpośrednio, ale nadal istnieją przypadki, w których jest to po prostu prostsze.

Drugi przykład kodu jest o wiele bardziej odpowiedni, ponieważ przejmujesz pełną kontrolę nad danymi, które są przekazywane class. Są przypadki, w których __set i __get są przydatne, ale nie w tym przypadku.