ทะเยอทะยานและ Setter?

ฉันไม่ใช่นักพัฒนา PHP ดังนั้นฉันจึงสงสัยว่าใน PHP นิยมใช้ตัวรับ / setters อย่างชัดเจนในรูปแบบ OOP บริสุทธิ์พร้อมฟิลด์ส่วนตัว (อย่างที่ฉันชอบ):

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

หรือเพียงแค่ฟิลด์สาธารณะ:

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

ขอบคุณ

คุณสามารถใช้วิธีมายากล PHP และ__get__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;
  }
}
?>

ทำไมต้องใช้ getters และ setters

1. ความสามารถในการปรับขนาด : มันง่ายกว่าในการสร้าง getter ให้ง่ายกว่าการค้นหาค่า var ทั้งหมดในรหัสโครงการ
2. การดีบัก : คุณสามารถวางเบรกพอยต์ที่ setters และ getters
3. ทำความสะอาด : ฟังก์ชั่นเวทย์มนตร์ไม่ได้เป็นทางออกที่ดีสำหรับการเขียนน้อยกว่า IDE ของคุณจะไม่แนะนำรหัส ใช้เท็มเพลตที่ดียิ่งขึ้นสำหรับตัวรับสัญญาณที่รวดเร็ว

Google ได้เผยแพร่คู่มือเกี่ยวกับการเพิ่มประสิทธิภาพของ PHP แล้วและข้อสรุปคือ:

ไม่มีทะเยอทะยานและ setter PHP เพิ่มประสิทธิภาพ

และไม่มีคุณต้องไม่ใช้วิธีการมายากล สำหรับ PHP, Magic Method นั้นชั่วร้าย ทำไม?

1. พวกมันยากที่จะดีบั๊ก
2. มีผลกระทบด้านลบต่อประสิทธิภาพ
3. พวกเขาต้องการการเขียนโค้ดเพิ่มเติม

PHP ไม่ใช่ Java, C ++ หรือ C # PHP มีความแตกต่างและมีบทบาทแตกต่างกัน

การห่อหุ้มมีความสำคัญในภาษา OO ใด ๆ ความนิยมไม่มีอะไรเกี่ยวข้องกับมัน ในภาษาที่พิมพ์แบบไดนามิกเช่น PHP มีประโยชน์อย่างยิ่งเพราะมีวิธีการเล็กน้อยเพื่อให้แน่ใจว่าคุณสมบัติเป็นประเภทเฉพาะโดยไม่ต้องใช้ตัวตั้งค่า

ใน PHP งานนี้:

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

ใน Java มันไม่ได้:

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

การใช้วิธีการเวทย์มนตร์ ( __getและ__set) ใช้งานได้ แต่เมื่อเข้าถึงคุณสมบัติที่มีทัศนวิสัยต่ำกว่าขอบเขตปัจจุบันที่สามารถเข้าถึงได้ สามารถทำให้คุณปวดหัวได้อย่างง่ายดายเมื่อพยายามดีบั๊กหากไม่ได้ใช้อย่างถูกต้อง

หากคุณต้องการใช้ฟังก์ชัน __call คุณสามารถใช้วิธีนี้ได้ มันใช้ได้กับ

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

นอกเหนือจากคำตอบที่ยอดเยี่ยมและเป็นที่ยอมรับแล้วในที่นี้ฉันต้องการขยาย PHP โดยไม่มี setters / getters

PHP ไม่ได้มีความทะเยอทะยานและหมาไวยากรณ์ มันมีวิธีการsubclassed หรือเวทมนต์เพื่ออนุญาตให้ "hooking" และแทนที่กระบวนการค้นหาคุณสมบัติตามที่ Daveอธิบาย

Magicช่วยให้เราโปรแกรมเมอร์ขี้เกียจทำมากขึ้นด้วยรหัสน้อยลงในเวลาที่เรามีส่วนร่วมในโครงการและรู้ว่ามันอย่างใกล้ชิด แต่มักจะเสียค่าใช้จ่ายในการอ่าน

ประสิทธิภาพการทำงานทุกฟังก์ชั่นที่ไม่จำเป็นซึ่งเป็นผลมาจากการบังคับใช้โค้ดสถาปัตยกรรมแบบ getter / setter ใน PHP เกี่ยวข้องกับสแต็กเฟรมหน่วยความจำของตัวเองเมื่อทำการเรียกใช้และทำให้รอบการทำงานของ CPU สิ้นเปลือง

ความสามารถในการอ่าน:โค้ดเบสเกิดการบวมของโค้ดบรรทัดซึ่งส่งผลกระทบต่อการนำทางโค้ดเนื่องจาก LOC มากกว่าหมายถึงการเลื่อนที่มากขึ้น

การตั้งค่า: โดยส่วนตัวตามกฎของฉันฉันใช้ความล้มเหลวของการวิเคราะห์รหัสแบบคงที่เป็นสัญญาณเพื่อหลีกเลี่ยงการลงไปบนถนนเวทย์มนตร์ตราบเท่าที่ผลประโยชน์ระยะยาวที่เห็นได้ชัดทำให้ฉันหลงในเวลานั้น

ชักนำ:

อาร์กิวเมนต์ทั่วไปคือความสามารถในการอ่าน ตัวอย่างที่ง่ายต่อการอ่านกว่า$someobject->width $someobject->width()อย่างไรก็ตามไม่เหมือนกับดาวเคราะห์circumferenceหรือwidthซึ่งสามารถสันนิษฐานได้ว่า staticเป็นอินสแตนซ์ของวัตถุเช่น$someobjectซึ่งต้องการฟังก์ชันความกว้างอาจใช้การวัดความกว้างของอินสแตนซ์ของวัตถุ
ดังนั้นความสามารถในการอ่านจึงเพิ่มขึ้นส่วนใหญ่เป็นเพราะโครงร่างการตั้งชื่อที่แน่วแน่และไม่ใช่โดยการซ่อนฟังก์ชั่นที่ส่งออกค่าคุณสมบัติที่กำหนด

__get / __set ใช้:

• การตรวจสอบความถูกต้องก่อนล่วงหน้าและการสุขาภิบาลล่วงหน้าของค่าคุณสมบัติ

• สตริงเช่น

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

  ในกรณีนี้generatelatexจะเป็นไปตามรูปแบบการตั้งชื่อของ actionname + methodname

• กรณีพิเศษที่ชัดเจน

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

หมายเหตุ: PHP เลือกที่จะไม่ใช้ไวยากรณ์ getter / setter ฉันไม่ได้อ้างว่า getters / setter โดยทั่วไปแล้วไม่ดี

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

พร้อม!

ดีPHPจะมีวิธีมายากล__get, __set, __issetและ__unsetซึ่งมักจะเป็นจุดเริ่มต้น อนิจจาเหมาะสม (รับเลย) คุณสมบัติ OO เป็นมากกว่าวิธีเวทย์มนตร์ ปัญหาหลักของการนำ PHP ไปใช้คือวิธีการทางเวทมนตร์ถูกเรียกใช้สำหรับคุณสมบัติที่ไม่สามารถเข้าถึงได้ทั้งหมด ซึ่งหมายความว่าคุณต้องทำซ้ำตัวเอง (เช่นโดยการเรียก property_exists ()) ในวิธีเวทย์มนตร์เมื่อพิจารณาว่าชื่อนั้นเป็นสมบัติของวัตถุของคุณหรือไม่ และคุณไม่สามารถแก้ปัญหาทั่วไปนี้ได้ด้วยคลาสพื้นฐานเว้นแต่ว่าคลาสทั้งหมดของคุณสืบทอดมาจาก ClassWithProperties เนื่องจาก PHP ขาดการสืบทอดหลายอย่าง

ในทางตรงกันข้ามPythonคลาสสไตล์ใหม่ให้property()ซึ่งจะช่วยให้คุณกำหนดคุณสมบัติทั้งหมดได้อย่างชัดเจน C #มีไวยากรณ์พิเศษ

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

ฉันทำการทดลองโดยใช้เวทมนต์ __call ไม่แน่ใจว่าฉันควรโพสต์ไว้หรือไม่ (เพราะคำเตือน "อย่าใช้วิธีวิเศษ" ในคำตอบและความคิดเห็นอื่น ๆ ) แต่ฉันจะทิ้งไว้ที่นี่ .. ในกรณีที่บางคนพบว่ามีประโยชน์

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

เพียงเพิ่มวิธีการข้างต้นในชั้นเรียนของคุณตอนนี้คุณสามารถพิมพ์:

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

วิธีนี้คุณสามารถรับ / ตั้งค่าทุกอย่างในชั้นเรียนของคุณถ้ามันมีอยู่หากคุณต้องการมันสำหรับองค์ประกอบเฉพาะบางอย่างคุณสามารถใช้ "รายการที่อนุญาต" เป็นตัวกรอง

ตัวอย่าง:

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

ตอนนี้คุณสามารถรับ / ตั้งค่า "foo" และ "ค่าธรรมเนียม" เท่านั้น
นอกจากนี้คุณยังสามารถใช้ "บัญชีขาว" นั้นเพื่อกำหนดชื่อที่กำหนดเองเพื่อเข้าถึง vars ของคุณ
ตัวอย่างเช่น,

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

ด้วยรายการนั้นคุณสามารถพิมพ์:

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

.
.
.
นั่นคือทั้งหมดที่

Doc: __call ()จะถูกเรียกใช้เมื่อเรียกใช้เมธอดที่ไม่สามารถเข้าถึงได้ในบริบทของวัตถุ

หลังจากอ่านคำแนะนำอื่น ๆ ฉันก็อยากจะบอกว่า:

ในฐานะที่เป็นสามัญกฎที่คุณจะไม่เคยกำหนด setters สำหรับALLคุณสมบัติพิเศษคน "ภายใน" (semaphores ธงภายใน ... ) คุณสมบัติแบบอ่านอย่างเดียวจะไม่มีตัวตั้งค่าดังนั้นคุณสมบัติบางอย่างจะมีตัวตั้งค่าเท่านั้น นั่นคือสิ่งที่ __get () มาเพื่อย่อขนาดโค้ด:

• กำหนด __get () (ผู้ให้บริการทั่วโลกที่มีมนต์ขลัง) สำหรับคุณสมบัติทั้งหมดที่เหมือนกัน
• จัดกลุ่มไว้ในอาร์เรย์ดังนั้น:
  • พวกเขาจะแบ่งปันลักษณะทั่วไป: ค่าเงินจะ / อาจมีรูปแบบที่เหมาะสมวันที่ในรูปแบบเฉพาะ (ISO, US, Intl.) ฯลฯ
  • รหัสนั้นสามารถตรวจสอบได้ว่ามีการอ่านคุณสมบัติที่ได้รับอนุญาตเท่านั้นที่มีอยู่โดยใช้วิธีการทางเวทย์มนตร์นี้
  • เมื่อใดก็ตามที่คุณต้องการสร้างคุณสมบัติที่คล้ายกันใหม่ให้ประกาศและเพิ่มชื่อให้กับอาร์เรย์ที่เหมาะสมและเสร็จสิ้น นั่นคือวิธีที่เร็วกว่าการกำหนดผู้ทะเยอทะยานใหม่บางทีอาจมีบางบรรทัดของรหัส REPEATED ซ้ำแล้วซ้ำอีกทั่วรหัสชั้นเรียน

ใช่ เราสามารถเขียนวิธีการส่วนตัวเพื่อทำเช่นนั้น แต่อีกครั้งเราจะประกาศวิธีการมากมาย (++ หน่วยความจำ) ที่สิ้นสุดการเรียกวิธีอื่นเสมอวิธีการเดียวกัน ทำไมไม่เขียนวิธีการเดียวเพื่อควบคุมทั้งหมด ... [อ๋อ! ปุนตั้งใจอย่างแน่นอน! :)]

ผู้ตั้งค่าเวทย์มนตร์ยังสามารถตอบสนองต่อคุณสมบัติเฉพาะเท่านั้นดังนั้นคุณสมบัติประเภทวันที่ทั้งหมดสามารถตรวจสอบกับค่าที่ไม่ถูกต้องในวิธีเดียว หากคุณสมบัติประเภทวันที่มีการระบุไว้ในอาร์เรย์ผู้กำหนดสามารถกำหนดได้อย่างง่ายดาย เป็นเพียงตัวอย่างเท่านั้น มีสถานการณ์มากเกินไป

เกี่ยวกับความสามารถในการอ่าน ... ดี ... นั่นเป็นอีกการถกเถียงกัน: ฉันไม่ชอบที่จะใช้ IDE (ในความเป็นจริงฉันไม่ได้ใช้มันพวกเขามักจะบอกฉัน (และบังคับฉัน) วิธีการ เขียน ... และฉันมีชอบของฉันเกี่ยวกับการเข้ารหัส "ความงาม") ฉันมักจะมีความสอดคล้องกันเกี่ยวกับการตั้งชื่อดังนั้นการใช้ ctags และตัวช่วยอื่นอีกสองอย่างก็เพียงพอแล้วสำหรับฉัน ... อย่างไรก็ตาม: เมื่อผู้ทำเวทมนต์และผู้ที่ทะเยอทะยานเสร็จแล้วฉันก็จะเขียนตัวตั้งอื่นที่เจาะจงเกินไปหรือ "พิเศษ" ไป ทั่วไปในวิธี __set () และนั่นครอบคลุมทั้งหมดที่ฉันต้องการเกี่ยวกับการรับและการตั้งค่าคุณสมบัติ แน่นอน: ไม่มีพื้นดินทั่วไปหรือมีคุณสมบัติบางอย่างที่ไม่คุ้มค่ากับการเข้ารหัสวิธีเวทมนต์และจากนั้นยังมีคู่เซ็ตเตอร์ / ผู้ทะเยอทะยานแบบดั้งเดิมที่เก่าแก่

ภาษาโปรแกรมเป็นเพียง: ภาษาประดิษฐ์ของมนุษย์ ดังนั้นแต่ละคนมีน้ำเสียงหรือสำเนียงไวยากรณ์และรสชาติของตัวเองดังนั้นฉันจะไม่แกล้งเขียนรหัส Ruby หรือ Python โดยใช้ "สำเนียง" เดียวกันมากกว่า Java หรือ C # หรือฉันจะเขียน JavaScript หรือ PHP เพื่อคล้าย Perl หรือ SQL ... ใช้วิธีที่พวกเขาตั้งใจจะใช้

โดยทั่วไปแล้ววิธีแรกนั้นเป็นที่นิยมมากกว่าเพราะผู้ที่มีความรู้ด้านการเขียนโปรแกรมมาก่อนสามารถเปลี่ยนไปใช้ PHP และทำงานในรูปแบบเชิงวัตถุได้อย่างง่ายดาย วิธีแรกเป็นสากลมากขึ้น คำแนะนำของฉันคือยึดสิ่งที่พยายามและเป็นจริงในหลายภาษา จากนั้นเมื่อใดและถ้าคุณใช้ภาษาอื่นคุณก็พร้อมที่จะทำบางสิ่งให้สำเร็จ ( แทนที่จะใช้เวลาในการปรับแต่งวงล้อ )

มีหลายวิธีในการสร้างซอร์สโค้ดใน netbeans-Convention นี่เป็นสิ่งที่ดี มันทำให้คิดว่าง่ายกว่า === FALSE เพียงแค่ใช้ประเพณีโดยเฉพาะอย่างยิ่งถ้าคุณไม่แน่ใจว่าหนึ่งในคุณสมบัติที่ควรจะถูกห่อหุ้มและที่หนึ่งไม่ ฉันรู้ว่ามันเป็นรหัส boi .... pla ... แต่สำหรับการดีบั๊ก - งานและอีกหลายคนคิดว่ามันเป็นวิธีที่ดีกว่าชัดเจน อย่าใช้เวลามากกับศิลปะมากมายวิธีการสร้างผู้ได้รับและผู้ตั้งง่าย คุณไม่สามารถใช้รูปแบบการออกแบบบางอย่างเช่นกฎ demeter ได้เช่นกันหากคุณใช้เวทมนต์ ในสถานการณ์เฉพาะคุณสามารถใช้ magic_calls หรือสำหรับโซลูชันขนาดเล็กรวดเร็วและชัดเจน แน่นอนว่าคุณสามารถแก้ปัญหาสำหรับผู้ออกแบบด้วยวิธีนี้ได้เช่นกัน แต่ทำไมต้องทำให้คุณมีชีวิตที่ยากขึ้น

การตรวจสอบความถูกต้อง + การจัดรูปแบบ / ค่าที่ได้รับ

ตัวตั้งค่าช่วยให้คุณสามารถตรวจสอบความถูกต้องของข้อมูลและตัวรับสัญญาณช่วยให้คุณสามารถจัดรูปแบบหรือรับข้อมูลได้ วัตถุช่วยให้คุณสามารถแค็ปซูลข้อมูลและการตรวจสอบและรหัสการจัดรูปแบบเป็นแพคเกจเรียบร้อยที่ส่งเสริม DRY

ตัวอย่างเช่นพิจารณาคลาสง่าย ๆ ดังต่อไปนี้ที่มีวันเกิด

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

คุณจะต้องตรวจสอบว่ามีการตั้งค่า

• วันที่ที่ถูกต้อง
• ไม่ใช่ในอนาคต

และคุณไม่ต้องการทำการตรวจสอบนี้กับแอปพลิเคชันของคุณ (หรือมากกว่าแอพพลิเคชั่นหลายตัวสำหรับเรื่องนั้น) แต่จะทำให้ตัวแปรสมาชิกได้รับการปกป้องหรือเป็นเรื่องส่วนตัวได้ง่ายขึ้น (เพื่อให้ตัวตั้งค่าเป็นจุดเข้าใช้งานเท่านั้น) และตรวจสอบความถูกต้องในตัวตั้งค่าเพราะคุณจะรู้ว่าวัตถุนั้นมีวันเดือนปีเกิดที่ถูกต้อง แอปพลิเคชันวัตถุมาจากและหากคุณต้องการเพิ่มการตรวจสอบเพิ่มเติมจากนั้นคุณสามารถเพิ่มได้ในที่เดียว

คุณอาจต้องการเพิ่มตัวจัดรูปแบบหลายตัวที่ทำงานกับตัวแปรสมาชิกเดียวกันgetAge()และgetDaysUntilBirthday()และคุณอาจต้องการบังคับใช้รูปแบบที่กำหนดค่าได้getBirthDate()ขึ้นอยู่กับโลแคล ดังนั้นผมจึงชอบอย่างต่อเนื่องในการเข้าถึงค่าผ่านทาง getters เมื่อเทียบกับการผสมกับ$date->getAge()$date->birth_date

getters และ setters ยังมีประโยชน์เมื่อคุณขยายวัตถุ ตัวอย่างเช่นสมมติว่าแอปพลิเคชันของคุณจำเป็นต้องอนุญาตให้มีวันเดือนปีเกิดมากกว่า 150 ปีในบางแห่ง แต่ไม่ใช่ในประเทศอื่น ๆ วิธีหนึ่งในการแก้ปัญหาโดยไม่ต้องทำซ้ำรหัสใด ๆ ก็คือการขยายBirthDateวัตถุและทำให้การตรวจสอบเพิ่มเติมใน 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);
    }
}

โพสต์นี้ไม่เฉพาะเจาะจงเกี่ยวกับ__getและ__setค่อนข้าง__callจะเป็นความคิดเดียวกันยกเว้นวิธีการโทร ตามกฎแล้วฉันอยู่ห่างจากวิธีการทางเวทย์มนตร์ทุกประเภทที่อนุญาตให้มีการโอเวอร์โหลดด้วยเหตุผลที่ระบุไว้ในความคิดเห็นและโพสต์อย่างไรก็ตามเมื่อเร็ว ๆ นี้ฉันพบกับ API ของบุคคลที่สามที่ฉันใช้ซึ่งใช้บริการและ SUB-SERVICE :

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

ส่วนที่สำคัญคือ API นี้มีทุกอย่างเหมือนกันยกเว้นการกระทำย่อยในกรณีdoActionOneนี้ แนวคิดก็คือผู้พัฒนา (ตัวฉันเองและคนอื่น ๆ ที่ใช้คลาสนี้) สามารถเรียกใช้บริการย่อยโดยใช้ชื่อแทนสิ่งที่ต้องการ:

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

ฉันสามารถทำแทน:

 $myClass->doActionOne($args);

หากต้องการ hardcode นี่เป็นการทำซ้ำจำนวนมาก (ตัวอย่างนี้มีลักษณะคล้ายกับโค้ดอย่างหลวม ๆ ):

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

แต่ด้วยวิธีมหัศจรรย์ของ__call()ฉันสามารถเข้าถึงบริการทั้งหมดด้วยวิธีการแบบไดนามิก:

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

ประโยชน์ของการโทรแบบไดนามิกสำหรับการส่งคืนข้อมูลคือถ้าผู้ขายเพิ่มบริการย่อยอื่นฉันไม่ต้องเพิ่มวิธีอื่นในชั้นเรียนหรือสร้างคลาสเพิ่มเติม ฯลฯ ฉันไม่แน่ใจว่าสิ่งนี้มีประโยชน์สำหรับ ทุกคน แต่ฉันคิดฉันจะแสดงตัวอย่างกรณีที่__set, __get, __callฯลฯ อาจเป็นตัวเลือกสำหรับการพิจารณาตั้งแต่ฟังก์ชั่นหลักคือการกลับมาของข้อมูล

แก้ไข:

บังเอิญฉันเห็นสิ่งนี้สองสามวันหลังจากโพสต์ซึ่งสรุปสถานการณ์ของฉัน ไม่ใช่ API ที่ฉันอ้างถึง แต่การใช้วิธีการเหมือนกัน:

ฉันใช้ API อย่างถูกต้องหรือไม่

อัปเดต: อย่าใช้คำตอบนี้เพราะนี่เป็นรหัสใบ้ที่ฉันพบในขณะที่เรียนรู้ เพียงใช้ตัวทะลุธรรมดาและตัวเซ็ตมันจะดีกว่ามาก

ฉันมักจะใช้ชื่อตัวแปรนั้นเป็นชื่อฟังก์ชั่นและเพิ่มพารามิเตอร์ทางเลือกให้กับฟังก์ชั่นนั้นดังนั้นเมื่อพารามิเตอร์ตัวเลือกเต็มไปด้วยผู้เรียกจากนั้นตั้งค่าเป็นคุณสมบัติและส่งกลับ $ this object (chaining) แล้วเมื่อพารามิเตอร์ทางเลือกนั้นไม่ได้ระบุ ผู้โทรฉันแค่ส่งคืนคุณสมบัติไปยังผู้โทร

ตัวอย่างของฉัน:

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