Getter ve Setter?

Ben bir PHP geliştiricisi değilim, bu yüzden PHP'de özel alanlarla (sevdiğim şekilde) saf bir OOP tarzında, açık alıcı / ayarlayıcıları kullanmak için daha popüler olup olmadığını merak ediyorum:

class MyClass {
    private $firstField;
    private $secondField;

    public function getFirstField() {
        return $this->firstField;
    }
    public function setFirstField($x) {
        $this->firstField = $x;
    }
    public function getSecondField() {
        return $this->secondField;
    }
    public function setSecondField($x) {
        $this->secondField = $x;
    }
}

veya yalnızca genel alanlar:

class MyClass {
    public $firstField;
    public $secondField;
}

Teşekkürler

Php magic yöntemlerini __get ve kullanabilirsiniz __set.

<?php
class MyClass {
  private $firstField;
  private $secondField;

  public function __get($property) {
    if (property_exists($this, $property)) {
      return $this->$property;
    }
  }

  public function __set($property, $value) {
    if (property_exists($this, $property)) {
      $this->$property = $value;
    }

    return $this;
  }
}
?>

Alıcıları ve ayarlayıcıları neden kullanmalıyım?

1. Ölçeklenebilirlik : Bir alıcıyı bir proje kodundaki tüm ödevleri aramaktan daha kolay yeniden düzenleyen.
2. Hata ayıklama : Ayarlayıcılara ve alıcılara kesme noktaları koyabilirsiniz.
3. Daha temiz : Sihirli işlevler daha az yazı yazmak için iyi bir çözüm değildir, IDE'niz kodu önermez. Hızlı yazan alıcılar için daha iyi şablonlar kullanın.

Google zaten PHP optimizasyonu hakkında bir kılavuz yayınladı ve sonuç şuydu:

Alıcı ve ayarlayıcı yok PHP optimizasyonu

Ve hayır, sihirli yöntemler kullanmamalısınız . PHP için, Magic Method kötüdür. Neden?

1. Hata ayıklamak zordur.
2. Performans üzerinde olumsuz bir etkisi vardır.
3. Daha fazla kod yazmayı gerektirirler.

PHP Java, C ++ veya C # değildir. PHP farklıdır ve farklı rollerle oynar.

Kapsülleme herhangi bir OO dilinde önemlidir, popülerliğin bununla hiçbir ilgisi yoktur. PHP gibi dinamik olarak yazılan dillerde özellikle yararlıdır, çünkü bir özelliğin ayarlayıcıları kullanmadan belirli bir türde olmasını sağlamanın çok az yolu vardır.

PHP'de bu çalışır:

class Foo {
   public $bar; // should be an integer
}
$foo = new Foo;
$foo->bar = "string";

Java'da şunları yapmaz:

class Foo {
   public int bar;
}
Foo myFoo = new Foo();
myFoo.bar = "string"; // error

Sihirli yöntemleri ( __getve __set) kullanmak da çalışır, ancak yalnızca geçerli kapsamın erişebileceğinden daha düşük görünürlüğe sahip bir özelliğe erişirken. Düzgün kullanılmazsa, hata ayıklamaya çalışırken kolayca baş ağrısı verebilir.

__Call işlevini kullanmayı tercih ediyorsanız, bu yöntemi kullanabilirsiniz. İle çalışır

• GET => $this->property()
• SET => $this->property($value)
• GET => $this->getProperty()
• SET => $this->setProperty($value)

kalsdas

public function __call($name, $arguments) {

    //Getting and setting with $this->property($optional);

    if (property_exists(get_class($this), $name)) {


        //Always set the value if a parameter is passed
        if (count($arguments) == 1) {
            /* set */
            $this->$name = $arguments[0];
        } else if (count($arguments) > 1) {
            throw new \Exception("Setter for $name only accepts one parameter.");
        }

        //Always return the value (Even on the set)
        return $this->$name;
    }

    //If it doesn't chech if its a normal old type setter ot getter
    //Getting and setting with $this->getProperty($optional);
    //Getting and setting with $this->setProperty($optional);
    $prefix = substr($name, 0, 3);
    $property = strtolower($name[3]) . substr($name, 4);
    switch ($prefix) {
        case 'get':
            return $this->$property;
            break;
        case 'set':
            //Always set the value if a parameter is passed
            if (count($arguments) != 1) {
                throw new \Exception("Setter for $name requires exactly one parameter.");
            }
            $this->$property = $arguments[0];
            //Always return the value (Even on the set)
            return $this->$name;
        default:
            throw new \Exception("Property $name doesn't exist.");
            break;
    }
}

Burada zaten büyük ve saygın cevaplara ek olarak, ben hiçbir setters / alıcılar PHP genişletmek istiyorum.

PHP'nin alıcı ve ayarlayıcı sözdizimi yoktur . Dave tarafından belirtildiği gibi, özellik arama sürecini "kancalamak" ve geçersiz kılmak içinalt sınıf veya sihirli yöntemler sağlar.

Magic , tembel programcıların , bir projeye aktif olarak dahil olduğumuz ve onu yakından bildiğimiz bir zamanda daha az kodla daha fazlasını yapmamıza izin verir , ancak genellikle okunabilirlik pahasına.

Performans PHP'de alıcı / ayarlayıcı benzeri bir kod mimarisini zorlamaktan kaynaklanan her gereksiz işlev, çağrıldığında kendi bellek yığını çerçevesini içerir ve CPU döngülerini boşa harcar.

Okunabilirlik: Kod tabanı, daha fazla LOC daha fazla kaydırma anlamına geldiği için kod gezintisini etkileyen şişkin kod satırlarına neden olur.

Tercih: Şahsen, temel kuralım olarak, uzun vadeli faydalar o zamanlar elimde olduğu sürece büyülü yolda gitmekten kaçınmak için statik kod analizinin başarısızlığını bir işaret olarak alıyorum.

Yanılgı:

Ortak bir argüman okunabilirliktir. Örneğin $someobject->widthokumak daha kolay $someobject->width(). Bir gezegen Ancak farklı circumferenceya da widthkabul edilebilir olmak staticgibi bir nesnenin, örneğin $someobjectbir genişlik işlevi gerektiren, muhtemelen nesnenin örnek genişliğinin ölçümü yapılır.
Bu nedenle, okunabilirlik, belirli bir özellik değeri veren işlevi gizleyerek değil, temel olarak iddialı adlandırma şemaları nedeniyle artar.

__get / __set kullanır:

• mülkiyet değerlerinin ön validasyonu ve ön sanitasyonu

• dizeler ör.

  "
  some {mathsobj1->generatelatex} multi
  line text {mathsobj1->latexoutput}
  with lots of variables for {mathsobj1->generatelatex}
   some reason
  "

  Bu durumda generatelatex, actionname + methodname adlandırma düzenine bağlı kalırsınız

• özel, belirgin durumlar

  $dnastringobj->homeobox($one_rememberable_parameter)->gattaca->findrelated()
  $dnastringobj->homeobox($one_rememberable_parameter)->gttccaatttga->findrelated()

Not: PHP getter / setter sözdizimini uygulamamayı tercih etti. Getters / setter genellikle kötü olduğunu iddia etmiyorum.

class MyClass {
    private $firstField;
    private $secondField;
    private $thirdField;

    public function __get( $name ) {
        if( method_exists( $this , $method = ( 'get' . ucfirst( $name  ) ) ) )
            return $this->$method();
        else
            throw new Exception( 'Can\'t get property ' . $name );
    }

    public function __set( $name , $value ) {
        if( method_exists( $this , $method = ( 'set' . ucfirst( $name  ) ) ) )
            return $this->$method( $value );
        else
            throw new Exception( 'Can\'t set property ' . $name );
    }

    public function __isset( $name )
    {
        return method_exists( $this , 'get' . ucfirst( $name  ) ) 
            || method_exists( $this , 'set' . ucfirst( $name  ) );
    }

    public function getFirstField() {
        return $this->firstField;
    }

    protected function setFirstField($x) {
        $this->firstField = $x;
    }

    private function getSecondField() {
        return $this->secondField;
    }
}

$obj = new MyClass();

echo $obj->firstField; // works
$obj->firstField = 'value'; // works

echo $obj->getFirstField(); // works
$obj->setFirstField( 'value' ); // not works, method is protected

echo $obj->secondField; // works
echo $obj->getSecondField(); // not works, method is private

$obj->secondField = 'value'; // not works, setter not exists

echo $obj->thirdField; // not works, property not exists

isset( $obj->firstField ); // returns true
isset( $obj->secondField ); // returns true
isset( $obj->thirdField ); // returns false

Hazır!

Eh, PHP sihirli yöntemler var __get, __set, __issetve __unsether zaman bir başlangıç olan. Ne yazık ki uygun (olsun?) OO özellikleri sihirli yöntemlerden daha fazlasıdır. PHP'nin uygulanmasındaki temel sorun, erişilemeyen tüm özellikler için sihirli yöntemlerin çağrılmasıdır . Bu, adın gerçekten nesnenizin bir özelliği olup olmadığını belirlerken sihirli yöntemlerde Kendinizi Tekrarlamanız (örneğin, property_exists () yöntemini çağırarak) anlamına gelir . Ve tüm sınıflarınız ie miras almadıkça, bu genel problemi bir temel sınıfla gerçekten çözemezsiniz. ClassWithProperties, çünkü PHP birden fazla kalıtımdan yoksundur.

Buna karşılık, Python yeni stil sınıfları size verir property(), bu da tüm özelliklerinizi açıkça tanımlamanızı sağlar. C # özel sözdizimine sahiptir.

http://en.wikipedia.org/wiki/Property_(programming)

__Call sihirli yöntemini kullanarak bir deneme yaptım. Eğer diğer cevaplar ve yorumlar "tüm" BÜYÜ YÖNTEMLERİ KULLANMAYIN "uyarıları nedeniyle ben sonrası gerekir emin değilim ama ben burada bırakacaktır .. sadece biri yararlı bulursanız.

public function __call($_name, $_arguments){
    $action  = substr($_name, 0, 4);
    $varName = substr($_name, 4);

    if (isset($this->{$varName})){
        if ($action === "get_") return $this->{$varName};
        if ($action === "set_") $this->{$varName} = $_arguments[0];
    }
}

Sadece bu yöntemi sınıfınıza ekleyin, şimdi şunları yazabilirsiniz:

class MyClass{
    private foo = "bar";
    private bom = "bim";
    // ...
    // public function __call(){ ... }
    // ...
}
$C = new MyClass();

// as getter
$C->get_foo(); // return "bar"
$C->get_bom(); // return "bim"

// as setter
$C->set_foo("abc"); // set "abc" as new value of foo
$C->set_bom("zam"); // set "zam" as new value of bom

Bu şekilde sınıfınızdaki herşeyi varsa alabilir / ayarlayabilirsiniz, böylece yalnızca birkaç belirli öğeye ihtiyacınız varsa, filtre olarak bir "beyaz liste" kullanabilirsiniz.

Misal:

private $callWhiteList = array(
    "foo" => "foo",
    "fee" => "fee",
    // ...
);

public function __call($_name, $_arguments){
    $action  = substr($_name, 0, 4);
    $varName = $this->callWhiteList[substr($_name, 4)];

    if (!is_null($varName) && isset($this->{$varName})){
        if ($action === "get_") return $this->{$varName};
        if ($action === "set_") $this->{$varName} = $_arguments[0];
    }
}

Şimdi sadece "foo" ve "ücret" alabilirsiniz / ayarlayabilirsiniz.
Bu "beyaz listeyi", değişkenlerinize erişmek üzere özel adlar atamak için de kullanabilirsiniz.
Örneğin,

private $callWhiteList = array(
    "myfoo" => "foo",
    "zim" => "bom",
    // ...
);

Bu listeye şimdi şunları yazabilirsiniz:

class MyClass{
    private foo = "bar";
    private bom = "bim";
    // ...
    // private $callWhiteList = array( ... )
    // public function __call(){ ... }
    // ...
}
$C = new MyClass();

// as getter
$C->get_myfoo(); // return "bar"
$C->get_zim(); // return "bim"

// as setter
$C->set_myfoo("abc"); // set "abc" as new value of foo
$C->set_zim("zam"); // set "zam" as new value of bom

.
.
.
Bu kadar.

Doc: __call () , bir nesne bağlamında erişilemez yöntemler çağrıldığında tetiklenir.

Diğer tavsiyeleri okuduktan sonra şunu söylemeye meyilliyim:

Bir itibariyle GENERIC kural, her zaman için ayarlayıcılar tanımlamak olmaz TÜM (... semaforları, iç bayrakları) özelliklerine, özel olarak "iç" olanları. Salt okunur özelliklerin ayarlayıcıları olmayacağı açıktır, bu nedenle bazı özelliklerin yalnızca alıcıları olacaktır; __get () kodu küçültmek için buraya gelir:

• benzer tüm bu özellikler için bir __get () (büyülü küresel alıcılar) tanımlayın,
• bunları dizilerde gruplayın:
  • ortak özellikleri paylaşacaklardır: parasal değerler düzgün biçimlendirilmiş / belirli bir düzende (ISO, ABD, Uluslararası) vb.
  • kodun kendisi bu büyülü yöntemi kullanarak sadece mevcut ve izin verilen özelliklerin okunduğunu doğrulayabilir.
  • yeni bir benzer özellik oluşturmanız gerektiğinde, bunu bildirmeniz ve adını doğru diziye eklemeniz yeterlidir. Bu , belki de bazı kod satırları tekrar tekrar sınıf kodu üzerinde REPEATED ile yeni bir alıcı tanımlamaktan daha hızlı .

Evet! Bunu yapmak için özel bir yöntem de yazabiliriz, ancak yine de, her zaman aynı yöntemi çağıran başka bir yöntem (++ bellek) bildirmiş oluruz. Neden hepsini yönetmek için TEK bir yöntem yazmıyorsunuz ? [Evet! pun kesinlikle amaçlanan! :)]

Sihirli ayarlayıcılar SADECE belirli özelliklere de yanıt verebilir, böylece tüm tarih türü özellikleri yalnızca bir yöntemde geçersiz değerlere karşı taranabilir. Tarih türü özellikleri bir dizide listelenmişse, ayarlayıcıları kolayca tanımlanabilir. Tabii ki sadece bir örnek. çok fazla durum var.

Hakkında okunabilirliği ... Eh ... Bu başka bir tartışma var: Ben (aslında bir IDE kullanımlara bağlı kalmayı sevmem, onları kullanmayın, bunlar (ve söyle eğilimindedir zorlamak nasıl beni) yazmak ... ve ben "güzellik" kodlama hakkında benim sevdim var). Adlandırma konusunda tutarlı olma eğilimindeyim, bu yüzden ctags ve birkaç başka yardım kullanmak benim için yeterli ... Her neyse: tüm bu sihirli ayarlayıcılar ve alıcılar yapıldıktan sonra, çok özel veya "özel" olan diğer ayarlayıcıları __set () yöntemiyle genelleştirilmelidir. Bu özellik almak ve özellikleri ayarlamak için ihtiyacım olan her şeyi kapsar. Tabii ki: her zaman ortak bir zemin yoktur veya büyülü bir yöntemi kodlama zahmetine değmeyecek kadar az özellik vardır ve sonra hala eski iyi geleneksel ayarlayıcı / alıcı çifti vardır.

Programlama dilleri sadece: insan yapay dilleri. Yani, her birinin kendi tonlaması veya aksanı, sözdizimi ve lezzeti var, bu yüzden Java veya C # ile aynı "aksanını" kullanarak bir Ruby veya Python kodu yazmak gibi davranmayacağım, ya da benzemek için bir JavaScript veya PHP yazmam Perl veya SQL ... Onları kullanılması gerektiği gibi kullanın.

Genel olarak konuşursak, ilk yol genel olarak daha popülerdir, çünkü önceden programlama bilgisine sahip olanlar kolayca PHP'ye geçiş yapabilir ve nesneye yönelik bir şekilde iş yapabilirler. İlk yol daha evrensel. Benim tavsiyem birçok dilde denenmiş ve doğru olana sadık kalmak olacaktır. Daha sonra, başka bir dil ne zaman ve kullanırsanız, bir şeyleri başarmaya hazır olacaksınız ( tekerleği yeniden keşfetmek için zaman harcamak yerine ).

Bir netbeans sözleşmesinde kaynak kodu oluşturmanın birçok yolu vardır. Bu güzel. Düşünceleri bu kadar kolaylaştırır === YANLIŞ. Sadece gelenekleri kullanın, özellikle hangi özelliklerden hangisinin kapsülleneceğinden ve hangisinin kapsüllenmediğinden emin değilseniz. Biliyorum, bu bir boi .... pla ... kodu, ama hata ayıklama işleri ve diğer birçok şey için daha iyi, net bir yol olduğunu düşünüyor. Sanatın basit alıcıları ve ayarlayıcıları yapmak için çok fazla zaman harcamayın. Eğer sihir kullanırsanız, demeter kuralı gibi bazı tasarım desenlerini çok fazla uygulayamazsınız. Belirli durumlarda magic_calls veya küçük, hızlı ve net çözümler için kullanabilirsiniz. Elbette tasarım desenleri için de bu şekilde çözümler üretebilirsiniz, ancak neden sizi daha zor yaşamanız gerekir.

Değerleri Doğrulama + Biçimlendirme / Türetme

Ayarlayıcılar verileri doğrulamanıza ve alıcılar verileri biçimlendirmenize veya türetmenize olanak tanır. Nesneler, verileri ve doğrulama ve biçimlendirme kodunu DRY'yi teşvik eden düzgün bir pakete kapsüllemenizi sağlar.

Örneğin, doğum tarihi içeren aşağıdaki basit sınıfı düşünün.

class BirthDate {

    private $birth_date;

    public function getBirthDate($format='Y-m-d') {
        //format $birth_date ...
        //$birth_date = ...
        return $birth_date;
    }

    public function setBirthDate($birth_date) {                   
        //if($birth_date is not valid) throw an exception ...          
        $this->birth_date = $birth_date;
    }

    public function getAge() {
        //calculate age ...
        return $age;
    }

    public function getDaysUntilBirthday() {
        //calculate days until birth days
        return $days;
    }
}

Ayarlanan değerin geçerli olduğunu doğrulamak isteyeceksiniz

• Geçerli bir tarih
• Gelecekte değil

Ve bu doğrulamayı uygulamanızın her yerinde (veya bu konu için birden fazla uygulamada) yapmak istemezsiniz. Bunun yerine, üye değişkenini korumalı veya özel yapmak (ayarlayıcıyı tek erişim noktası yapmak için) ve ayarlayıcıda doğrulamak daha kolaydır, çünkü o zaman nesnenin, uygulama nesneden geldi ve daha fazla doğrulama eklemek istiyorsanız, o zaman tek bir yerde ekleyebilirsiniz.

Aynı üye değişken üzerinde çalışan birden çok biçimlendirici eklemek isteyebilirsiniz, ör. getAge() ve getDaysUntilBirthday()ve içinde yapılandırılabilir bir biçim zorlamak isteyebilirsiniz getBirthDate()yerel ayara bağlı. Karıştırma aksine nedenle ben sürekli alıcılar üzerinden değerleri erişen tercih $date->getAge()ile $date->birth_date.

alıcılar ve ayarlayıcılar nesneleri genişlettiğinizde de yararlıdır. Örneğin, uygulamanızın bazı yerlerde 150'den fazla doğum tarihine izin vermek için gerekli olduğunu, ancak diğerlerinde olmadığını düşünün. Herhangi bir kodu tekrarlamadan sorunu çözmenin bir yolu, BirthDatenesneyi genişletmek ve ayarlayıcıya ek doğrulama koymak olacaktır.

class LivingBirthDate extends BirthDate {

    public function setBirthDate($birth_date) {
        //if $birth_date is greater than 150 years throw an exception
        //else pass to parent's setter
        return parent::setBirthDate($birth_date);
    }
}

Bu yazı özellikle ilgili değildir __getve __setdaha çok __callyöntem çağrısı dışında aynı fikirdir. Kural olarak, yorumlarda ve yazılarda belirtilen nedenlerle aşırı yüklemeye izin veren her türlü sihirli yöntemden uzak duruyorum , ancak son zamanlarda kullandığım bir SERVICE ve SUB-SERVICE kullanan bir üçüncü taraf API'sına girdim, örnek :

http://3rdparty.api.com?service=APIService.doActionOne&apikey=12341234

Bunun önemli kısmı, bu API'nın bu durumda alt eylem hariç her şeye sahip olmasıdır doActionOne. Fikir geliştirici (ben ve bu sınıfı kullanan diğerleri) gibi bir şey yerine alt hizmet adıyla çağırabilir:

$myClass->doAction(array('service'=>'doActionOne','args'=>$args));

Bunun yerine yapabilirim:

 $myClass->doActionOne($args);

Sabit kodlamak için bu çok fazla çoğaltma olacaktır (bu örnek koda çok gevşek bir şekilde benzemektedir):

public function doActionOne($array)
    {
        $this->args     =   $array;
        $name           =   __FUNCTION__;
        $this->response =   $this->executeCoreCall("APIService.{$name}");
    }

public function doActionTwo($array)
    {
        $this->args     =   $array;
        $name           =   __FUNCTION__;
        $this->response =   $this->executeCoreCall("APIService.{$name}");
    }

public function doActionThree($array)
    {
        $this->args     =   $array;
        $name           =   __FUNCTION__;
        $this->response =   $this->executeCoreCall("APIService.{$name}");
    }

protected function executeCoreCall($service)
    {
        $cURL = new \cURL();
        return $cURL->('http://3rdparty.api.com?service='.$service.'&apikey='.$this->api.'&'.http_build_query($this->args))
                    ->getResponse();
    }

Ancak sihirli yöntemiyle __call()tüm hizmetlere dinamik yöntemlerle erişebiliyorum:

public function __call($name, $arguments)
    {
        $this->args     =   $arguments;
        $this->response =   $this->executeCoreCall("APIService.{$name}");   
        return $this;
    }

Veri dönüşü için bu dinamik çağrının yararı, satıcı başka bir alt hizmet eklerse, sınıfa başka bir yöntem eklemek veya genişletilmiş bir sınıf, vb. Oluşturmak zorunda olmadığımdır. herkes, ama ben bir örnek göstermek düşündüm __set, __get, __callbirincil işlevi verilerinin dönüş olduğundan, vb değerlendirilmesi için bir seçenek olabilir.

DÜZENLE:

Tesadüfen, bunu yayınladıktan birkaç gün sonra gördüğüm senaryo tam olarak senaryomu özetliyor. Bahsettiğim API değil ama yöntemlerin uygulaması aynı:

API'yi doğru kullanıyor muyum?

Güncelleme: Bu cevabı kullanmayın, çünkü bu öğrenirken bulduğum çok aptal bir kod. Sadece düz alıcı ve ayarlayıcı kullanın, çok daha iyi.

Genellikle bu değişken adını işlev adı olarak kullanırım ve isteğe bağlı parametre bu işleve, bu isteğe bağlı parametre arayan tarafından dolduğunda eklenir, sonra özelliğe ayarlayın ve $ bu nesneyi (zincirleme) döndürün ve sonra bu isteğe bağlı parametre tarafından belirtilmediğinde arayan, ben sadece özelliği arayan dönmek.

Örneğim:

class Model
{
     private $propOne;
     private $propTwo;

     public function propOne($propVal = '')
     {
          if ($propVal === '') {
              return $this->propOne;
          } else {
              $this->propOne = $propVal;
              return $this;
          }
     }

     public function propTwo($propVal = '')
     {
          if ($propVal === '') {
              return $this->propTwo;
          } else {
              $this->propTwo = $propVal;
              return $this;
          }
     }
}