Variablen-Bezeichnungen via For-Schleife festlegen

Variablen-Bezeichnungen via For-Schleife festlegen

am 12.11.2007 20:28:16 von andre-info

Guten Abend!

Ich habe ein HTML-Formular gestrickt, in dem ein Benutzer aus mehreren
Dropdown-Menüs insgesamt 3 Lieblings-Musikalben wählen kann. Es wird per
POST eine Album-ID übermittelt, die sich auch in der MySQL-Tabelle
wiederfindet.

In einer For-Schleife soll dann eine Tabelle entstehen, in der alle zur
jeweiligen Album-ID zugehörigen Attribute angezeigt werden sollen.

So sehen meine Variablen aus:

$albumid1 = $_POST['album1'];
$albumid1 = $_POST['album2'];
$albumid1 = $_POST['album3'];


In der For-Schleife
for ($i = 1; $i < 4; $i++) { ... }
sollen dann diese SQL-Befehle entstehen (wichtig sind die Ziffern 1 - 3
am jeweiligen Befehlsende):
$abfrage = "SELECT * FROM gpg_alben WHERE albumid = $albumid1";
$abfrage = "SELECT * FROM gpg_alben WHERE albumid = $albumid2";
$abfrage = "SELECT * FROM gpg_alben WHERE albumid = $albumid3";

wie erreiche ich so etwas?


Ich habe gerade dies hier ausprobiert:

for ($i = 1; $i < 4; $i++) {
$aktuellesalbum = "\$albumid".$count;
$abfrage = "SELECT * FROM gpg_alben WHERE albumid = $aktuellesalbum";
[...]
}

Aber das spuckt nicht nur einen SQL-Fehler aus [1], sondern sieht auch
sehr unbeholfen aus.

Wer kann mir sagen, wie ich so etwas besser mache?


Besten Dank vorab,
André




[1] "Warning: mysql_fetch_object(): supplied argument is not a valid
MySQL result resource"

Re: Variablen-Bezeichnungen via For-Schleife festlegen

am 12.11.2007 20:45:02 von Carsten Wiedmann

André Wilke schrieb:

> So sehen meine Variablen aus:
>
> $albumid1 = $_POST['album1'];
> $albumid1 = $_POST['album2'];
> $albumid1 = $_POST['album3'];
>
>
> In der For-Schleife
> for ($i = 1; $i < 4; $i++) { ... }
> sollen dann diese SQL-Befehle entstehen (wichtig sind die Ziffern 1 - 3 am
> jeweiligen Befehlsende):
> $abfrage = "SELECT * FROM gpg_alben WHERE albumid = $albumid1";
> $abfrage = "SELECT * FROM gpg_alben WHERE albumid = $albumid2";
> $abfrage = "SELECT * FROM gpg_alben WHERE albumid = $albumid3";
>
> Ich habe gerade dies hier ausprobiert:
>
> for ($i = 1; $i < 4; $i++) {
> $aktuellesalbum = "\$albumid".$count;
> $abfrage = "SELECT * FROM gpg_alben WHERE albumid = $aktuellesalbum";


Funktionierend, aber auch sehr unschön ist:
| $abfrage = "SELECT * FROM gpg_alben WHERE albumid = " . (int)
${'albumid'.$i};


Schöner wäre es aber, wenn du im HTML-Formular die Select-Boxen als Array
(name ="albumid[]") anlegst. Dann kannst du im Script einfach mit foreach
durch das Array gehen.

Prinzipiell wird das hier beschrieben:
11.10. Wie kann man Checkboxen verarbeiten?
http://www.php-faq.de/q/q-formular-checkbox.html

Gruß
Carsten

Re: Variablen-Bezeichnungen via For-Schleife festlegen

am 13.11.2007 00:42:13 von Martin Lemke

André Wilke schrieb:

> So sehen meine Variablen aus:
>
> $albumid1 = $_POST['album1'];
> $albumid1 = $_POST['album2'];
> $albumid1 = $_POST['album3'];

Danach gibt es nur eine Variable und die hat den Wert $_POST['album3'].

> In der For-Schleife
> for ($i = 1; $i < 4; $i++) { ... }
> sollen dann diese SQL-Befehle entstehen (wichtig sind die Ziffern 1 - 3
> am jeweiligen Befehlsende):
> $abfrage = "SELECT * FROM gpg_alben WHERE albumid = $albumid1";
> $abfrage = "SELECT * FROM gpg_alben WHERE albumid = $albumid2";
> $abfrage = "SELECT * FROM gpg_alben WHERE albumid = $albumid3";

Die Variablen $albumid2 und $albumid3 sind nicht initialisiert oder gesetzt
worden. Welchen Sinn hat es, diese Werte in SQL-Strings einzufügen?

Nach obigen Code gibt es nur folgendes:

$abfrage="SELECT * FROM gpg_alben WHERE albumid = $albumid3";

Wohlgemerkt: '$albumid' als String, nicht ale Wertinhalt einer Variablen
namens $albumid.

Was der Zähler bewirken soll, ist mir vollkommen schleierhaft.

> Ich habe gerade dies hier ausprobiert:
>
> for ($i = 1; $i < 4; $i++) {
> $aktuellesalbum = "\$albumid".$count;
> $abfrage = "SELECT * FROM gpg_alben WHERE albumid = $aktuellesalbum";
> [...]
> }
>
> Aber das spuckt nicht nur einen SQL-Fehler aus [1], sondern sieht auch
> sehr unbeholfen aus.

Wenn der obige Code vollständig ist, sieht der SQL-String nach Durchlaufen
der Schleife folgendermaßen aus:

$abfrage='SELECT * FROM gpg_alben WHERE albumid = $albumid';

Dass Du eine Fehlermeldung erhältst, wundert mich nicht.

> Wer kann mir sagen, wie ich so etwas besser mache?

Ich habe den Eindruck, dass Du keinen blassen Schimmer hast, was da
passiert. Es hilft Dir nicht, Dir eine Lösung zu präsentieren.

Ich versuche es trotzdem mal. Besser wäre es, Du lernst erstmal die
Grundlagen von php.

Vielleicht dies:
// Variablen initialisieren
$album_1=0;
$album_2=0;
$album_3=0;

// Minimale Sicherheit. Ein Filter der Eingaben wäre besser
if (is_numeric($_POST['album1']))
$album_1 = $_POST['album1'];
if (is_numeric($_POST['album2']))
$albumi_2 = $_POST['album2'];
if (is_numeric($_POST['album3']))
$album_3 = $_POST['album3'];

$sql="SELECT * FROM gpg_alben
WHERE albumid = $album_1
OR albumid = $album_2
OR albumid = $album_3";

// SQL-Abfrage
....


Martin

Re: Variablen-Bezeichnungen via For-Schleife festlegen

am 13.11.2007 08:37:35 von Claus Reibenstein

André Wilke schrieb:

> So sehen meine Variablen aus:
>
> $albumid1 = $_POST['album1'];
> $albumid1 = $_POST['album2'];
> $albumid1 = $_POST['album3'];

Die letzten beiden Zeilen sollen doch sicher heißen:

$albumid2 = $_POST['album2'];
$albumid3 = $_POST['album3'];

> In der For-Schleife
> for ($i = 1; $i < 4; $i++) { ... }
> sollen dann diese SQL-Befehle entstehen (wichtig sind die Ziffern 1 - 3
> am jeweiligen Befehlsende):
> $abfrage = "SELECT * FROM gpg_alben WHERE albumid = $albumid1";
> $abfrage = "SELECT * FROM gpg_alben WHERE albumid = $albumid2";
> $abfrage = "SELECT * FROM gpg_alben WHERE albumid = $albumid3";

$abfrage = "SELECT * FROM gpg_alben WHERE albumid = ${albumid$i}";

Ich würde allerdings ein Array vorziehen:

$albumid = array(1 => $_POST['album1'],
$_POST['album2'],
$_POST['album3']);
for ($i = 1; $i < 4; ++$i) {
$abfrage = "SELECT * FROM gpg_alben WHERE albumid = $albumid[$i]";
...
}

Gruß. Claus

Re: Variablen-Bezeichnungen via For-Schleife festlegen

am 13.11.2007 08:38:26 von Christoph Herrmann

Martin Lemke schrieb:
> Vielleicht dies:
> // Variablen initialisieren
> $album_1=0;
> $album_2=0;
> $album_3=0;
>
> // Minimale Sicherheit. Ein Filter der Eingaben wäre besser
> if (is_numeric($_POST['album1']))
> $album_1 = $_POST['album1'];
> if (is_numeric($_POST['album2']))
> $albumi_2 = $_POST['album2'];
> if (is_numeric($_POST['album3']))
> $album_3 = $_POST['album3'];

und wenn die Parameter überhaupt nicht übergeben wurden bekommt er
Notice Meldungen weil die Indexe im POST nicht existieren...

Besser wäre doch:
if(isset($_POST['album1']))
{
$album1 = (int) $_POST['album1'];
}
....

Im übrigen würde ich geschweifte Klammern im Leben nicht weglassen (kann
fehleranfällig sein, wenn man das mal erweitern will). Aber deine und
meine Lösung sind beides nicht sehr gut, wenn Carsten's seine bedenkt
mit der Übergabe eines Array.

--
Mit freundlichen Grüßen,
Christoph Herrmann

http://dragonprojects.de/

Re: Variablen-Bezeichnungen via For-Schleife festlegen

am 13.11.2007 13:43:58 von Martin Lemke

Christoph Herrmann schrieb:

> und wenn die Parameter überhaupt nicht übergeben wurden bekommt er
> Notice Meldungen weil die Indexe im POST nicht existieren...

Sicher? Ich habe es nicht ausprobiert, aber ich denke, er wird einfach nur
die Alben heraus suchen, die er angegeben hat. Einträge mit ID=0 findet er
einfach nicht.

> Besser wäre doch:
> if(isset($_POST['album1']))
> {
> $album1 = (int) $_POST['album1'];
> }

Was soll daran besser sein?

Besser wäre dies:

function filt_num($num)
{
$ziffern='0123456789';
$result='';
if (strlen($num)>0)
for($i=0; $i if (!false==strstr($ziffern,$num[$i]))
$resut.=$num[$i];
return $result;
}

if (strlen(filt_num($_POST['album1'])>0)
$albums[]=filt_num($_POST['album1']);
....

> Im übrigen würde ich geschweifte Klammern im Leben nicht weglassen (kann
> fehleranfällig sein, wenn man das mal erweitern will).

Das muss jeder für sich entscheiden. Ich formatiere meinen Source so, dass
die öffnene und die schließende Klammer immer in der selben Spalte stehen.
Da sieht man ziemlich schnell wo eine Klammer fehlt, wenn mal eine fehlt.

So etwas wie

if (....) {
....;
....;
}

ist in meinen Augen des fehlerträchtigste überhaupt.

Für

if (....)
{
....;
}

sehe ich absolut keine Notwendigkeit. Wozu rückt man denn ein?

> Aber deine und
> meine Lösung sind beides nicht sehr gut, wenn Carsten's seine bedenkt
> mit der Übergabe eines Array.

Mir ging es darum, einem Anfänger nahe zu legen, dass Formulardaten auf
jeden Fall zu filtern sind.

Neulich postete hier mal jemand ein Eingabeformular und nannte sogar einen
URL dazu. Dort kann bis heute jeder Hilfshacker php-Skripte hochladen und
diese dann auch noch aufrufen.

http://bm.it-openproject.de/mytest/myupload.php

Martin

Re: Variablen-Bezeichnungen via For-Schleife festlegen

am 13.11.2007 13:53:44 von Christoph Herrmann

Martin Lemke schrieb:
> Sicher? Ich habe es nicht ausprobiert, aber ich denke, er wird einfach nur
> die Alben heraus suchen, die er angegeben hat. Einträge mit ID=0 findet er
> einfach nicht.

Klar nimmt er einfach nur die die verwendet werden da ein ungültiger
Array Index nun mal keine Nummer ist. Aber trotzdem werden wegen dem
ungültigen Zugriff Notice Meldungen ausgegeben, was einfach nur hässlich
ist und vielleicht Sicherheitsrelevante Notice Meldungen somit übersehen
werden könnten.

>> Besser wäre doch:
>> if(isset($_POST['album1']))
>> {
>> $album1 = (int) $_POST['album1'];
>> }
>
> Was soll daran besser sein?

Es kommen keine Notice Meldungen wegen ungültigem Array Zugriff und nach
den Zeilen ist $album1 auch mit seinem Datentyp eine Zahl und kein
numerischer String mehr.

> Besser wäre dies:
>
> function filt_num($num)
> {
> $ziffern='0123456789';
> $result='';
> if (strlen($num)>0)
> for($i=0; $i > if (!false==strstr($ziffern,$num[$i]))
> $resut.=$num[$i];
> return $result;
> }

Dann wäre "1a2" bei dir 12? Finde ich persönlich nicht sehr schön dass
einfach alle Ziffern eines Strings aneinander geheftet werden. Im
übrigen ist dein Return danach immer noch ein String und keine Zahl vom
Datentyp her.

> if (strlen(filt_num($_POST['album1'])>0)
> $albums[]=filt_num($_POST['album1']);
> ...

immer noch Notice Meldungen wegen ungültigem Zugriff.

> Das muss jeder für sich entscheiden. Ich formatiere meinen Source so, dass
> die öffnene und die schließende Klammer immer in der selben Spalte stehen.
> Da sieht man ziemlich schnell wo eine Klammer fehlt, wenn mal eine fehlt.
>
> So etwas wie
>
> if (....) {
> ....;
> ....;
> }
>
> ist in meinen Augen des fehlerträchtigste überhaupt.

Finde ich auch unschön und würde ich nicht verwenden.

> Für
>
> if (....)
> {
> ....;
> }
>
> sehe ich absolut keine Notwendigkeit. Wozu rückt man denn ein?

spätestens wenns Verschachtelt wird oder erweitert wird gibts Probleme.
Es ist einfach unleserlich. So ist ganz klar erkenntlich was zum if
gehört und was nicht. Aber wie du sagtest, bleibt jedem selbst
überlassen (da Geschmackssache), daher keine weitere Diskussion mehr
darüber. :)

> Mir ging es darum, einem Anfänger nahe zu legen, dass Formulardaten auf
> jeden Fall zu filtern sind.
>
> Neulich postete hier mal jemand ein Eingabeformular und nannte sogar einen
> URL dazu. Dort kann bis heute jeder Hilfshacker php-Skripte hochladen und
> diese dann auch noch aufrufen.
>
> http://bm.it-openproject.de/mytest/myupload.php

Deswegen wundert es mich so sehr, dass in vielen Anfängerbüchern kein
Wort darüber verloren wird. Ich musste mir erst "PHP Sicherheit" kaufen
bis ich dies gelernt hatte.

--
Mit freundlichen Grüßen,
Christoph Herrmann

http://dragonprojects.de/

Re: Variablen-Bezeichnungen via For-Schleife festlegen

am 13.11.2007 14:13:47 von Martin Lemke

Christoph Herrmann schrieb:

> Martin Lemke schrieb:
>> Sicher? Ich habe es nicht ausprobiert, aber ich denke, er wird einfach nur
>> die Alben heraus suchen, die er angegeben hat. Einträge mit ID=0 findet er
>> einfach nicht.
>
> Klar nimmt er einfach nur die die verwendet werden da ein ungültiger
> Array Index nun mal keine Nummer ist.

Das ist kein Array-Index, sondern eine Id in einer SQL-Abfrage.

> Aber trotzdem werden wegen dem
> ungültigen Zugriff Notice Meldungen ausgegeben

Anscheinend reden wir von verschiedenem.

>> function filt_num($num)
[...]

> Dann wäre "1a2" bei dir 12?

Ja.

> Finde ich persönlich nicht sehr schön dass
> einfach alle Ziffern eines Strings aneinander geheftet werden.

Man kann es auch so lösen, dass eine Exception geschmissen wird, wenn die
Eingabe nicht dem erwarteten entspricht, aber ich fürchte, dass der OP, der
schon jetzt mit dieser Aufgabe an seine Grenzen zu stoßen scheint, dann
nicht einmal mehr anstatzweise versteht, wovon wir reden.

Wir wollen ihm doch weiterhelfen und nicht nur klugscheißen.

> Im
> übrigen ist dein Return danach immer noch ein String und keine Zahl vom

Das wird in php automatishc konvertiert.

>> if (strlen(filt_num($_POST['album1'])>0)
>> $albums[]=filt_num($_POST['album1']);
>> ...
>
> immer noch Notice Meldungen wegen ungültigem Zugriff.

Ich verstehe nicht, was Du meinst.

Die Zeile
$albums[]=filt_num($_POST['album1']);

fügt dem Array $albums einen neuen Index mit dem Wert
filt_num($_POST['album1']) hinzu. Da wird kein Index in irgend einer Art
adressiert.

Wo ist da ein ungültiger Zugriff?

Martin

Re: Variablen-Bezeichnungen via For-Schleife festlegen

am 13.11.2007 14:18:48 von Christoph Herrmann

Martin Lemke schrieb:
> Das ist kein Array-Index, sondern eine Id in einer SQL-Abfrage.
>
>> Aber trotzdem werden wegen dem
>> ungültigen Zugriff Notice Meldungen ausgegeben
>
> Anscheinend reden wir von verschiedenem.

Also ich rede von deinem $_POST['album1'], genauer gesagt von der Zeile
"if (strlen(filt_num($_POST['album1'])>0)".

> Man kann es auch so lösen, dass eine Exception geschmissen wird, wenn die
> Eingabe nicht dem erwarteten entspricht, aber ich fürchte, dass der OP, der
> schon jetzt mit dieser Aufgabe an seine Grenzen zu stoßen scheint, dann
> nicht einmal mehr anstatzweise versteht, wovon wir reden.
>
> Wir wollen ihm doch weiterhelfen und nicht nur klugscheißen.

Deswegen würden bei mir ungültige Angaben mit einer 0 beantwortet
werden. :) Aber ja, ich mache es bei mir auch mit Exceptions, aber
natürlich sollte der OP erstmal grundsätzlich verstehen was hier von
sich geht.

>> Im
>> übrigen ist dein Return danach immer noch ein String und keine Zahl vom
>
> Das wird in php automatishc konvertiert.

print gettype(filt_num("5"));

Ich wette da bekommst "string" ausgegeben und nicht "int". PHP
konvertiert es erst bei Bedarf, daher wenn mit dem Wert rechnen willst.
Aber wenn es schon zu einer Zahl validierst kannst auch den Datentyp
richtig machen.

> Ich verstehe nicht, was Du meinst.
>
> Die Zeile
> $albums[]=filt_num($_POST['album1']);
>
> fügt dem Array $albums einen neuen Index mit dem Wert $_POST['album1']
> hinzu. Da wird kein Index in irgend einer Art adressiert.
>
> Wo ist da ein ungültiger Zugriff?

Du greifst auf den Index "album1" des Arrays $_POST zu. Ist dieses nicht
gefüllt (absichtlich oder nicht) ist der Zugriff ungültig. Im übrigen
würde ich nicht zwei mal filt_num aufrufen, sondern das Ergebnis des
ersten Aufrufes zwischenspeichern, spart etwas CPU Last. :)

--
Mit freundlichen Grüßen,
Christoph Herrmann

http://dragonprojects.de/

Re: Variablen-Bezeichnungen via For-Schleife festlegen

am 13.11.2007 16:24:59 von andre-info

Claus Reibenstein schrieb:
> André Wilke schrieb:
>
>>So sehen meine Variablen aus:
>>
>>$albumid1 = $_POST['album1'];
>>$albumid1 = $_POST['album2'];
>>$albumid1 = $_POST['album3'];
>
> Die letzten beiden Zeilen sollen doch sicher heißen:
>
> $albumid2 = $_POST['album2'];
> $albumid3 = $_POST['album3'];

Pardon, du hast natürlich Recht!


>>In der For-Schleife
>> for ($i = 1; $i < 4; $i++) { ... }
>>sollen dann diese SQL-Befehle entstehen (wichtig sind die Ziffern 1 - 3
>>am jeweiligen Befehlsende):
>> $abfrage = "SELECT * FROM gpg_alben WHERE albumid = $albumid1";
>> $abfrage = "SELECT * FROM gpg_alben WHERE albumid = $albumid2";
>> $abfrage = "SELECT * FROM gpg_alben WHERE albumid = $albumid3";
>
>

Danke, der Hinweis mit dem Array hat mir gut geholfen!
Auch vielen Dank an Carsten W. für seine Tipps und dem Link.


MfG,
André

Re: Variablen-Bezeichnungen via For-Schleife festlegen

am 13.11.2007 19:00:11 von Niels Braczek

Martin Lemke schrieb:
> Christoph Herrmann schrieb:
>=20
>> Besser wäre doch:
>> if(isset($_POST['album1']))
>> {
>> $album1 =3D (int) $_POST['album1'];
>> }
>=20
> Was soll daran besser sein?=20

Es berücksichtigt die Tatsache, dass $_POST['album1'] nicht gesetzt sei=
n
könnte.

> Besser wäre dies:
>=20
> function filt_num($num)
> {
> $ziffern=3D'0123456789';
> $result=3D'';
> if (strlen($num)>0)
> for($i=3D0; $i > if (!false==strstr($ziffern,$num[$i]))
> $resut.=3D$num[$i];
> return $result;
> }

Du meinst wohl

function filt_num( $num )
{
return preg-replace( '~\D~', '', $num );
}

> if (strlen(filt_num($_POST['album1'])>0)
> $albums[]=3Dfilt_num($_POST['album1']);
> ....

*grusel*
Du solltest dich bei MS bewerben. Deren Programme machen auch immer, was
*die* glauben, das der Benutzer gewollt haben könnte. Außerdem schmei=
ßt
das immer noch eine Notice, wenn $_POST['album1'] nicht gesetzt ist.

> So etwas wie=20
>=20
> if (....) {
> ....;
> ....;
> }
>=20
> ist in meinen Augen des fehlerträchtigste überhaupt.

Ist bei mir vorgeschriebener Standard. Es ist in keiner Weise
fehlerträchtig. Es entspricht zudem den Codingstandards vieler großer=

Projekte und ist somit jedem vertraut.

> Für
>=20
> if (....)
> {
> ....;
> }
>=20
> sehe ich absolut keine Notwendigkeit.=20

Es wird *immer* geklammert, um so etwas zu vermeiden:

> function filt_num($num)
> {
> $ziffern=3D'0123456789';
> $result=3D'';
> if (strlen($num)>0)
> $n=3Dstrlen($num);
> for($i=3D0; $i<$n; $i++)
> if (!false==strstr($ziffern,$num[$i]))
> $result.=3D$num[$i];
> return $result;
> }

> Wozu rückt man denn ein?

Für die Über/sicht/.

MfG
Niels

--=20
| http://www.kolleg.de =B7 Das Portal der Kollegs in Deutschland |
| http://www.bsds.de =B7 BSDS Braczek Software- und DatenSysteme |
| Webdesign =B7 Webhosting =B7 e-Commerce =B7 Joomla! Content Management =
|
------------------------------------------------------------ ------

Re: Variablen-Bezeichnungen via For-Schleife festlegen

am 13.11.2007 19:43:46 von Christoph Herrmann

Niels Braczek schrieb:
> Martin Lemke schrieb:
>> So etwas wie
>>
>> if (....) {
>> ....;
>> ....;
>> }
>>
>> ist in meinen Augen des fehlerträchtigste überhaupt.
>
> Ist bei mir vorgeschriebener Standard. Es ist in keiner Weise
> fehlerträchtig. Es entspricht zudem den Codingstandards vieler großer
> Projekte und ist somit jedem vertraut.

PEAR zum Beispiel schreibt dies als Standard vor. Ich persönlich
schließe mich allerdings der Meinung an, dass die Klammern untereinander
für mich zumindest übersichtlicher ist. So sehe ich sofort welche
Klammer zu welcher gehört.

--
Mit freundlichen Grüßen,
Christoph Herrmann

http://dragonprojects.de/

Re: Variablen-Bezeichnungen via For-Schleife festlegen

am 13.11.2007 19:54:23 von Niels Braczek

Christoph Herrmann schrieb:
> Niels Braczek schrieb:
>> Martin Lemke schrieb:
>>> So etwas wie=20
>>>
>>> if (....) {
>>> ....;
>>> ....;
>>> }
>>>
>>> ist in meinen Augen des fehlerträchtigste überhaupt.
>>=20
>> Ist bei mir vorgeschriebener Standard. Es ist in keiner Weise
>> fehlerträchtig. Es entspricht zudem den Codingstandards vieler groß=
er
>> Projekte und ist somit jedem vertraut.
>=20
> PEAR zum Beispiel schreibt dies als Standard vor. Ich persönlich=20
> schließe mich allerdings der Meinung an, dass die Klammern untereinan=
der=20
> für mich zumindest übersichtlicher ist. So sehe ich sofort welche=20
> Klammer zu welcher gehört.

Das habe ich früher in C/C++ auch so gehalten. Allerdings habe ich aus
rein praktischen Gründen den Coding Standard von Joomla! (baut auf
PEAR-CS auf) adaptiert.
Da es sich hierbei un *technisch* gleichwertige Varianten handelt, ist
das letztlich Geschmackssache bzw. Entscheidung des Auftraggebers. Das
Weglassen der Klammern ist hingegen keine Option.

MfG
Niels

--=20
| http://www.kolleg.de =B7 Das Portal der Kollegs in Deutschland |
| http://www.bsds.de =B7 BSDS Braczek Software- und DatenSysteme |
| Webdesign =B7 Webhosting =B7 e-Commerce =B7 Joomla! Content Management =
|
------------------------------------------------------------ ------

Re: Variablen-Bezeichnungen via For-Schleife festlegen

am 13.11.2007 19:59:55 von Johannes Mueller

Christoph Herrmann wrote:
> Niels Braczek schrieb:
>> Martin Lemke schrieb:
>>> So etwas wie
>>>
>>> if (....) {
>>> ....;
>>> ....;
>>> }
>>>
>>> ist in meinen Augen des fehlerträchtigste überhaupt.
>>
>> Ist bei mir vorgeschriebener Standard. Es ist in keiner Weise
>> fehlerträchtig. Es entspricht zudem den Codingstandards vieler großer
>> Projekte und ist somit jedem vertraut.
>
> PEAR zum Beispiel schreibt dies als Standard vor. Ich persönlich
> schließe mich allerdings der Meinung an, dass die Klammern
> untereinander für mich zumindest übersichtlicher ist. So sehe ich
> sofort welche Klammer zu welcher gehört.

spricht eigentlich irgendwas gegen

if(..) :
foreach(..) :
..
endforeach;
else :
..
endif;

....ich find das seit neuestem total praktisch, so weiss ich bei if's mit
schleifen etc. sofort was zu wem gehört.

Grüße
Johannes

--
Emails ohne "[nospam]" im Betreff werden kommentarlos gelöscht.

Re: Variablen-Bezeichnungen via For-Schleife festlegen

am 13.11.2007 20:15:46 von Christoph Herrmann

Johannes Mueller schrieb:
> spricht eigentlich irgendwas gegen
>
> if(..) :
> foreach(..) :
> ..
> endforeach;
> else :
> ..
> endif;

Technisch nein, alternative Syntax macht ja das selbe. Allerdings ist
diese nicht sehr gebräuchlich und wird (zumindest von mir und ich denke
von vielen auch) nicht gerne gesehen. :)

> ...ich find das seit neuestem total praktisch, so weiss ich bei if's mit
> schleifen etc. sofort was zu wem gehört.

Sieht man hier doch auch sehr deutlich:

if(...)
{
foreach(...)
{
...
}
} else
{
...
}

Daher warum sollte man alternative Syntax nehmen, wenn diese keine
Vorteile bringt (nur Nachteile weil Sie nicht sehr gebräuchlich und
dadurch schlecht lesbar ist wenn man Sie nicht kennt).

--
Mit freundlichen Grüßen,
Christoph Herrmann

http://dragonprojects.de/

Re: Variablen-Bezeichnungen via For-Schleife festlegen

am 13.11.2007 20:40:07 von Carsten Wiedmann

Johannes Mueller schrieb:

> spricht eigentlich irgendwas gegen
>
> if(..) :
> foreach(..) :
> ..
> endforeach;
> else :
> ..
> endif;
>
> ...ich find das seit neuestem total praktisch, so weiss ich bei if's mit
> schleifen etc. sofort was zu wem gehört.

Geht mir genau anders herum. Mein Editor kennt dieses Syntax nicht, und
somit funktioniert Codefaltung oder Markierung der Klammerpaare nicht mehr.
Andere (dein) Editoren mögen dies natürlich unterstützen.

Gruß
Carsten

Re: Variablen-Bezeichnungen via For-Schleife festlegen

am 13.11.2007 21:19:50 von Niels Braczek

Johannes Mueller schrieb:

> spricht eigentlich irgendwas gegen
>=20
> if(..) :
> foreach(..) :
> ..
> endforeach;
> else :
> ..
> endif;

Nur der Usus. Ich benutze diese Syntax ausschließlich in Templates.

> ....ich find das seit neuestem total praktisch, so weiss ich bei if's m=
it=20
> schleifen etc. sofort was zu wem gehört.

Wenn dir das zu besserer Übersicht verhilft, solltest du deine
Code-Blöcke verkleinern und Wächter nutzen. Man braucht nur sehr selt=
en
mehr als zwei-drei Einrückungsebenen.

MfG
Niels

--=20
| http://www.kolleg.de =B7 Das Portal der Kollegs in Deutschland |
| http://www.bsds.de =B7 BSDS Braczek Software- und DatenSysteme |
| Webdesign =B7 Webhosting =B7 e-Commerce =B7 Joomla! Content Management =
|
------------------------------------------------------------ ------

Re: Variablen-Bezeichnungen via For-Schleife festlegen

am 14.11.2007 01:41:02 von Martin Lemke

Niels Braczek schrieb:

> Du solltest dich bei MS bewerben. Deren Programme machen auch immer, was
> *die* glauben, das der Benutzer gewollt haben könnte.

Darum geht es nicht.

Es geht darum, dem OP nahezulegen, dass Eingaben (irgendwie) gefiltert
werden müssen. Wenn ich als Beispiel das bestmögliche bringe, versteht er
gar nichts, weil ich ihn überfordere.

Dafür stehe ich vor allen routinierteren Programmierern als kluger Kopf da.
Man muss eben wissen was man will. Schaumschlagen oder helfen.

Bei einem einfachen Beispiel hat der OP wenigstens potentiell die
Möglichkeit das vorgeschlagene nachvolllziehen zu können.

>> So etwas wie
>>
>> if (....) {
>> ....;
>> ....;
>> }
>>
>> ist in meinen Augen des fehlerträchtigste überhaupt.
>
> Ist bei mir vorgeschriebener Standard. Es ist in keiner Weise
> fehlerträchtig.

Dass es das ist, ist evident.

> Es entspricht zudem den Codingstandards vieler großer
> Projekte und ist somit jedem vertraut.

In negativer Weise. Ich will niemandem Vorschriften machen. Es gibt hier
kein "Falsch" in Oposition zu "Richtig". Selbst syntaktisch korrekter
Source, der in einer einzigen Zeile steht, ist eben einfach syntaktisch
korrekt.

>> Wozu rückt man denn ein?
>
> Für die Über/sicht/.

Und wozu setzt man syntaktisch nicht notwendige Klammern?

Martin

Re: Variablen-Bezeichnungen via For-Schleife festlegen

am 14.11.2007 05:56:40 von Niels Braczek

Martin Lemke schrieb:
> Niels Braczek schrieb:
>=20
>> Du solltest dich bei MS bewerben. Deren Programme machen auch immer, w=
as
>> *die* glauben, das der Benutzer gewollt haben könnte.=20
>=20
> Darum geht es nicht.
>=20
> Es geht darum, dem OP nahezulegen, dass Eingaben (irgendwie) gefiltert
> werden müssen. Wenn ich als Beispiel das bestmögliche bringe, vers=
teht er
> gar nichts, weil ich ihn überfordere.

Dann wäre is_numeric() oder intval() sinnvoller gewesen als die
*Veränderung* der Userdaten.

>>> So etwas wie=20
>>>=20
>>> if (....) {
>>> ....;
>>> ....;
>>> }
>>>=20
>>> ist in meinen Augen des fehlerträchtigste überhaupt.
>>=20
>> Ist bei mir vorgeschriebener Standard. Es ist in keiner Weise
>> fehlerträchtig.=20
>=20
> Dass es das ist, ist evident.

Das ist nicht wahr. Es mag für *deine* Wahrnehmungsgewohnheiten
zutreffen, ist aber in keiner Weise allgemein gültig.

>> Es entspricht zudem den Codingstandards vieler großer
>> Projekte und ist somit jedem vertraut.
>=20
> In negativer Weise.

Das ist *deine* Meinung und wieder in keiner Weise allgemein gültig.
Dieser Coding-Standard funktioniert.

> Ich will niemandem Vorschriften machen. Es gibt hier
> kein "Falsch" in Oposition zu "Richtig". Selbst syntaktisch korrekter
> Source, der in einer einzigen Zeile steht, ist eben einfach syntaktisch=

> korrekt.

Das ist nicht der Punkt. Guter Code zeichnet sich unter anderem dadurch
aus, dass ein anderer Programmierer sich darin sofort zuhause fühlt.
Einhaltung von Coding-Standards hilft dabei. Bei C ist das
Kernigan/Richie mit Klammern in eigener Zeile und drei Leerzeichen
Einrückung, bei PHP eben PEAR (Joomla!) mit Klammern in eigener Zeile
nur bei Funktionen und Klasse und vier Leerzeichen Einrückung. Man tut
klug daran, sich dem anzupassen, wenn man Code veröffentlicht (Open
Source). Was du für dich selber machst, ist natürlich sch**egal.

>>> Wozu rückt man denn ein?
>>=20
>> Für die Über/sicht/.
>=20
> Und wozu setzt man syntaktisch nicht notwendige Klammern?

Das habe ich dir bereits gezeigt.

MfG
Niels

--=20
| http://www.kolleg.de =B7 Das Portal der Kollegs in Deutschland |
| http://www.bsds.de =B7 BSDS Braczek Software- und DatenSysteme |
| Webdesign =B7 Webhosting =B7 e-Commerce =B7 Joomla! Content Management =
|
------------------------------------------------------------ ------

Re: Variablen-Bezeichnungen via For-Schleife festlegen

am 14.11.2007 08:45:22 von Christoph Herrmann

Niels Braczek schrieb:
> Dann wäre is_numeric() oder intval() sinnvoller gewesen als die
> *Veränderung* der Userdaten.

Zur Ergänzung: Und natürlich vorher prüfen, ob die Variable überhaupt
existiert (isset oder empty). Man sollte ungültige Daten nicht versuchen
zu berichtigen, sondern immer ablehnen.

--
Mit freundlichen Grüßen,
Christoph Herrmann

http://dragonprojects.de/

Re: Variablen-Bezeichnungen via For-Schleife festlegen

am 14.11.2007 09:56:25 von Martin Lemke

Niels Braczek schrieb:

> Dann wäre is_numeric() oder intval() sinnvoller gewesen als die
> *Veränderung* der Userdaten.

An dem Argument ist wirklich etwas dran.

>>> Ist bei mir vorgeschriebener Standard. Es ist in keiner Weise
>>> fehlerträchtig.
>>
>> Dass es das ist, ist evident.
>
> Das ist nicht wahr. Es mag für *deine* Wahrnehmungsgewohnheiten
> zutreffen, ist aber in keiner Weise allgemein gültig.

Dass dies ein allgemeingültiger Ansatz sei, habe ich auch nicht gesagt.
Allerdings fehlt ein nachvollziehbares Argument, warum diese Notation
besonders übersichtlich sei. "Das wurde immer so gemacht" bzw. "ist in
vielen Projekten Standard" ist kein Argument.

> Guter Code zeichnet sich unter anderem dadurch
> aus, dass ein anderer Programmierer sich darin sofort zuhause fühlt.

Es wird immer einen Teil geben, der sich bai dieser Notation nicht zuhause
fühlt.

> Einhaltung von Coding-Standards hilft dabei. Bei C ist das
[...]

Bei C war diese Unsitte immer Standard (warum, habe ich nie verstanden).
Den Source unübersichtlich formatieren, weil viele es so gewohnt sind, kann
man doch nicht ernsthaft als Argument bezeichnen.

Martin

Re: Variablen-Bezeichnungen via For-Schleife festlegen

am 14.11.2007 10:01:19 von Martin Lemke

Christoph Herrmann schrieb:

> Allerdings ist diese nicht sehr gebräuchlich

Johannes hat Recht, das ist erheblich übersichtlicher, wenn auch ziemlich
gewöhnungsbedürftig.

Bei Features, die kaum genutzt werden, besteht allerdings immer die Gefahr,
dass sie ab irgend eines Versionssprunges nicht mehr verfügbar sind.

Martin

Re: Variablen-Bezeichnungen via For-Schleife festlegen

am 14.11.2007 10:11:48 von Gregor Kofler

Martin Lemke meinte:

> So etwas wie
>
> if (....) {
> ....;
> ....;
> }
>
> ist in meinen Augen des fehlerträchtigste überhaupt.

Schmarrn - da schreit die IDE schon beim Tippen und der Parser findet
vergessene Klammern normal recht schnell.


>
> Für
>
> if (....)
> {
> ....;
> }
>
> sehe ich absolut keine Notwendigkeit. Wozu rückt man denn ein?

*Das* hingegen ist ein Killer. Eine weitere hinzugefügt im IF-Block
führt weder in der IDE, noch im Parser zu einem Fehler. Nur im Ergebnis.
Klammern gibt es bei mir *immer*.

Gregor




--
http://www.gregorkofler.at ::: Landschafts- und Reisefotografie
http://www.licht-blick.at ::: Forum für Multivisionsvorträge
http://www.image2d.com ::: Bildagentur für den alpinen Raum

Re: Variablen-Bezeichnungen via For-Schleife festlegen

am 14.11.2007 10:37:07 von Johannes Mueller

Martin Lemke wrote:

>> Allerdings ist diese nicht sehr gebräuchlich
>
> Johannes hat Recht, das ist erheblich übersichtlicher, wenn auch
> ziemlich gewöhnungsbedürftig.
>
> Bei Features, die kaum genutzt werden, besteht allerdings immer die
> Gefahr, dass sie ab irgend eines Versionssprunges nicht mehr
> verfügbar sind.

Ja - ich hab auch son latentes Gefühl, dass das irgendwann wegrationalisiert
wird und ich alles anpassen müsste. Wie gesagt, da es noch ein recht neuer
"Spleen" von mir ist kann ich auch noch 'n Rückzieher machen.

Grüße
Johannes

--
Emails ohne "[nospam]" im Betreff werden kommentarlos gelöscht.

Re: Variablen-Bezeichnungen via For-Schleife festlegen

am 14.11.2007 10:49:41 von Claus Reibenstein

Martin Lemke schrieb:

> So etwas wie
>
> if (....) {
> ....;
> ....;
> }
>
> ist in meinen Augen des fehlerträchtigste überhaupt.

Ich habe mir den Thread durchgelesen, insbesondere diesen Teilthread
einschließlich Deiner Argumentationen, aber _was_ daran fehlerträchtig
sein soll und vor allem _warum_, ist mir nach wie vor absolut schleierhaft.

Dieser Programmierstil wird von mir seit etwa 25 Jahren (in C, C++, Java
und PHP) gepflegt, und bis jetzt bin ich damit sehr gut gefahren.

> Für
>
> if (....)
> {
> ....;
> }
>
> sehe ich absolut keine Notwendigkeit.

Es besteht auch "absolut keine Notwendigkeit", ein Programm in mehrere
Zeilen aufzuteilen. Das kann man auch in eine einzige Zeile schreiben
oder von einem Layout-Programm im Blocksatz formatieren lassen. Trotzdem
schreiben die meisten Menschen ihre Programme in mehrere Zeilen. Warum?
Weil es sinnvoll ist.

Es besteht auch "absolut keine Notwendigkeit", Variablennamen mit mehr
als 2 Zeichen zu benutzen. Damit lassen sich schon 3392 verschiedene
Variablen innerhalb eines Blocks definieren. Oft reicht sogar ein
Zeichen aus (53 Variablen). Trotzdem benutzen die meisten Menschen
deutlich längere und vor allem sprechende Variablennamen. Warum? Weil es
sinnvoll ist.

Es besteht auch "absolut keine Notwendigkeit", Programme zu
kommentieren. Trotzdem schreiben - hoffentlich viele - Menschen in einer
ihnen verständlichen, natürlichen Sprache häufig dazu, was das Programm
an welcher Stelle macht und was damit erreicht werden soll. Warum? Weil
es sinnvoll ist.

Programme werden von Menschen geschrieben. Diese Programme müssen nicht
nur vom Computer gelesen und verstanden werden können, sondern auch von
anderen Menschen. Spätestens dann, wenn ein solches Programm mal
geändert werden soll und der ursprüngliche Programmierer nicht mehr
greifbar ist, weiß man, wozu das alles gut ist.

Notwendig ist das alles nicht. Technisch gesehen.

Im Übrigen ziehe ich

if (...) {
...;
}

Deinem Konstrukt vor, denn da erkenne ich sofort, dass die schließende
Klammer zu einem if gehört und dieser Block kein eigenständiges Gebilde
darstellt.

> Wozu rückt man denn ein?

Tut man das? Tust _Du_ das? Warum das denn? Dazu besteht doch "absolut
keine Notwendigkeit" ...

> Neulich postete hier mal jemand ein Eingabeformular und nannte sogar einen
> URL dazu. Dort kann bis heute jeder Hilfshacker php-Skripte hochladen und
> diese dann auch noch aufrufen.

Bis einer ein Script hochlädt, welches genau dieses Script löscht *veg*

Gruß. Claus

Re: Variablen-Bezeichnungen via For-Schleife festlegen

am 14.11.2007 11:03:38 von Christoph Herrmann

Claus Reibenstein schrieb:
> Es besteht auch "absolut keine Notwendigkeit", Programme zu
> kommentieren. Trotzdem schreiben - hoffentlich viele - Menschen in einer
> ihnen verständlichen, natürlichen Sprache häufig dazu, was das Programm
> an welcher Stelle macht und was damit erreicht werden soll. Warum? Weil
> es sinnvoll ist.

Mal ehrlich, wie viel % (gerade im PHP Bereich, wo sehr viele Anfänger
zu finden sind) Kommentieren ihren Quellcode? Und wie viel verwenden
dafür eine standardisierte API Dokumentation (Doxygen, PHPDoc)? Ich
denke das wird die Minderheit sein.

> Programme werden von Menschen geschrieben. Diese Programme müssen nicht
> nur vom Computer gelesen und verstanden werden können, sondern auch von
> anderen Menschen. Spätestens dann, wenn ein solches Programm mal
> geändert werden soll und der ursprüngliche Programmierer nicht mehr
> greifbar ist, weiß man, wozu das alles gut ist.

Viele denken hier halt "es ist ja nur für mich". Aber das ist ein großer
Irrtum, vor allem wenn man größere Teile objektorientiert schreibt oder
zumindest so Allgemein, dass man diese auch in anderen Projekten
verwenden kann. Und spätestens dann kommt es irgendwann auch vor, dass
andere Leute damit arbeiten müssen. Und genau DANN wird jeder froh sein
wenn die Qualität auch im nicht technischem Sinne stimmt.

--
Mit freundlichen Grüßen,
Christoph Herrmann

http://dragonprojects.de/

Re: Variablen-Bezeichnungen via For-Schleife festlegen

am 14.11.2007 12:03:33 von Claus Reibenstein

Christoph Herrmann schrieb:

> Claus Reibenstein schrieb:
>
>> Es besteht auch "absolut keine Notwendigkeit", Programme zu
>> kommentieren. Trotzdem schreiben - hoffentlich viele - Menschen in
>> einer ihnen verständlichen, natürlichen Sprache häufig dazu, was
>> das Programm an welcher Stelle macht und was damit erreicht werden
>> soll. Warum? Weil es sinnvoll ist.
>
> Mal ehrlich, wie viel % (gerade im PHP Bereich, wo sehr viele
> Anfänger zu finden sind) Kommentieren ihren Quellcode?

Nun ja, als Anfänger hat man genug andere Probleme und will sich nicht
auch noch damit belasten. Ging mir damals zumindest so.

Mittlerweile bin ich aber seit 30 Jahren im Geschäft und habe mir in
dieser Zeit oft genug mangelhaft oder auch gar nicht kommentierten Code
- darunter auch eigene Altlasten - anschauen dürfen. Das prägt!

> Und wie viel verwenden dafür eine standardisierte API Dokumentation
> (Doxygen, PHPDoc)?

Stop! Dokumentation ist ein ganz anderes Kapitel!

Dokumentation erstelle ich separat von Hand. Zum Einen, weil die
komplette Dokumentation im Quelltext eher verwirrt anstatt hilft, zum
Anderen, weil es bei der Dokumentation auf ganz andere Dinge ankommt.
Außerdem dürfte es - auch mit den "standardisierten" (von wem
eigentlich?) Werkzeugen - schwierig sein, illustrierende Grafiken oder
Tabellen oder Ähnliches zu erzeugen.

> Ich denke das wird die Minderheit sein.

Rate mal, warum ich "hoffentlich viele" in meinem Posting stehen habe ...

>> [...] Spätestens dann, wenn ein solches Programm mal geändert
>> werden soll und der ursprüngliche Programmierer nicht mehr greifbar
>> ist, weiß man, wozu das alles gut ist.
>
> [...] Und spätestens dann kommt es irgendwann auch vor, dass andere
> Leute damit arbeiten müssen. Und genau DANN wird jeder froh sein wenn
> die Qualität auch im nicht technischem Sinne stimmt.

Sachichdoch :-)

Gruß. Claus

Re: Variablen-Bezeichnungen via For-Schleife festlegen

am 14.11.2007 12:17:12 von Peter Sommerfeld

Martin Lemke schrieb:
> Niels Braczek schrieb:
>> Guter Code zeichnet sich unter anderem dadurch aus, dass ein anderer
>> Programmierer sich darin sofort zuhause fühlt.
>
> Es wird immer einen Teil geben, der sich bai dieser Notation nicht
> zuhause fühlt.

Es geht nicht darum dass man sich darin "zu Hause" fühlt sondern darum
dass der Stil in sich konsistent ist. Und wenn er in sich konsistent ist
versteht man den auch, - es sei denn man trägt Scheuklappen ;-)

>> Einhaltung von Coding-Standards hilft dabei. Bei C ist das
> [...]
>
> Bei C war diese Unsitte immer Standard (warum, habe ich nie verstanden).
> Den Source unübersichtlich formatieren, weil viele es so gewohnt sind,
> kann man doch nicht ernsthaft als Argument bezeichnen.

Des einen Sitte ist immer des anderen Unsitte..

Eigentlich albern über so etwas auch nur ein Wort zu verlieren aber ich
habe dank Erkältung gerade Matsch in der Birne ;-)

Peter

Re: Variablen-Bezeichnungen via For-Schleife festlegen

am 14.11.2007 15:28:04 von Niels Braczek

Martin Lemke schrieb:
> Niels Braczek schrieb:
>=20
>>>> Ist bei mir vorgeschriebener Standard. Es ist in keiner Weise
>>>> fehlerträchtig.=20
>>>=20
>>> Dass es das ist, ist evident.
>>=20
>> Das ist nicht wahr. Es mag für *deine* Wahrnehmungsgewohnheiten
>> zutreffen, ist aber in keiner Weise allgemein gültig.
>=20
> Dass dies ein allgemeingültiger Ansatz sei, habe ich auch nicht gesag=
t.

Doch, du sagtest "Dass es das [fehlerträchtig] ist, ist evident.". Das
Wort "evident" erhebt den Anspruch auf Allgemeingültigkeit.

> Allerdings fehlt ein nachvollziehbares Argument, warum diese Notation
> besonders übersichtlich sei.

Das wurde nicht behauptet.

> "Das wurde immer so gemacht" bzw. "ist in
> vielen Projekten Standard" ist kein Argument.

Doch, genau das ist *das* Argument. Die Wahrnehmungsgewohnheiten passen
sich dem nämlich an, insbesondere, wenn man sich selbst daran hält.

>> Guter Code zeichnet sich unter anderem dadurch
>> aus, dass ein anderer Programmierer sich darin sofort zuhause fühlt.=

>=20
> Es wird immer einen Teil geben, der sich bai dieser Notation nicht zuha=
use
> fühlt.=20

Dieser Teil hat dann aber ein selbst gewähltes Problem.

>> Einhaltung von Coding-Standards hilft dabei. Bei C ist das
> [...]
>=20
> Bei C war diese Unsitte immer Standard (warum, habe ich nie verstanden)=

> Den Source unübersichtlich formatieren, weil viele es so gewohnt sind=
, kann
> man doch nicht ernsthaft als Argument bezeichnen.

Doch, ernsthaft.

MfG
Niels

--=20
| http://www.kolleg.de =B7 Das Portal der Kollegs in Deutschland |
| http://www.bsds.de =B7 BSDS Braczek Software- und DatenSysteme |
| Webdesign =B7 Webhosting =B7 e-Commerce =B7 Joomla! Content Management =
|
------------------------------------------------------------ ------

Re: Variablen-Bezeichnungen via For-Schleife festlegen

am 14.11.2007 15:39:25 von Niels Braczek

Claus Reibenstein schrieb:
> Christoph Herrmann schrieb:

>> Und wie viel verwenden dafür eine standardisierte API Dokumentation
>> (Doxygen, PHPDoc)?
>=20
> Stop! Dokumentation ist ein ganz anderes Kapitel!

Finde ich nicht. Dokumentation geht vielleicht darüber hinaus, die
Überschneidung ist IMO aber sehr groß. Zu jeder Funktion gehört ein=

Block, der zumindest die Parameter und Rückgabewerte beschreibt. Gerade=

in PHP ist das unverzichtbar. Hierbei auf die von JavaDOC vorgeschlagene
Kommentarsyntax zu benutzen bietet sich an, weil Doxygen und PHPDoc
damit umgehen können.

> Dokumentation erstelle ich separat von Hand. Zum Einen, weil die
> komplette Dokumentation im Quelltext eher verwirrt anstatt hilft, zum
> Anderen, weil es bei der Dokumentation auf ganz andere Dinge ankommt.

Vielleicht solltest du zwischen der Quellcode-Dokumentation und der
Anwender-Dokumentation unterscheiden. Kommentare und vernünftige
Bezeichner dienen der Quellcode-Dokumentation. Die Anwender-Doku hat in
der Tat nichts im Quellcode verloren (obwohl Donald E. Knuth da anderer
Auffassung sein dürfte).

> Außerdem dürfte es - auch mit den "standardisierten" (von wem
> eigentlich?) Werkzeugen - schwierig sein, illustrierende Grafiken oder
> Tabellen oder Ähnliches zu erzeugen.

Das brauchst du bei einer API-Dokumentation (und mehr machen die Tools
nicht) auch nicht.

MfG
Niels

--=20
| http://www.kolleg.de =B7 Das Portal der Kollegs in Deutschland |
| http://www.bsds.de =B7 BSDS Braczek Software- und DatenSysteme |
| Webdesign =B7 Webhosting =B7 e-Commerce =B7 Joomla! Content Management =
|
------------------------------------------------------------ ------

Re: Variablen-Bezeichnungen via For-Schleife festlegen

am 14.11.2007 15:47:18 von Christoph Herrmann

Niels Braczek schrieb:
> Finde ich nicht. Dokumentation geht vielleicht darüber hinaus, die
> Überschneidung ist IMO aber sehr groß. Zu jeder Funktion gehört ein
> Block, der zumindest die Parameter und Rückgabewerte beschreibt. Gerade
> in PHP ist das unverzichtbar. Hierbei auf die von JavaDOC vorgeschlagene
> Kommentarsyntax zu benutzen bietet sich an, weil Doxygen und PHPDoc
> damit umgehen können.

Und viele IDEs können diese ebenfalls lesen und bieten die
Beschreibungen in der Methodenliste der Autovervollständigung an.

> Das brauchst du bei einer API-Dokumentation (und mehr machen die Tools
> nicht) auch nicht.

Doxygen erstellt UML Diagramme aller Vererbungshierarchien die sogar
verlinkt sind und per Klick zur jeweiligen Klasse führen. Mehr an
Diagrammen braucht man aber eigentlich wirklich nicht.

--
Mit freundlichen Grüßen,
Christoph Herrmann

http://dragonprojects.de/

Re: Variablen-Bezeichnungen via For-Schleife festlegen

am 14.11.2007 18:23:59 von dafox

Christoph Herrmann schrieb:
> Niels Braczek schrieb:

[Grafiken und Tabellen in API-Doku]

>> Das brauchst du bei einer API-Dokumentation (und mehr machen die Tools
>> nicht) auch nicht.

> Doxygen erstellt UML Diagramme aller Vererbungshierarchien die sogar
> verlinkt sind und per Klick zur jeweiligen Klasse führen.

Gibt es da für PHP eigentlich IDEs oder Tools, die den umgekehrten Weg
ermöglichen? Also das ich das Diagram erstelle (ggf. direkt in der IDE,
ansonsten wird z.B. nach XMI konvertiert), und dann daraus die Skeletons
generiere.

> Mehr an Diagrammen braucht man aber eigentlich wirklich nicht.

Und die ganzen anderen Diagramme und Modellierungselemente, die UML 2.0
ausser Klassendiagrammen zu bieten hat, sind überflüssig? Ahja.

Re: Variablen-Bezeichnungen via For-Schleife festlegen

am 14.11.2007 18:30:37 von Christoph Herrmann

Thomas Hamacher schrieb:
> Gibt es da für PHP eigentlich IDEs oder Tools, die den umgekehrten Weg
> ermöglichen? Also das ich das Diagram erstelle (ggf. direkt in der IDE,
> ansonsten wird z.B. nach XMI konvertiert), und dann daraus die Skeletons
> generiere.

Ich bin selbst auf der Suche nach einem "ordentlichen" Programm dafür.
Ich kenne nur ArgoUML, aber dies ist sehr umfangreich und dadurch
komplex und hinterlässt in den "Skeletons" völlig unnötige Kommentare
und Tags die einfach nur stören. In wie weit man diese jedoch entfernen
kann ohne eine Neugenerierung nach einer Änderung unmöglich zu machen
habe ich nicht weiter probiert. Aber allein die Tatsache, dass die
Syntax nicht einstellbar war (ich habe es zumindest nicht gefunden) ließ
mich davon wieder abwenden. Das Gerüst ist schnell selbst erstellt und
die Diagramme "male" ich mit Violet.

>> Mehr an Diagrammen braucht man aber eigentlich wirklich nicht.
>
> Und die ganzen anderen Diagramme und Modellierungselemente, die UML 2.0
> ausser Klassendiagrammen zu bieten hat, sind überflüssig? Ahja.

Deswegen das eigentlich. ;) Das Klassendiagramm ist aber (aus meiner
Erfahrung her) das nützlichste bisher und dürfte auch für solche
Generatoren am einfachsten zu erstellen sein.

--
Mit freundlichen Grüßen,
Christoph Herrmann

http://dragonprojects.de/

Re: Variablen-Bezeichnungen via For-Schleife festlegen

am 14.11.2007 19:04:04 von dafox

Christoph Herrmann schrieb:
> Thomas Hamacher schrieb:
>> Gibt es da für PHP eigentlich IDEs oder Tools, die den umgekehrten Weg
>> ermöglichen? Also das ich das Diagram erstelle (ggf. direkt in der IDE,
>> ansonsten wird z.B. nach XMI konvertiert), und dann daraus die Skeletons
>> generiere.

> Ich bin selbst auf der Suche nach einem "ordentlichen" Programm dafür.
> Ich kenne nur ArgoUML, aber dies ist sehr umfangreich und dadurch
> komplex und hinterlässt in den "Skeletons" völlig unnötige Kommentare
> und Tags die einfach nur stören.

Das ArgoUML werde ich mal testen, danke für den Tip. Ich glaube zwar,
dass ich das irgendwann sogar schonmal installiert hatte, aber da gab es
so einen Export wohl noch nicht (oder ich hab's übersehen).

> In wie weit man diese jedoch entfernen
> kann ohne eine Neugenerierung nach einer Änderung unmöglich zu machen
> habe ich nicht weiter probiert.

Das Problem mit den unnötigen Kommentaren und Tags kriegt man vielleicht
mit nem Code-Formatter automatisiert in den Griff. Nur wird dann, wie du
schon schreibst, wahrscheinlich das Neugenerieren in die Hose gehen. Das
wäre mir allerdings nicht ganz so wichtig, weil es mir in erster Linie
um das initiale Generieren des Gerüsts geht. Ich werde das die Tage mal
ausprobieren und dann berichten.

> Aber allein die Tatsache, dass die
> Syntax nicht einstellbar war (ich habe es zumindest nicht gefunden) ließ
> mich davon wieder abwenden. Das Gerüst ist schnell selbst erstellt und
> die Diagramme "male" ich mit Violet.

Das Gerüst ist schnell selbst erstellt, die Setter- und Getter sind
schnell erstellt (gerade bei reinen ValueObjects macht das Spaß), die
Doc-Comments sind schnell erstellt, das OR-Modell ist schnell erstellt,
die Routen (Zend-Framework) sind schnell getippt, ...

Alles im allem ist es aber lästig, immer wieder und wieder den selben
Scheiss zu tippen. Mit ner Java-IDE (ich nutze den Oracle JDeveloper)
kann man sich das alles Generieren lassen und grafisch (teils mit UML)
entwerfen.

Macht ja auch Sinn, denn wenn die Software entworfen ist, sind ja alle
Informationen praktisch schon vorhanden. Also ist es ja nur noch eine
Fleißarbeit die Diagramme und Metadaten in Code umzusetzen. Ich hatte
mir an dieser Stelle mehr vom Zend Studio erhofft, aber das bietet ja
ausser "Doc-Comment einfügen" gar keine Möglichkeit der Code-Generierung
und auch Plugins kann man nicht dafür schreiben.

[OT] Re: Variablen-Bezeichnungen via For-Schleife festlegen

am 14.11.2007 20:15:29 von Christoph Herrmann

Thomas Hamacher schrieb:
> Das ArgoUML werde ich mal testen, danke für den Tip. Ich glaube zwar,
> dass ich das irgendwann sogar schonmal installiert hatte, aber da gab es
> so einen Export wohl noch nicht (oder ich hab's übersehen).

Installieren? Muss man doch gar nicht, besteht ja nur aus Java JAR
Archive. :) Generate Code heißt die Funktion glaub ich, sieht man aber
in der Menüleiste oben als Unterpunkt. Kannst dann auswählen für welche
Sprache die Quellcodes generiert werden sollen.

> Das Problem mit den unnötigen Kommentaren und Tags kriegt man vielleicht
> mit nem Code-Formatter automatisiert in den Griff. Nur wird dann, wie du
> schon schreibst, wahrscheinlich das Neugenerieren in die Hose gehen. Das
> wäre mir allerdings nicht ganz so wichtig, weil es mir in erster Linie
> um das initiale Generieren des Gerüsts geht. Ich werde das die Tage mal
> ausprobieren und dann berichten.

Das Neugenerieren wäre schon wichtig, da man ja auch gerne die Sachen in
UML pflegen will und einfach mit dem Quellcode synchronisieren. Ich kenn
das nur con einem Dialog Hilfsprogramm von C++, der erstellt auch den
kompletten Quellcode, braucht aber ebenfalls Tags um sich zurecht zu
finden. Entfernt man diese, weiß das Programm nicht mehr welche Elemente
es gibt und macht dann vieles doppelt hin.

Aber da ArgoUML auch PHP Code interpretieren kann und daraus UML
Diagramme erstellen kann (also der Weg andersrum) verstehe ich nicht,
warum es dann die Tags benötigt als Hilfe.

> Alles im allem ist es aber lästig, immer wieder und wieder den selben
> Scheiss zu tippen. Mit ner Java-IDE (ich nutze den Oracle JDeveloper)
> kann man sich das alles Generieren lassen und grafisch (teils mit UML)
> entwerfen.

Ich nutze Eclipse, da ich auch Java entwickle. Wenn ich bedenke was dies
alles für Java unterstützt ist die vollständige Unterstützung von PHP
noch weit entfernt (allein der Code beautifuler ist ein Traum). Debugger
hab ich auch noch nicht zum laufen bekommen. ^^

> Macht ja auch Sinn, denn wenn die Software entworfen ist, sind ja alle
> Informationen praktisch schon vorhanden. Also ist es ja nur noch eine
> Fleißarbeit die Diagramme und Metadaten in Code umzusetzen. Ich hatte
> mir an dieser Stelle mehr vom Zend Studio erhofft, aber das bietet ja
> ausser "Doc-Comment einfügen" gar keine Möglichkeit der Code-Generierung
> und auch Plugins kann man nicht dafür schreiben.

Für den Preis was es kostet würde ich davon auch viel mehr erwarten. :)

--
Mit freundlichen Grüßen,
Christoph Herrmann

http://dragonprojects.de/