Zugriffsmethoden in JavaScript?

Posted by & filed under javascript.

Zugriffsmethoden (oder auch Akzessoren oder Getter und Setter) sind in der objektorientierten Programmierung spezielle Methoden, die ausgeführt werden, wenn einzelne Eigenschaften eines Objektes verändert oder ausgelesen werden.

Viele Sprachen haben diese Möglichkeiten bereits implementiert:

  • PHP besitzt die „magischen“ Methoden „__get“ und „__set“, mit denen sich allgemeine Zugriffsmethoden für alle nicht sichtbaren oder nicht existierenden Eigenschaften eines Objektes beschreiben lassen.
    Ein Anwendungsbeispiel:

    class Person {
        private $name = null;
        protected function __set($param, $value){
            $setterName = "set".ucfirst($param);
            if (method_exists($this,$setterName)) {
                $this->$setterName($value);
            }
        }
    
        protected function __get($param){
            $getterName = "get".ucfirst($param);
            if (method_exists($this,$getterName)) {
                return $this->$getterName();
            } else {
                return '';
            }
        }
        public function setName($value){
            // evtl. Gültigkeit von $value überprüfen...        
            $this->name = $value;
        }
    
        public function getName(){
            return $this->name;
        }
    }
    $p = new Person();
    $p->name = "Max";
    echo $p->name;
    
  • Java besitzt in den Java Beans eine vergleichbare Methode (Ich muss zugeben, ich hab‘ die Idee in PHP von den Beans geklaut, sorry 😉 )
  • C# überschreibt get und set einer Variablen:
    private string _name;
    
    public string Name
    {
        get { return this._name; }
        set { this._name = value; }
    }
  • Und JavaScript??

Zugriffsmethoden in JavaScript sind ab der Version 1.5 wie folgt definiert:

var Eigenschaft;
Eigenschaft = getter function(Werte){ /*...*/ return(Wert); }
Eigenschaft = setter function(Werte){ /*...*/ Eigenschaft = Wert;
                                     return(true | false); }

Ab der Version 2.0 funktioniert folgendes: ( MDC )

var getsetTest = {
    _b : 2,
    get b() {alert("getting b");return this._b;},
    set b(value) {alert("setting b"); this._b = value;},
    run : function(){
        alert(this.b);
        this.b = 9;
        alert(this.b);
    }
}
getsetTest.run()

Ich habe nur diese Version der Zugriffsmethoden zum Laufen bekommen, die erste (1.5) Version funktionierte weder im Firefox3 noch im IE6.
Der IE6 weigert sich natürlich komplett, etwas von den Methoden zu akzeptieren, daher kann ich für meinen Teil die Benutzung erst einmal vergessen…

Also bleibt nichts anderes übrig, extra Methoden zum Zugriff bereitzustellen. Nachteil ist natürlich, das man den Benutzer seiner Objekte zum Verwenden dieser Methoden zwingen sollte (bloss wie…)
Dazu sollte man dem Anwender möglichst intuitive Methoden geben. Dazu von mir zwei Anregungen:

1. Methode:

var Person = {
    _private_name : '',
    getName : function(){
        return this._private_name
    },
    setName : function(value){
        this._private_name = value;
    }
}
Person.setName("Max");
alert(Person.getName());

2. Methode:

var Person = {
    _private_name : '',
    name : {
        get : function(){
            return this._private_name;
        },
        set : function(value){
            this._private_name = value;
        }
    }
}
Person.name.set("Max");
alert(Person.name.get());

Ich denke, diese Methoden sollten die meisten Entwickler davon abhalten, die „private“ Eigenschaft zu verwenden.
Ich würde mich über Eure Kommentare und eventuelle weitere Anregungen sehr freuen!

Leave a Reply