在 PHP 中使用 getter 和 setter 代替函数或简单的公共字段有什么优点？

Question

Closed. This question is opinion-based. It is not currently accepting answers.

---

想要改进这个问题？更新问题，以便可以通过编辑这篇文章用事实和引文来回答它。

2 年前已关闭。

此帖子已于 2 年前编辑并提交审核，但未能重新打开帖子：

原始关闭原因未解决

Answer 1

您可以使用 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;
  }
}
?>

Answer 2

为什么要使用 getter 和 setter？

1. 可扩展性：重构 getter 比搜索项目代码中的所有 var 分配更容易。
2. 调试：您可以在 setter 和 getter 处放置断点。
3. 更干净：魔术函数并不是减少编写的好解决方案，您的 IDE 不会建议代码。更好地使用模板来快速编写 getter。

Answer 3

Google 已经发布了 PHP 优化指南，结论是：

没有 getter 和 setter 优化 PHP

不，您不能使用魔法方法。对于 PHP 来说，魔法方法是邪恶的。为什么？

1. 它们很难调试。
2. 这会对性能产生负面影响。
3. 他们需要编写更多代码。

PHP 不是 Java、C++ 或 C#。 PHP 是不同的，并且遵循不同的规则。

Answer 4

封装在任何 OO 语言中都很重要，流行度与之无关。在动态类型语言（如 PHP）中，它特别有用，因为在不使用 setter 的情况下几乎没有方法可以确保属性属于特定类型。

在 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）也有效，但仅在访问可见性低于该属性的属性时有效。当前范围可以访问。如果使用不当，在尝试调试时很容易让您头疼。

Answer 5

如果您喜欢使用 __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;
    }
}

Answer 6

除了这里已经很棒且受人尊敬的答案之外，我还想扩展一下没有 setter/getter 的 PHP。

PHP 没有 getter 和 setter 语法。正如 Dave 所指出的，它提供了子类或神奇方法来允许“挂钩”并覆盖属性查找过程。

Magic 允许我们这些懒惰的程序员做更多事情当我们积极参与一个项目并熟悉它时，代码会减少，但通常会牺牲可读性。

性能 每个不必要的函数（由于在 PHP 中强制使用类似 getter/setter 的代码架构而产生）在调用时都会涉及到自己的内存堆栈帧，并且会浪费 CPU 周期。

可读性：代码库会导致代码行膨胀，这会影响代码导航，因为更多的 LOC 意味着更多的滚动。

偏好：就我个人而言，根据我的经验，我认为静态代码分析的失败
只要当时我无法获得明显的长期利益，就可以作为避免走上神奇之路的标志。

谬误：

一个常见的论点是可读性。例如，$someobject->width 比 $someobject->width() 更容易阅读。然而，与行星的周长或宽度（可以假定为静态）不同，对象的实例（例如$someobject） > 需要宽度函数，可能需要测量对象的实例宽度。
因此，可读性的增加主要是因为断言的命名方案，而不是通过隐藏输出给定属性值的函数。

__get / __set 使用：

• 属性值的预验证和预清理

• 字符串例如

  <前><代码>”
  一些 {mathsobj1->generatelatex} 多重
  行文本 {mathsobj1->latexoutput}
  {mathsobj1->generatelatex} 有很多变量
  某种原因
  ”

  在这种情况下generatelatex将遵循actionname + methodname

• 特殊、明显的情况

  $dnastringobj->homeobox($one_rememberable_parameter)->gattaca->findlated()
  $dnastringobj->homeobox($one_rememberable_parameter)->gttccaatttga->findlinked()
  

注意： PHP 选择不实现 getter/setter 语法。我并不是说 getter/setter 通常都是不好的。

Answer 7

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

准备好！

Answer 8

我使用魔术方法 __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”和“fee”。
您还可以使用该“白名单”来分配自定义名称以访问您的变量。
例如，

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

---

.
.
.
就这样。

---

文档：
__call() 在调用不可访问的方法时触发对象上下文。

Answer 9

嗯，PHP 确实有神奇的方法 __get、__set、__isset & 。 __unset，这始终是一个开始。唉，正确的（明白了吗？）OO 属性不仅仅是魔法方法。 PHP 实现的主要问题是为所有 不可访问的属性调用魔术方法。这意味着在确定 name 是否实际上是对象的属性时，您必须在魔术方法中重复自己（例如，通过调用 property_exists()）。除非所有类都继承自 ie，否则您无法真正使用基类解决这个普遍问题。 ClassWithProperties，因为 PHP 缺乏多重继承。

相比之下，Python新样式类为您提供property()，它允许您显式定义所有属性。 C# 有特殊的语法。

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

Answer 10

阅读完其他建议后，我倾向于这样说：

作为 GENERIC 规则，您不会总是为 ALL 属性定义设置器，特别是“内部”属性（信号量） ，内部标志...）。显然，只读属性不会有 setter，因此某些属性只会有 getter；这就是 __get() 缩小代码的地方：

• 为所有相似的属性定义一个 __get() （神奇的全局 getter），
• 将它们分组在数组中，如下所示：
  • 它们将具有共同的特征：货币值将/可能以正确的格式显示、特定布局中的日期（ISO、美国、国际）等。
  • 代码本身可以验证只有现有的 &允许的属性正在使用这种神奇的方法读取。
  • 每当您需要创建一个新的类似属性时，只需声明它并将其名称添加到正确的数组中即可完成。这比定义一个新的 getter 更快，也许在整个类代码中一遍又一遍地重复某些代码行。

是的！我们也可以编写一个私有方法来做到这一点，但话又说回来，我们将声明许多方法（++内存），最终会调用另一个始终相同的方法。为什么不编写一个SINGLE方法来统治它们...？ [是的！双关语绝对是故意的！ :)]

魔术设置器也可以仅响应特定属性，因此可以仅在一种方法中针对无效值筛选所有日期类型属性。如果日期类型属性在数组中列出，则可以轻松定义它们的设置器。当然，这只是一个例子。有太多的情况。

关于可读性...嗯...这是另一场争论：我不喜欢被 IDE 的使用所束缚（事实上，我不使用它们，它们倾向于告诉我（并且强迫我）如何编写......并且我喜欢编码“美”）。我倾向于在命名方面保持一致，因此使用 ctags 和其他一些辅助工具对我来说就足够了......无论如何：一旦完成所有这些神奇的 setter 和 getter，我会编写其他过于具体或“特殊”的 setter可以概括为 __set() 方法。这涵盖了我需要的有关获取和设置属性的所有内容。当然：并不总是有共同点，或者有一些属性不值得编写一个神奇的方法，然后仍然是古老的良好的传统 setter/getter 对。

编程语言就是：人类人工语言。因此，它们中的每一个都有自己的语调或重音、语法和风格，因此我不会假装使用与 Java 或 C# 相同的“重音”来编写 Ruby 或 Python 代码，也不会编写类似的 JavaScript 或 PHP Perl 或 SQL...按其应有的方式使用它们。

Answer 11

一般来说，第一种方式总体上更受欢迎，因为那些具有编程知识的人可以轻松过渡到 PHP 并以面向对象的方式完成工作。第一种方式更为通用。我的建议是坚持在多种语言中经过尝试和正确的做法。然后，当您使用另一种语言时，您将准备好完成一些事情（而不是花时间重新发明轮子）。

Answer 12

在 netbeans 约定中创建源代码的方法有很多。这很好。它让思考变得更容易===错。只需使用传统方法，特别是当您不确定应该封装哪一项属性以及不应该封装哪一项属性时。我知道，这是一个 boi.... pla... 代码，但对于调试工作和许多其他人来说，这是更好、更清晰的方法。不要花太多时间研究如何制作简单的 getter 和 setter 的数千种艺术。如果你使用魔法，你就不能实现太多的设计模式，比如德米特规则等等。在特定情况下，您可以使用 magic_calls 或小型、快速且清晰的解决方案。当然，您也可以通过这种方式为设计模式制定解决方案，但为什么会让您的生活变得更加困难。

Answer 13

验证 + 格式化/导出值

Setters 让您验证数据，getters 让您格式化或导出数据。对象允许您将数据及其验证和格式化代码封装到一个鼓励 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;
    }
}

您需要验证所设置的值是否为

• 有效日期，
• 而不是将来

，并且您不想在整个应用程序（或就此而言的多个应用程序）上进行此验证。相反，将成员变量设置为受保护或私有（以便使 setter 成为唯一的访问点）并在 setter 中进行验证会更容易，因为这样您就会知道该对象包含有效的出生日期，无论该对象的哪一部分对象来自的应用程序，如果您想添加更多验证，则可以将其添加在一个位置。

您可能希望添加对同一成员变量进行操作的多个格式化程序，即 getAge() 和 getDaysUntilBirthday()，并且您可能希望在 getBirthDate 中强制执行可配置格式() 取决于区域设置。因此，我更喜欢通过 getters 一致地访问值，而不是将 $date->getAge() 与 $date->birth_date 混合在一起。

当您扩展对象时，getter 和 setter 也很有用。例如，假设您的应用程序需要在某些地方允许 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);
    }
}

Answer 14

这篇文章并不是专门讨论 __get 和 __set 而是 __call，除了方法调用之外，它们的想法是相同的。一般来说，由于评论和帖子中概述的原因，我会远离任何类型的允许重载的魔术方法但是，我最近遇到了我使用的第 3 方 API，它使用 SERVICE和子服务，例如：

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

其中重要的部分是，除了子操作之外，该 API 具有相同的所有内容，在本例中为 doActionOne。这个想法是，开发人员（我自己和其他使用此类的人）可以通过名称调用子服务，而不是像这样：

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

我可以这样做：

 $myClass->doActionOne($args);

硬编码这只会导致大量重复（这个例子非常 与代码大致相似）：

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正确吗？

Answer 15

更新：不要使用这个答案，因为这是我在学习时发现的非常愚蠢的代码。只需使用普通的 getter 和 setter，就好多了。

---

我通常使用该变量名作为函数名，并向该函数添加可选参数，以便当调用者填充该可选参数时，然后将其设置为属性并返回 $this 对象（链接），然后当该可选参数未指定时呼叫者，我只是将财产返回给呼叫者。

我的例子：

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