referencia változó módosítása osztályban

Ennek így működnie kell, az egyetlen furcsaság, hogy . operátorral próbálsz hozzáférni az osztályod metódusához. Szóval azt cseréld le, $obj.changeNode(); helyett $obj->changeNode(); legyen. Emiatt amúgy Fatal errort is kaptál, nem?

Egyébként a kérdésed kapcsán elolvastam ChX remek bejegyzését a témában, nekem eléggé felnyitotta a szemem, hátha hasznos lesz neked/nektek is.

(Ja, és gondolom a Drupal verzió 6.x akart lenni, 7.x-nél már nincs hook_nodeapi(). :))

én csak visszakérdeznék:
igazából itt mi értelme van a mymoduleNode osztálynak? Mert annyi alapján, amit ez csinál, nem sok. Az egész igazából csak "zaj" a kódban, felesleges többlet.
lehetne simán a hook_nodeapi-ban
$node->title = "új cím";
nem kell erre külön osztály, külön metódus, stb.

(Szerk.:) Az osztályban vétett hibákra Rimelek elég jól válaszolt.

Bálint:
szerintem a referencia megértéséhez a PHP manualja bőven elég lehet (lényegében a belinkelt tutorial azt mondja el másként, ami itt van):
http://php.net/manual/en/language.references.pass.php
:)

Nem csak az $obj.changeNode() a furcsa, hanem az osztály deklarálása is. Mert az osztály fejlécében nem kell a "kerek" zárójelet kitenni. Valamint az osztálynak PHP-ben a Java-val szemben nincsen láthatóság jelzője. Tehát csak class MyModuleNode {

A changeNode elé pedig kell a function kulcsszó, nem úgy, mint java-ban.

De ezeket a nyilvánvalóan véletlen elírásokat leszámítva a kód jó úgy, ahogy van, ha a PHP 5 -öt használsz. Az objektumok ugyanis PHP 5 óta mindig referencia szerint adódnak át paraméterként is és értékadásnál sem készül róluk másolat.

Ha a $node változó nem objektum lenne, vagy a PHP 4-es verzióját használnád, akkor a megoldás a következő lenne:

Ahogyan a nodeapi hook is & jellel kapja meg a $node változót, úgy az osztály konstruktorának is úgy kellene azt várnia.

public function __construct(&$node) {

Ez persze csak arra volna elég, hogy a konstruktorban ugyanazt a változót érd el, mint amit átadtál a konstruktornak. De ha továbbadnád tulajdonságnak, akkor ott is kellene használni a referenciajelölést.

  function __construct(&$node) {
    $this->node = &$node;
  }

Viszont mivel az objektumokat az ember többnyire nem másolgatni akarja, így azoknál nem szükséges a referenciajelölés. Ha mégis valami oknál fogva másolatot akarsz az objektumról, akkor a clone kulcsszót kell használnod.

  function __construct($node) {
    $this->node = clone $node;
  }

Így már egy másolaton dolgoznál. És pontosan ugyanazt az objektumot kapnád, mint az eredeti, csak más címen. Kivéve, ha változtatsz az adott osztály klónozásának működésén, de ebbe már nem megyek bele.

Tehát:
Ha egyszerre kellene neked az eredeti $node objektum és közben egy új is, akkor használnám a clone kulcsszót és másolnék. De nem ezt szeretnéd.

Ha kizárólag az eredeti objektum módosítására kell az osztály, és az osztály konkrétan a node-hoz tartozik, tehát a modul egyéb funkcióiban nem játszik szerepet, akkor nem is használnék osztályt. Vagy ha több ilyen változtatás van, akkor statikus metódusokat használnák.

class MyModuleNode {
    public static function changeNode1($node) { //stb... }
    public static function changeNode2($node) { //stb... }
    ///stb...
}

Ha pedig az eredeti, a drupal által stdClass-ba csomagolt node kiterjesztésére kell, és szintén más modulbeli műveleteket nem szolgál, akkor ilyesmit csinálnék:

class mymoduleNode {
  private $node;
  function __construct($node) {
    $this->node = $node;
  }
 
  public function changeNode() {
    // Change node
    $this->node->title = "New title";
  }
 
  public function __get($var) {
      return $this->node->$var;
  }
 
  public function __set($var, $value) {
     $this->node->$var = $value;
  }
 
  public function __isset($var) {
     return isset($this->node->$var);
  }
 
  public function __unset($var) {
     unset($this->node->$var);
  }
}

A __get, __set, __isset, __unset metódusok miatt az értékadó és lekérdező műveletek, illetve az isset és unset műveletek is normál módon működnének. A nodeapi-ban pedig lecserélném a $node változót a sajátomra így:

$node = new myModuleNode($node);

És a drupal is úgy tud vele dolgozni, mint eredetileg, mert az eredeti node tulajdonságait éred el a kiterjesztetten keresztül. Viszont bővítheted saját metódusokkal, amiket felhasználhatsz. Ha kell, akkor vizsgálva, hogy milyen típusú a node.

if ($node instanceof MyModuleNode) {
    //Hívhatod a saját metódusaid. 
} else {
   //valószínűleg normál stdClass típusú node. 
}

Remélem, nem voltam túl bőbeszédű és nem néztem el valamit.

"Az objektumok ugyanis PHP 5 óta mindig referencia szerint adódnak át paraméterként is és értékadásnál sem készül róluk másolat."

A mai napig ezt én is így fogalmaztam volna meg. ChX cikke azonban rávilágít, hogy ez nem így van, érdemes elolvasni.