Getter dan Setter?

Saya bukan pengembang PHP, jadi saya ingin tahu apakah di PHP lebih populer untuk menggunakan pengambil / penyetel eksplisit, dengan gaya OOP murni, dengan bidang pribadi (seperti yang saya suka):

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;
    }
}

atau hanya bidang publik:

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

Terima kasih

Anda dapat menggunakan metode sulap php __get dan __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;
  }
}
?>

Mengapa menggunakan getter dan setter?

1. Skalabilitas : Lebih mudah mereaksikan pengambil daripada mencari semua tugas var dalam kode proyek.
2. Debugging : Anda dapat menempatkan breakpoint di setter dan getter.
3. Pembersih : Fungsi sulap bukan solusi yang baik untuk menghasilkan lebih sedikit, IDE Anda tidak akan menyarankan kode. Lebih baik gunakan templat untuk pengambil yang rajutan cepat.

Google sudah menerbitkan panduan tentang optimasi PHP dan kesimpulannya adalah:

Tidak ada pengambil dan penyetel Mengoptimalkan PHP

Dan tidak, Anda tidak harus menggunakan metode sihir . Untuk PHP, Metode Sihir itu jahat. Mengapa?

1. Mereka sulit di-debug.
2. Ada dampak kinerja negatif.
3. Mereka membutuhkan penulisan lebih banyak kode.

PHP bukan Java, C ++, atau C #. PHP berbeda dan dimainkan dengan peran yang berbeda.

Enkapsulasi penting dalam bahasa OO apa pun, popularitas tidak ada hubungannya dengan itu. Dalam bahasa yang diketik secara dinamis, seperti PHP, ini sangat berguna karena ada sedikit cara untuk memastikan properti adalah tipe tertentu tanpa menggunakan setter.

Di PHP, ini berfungsi:

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

Di Jawa, itu tidak:

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

Menggunakan metode ajaib ( __getdan __set) juga berfungsi, tetapi hanya ketika mengakses properti yang memiliki visibilitas lebih rendah daripada ruang lingkup saat ini dapat mengakses. Ini dapat dengan mudah membuat Anda sakit kepala ketika mencoba untuk debug, jika tidak digunakan dengan benar.

Jika Anda lebih suka menggunakan fungsi __call, Anda dapat menggunakan metode ini. Ini bekerja dengan

• DAPATKAN>> $this->property()
• SET => $this->property($value)
• DAPATKAN>> $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;
    }
}

Selain jawaban yang sudah sangat bagus dan dihormati di sini, saya ingin mengembangkan PHP yang tidak memiliki setter / getter.

PHP tidak memiliki sintaks pengambil dan penyetel . Ini memberikanmetodesubclassed atau sihir untuk memungkinkan "hooking" dan mengesampingkan proses pencarian properti, seperti yang ditunjukkan oleh Dave .

Magic memungkinkan kita programmer yang malas untuk berbuat lebih banyak dengan lebih sedikit kode pada saat kita secara aktif terlibat dalam suatu proyek dan mengetahuinya secara intim, tetapi biasanya dengan mengorbankan keterbacaan.

Kinerja Setiap fungsi yang tidak perlu, yang dihasilkan dari pemaksaan arsitektur kode pengambil / penyetel-seperti dalam PHP, melibatkan memori tumpukan-bingkai sendiri atas permintaan dan membuang-buang siklus CPU.

Keterbacaan: Basis kode menimbulkan garis kode kembung, yang memengaruhi navigasi kode karena lebih banyak LOC berarti lebih banyak bergulir.

Preferensi: Secara pribadi, sebagai pedoman praktis saya, saya menganggap kegagalan analisis kode statis sebagai tanda untuk menghindari jalan magis selama manfaat jangka panjang yang jelas luput dari saya pada waktu itu.

Kekeliruan:

Argumen yang umum adalah keterbacaan. Misalnya yang $someobject->widthlebih mudah dibaca daripada $someobject->width(). Namun tidak seperti planet circumferenceatau width, yang dapat diasumsikan sebagai static, contoh objek seperti $someobject, yang membutuhkan fungsi lebar, kemungkinan mengambil pengukuran lebar contoh objek.
Oleh karena itu keterbacaan meningkat terutama karena skema penamaan yang asertif dan bukan dengan menyembunyikan fungsi yang menghasilkan nilai properti yang diberikan.

__get / __set gunakan:

• pra-validasi dan pra-sanitasi nilai properti

• string misalnya

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

  Dalam hal ini generatelatexakan mematuhi skema penamaan actionname + methodname

• kasus khusus, jelas

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

Catatan: PHP memilih untuk tidak mengimplementasikan sintaks pengambil / penyetel. Saya tidak mengklaim bahwa getter / setter umumnya buruk.

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

Siap!

Nah, PHP memang memiliki metode magic __get, __set, __isset& __unset, yang selalu memulai. Sungguh pantas (mengerti?) Properti OO lebih dari sekadar metode ajaib. Masalah utama dengan implementasi PHP adalah bahwa metode ajaib dipanggil untuk semua properti yang tidak dapat diakses. Yang berarti Anda harus Mengulangi Diri Anda (mis. Dengan memanggil property_exists ()) dalam metode ajaib ketika menentukan apakah nama sebenarnya adalah properti dari objek Anda. Dan Anda tidak bisa benar-benar menyelesaikan masalah umum ini dengan kelas dasar kecuali semua kelas Anda mewarisi dari itu. ClassWithProperties, karena PHP tidak memiliki banyak pewarisan.

Sebaliknya, kelas gaya baru Python memberi Anda property(), yang memungkinkan Anda menentukan semua properti Anda secara eksplisit. C # memiliki sintaks khusus.

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

Saya membuat percobaan menggunakan metode ajaib __call. Tidak yakin apakah saya harus mempostingnya (karena semua peringatan "JANGAN GUNAKAN METODE MAGIK" dalam jawaban dan komentar lain) tetapi saya akan meninggalkannya di sini .. kalau-kalau ada orang yang merasa berguna.

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];
    }
}

Cukup tambahkan metode di atas di kelas Anda, sekarang Anda dapat mengetik:

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

Dengan cara ini Anda bisa mendapatkan / mengatur segala sesuatu di kelas Anda jika ada, jika Anda membutuhkannya hanya untuk beberapa elemen tertentu, Anda bisa menggunakan "daftar putih" sebagai filter.

Contoh:

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];
    }
}

Sekarang Anda hanya bisa mendapatkan / menetapkan "foo" dan "biaya".
Anda juga dapat menggunakan "daftar putih" untuk menetapkan nama khusus untuk mengakses vars Anda.
Sebagai contoh,

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

Dengan daftar itu sekarang Anda dapat mengetik:

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

.
.
.
Itu saja.

Doc: __call () dipicu ketika memanggil metode yang tidak dapat diakses dalam konteks objek.

Setelah membaca saran lainnya, saya cenderung mengatakan bahwa:

Sebagai aturan GENERIC , Anda tidak akan selalu menentukan setter untuk SEMUA properti, khususnya yang "internal" (semaphores, flag internal ...). Properti read -only tidak akan memiliki setter, jadi beberapa properti hanya akan mendapatkan getter; di situlah __get () datang untuk mengecilkan kode:

• mendefinisikan __get () (getter global gaib) untuk semua properti yang sama,
• kelompokkan mereka dalam susunan jadi:
  • mereka akan berbagi karakteristik umum: nilai moneter akan / mungkin muncul dengan format yang benar, tanggal dalam tata letak tertentu (ISO, US, Intl.), dll.
  • kode itu sendiri dapat memverifikasi bahwa hanya properti yang ada & diizinkan sedang dibaca menggunakan metode ajaib ini.
  • setiap kali Anda perlu membuat properti serupa yang baru, cukup deklarasikan dan tambahkan namanya ke array yang tepat dan selesai. Itu jauh lebih cepat daripada mendefinisikan pengambil baru, mungkin dengan beberapa baris kode berulang-ulang di seluruh kode kelas.

Iya! kita bisa menulis metode pribadi untuk melakukan itu, juga, tapi sekali lagi, kita akan memiliki metode BANYAK yang dinyatakan (memori ++) yang akhirnya memanggil metode lain, selalu sama, metode. Mengapa tidak menulis metode TUNGGAL untuk mengatur semuanya ...? [ya! pun benar-benar dimaksudkan! :)]

Magic setters juga dapat merespons HANYA pada properti tertentu, jadi semua properti tipe tanggal dapat disaring terhadap nilai yang tidak valid dalam satu metode saja. Jika properti tipe tanggal dicantumkan dalam array, setternya dapat ditentukan dengan mudah. Contoh saja, tentu saja. ada terlalu banyak situasi.

Tentang keterbacaan ... Ya ... Itu perdebatan lain: Saya tidak suka terikat dengan penggunaan IDE (pada kenyataannya, saya tidak menggunakannya, mereka cenderung memberi tahu saya (dan memaksa saya) bagaimana tulis ... dan saya suka suka mengodekan "keindahan"). Saya cenderung konsisten tentang penamaan, jadi menggunakan ctag dan beberapa alat bantu lain sudah cukup bagi saya ... Pokoknya: begitu semua setter dan getter ajaib ini selesai, saya menulis setter lain yang terlalu spesifik atau "khusus" untuk digeneralisasikan dalam metode __set (). Dan itu mencakup semua yang saya butuhkan tentang mendapatkan dan mengatur properti. Tentu saja: tidak selalu ada kesamaan, atau ada beberapa properti yang tidak sepadan dengan kesulitan pengkodean metode magis, dan kemudian masih ada pasangan setter / pengambil tradisional yang baik.

Bahasa pemrograman hanya itu: bahasa buatan manusia. Jadi, masing-masing dari mereka memiliki intonasi atau aksen, sintaksis dan rasa sendiri, jadi saya tidak akan berpura-pura menulis kode Ruby atau Python menggunakan "aksen" yang sama dengan Java atau C #, saya juga tidak akan menulis JavaScript atau PHP untuk menyerupai Perl atau SQL ... Gunakan cara mereka seharusnya digunakan.

Secara umum, cara pertama lebih populer secara keseluruhan karena mereka yang memiliki pengetahuan pemrograman sebelumnya dapat dengan mudah beralih ke PHP dan menyelesaikan pekerjaan dengan cara yang berorientasi objek. Cara pertama lebih universal. Saran saya adalah tetap dengan apa yang dicoba dan benar di banyak bahasa. Kemudian, ketika dan jika Anda menggunakan bahasa lain, Anda akan siap untuk mencapai sesuatu ( alih-alih menghabiskan waktu menciptakan kembali roda ).

Ada banyak cara untuk membuat kode sumber dalam konvensi netbeans. Ini bagus. Itu membuat berpikir lebih mudah === SALAH. Cukup gunakan tradelel, khususnya jika Anda tidak yakin properti mana yang harus dienkapsulasi dan mana yang tidak. Saya tahu, ini adalah boi .... kode ... pla, tetapi untuk debugging-works dan banyak lainnya berpikir itu adalah cara yang lebih baik dan jelas. Jangan menghabiskan banyak waktu dengan thousend seni cara membuat getter dan setter sederhana. Anda tidak dapat menerapkan terlalu banyak pola desain seperti aturan-demeter dan sebagainya, jika Anda menggunakan sihir. Dalam situasi tertentu Anda dapat menggunakan magic_calls atau untuk solusi kecil, cepat dan jelas. Tentu Anda bisa membuat solusi untuk desain-patters dengan cara ini juga, tetapi mengapa membuat Anda hidup lebih sulit.

Memvalidasi + Memformat / Menurunkan Nilai

Setters memungkinkan Anda untuk memvalidasi data dan getter memungkinkan Anda memformat atau menurunkan data. Objek memungkinkan Anda untuk merangkum data dan validasinya serta memformat kode ke dalam paket rapi yang mendorong KERING.

Misalnya, pertimbangkan kelas sederhana berikut yang berisi tanggal lahir.

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;
    }
}

Anda ingin memvalidasi bahwa nilai yang ditetapkan adalah

• Tanggal yang valid
• Tidak di masa depan

Dan Anda tidak ingin melakukan validasi ini di seluruh aplikasi Anda (atau lebih dari beberapa aplikasi dalam hal ini). Alih-alih, lebih mudah membuat variabel anggota terlindungi atau pribadi (untuk menjadikan setter sebagai satu-satunya titik akses) dan untuk memvalidasi dalam setter karena Anda akan tahu bahwa objek tersebut berisi tanggal lahir yang valid tidak peduli bagian mana dari aplikasi objek berasal dan jika Anda ingin menambahkan lebih banyak validasi maka Anda dapat menambahkannya di satu tempat.

Anda mungkin ingin menambahkan beberapa pemformat yang beroperasi pada variabel anggota yang sama yaitu getAge()dan getDaysUntilBirthday()dan Anda mungkin ingin menerapkan format yang dapat dikonfigurasi dalam getBirthDate()tergantung pada lokal. Oleh karena itu saya lebih suka mengakses nilai secara konsisten melalui getter daripada berbaur $date->getAge()dengan $date->birth_date.

getter dan setter juga berguna saat Anda memperluas objek. Misalnya, anggap aplikasi Anda perlu mengizinkan 150+ tahun tanggal lahir di beberapa tempat tetapi tidak di tempat lain. Salah satu cara untuk memecahkan masalah tanpa mengulangi kode apa pun adalah dengan memperluas BirthDateobjek dan memasukkan validasi tambahan dalam setter.

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);
    }
}

Posting ini tidak secara khusus tentang __getdan __setmelainkan __callmerupakan ide yang sama kecuali untuk pemanggilan metode. Sebagai aturan, saya tinggal jauh dari semua jenis metode ajaib yang memungkinkan untuk kelebihan karena alasan yang diuraikan dalam komentar dan posting NAMUN , saya baru-baru ini berlari ke API pihak ke-3 yang saya gunakan yang menggunakan LAYANAN dan SUB-LAYANAN, contoh :

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

Bagian penting dari ini adalah bahwa API ini memiliki segalanya yang sama kecuali sub-tindakan, dalam hal ini doActionOne. Idenya adalah bahwa pengembang (saya dan orang lain yang menggunakan kelas ini) dapat memanggil sub-layanan dengan nama yang bertentangan dengan sesuatu seperti:

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

Saya bisa melakukannya:

 $myClass->doActionOne($args);

Untuk hardcode ini hanya akan banyak duplikasi (contoh ini sangat mirip dengan kode):

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();
    }

Tetapi dengan metode ajaib __call()saya dapat mengakses semua layanan dengan metode dinamis:

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

Manfaat dari panggilan dinamis ini untuk pengembalian data adalah bahwa jika vendor menambahkan sub-layanan lain, saya tidak perlu menambahkan metode lain ke dalam kelas atau membuat kelas tambahan, dll. Saya tidak yakin apakah ini berguna untuk siapa pun, tapi kupikir aku akan menunjukkan contoh di mana __set, __get, __call, dll dapat menjadi pilihan untuk dipertimbangkan karena fungsi utama adalah kembalinya data.

EDIT:

Secara kebetulan, saya melihat ini beberapa hari setelah posting yang menguraikan persis skenario saya. Ini bukan API yang saya maksudkan tetapi penerapan metode ini identik:

Apakah saya menggunakan api dengan benar?

Pembaruan: Jangan gunakan jawaban ini karena ini adalah kode yang sangat bodoh yang saya temukan saat saya belajar. Cukup gunakan pengambil dan penyetel biasa, ini jauh lebih baik.

Saya biasanya menggunakan nama variabel itu sebagai nama fungsi, dan menambahkan parameter opsional ke fungsi itu sehingga ketika parameter opsional diisi oleh penelepon, kemudian mengaturnya ke properti dan mengembalikan $ objek ini (rantai) dan kemudian ketika parameter opsional itu tidak ditentukan oleh penelepon, saya hanya mengembalikan properti ke penelepon.

Contoh saya:

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;
          }
     }
}