Was sind die Vorteile der Verwendung von Gettern und Settern anstelle von Funktionen oder einfach öffentlichen Feldern in PHP? [closed]

Ich bin kein PHP-Entwickler, daher frage ich mich, welche Vor- und Nachteile in PHP die Verwendung expliziter Getter/Setter in einem reinen OOP-Stil mit privaten Feldern hat (so wie ich es mag):

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

oder nur öffentliche Felder:

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

Sie können verwenden php magische Methoden __get und __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;
  }
}
?>

Warum Getter und Setter verwenden?

1. SkalierbarkeitHinweis: Es ist einfacher, einen Getter umzugestalten, als alle Var-Zuweisungen in einem Projektcode zu durchsuchen.
2. Debuggen: Sie können Haltepunkte bei Settern und Gettern setzen.
3. Reiniger: Magische Funktionen sind keine gute Lösung, um weniger zu schreiben, Ihre IDE schlägt den Code nicht vor. Verwenden Sie besser Vorlagen für schnell schreibende Getter.

Google hat bereits einen Leitfaden zur Optimierung von PHP veröffentlicht und das Fazit war:

Kein Getter und Setter PHP optimieren

Und nein, du musst keine magischen Methoden anwenden. Für PHP sind Magic Methods böse. Wieso den?

1. Sie sind schwer zu debuggen.
2. Es gibt negative Auswirkungen auf die Leistung.
3. Sie erfordern das Schreiben von mehr Code.

PHP ist nicht Java, C++ oder C#. PHP ist anders und spielt mit anderen Regeln.

Kapselung ist in jeder OO-Sprache wichtig, Popularität hat damit nichts zu tun. In dynamisch typisierten Sprachen wie PHP ist dies besonders nützlich, da es nur wenige Möglichkeiten gibt, sicherzustellen, dass eine Eigenschaft von einem bestimmten Typ ist, ohne Setter zu verwenden.

In PHP funktioniert das:

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

In Java nicht:

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

Mit magischen Methoden (__get und __set) funktioniert auch, aber nur, wenn auf eine Eigenschaft zugegriffen wird, die eine geringere Sichtbarkeit hat, als der aktuelle Bereich darauf zugreifen kann. Es kann Ihnen beim Debuggen leicht Kopfschmerzen bereiten, wenn es nicht richtig verwendet wird.

Wenn Sie die __call-Funktion bevorzugen, können Sie diese Methode verwenden. Es funktioniert mit

• ERHALTEN => $this->property()
• EINSTELLEN => $this->property($value)
• ERHALTEN => $this->getProperty()
• EINSTELLEN => $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;
    }
}

Zusätzlich zu den bereits großartigen und respektierten Antworten hier möchte ich auf PHP eingehen, das keine Setter/Getter hat.

PHP hat keine Getter- und Setter-Syntax. Es bietet Unterklassen oder Magie Methoden, um das “Hooking” und Überschreiben des Eigenschaftssuchprozesses zu ermöglichen, wie von aufgezeigt David.

Magie erlaubt wir faulen Programmierer mehr mit weniger Code zu einem Zeitpunkt zu erreichen, an dem wir aktiv an einem Projekt beteiligt sind und es genau kennen, aber normalerweise auf Kosten der Lesbarkeit.

Leistung Jede unnötige Funktion, die aus dem Erzwingen einer Getter/Setter-ähnlichen Code-Architektur in PHP resultiert, beinhaltet beim Aufruf einen eigenen Speicher-Stack-Frame und verschwendet CPU-Zyklen.

Lesbarkeit: Die Codebasis verursacht aufgeblähte Codezeilen, was sich auf die Codenavigation auswirkt, da mehr LOC mehr Scrollen bedeutet.

Präferenz: Persönlich nehme ich als Faustregel das Scheitern der statischen Codeanalyse als Zeichen dafür, den magischen Weg nicht zu beschreiten, solange mir zu diesem Zeitpunkt offensichtliche langfristige Vorteile entgehen.

Irrtümer:

Ein häufiges Argument ist die Lesbarkeit. Zum Beispiel das $someobject->width ist leichter zu lesen als $someobject->width(). Allerdings anders als bei einem Planeten circumference oder widthwovon ausgegangen werden kann staticdie Instanz eines Objekts wie z $someobjectdie eine Breitenfunktion erfordert, misst wahrscheinlich die Instanzbreite des Objekts.
Daher erhöht sich die Lesbarkeit hauptsächlich durch durchsetzungsfähige Benennungsschemata und nicht durch das Verstecken der Funktion, die einen bestimmten Eigenschaftswert ausgibt.

__get / __set verwendet:

• Vorvalidierung und Vorsanierung von Immobilienwerten

• Saiten zB

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

  In diesem Fall generatelatex würde sich an ein Namensschema von Aktionsname + Methodenname halten

• besondere, offensichtliche Fälle

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

Notiz: PHP hat sich entschieden, keine Getter/Setter-Syntax zu implementieren. Ich behaupte nicht, dass Getter/Setter generell schlecht sind.

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

Bereit!