Tool um Quelltext zu generieren

[LL0rd]

Hallo Leute,

ich bin auf der Suche nach einem Tool, dass mir "dumme" Quelltexte generieren kann. Ich habe z.B. folgendes heute Nacht schreiben müssen:

		   $this->ArtikelName              =$data[ArtikelName];
		   $this->Title1                   =$data[Title1];
		   $this->Title2                   =$data[Title2];
		   $this->ShortDesc                =$data[ShortDesc];
		   $this->TwoColDescTitle          =$data[TwoColDescTitle];
		   $this->TwoColDesc1              =$data[TwoColDesc1];
		   $this->TwoColDesc2              =$data[TwoColDesc2];
		   $this->ImgMURL                  =$data[ImgMURL];
		   $this->ImgMText                 =$data[ImgMText];
		   $this->ImgB1URL                 =$data[ImgB1URL];
		   $this->ImgB1Text                =$data[ImgB1Text];
		   $this->ImgB2URL                 =$data[ImgB2URL];
		   $this->ImgB2Text                =$data[ImgB2Text];
		   $this->ImgD1URL                 =$data[ImgD1URL];
		   $this->ImgD1Text                =$data[ImgD1Text];
		   $this->ImgD2URL                 =$data[ImgD2URL];
		   $this->ImgD2Text                =$data[ImgD2Text];
		   $this->ImgD3URL                 =$data[ImgD3URL];
		   $this->ImgD3Text                =$data[ImgD3Text];
		   .......
		   .......

Gibt es da nichts, was mir die Arbeit etwas erleichtern kann?

 

[Admi]

Machs doch in ne Schleife ^^

Etwa in der Art

for($i=0;$i<100;$i++)
{
echo '$this->'.$i.'                =$data['.$i.'];<br />';
}

Musst halt nur irgendwoher deine Variablennamen hernehmen? DB oder Array oder Textdatei.

 

[Irgendjemand_1]

Lern reguläre Ausdrücke

Wenn irgendetwas einem Muster folgt, kannst du das damit eigentlich immer beschreiben und dann auch entsprechend verändern, wenn du willst.

Edit: Hab das wohl grad auf den ersten Blick falsch verstanden. Okay, der Vorschlag mit der Schleife war gar nicht so schlecht

 

[Gumbo]

Wieso packst du das Ganze nicht einfach in eine Variable? Beispielsweise:

$this->data = $data;

 

[LL0rd]

Lern reguläre Ausdrücke

Wenn irgendetwas einem Muster folgt, kannst du das damit eigentlich immer beschreiben und dann auch entsprechend verändern, wenn du willst.

Reguläre Ausrücke kann ich mehr oder weniger gut, aber hier wird man wahrscheinlich nicht weiterkommen, da ich ja einen String einfügen möchte. Ich weiß auch nicht, wieso ich nicht daran gedacht habe, einfach ein Script zu schreiben, dass den Quellcode generiert. Wahrscheinlich war es da schon zu spät und mein Gehirn hatte ein paar Lags

$this->data = $data;

Wieso ich das nicht so mache? Ganz einfach, $data ist einfach zu groß dafür. Und wenn ich 1000 Instanzen der Klasse anlege, dann spührt man schon den Unterschied. Ich habe es schon ausprobiert, musste Testweise deshalb den maximalen Speicherverbrauch von php auf 128MB hochschrauben.

Aber genau an dieser Stelle habe ich auch noch eine Frage:
Ich habe nicht so ganz verstanden, wie in PHP der Umgang mit Klassen ist. Sagen wir mal ich schreibe nun folgendes:

$i=1;
$j=$i;
$i=3;

Dann ist $i=3 und $j=1, oder?

Und wie ist das ganze bei Klassen?

$bla = new Bla();
$bla->i=1;
$bla2=$bla;
$bla2->i=2;

wurde dann der Wert bei $bla auch übernommen, oder habe ich da eine Kopie der Klasseninstanz?

 

[Gumbo]

Durch eine einfache Zuweisung wird nur eine Kopie des Werts der Variable zugewiesen. Nur bei einer Referenz greifen beide Variablen auf denselben Wert zu.

 

[LL0rd]

Dankeschön nun habe ich es auch verstanden. Wie es aussieht, hat sich die OOP auch in den letzten Jahren in PHP verbessert. Wie ich sehe gibt es hier bereits statische Variablen etc.

 

[Gumbo]

Referenzen haben aber nichts mit objektorientierter Programmierung zu tun.

Wozu brauchst du eigentlich 1000 Instanzen einer Klasse gleichzeitig?

 

[maeTimmae]

Gumbo: Ab PHP5 werden Objekte via Zuweisungsoperator referenziert, und über die clone Direktive kopiert. Wollte das nur mal der Korrektheit erwähnen.

<?php
$foo = new StdClass();
$foo->a = 1;

// ab PHP5 --> Referenzierung
$bar = $foo;
$bar->a = 2;
echo $foo->a; // gibt 2 aus

// ebenfalls Referenzierung
$bar = &$foo;
$bar->a = 3;
echo $foo->a; // gibt 3 aus

// Kopieren
$bla = clone $foo;
$bla->a = 4;
echo $foo->a; // gibt 3 aus
echo $bla->a; // gibt 4 aus

LL0rd: Warum verwendest du nicht einfach eine Eigenschaft des Objekts als Storage-Vektor / Array und definierst die benötigten Werte-Indizies vor, à la

class Foo {
    private $_vars = array(
        'keyname1' => null,
        'keyname2' => null,
        // ...
        );
    // ...
}

// oder

class Foo {
    private $_fields = array(
        'keyname1',
        'keyname2',
        // ...
        );
    // ...
}

Anschließend weist du das $data Array via Referenz an einer Objektmethode oder wie auch immer zu und durchläufst $this->_fields oder $this->_vars oder was auch immer und weist den entsprechenden Index des $data Arrays zu:

public function setData(array &$data) {
    foreach ($this->_fields as &$fieldname) {
        $this->_vars[$fieldname] = $data[$fieldname]; // oder ähnlich, oder anders
    }
}

 

[Fabian H]

Ein Beispiel, mit dem man deinen Code in Vim erzeugen kann:

iArtikelName
Title1
Title2
...<ESC>:%s/^\(.*\)$/$this->\1 = $data[\1];/g<CR>

<ESC> und <CR> sind Platzhalter fuer die Escape- bzw. Entertaste.

Wie man sieht kommt es lediglich auf die Wahl der richtigen Werkzeuge an.
Jeder bessere Editor erledigt Aufgaben solcher Art, und falls doch nicht, gibt es
immernoch genuegend Alternativen (man denke hier z.B. an die Unix-Befehle,
die Text verarbeiten koennen. sed, awk, cut, grep, etc..). Gerade bei solchen
Sachen sollte ein Programmierer eine moeglichst Grosse Vielfalt an Tools
kennen, damit er nicht einer Verletzung des DRY-Prinzips (Don't Repeat
Yourself) zum Opfer faellt.

Wie hier bereits erwaehnt, laesst sich dein Problem aber auch im Code selbst
loesen, z.B. mit Hashtables. Gerade Skriptsprachen erleichtern einem hier
die Arbeit, weil man nicht auf komplexere Techniken wie Reflection ange-
wiesen ist. Der entsprechende Code in PHP ist gerade mal zwei Zeilen lang:

foreach (array("Title1", "Title2", "..") as $v)
    $this->$v = $data[$v];

Immer daran denken: Sobald man sich wiederholt, hat man was falsch gemacht .

Nachtrag:
In manchen Sprachen sind die Werkzeuge gleich fest eingebaut.
Zum Beispiel in Form des Praeprozessors von C.
Dein Code koennte in C so aussehen:

#define COPY_MEMBER(m) (out->(m) = in->(m))

COPY_MEMBER(ArtikelName);
COPY_MEMBER(Title1);
COPY_MEMBER(Title2);
COPY_MEMBER(...);

#undef COPY_MEMBER