PHP Include mit Parametern im Link

[PieDie]

Moinsen,

ich hab ein Problem mit der include()-Funktion in PHP.

Ich mächte einer include()-Funktion einen Link/Dateinamen mitgeben, der aber nicht nur den Dateinamen enthält, sondern auch Parameter.

Folgendermaßen bekommt PHP den Link:

<a href="index.php?ziel=blub.php&param=var_leeren=1"" target="_self">EinLink</a>

Im aufgerufenen Skript "index.php" nehme ich die beiden Parameter und führe sie zusammen:

$ziel = $ziel.'?'.$param; 

[/PHP]

Lasse ich mir das echoen, gibts: [b]blub.php?var_leeren=1[/b]

Sieht aus, wie es soll.

Im Skript [b]index.php[/b] will ich nun über [b]include($ziel);[/b] diese Seite (blub.php?var_leeren=1) in die Seite einbinden, kassiere aber nur die Fehlermeldung

Warning: include(blub.php?var_leeren=1) [function.include]: failed to open stream: No such file or directory in /var/www/html/ba/test/index.php on line 41

Warning: include() [function.include]: Failed opening 'blub.php?var_leeren=1' for inclusion (include_path='.:/usr/share/pear') in /var/www/html/ba/test/index.php on line 41

Include ich nur [b]blub.php[/b] klappts. Wenn ich über die Adresszeile direkt [b]blub.php?var_leeren=1[/b] eingebe, kann ich die Seite aufrufen. Die include-Anweisung kommt damit aber nicht zurecht.

Was mache ich falsch?

[MaddinMV]

<a href="index.php?ziel=blub.php&param=var_leeren=1"" target="_self">EinLink</a>

musst du die sonderzeichen vielleicht escapen?

   <a href="index.php\?ziel\=blub.php\&param\=var_leeen\=1" target="_self"> Ein Link </a> 

kann das hinkommen? habs nicht versucht^^

[ZuVieL]

ich verstehe dein problem nicht ganz,

die parameter übergibst du doch so oder so, die brauchst du doch nicht im include befehl übergeben

$ziel = "blub.php";

include($ziel);

wenn du nun $ziel includet hast, kommst du doch an zB $var_leeren ran.

wo is das problem?

[PieDie]

@Maddin:

Ne, das ist so schon in Ordnung, das ist good-old-plain-HTML.

Und Du hast an den falschen Stellen escaped - die " wollen escaped werden. Oder gehst Du nach einem anderen Schema vor?

@ ZuViel:

Ich versteh dich nicht wirklich - was meinst Du? Ich übergebe der Seite index.php den Parameter $ziel mit dem inhalt blub.php und $param mit dem Wert var_leeren=1.

Das ist allerdings nur ein Workaround. Ich war mir nicht sicher, ob PHP mit einem verschachtelten Link der Marke index.php?ziel=blub.php?var_leeren=1 klarkommt. Wegen der Fragezeichen und so weiter. Daher das ziel-param-Gefrickel.

However: Ich habs eben hinbekommen:

Link:

<a href="index.php?ziel=blub.php?var_leeren=1">EinLink</a>

In PHP includet man dann:

include ("http://SubDomain.TopLevelDomain.de/test/".$ziel);

[/PHP]

Alternativ dazu kann man auch den Text der Datei in eine Variable schreiben und den dann echoen:

[PHP]
$dateiinhalt=file_get_contents ("http://SubDomain.TopLevelDomain.de/test/".$ziel);
echo $dateiinhalt;

Danke für eure Antworten.

[MaddinMV]

haette die sonderzeichen zwischen den " --- "escaped, aber war mir ja eyh nicht sicher, wenn du es hinbekommen hast, ist doch fein^^ grtz hierzu

[geloescht_JesterDay]

Im Skript index.php will ich nun über include($ziel); diese Seite (blub.php?var_leeren=1) in die Seite einbinden, kassiere aber nur die Fehlermeldung

Include ich nur blub.php klappts. Wenn ich über die Adresszeile direkt blub.php?var_leeren=1 eingebe, kann ich die Seite aufrufen. Die include-Anweisung kommt damit aber nicht zurecht.

[...]

Was mache ich falsch?

Du denkst falsch. Wenn du das über die Adresszeile eingibst, wird die Seite über den Webserver aufgerufen. Ein include in php bindet die angegebene Datei aus dem Dateisystem direkt in das auszuführende Skript ein. Das ist ein riesiger Unterschied.

Bei einem include wird nichts anderes getan als die angegebene Datei geöffnet und an der Stelle des includes in das Skript kopiert, wie wenn du das mit Copy&Paste machen würdest.

Wenn du also sowas machst:

$var_leeren=1;

include($ziel);


[/php]

dann ist die Variable $var_leeren für den Code der in der Datei $ziel angegeben ist Verfügbar, und zwar als globale Variable. Nach einem include ist es genauso, wie wenn der Code aller includeten Dateien in der ausgeführten Datei stehen würde.

Das ist ein riesen Unterschied zum Vorgehen, wenn du das über den Webserver aufrufst.

EDIT:

Nur der Vollständigkeit halber...

[php]
include("http://url/blubb.php?var_leeren=1");

würde gehen wie du das dir vorstellst. Aber wenn man sich das ansieht schüttelt es einen ja schon

[PieDie]

include("http://url/blubb.php?var_leeren=1");

[/php]

würde gehen wie du das dir vorstellst. Aber wenn man sich das ansieht schüttelt es einen ja schon

So in der Art mach ich das ja:

[PHP]
include ("http://SubDomain.TopLevelDomain.de/test/".$ziel);

Oder meinst Du noch was anderes?

Wenn nein: wie könnte man es denn hübscher/eleganter machen?

[Eupinkepank]

Wenn ich dieses Programm sehe, wachsen mir Haare auf dem Rücken.

Sag uns doch mal was das Ding überhaupt machen soll...

Ein "include" fügt lediglich das an der Stelle ein, was das inkludierte Programm liefert.

Wenn Du also mit Deinem Programm auf z.B. Neue Internetpräsenz bist, und dann ein Include auf "www.subdomain.meineDomain.de/wasweissich.php?paramater=12" machst, bekommst Du dort kein PHP Programmcode, sondern interpretiertes HTML.

[edit]

Ein Include mit führendem "http://...." sollte es in keinem Programm der Welt geben!

Programme, die Du inkludierst, sollten immer UNTERHALB oder parallel zu "html" (oder halt "htdocs" oder wie auch immer dieser Ordner bei Dir heisst) liegen.

Es mag auch Ausnahmen geben, dann solltest Du aber wissen was Du tust und das scheint hier nicht der Fall zu sein.

[/edit]

[PieDie]

Wenn ich dieses Programm sehe, wachsen mir Haare auf dem Rücken.

Dann sag mir bitte, wie ich es besser machen kann.

Über ein einfaches

include ($ziel);

[/PHP]

geht es nicht. Die Dateien liegen auf dem Webserver im gleichen Verzeichnis. Das Mitgeben der Parameter scheint PHP sauer aufzustoßen, denn ohne lässt sich die Seite aufrufen.

Wie lässt sich das anders lösen?

EDIT:

Was soll es machen? es soll schlicht eine Seite einbinden, die Parameter enthält. So, als hätte man einen Link angeklickt.

Ich möchte ein Frame-basiertes Seitenlayout in ein anderes umbauen.

[code] <? $ziel = $_GET['ziel']; echo" <!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\"> <html> <head> <title>Navigation</title> <meta name=\"author\" content=\"bla\"> <link href=\"CSS/Style.css\" type=\"text/css\" rel=stylesheet> </head> <body> <table width=\"100%\"> <tr> <td>"; include ('titel.php'); echo" </td> </tr> </table> <table width=\"100%\"> <tr> <td> <table> <tr valign=\"top\"> <td width=\"30%\">"; include ('navigation.php'); echo" </td> <td>"; if ($ziel != '') { echo $ziel; include ("http://blub.tld.de/test/".$ziel); } echo" <td> </tr> <table> </body> </html>"; ?> [/code]

Ich weiß, Tabellendesign ist out, aber zum anfangen langts :floet:

In der navigation stehen Links mit Parametern, die ich beim Seitenaufruf laden will. Wahrscheinlich mach ich da was grundfalsch (so wie ich mich kenne:D).

[geloescht_JesterDay]

Wenn nein: wie könnte man es denn hübscher/eleganter machen?

Wenn die Datei nicht wirklich auf einem anderen Server liegt, dann machst du das einfach über das Dateisystem.

also

  include("/pfad/zur/Datei.php");

[/php]

Dieser Datei brauchst du keine Parameter übergeben, da die Datei einfach in den Code deines Skripts kopiert wird und dann entprechend auch ausgeführt.

Also richtig hübsch und elegant machst du das, wenn in deiner ausgelagerten Datei nur Funktionen stehen (mit "normalem" Code geht es auch, ist dann aber alles andere als hübsch oder elegant).

Also ung. so:

[php]
# includeDatei.php

function doSomething($aParam)
{
return "übergebener Parameter: $aParam";
}

und die Datei bindest du dann im eigentlichen Skript ein:

// am schönsten machst du das irgendwo "zentral", 

// also ganz am Anfang des Skripts o.ä.

include("/pfad/includeDatei.php");

...

$aVar = "x";


echo doSomething($aVar);

...

[/php]

So ergibt das einen schönen, sauberen, modularen Code.

Und wenn das wirklich auf einem anderen Server liegt, dann solltest du dir überlegen, ob du das nicht bei dir auf den Server legst. Es ist nämlich nicht immer zugelassen, include über http-zu machen. (kann man AFAIR über die fopen-Wrapper steuern). Und falls du das doch so machen musst, dann nimm phps als Endung oder Typ. phps = php-source und wird uninterpretiert von Server ausgegeben (sollte zumindest).

Dann brauchst du allerdings genausowenig Parameter übergeben.

Der einzige Grund warum man sowas macht wie du es da tust ist der, dass man ein (fremdes) Skript aufruft und dessen Ergebnis haben will, nur dessen Ergebnis. Und das auch nur wenn man es nicht anders lösen kann.

EDIT:

Dein Code ist sehr unsauber. an zig Stellen ein include nur um etwas bestimmtes da anzuzeigen.

Sauber machst du die includes zentral an einer Stelle und die Ausgaben als Funktion. Und dabei geben die Funktionen nur was zurück und geben selber nix aus. Dann weißt du nämlich immer genau wann und wieso du was ausgibst und kannst das auch alles so steuern wie du es willst.

Du kannst dann z.B. auch sowas machen:

[php]

include("titel.php");
include("navigation.php");
include("content.php");

$ausgabe = getTitel();
$ausgabe .= getNavigation();
$ausgabe .= getContent();

...

echo $ausgabe;

Aber du solltest die überlegen wo es sinnvoll ist, die einzelnen Bereiche in eigene Dateien auszulagern. Ich hab es anfangs auch sehr übertrieben weil ich dachte es ist sauberer dann. Es wird aber nur sehr sehr unübersichtlich jeden kleinen Mist in einer eigenen Datei zu haben

[Eupinkepank]

Hi!

Du sagst: Tabllen sind out.

Das finde ich nun icht, aber egal.....

Dein Layout ist eigentlich in ungfähr so, wie man es sich wünscht.

Jedoch solltest Du Dir überlegen, die Auwertung (also die Engine, die entscheidet wo, was inkludiert wird) auszulagern.

Nehmen wir folgendes an:

Du hast eine Seite, die sich, wie ja auch in Deinem Fall, die Inhalte dynamisch zusammensucht.

Welche Inhalte gibt es? (Nur Beispiele)

1. Navigation --->nennen wir $navi

2. linker Bereich --->nennen wir $leftFrame

3. mittlerer Hauptbereich --->nennen wir $mainFrame

4. rechte Bereich --->nennen wir $rightFrame

5. footer --->nennen wir $footer

Nun wird z.B. diese URL aufgerufen:

http://www.meinedomain.de?navi=1&left=4&mid=8&right=11

[/PHP]

Zentrale Datei ist Deine Index.php

Dort ist fix das Tabellendesign in HTML hinterlegt (Das hast Du ja schon).

Nun ist ganz oben in der Index.php ein include auf eine Datei.

Wir nennen sie "engine.php"

also:

[PHP]
...
include("engine.php");
...

So könnte die engine.php z.B. aussehen:

<?

if($_GET['navi']==1){

$navi='navi_1.php';

}


if($_GET['left']==4){

$leftFrame='left_4.php';

}


if($_GET['mid']==8){

$mainFrame='mid_8.php';

}


if($_GET['right']==11){

$rightFrame='right_11.php';

}

if(!isset($_GET['footer'])){

$footer='footer.php';

}



?>


[/PHP]

Nun wird die index.php durchlaufen.

an den Stellen wo die einzelnen Blöcke dargestellt werden sollen, kommt dann das hier:

[PHP]
....
include("navigation/$navi");
....
include("linker_brereich/$leftFrame");
....
include("hauptbereich/$mainFrame");
....
include("rechter_bereich/$rightFrame");
....
include("footer/$footer");
....

Was hast Du nun erreicht?

1. Niemand kann durch das blosse ansehen Deiner URLs erraten, wie der Dateiname lautet.

2. Du hast eine "saubere" index.php, die Du komplett in HTML machen kannst, lediglich die includes müssen halt in php Tags stehen.

3. Du hast eine saubere Verzeichnisstruktur und kannst auch später mal gezielt Änderungen vornehmen.

4. Du kannst jederzeit OHNE viel Aufwand Punkte hinzufügen oder entfernen.

5. Du hast durch die engine.php eine weitere Abstraktionsebene geschaffen, die es einem potentiellen Angreifer etwas schwerer macht. Wenn Du so verfährst kannst Du "register Globals" auch auf "Off" stellen. Die Register Globals sind eines der größten Sicherheitsrisiken.

Bei Fragen: Einfach fragen!

[PieDie]

@Eupinke:

Was Du da machst ist ja im Prinzip das, was ich auch mache, nur lasse ich die Zwischenebenen Weg und habe die URL etwas transparenter sichtbar.

Letztenendes bekomme ich doch genauso diese dämlichen Fehlermeldungen, weil include gefälligst nur bla.php will, und nicht bla.php?blub=1...

Ob ich nun aus einem Link heraus in die Variable bla.php?blub=1 schreibe, oder hart in einer anderen Datei - dürfte keinen unterschied machen. Text bleibt Text.

Sei es denn, man kloppt immer ein http://... davor. Macht das einen unterschied? (*anfängt zu testen*). Also, wird das die "Sicherheit" nicht beeinträchtigen? Du sagst ja, dass man das bei Todesstrafe lassen soll.

@JesterDay: Ehrlichgesagt verstehe ich nicht wirklich, was Du da machst :confused: *Brett vorm Kopf*

EDIT:

Nochmal: die Dateien liegen ALLE im gleichen Verzeichnis auf demselben Server. Deshalb verstehe ich die Fehlermeldungen auch nicht

[Eupinkepank]

@PieDie:

Ich gehe mal davon aus, dass Du noch an den Anfängen der php Programmierung stehst...

Aus diesem Grund sei Dir verziehen.

Wenn Du keinerlei Abstraktionsebenen zwischen Deinem Frontend (also dem was der Benutzer in seinem Browser sieht) und Deiner Engine (also dem php Programm, welches dahinter steht) schaffst, ist das ein Angriffspunkt für jeden der Dir Böses will.

wenn Du z.B.

meinedomain.de?new_link=blub.php

schreibst, so kann jeder von aussen Dein Programm beeinflussen.

Es sei denn, Du schaffst eine Abstraktionsebene.

In diesem Fall prüfst Du also, ob der Inhalt von $_GET['new_link'] überhaupt "blub.php" sein darf.

Ferner....

Es mach keinen, aber auch wirkliich gar keinen Sinn, ein Programm zu inkludieren, welches nicht innerhalb der gleichen Domäne läuft.

Wenn Du das dennoch brauchst, ist Dein Programm sehr schlecht durchdacht worden und Du solltest es neu schreiben bzw. abändern.

Noch ganz wichtig....

Zu inkludierende Programme gehören ALLE in ein Verzeichnis, welches ausserhalb vom DOCUMENT_ROOT liegt... Also in ein Verzeichnis, welches durch den Webbrowser nie direkt erreicht werden kann.

Am Wichtigsten....

zu inkludirende Programme MÜSSEN immer mit .php enden.

Sollte dennoch mal ein böser Bube an diese Programme herankommen, so bekommt er nur das interpretierte HTML, nicht aber den php Quelltext.

Es gibt Leute, die nenne diese Programme gerne .inc oder so.... Das ist aber sehr gefährlich.

[PieDie]

@PieDie:

Ich gehe mal davon aus, dass Du noch an den Anfängen der php Programmierung stehst...

Aus diesem Grund sei Dir verziehen.

Ja, ich bin noch am Anfang...

Wenn Du keinerlei Abstraktionsebenen zwischen Deinem Frontend

[...]

In diesem Fall prüfst Du also, ob der Inhalt von $_GET['new_link'] überhaupt "blub.php" sein darf.

Macht Sinn, danke für das Beispiel. Jetzt versteh ich das zumindest.

Ferner....

Es mach keinen, aber auch wirkliich gar keinen Sinn, ein Programm zu inkludieren, welches nicht innerhalb der gleichen Domäne läuft.

Wenn Du das dennoch brauchst, ist Dein Programm sehr schlecht durchdacht worden und Du solltest es neu schreiben bzw. abändern.

Tu ich auch nicht. Alles liegt im selben Verzeichnis des selben Webservers.

Zu inkludierende Programme gehören ALLE in ein Verzeichnis, welches ausserhalb vom DOCUMENT_ROOT liegt... Also in ein Verzeichnis, welches durch den Webbrowser nie direkt erreicht werden kann.

Das ist ein Projekt, das nur innerhalb der Firma, und hier auch nur mit selbstgestricktem Login "betretbar" ist. Direkter Aufruf ohne Login hat eine Fehlermeldung zur Folge.

Dieses Konzept stammt übrigens nicht von mir. Ich trage nur einen Teil dazu bei. Dooferweise war das Frame-Design von mir, weil ich zu dem zeitpunkt noch nix anderes Konnte, und wir schnell was brauchten. So hat sich das dann entwickelt. Und nun würde ich das gerne ummodeln.

zu inkludirende Programme MÜSSEN immer mit .php enden.

Sollte dennoch mal ein böser Bube an diese Programme herankommen, so bekommt er nur das interpretierte HTML, nicht aber den php Quelltext.

Es gibt Leute, die nenne diese Programme gerne .inc oder so.... Das ist aber sehr gefährlich.

Das weiß ich auch schon

Wie löse ich das denn am besten?

Das Layout sieht aus wie oben gepostet, die Verzeichnisstruktur sei mal so:

IMAGES

index.php

bla.php

blö.php

Wie verklicker ich PHP, dass ich die Ausgabe von bla.php so haben will, wie sie kommen würde, wenn ich sie per link (bla.php?parameter=1) aufrufen würde.

Sorry, falls es oben schon irgendwo steht, aber PHP verwirrt mich ziemlich oft. Meistens mit seinen Variablen (SESSION ist ziemlich unberechenbar ) und diesem Linkgehabe

[Eupinkepank]

ich mach mal ganz langsam....

Du willst also die "bla.php" inkludieren?

Dein Aufruf sollte nun so aussehen: (z.B. natürlich nur )

index.php?file=bla&parameter=1

Irgendwo in der Index.php kommt dann der Include auf bla.php

Und in dieser bla.php wertest Du die $_GET['parameter'] aus.

eine "blö.php" sollte es nicht geben...

Nenne sie bitte "bloe.php"

ein include("bla.php?parameter=1") ist im Grunde genommen Kokolores und somit Müll.

[PieDie]

Ich habs gerallt :upps *Brett vorm Kopf auseinanderbrech*

Vielen Dank für deine Geduld und Hilfe :e@sy

BTW: mir fällt grade auf, dass in der Adresszeile tatsächlich immer der die ganze Adresse mit allem drum und dran an Parametern zu sehen sind. Ich werde mal versuchen, das mit den Zwischenschichten nach deinen Vorschlägen umzusetzen (und melde mich bei Fragen wieder ).

Aber was JesterDay meint, wäre trotzdem interessant, zu wissen. So ganz hab ich das nicht verstanden.

[geloescht_JesterDay]

@JesterDay: Ehrlichgesagt verstehe ich nicht wirklich, was Du da machst :confused: *Brett vorm Kopf*

Hmmm....

Ok. Du willst deinen Code für eine Datei aufteilen, so dass er in verschiedenen Dateien liegt. Ob das immer so gut ist sei dahingestellt und sollte aber auf jeden Fall hinterfragt werden, wenn es nicht unbedingt nötig oder der Code z.B. in mehrere Skripten unabhängig voneinander genutzt wird. Am Ende verwirrt es einen nur selber in zig Dateien nachsehen zu müssen immer.

Aber bei dir ist es erstmal so...

Also du hast z.B. den Teil der den Titel für die Seite generiert in eine eigene Datei ausgelagert. Diese Datei bindest du einfach ein ("inkludierst sie") und damit war es das für dich und der titel ist ausgegeben.

Bei einem Anfänger kann man das gerade noch durchgehen lassen, schöner Code ist aber was anderes

Wenn du dir den Code deiner Hauptseite ansiehst, dann siehst du da nur den include Befehl, was sonst alles passiert weißt du erstmal nicht. Klar kann man ja einfach in der Datei dann nachsehen, aber schön ist das nicht, wenn die eigentliche Ausgabe über etliche Dateien verstreut ist.

Änderungen und Fehlersuche wird dadurch extrem behindert und erschwert.

Am schönsten ist es, wenn du nur an einer Stelle, kontrolliert, deine Ausgaben machst. Damit weißt du immer genau wo du hingucken musst wenn es um die Ausgabe geht.

Den Code selber kannst du aber ruhig aufteilen, das ist sogar von Vorteil.

Um diese 2 Paradigmen jetzt zu verbinden machst du folgendes: Der ausgelagerte Code für das, was ausgegeben werden soll gibt selbst nichts aus, sondern liefert das, was ausgegeben werden soll nur zurück. Etwas das etwas zurückliefert ist im allgemeinen eine Funktion. Daher werden deine Codeteile für die Ausgaben in Funktionen geschrieben.

Bei dir sieht es im Moment so ung. aus:

Die Datei für den Titel:

# titel.inc.php (das ist der Name den die Datei hat,

  deren Inhalt gleich folgt)


Echo "<H1>Ich bin der Titel</h1>";

[/php]

und die Hauptdatei:

[php]
...
echo "bla";
include("titel.inc.php");
echo "blubb";
...

Damit sind deine Ausgaben ganz verstreut, erstens in deinem Hauptdokument und zweitens auch noch über mehrere Dateien.

Es ist möglich das so zu machen und gerade von Anfängern (aber nicht nur) wird das auch so gemacht, besser aus Entwicklersicht ist es aber, das anders zu machen.

Dazu kommen wir nochmal zur eigentlichen Natur des include-Befehls

Die include() Anweisung bindet die angegebene Datei ein und wertet diese aus.

Auf deutsch: Die angegebene Datei wird eingelesen, an die Stelle des include-Befehls kopiert und somit bei der Ausführung des Skriptes so berücksichtigt, wie wenn sie dort stehen würde, und nicht der include-Befehl.

(Das alles geschieht nur bei der Ausführung des Skriptes)

Den ausgelagerten Code kannst du also ganz normal verwenden wie jeden anderen Code in deinem Skript auch.

Zurück zur Ausgabe. Also wir wollen nicht, dass die Ausgaben irgendwo in unserem Code erfolgen. Aus diesem Grund haben wir uns entschieden, dass wir das über eine Funktion lösen. Kombiniert mit dem Include-Befehl sähe deine Lösung dann so aus:

# titel.inc.php

function getTitle()

{

  $result = "<H1>Ich bin der Titel</h1>";

  return $result;

}

[/php]

und dein Hauptskript:

[php]

include("title.inc.php");
...
echo "bla";
echo getTitle();
echo "blubb";
...

Damit hast du nur noch eine Stelle an der die ausgaben passieren. Das ist erstmal sauberer, weil du genau weißt wo du hingucken musst, wenn du was bei der Ausgabe sehen willst (die Erzeugung der Ausgaben erfolgt aber weiterhin u.U. woanders) und zweitens bringt es vorteile wenn du z.B. irgendwann mal sowas wie z.B. Cookies senden willst oder musst. Cookies (oder alle Anweisungen für den HTTP-Header) müssen vor allen anderen ausgaben gesendet werden. Wenn jetzt deine Ausgaben wild verteilt sind, und vielleicht auch noch über etliche Dateien, wird es auf jeden Fall schwieriger und aufwendiger das zu tun (vielleicht bekommst du die Daten die der Cookie enthalten soll ja erst später im Code).

Ich hab mir z.B. mittlerweile angewöhnt alles über Funktionen zu machen. eine ausnahme davon bildet das Grundgerüst der Seite.

Ein Skript sieht dann z.B. so ung. aus:

<?php

# alle möglichen INcludes, requires etc.

...

function ausgabe1()

{

  ...

}


...


function ausgabe2()

{

  ...

}

...

function berechnung1($param1, $param2)

{

  ...

}

...

function ausgabeX()

{

  ...

}



// Hier steht irgendwelcher Initialisierungscode, der auf jeden 

// Fall bei jedem aufruf des Skripts ausgeführt wird

echo "<?xml version=\"1.0\"?>

?>


<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"

     "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html>

  <head>

    <!-- Headeranweisungen -->

  </head>

  <body>

    <div>Hier steht der ganze HTML Code, der vor der 

      ersten dynamischen Ausgabe kommt</div>

    <?php echo ausgabe1(); ?>

    <div>Hier steht weiterer HTML Code</div>

    <?php echo ausgabe2(); ?>

    <div>Usw. usw.</div>

  </body>

</html>

[/php]

Noch was zur Strukturierung:

Es ist wirklich Schade, dass die meisten Programmiersprachen viel zu lasch mit sowas umgehen. Wer Pascal programmiert lernt automatisch strukturiert zu programmieren, weil die Sprache ja ausdrücklich dafür entwickelt wurde um den Studenten strukturiertes Programmieren beizubringen.

Dein Code ist viel besser lesbar (auch für andere die ihn vielleicht irgendwann mal ansehen werden oder müssen oder für dich in einem halben Jahr oder so) wenn du deinem gecode ein bisschen Struktur verleihst.

Irgendwelche Definitionen o.ä. ganz an den Anfang des Codes. Alle Includes/Requires zusammen und an eine Stelle oben im Code.

Bei pascal kannst du gar nicht anders, bei C (oder PHP) und anderen kannst du dich nur darauf verlassen, dass du dich auch daran hälst, sonst passiert es dir vielleich mal, dass du nach stundenlangem Suchen nach einem Fehler auf einen include (z.B.) stößt, der irgendwo steht wo er eigentlich gar nix zu suchen hat.

"Ein Genie beherrscht das Chaos" mag vielleicht beim Schreibtisch noch passen, aber dein Code sollte aufgeräumt sein

[PieDie]

Jetzt schnall ich das. Nochmal danke !

Zu meiner Schande muss ich gestehen, dass ich mit Pascal "groß" geworden bin. Zusätzlich hab ich etliche tausend Zeilen in Delphi geschrieben. *selfslap*

Ich hab mich einfach "planlos" in PHP gestürzt und learning by doing gemacht

Dass solche Strukturen dabei verlorengehen und garnicht zur Geltung kommen, war dann nur eine Frage der zeit (einer sehr kurzen

Mal schauen, ob ich JesterDays und Eupinkepanks Systeme verbinden kann.

Danke :e@sy

EDIT:

Noch was: Der Macker, der hier die Grundgerüste legt, sagt, er habe es so gelernt, nicht dauernd die <? ?> tags auf und zu zu machen, sondern lieber den ganzen HTML Code in <? echo "blabla" ?> zu packen und so nur ein <? ?> zu haben. Kann man irgendwo die Vor und Nachteile solcher Vorgehensweisen nachlesen? Oder kennst Du da die Gründe für, warum das so gelehrt worden sein könnte?

[geloescht_JesterDay]

Noch was: Der Macker, der hier die Grundgerüste legt, sagt, er habe es so gelernt, nicht dauernd die <? ?> tags auf und zu zu machen, sondern lieber den ganzen HTML Code in <? echo "blabla" ?> zu packen und so nur ein <? ?> zu haben. Kann man irgendwo die Vor und Nachteile solcher Vorgehensweisen nachlesen? Oder kennst Du da die Gründe für, warum das so gelehrt worden sein könnte?

Erstens: <? ist unschön, die 3 Tastendrücke für <?php wird er noch hinbekommen <? ist das verkürzte php-Open-Tag und das kann in der php.ini abgeschalten werden. Das "lange" php-Open-Tag geht immer. Außerdem hast du mit XHTML Seiten dann keine Probleme wenn du das auf dem Server abschaltest

echo "<?xml version=\"1.0\"?>

könntest du einfach im HTML stehen lassen als

<?xml version="1.0"?>

und es würde nicht versucht werden das als PHP zu interpretieren

Keine Ahnung warum das so gelehrt worden sein könnte. Aber ich war früher auch der Meinung das wäre so besser, keine Ahnung warum. Es bringt dir aber keinerlei Vorteile, nur sehr unleserlichen HTML-Code.

Eine PHP-Seite wird vor der Auslieferung vom Apache an den PHP-Interpreter gegeben. Dieser interpretiert den PHP-Code, fügt evtl. Ausgaben ein und entfernt alles PHP-mäßige und gibt es an den Webserver zurück, der es dann an den Client ausliefert. Der Interpreter geht also auf jeden Fall den kompletten Text durch und sucht nach PHP-Code. PHP-Code ist für ihn all das, was zwischen den PHP-Tags steht. Ob er diese Tags jetzt nur einmal findet oder mehrfach ist doch kein Unterschied. Selbst wenn es da zeitliche Unterschiede in der Ausführung gäbe, die wären wohl so gering, dass sie mehr als vernachlässigbar sind. Man könnte wohl auch für beide Varianten Pros und Contras bezgl. der Ausführungszeit finden. Fakt ist aber, dass vom Interpreter nur das ausgewertet wird, was zwischen den PHP-Tags steht, alles andere wird einfach 1:1 zurückgegeben. Der einzige Unterschied ist als, dass die Variante mit vielen PHP-Tags ein besser lesbares Dokument hinterlässt.

EDIT:

Ach ja, wenn du von Pascal kommst: include = uses

[PieDie]

Nachdem ich mich wieder verrannt hab, nachdem ich es doch verstanden hatte, will ichs (auch für mich) einmal dokumentieren:

Link:

index.php?ziel=bla.php[U][B]&[/B][/U]var=1

So, nun kann man das inkludieren:

$ziel = $_SESSION['ziel'];

include (ziel);

WICHTIG: (Darauf bin ich immer reingefallen) Man darf nicht einfach den Link, den man eigentlich nehmen wollte benutzen!

index.php?ziel=bla.php[U][B]?[/B][/U]var=1

Mag PHP überhaupt nicht, es sei denn, man benutzt

include ("http://blub.de/bla/".ziel) 

Das ist aber nicht schön, wie man hier ja nachlesen kann

Also einfach den Link wie er oben steht nehmen, weil die bla.php dann die mitgegebene Variable ausliest, als würde sie wirklich im Dokument stehen, und nicht nur inkludiert werden.

Fieser Stolperstein, wenn man mit meiner verqueren Logik daran geht :floet:

EDIT: und über Zwischenschichten und solche Funktionsbausteine, wie JesterDay und Eupinkepank das hier vorschlagen, sollte man sich auch noch Gedanken machen - was ein Aufwand :beagolisc

[ZuVieL]

Wieso $_SESSION, $_REQUEST oder $_GET wäre da besser angebracht, oder irre ich mich da, wieso speicherst du das ziel in der session ?

[PieDie]

Du hast recht. Ich benutze nicht $_SESSION, sondern $_GET. :upps

Hab mich beim Tippen vertan (ich sag ja, SESSIONS ärgern mich immer )

[Eupinkepank]

Hmmm....

Ok. Du willst deinen Code für eine Datei aufteilen, so dass er in verschiedenen Dateien liegt. Ob das immer so gut ist sei dahingestellt und sollte aber auf jeden Fall hinterfragt werden, wenn es nicht unbedingt nötig oder der Code z.B. in mehrere Skripten unabhängig voneinander genutzt wird. Am Ende verwirrt es einen nur selber in zig Dateien nachsehen zu müssen immer. [...]

Leider muss ich Dir da widersprechen...

Recht hast Du lediglich, wenn Du schon beim Programmieren genau weisst, dass das fertige Produkt nie wieder angefasst wird.

Musst Du allerdings mit zukünftigen Updates, oder Layoutänderungen usw. rechnen, ist es immer sehr vernünftig Design und Programm voneinander zu trennen.

Gerade beim Entwickeln von großen Projekten macht das durchaus Sinn.

Bei uns gehen wir da immer so vor.

Einer ist zuständig für das Design und Layout, also HTML und die Grafiken.

Einer ist zuständig für das Implementieren der nötigen PHP Codes in das HTML Gerüst.

Einer ist zuständig für den Entwurf und die Umsetzung der Klassen, Methoden und Funktionen, die aus dem HTML Gerüst angesprochen werden. (Stichwort OOP)

Es wird bei uns seit PHP5.1 alles in OOP gemacht, was auch durchaus Sinn macht und ich hier jedem nur ans Herz legen kann.

Gerade die Leute aus der JavaScript Ecke werden mir da wohl recht geben

Selbst hier in diesem Miniprogramm, was ja in Zukunft durchaus groß werden kann, macht es Sinn das Design vom Programm zu trennen.

Wenn das dann so geschehen ist, würde ich mir das gesamte Programm erneut vornehmen und es auf OOP umstellen.

Noch ein Tipp von mir:

Viele von euch sind wohl gerade in der Ausbildung oder sind zumidest am Lernen von PHP.

Schafft euch, um vernünftig entwickeln und debuggen zu können das Zend Studio an.

Das ist mit etwas über 300 Euro wirklich sauteuer aber es erleichtert euch die Arbeit.

Es gibt im Bereich Entwicklungsumgebungen für PHP viele Produkte, z.T. auch Shareware, allerdings können diese Dinger dem Zend Studio nicht im Geringsten das Wasser reichen.

Man kann sich das Ding erstmal herunterladen und im vollen Funktionsumfang für 30 Tage nutzen.

Zend.com

dort dann aud das Zend Studio gehen.... es lohnt sich....

Alleine der Debugger ist Weltklasse!

[geloescht_JesterDay]

Leider muss ich Dir da widersprechen...

Recht hast Du lediglich, wenn Du schon beim Programmieren genau weisst, dass das fertige Produkt nie wieder angefasst wird.

Musst Du allerdings mit zukünftigen Updates, oder Layoutänderungen usw. rechnen, ist es immer sehr vernünftig Design und Programm voneinander zu trennen.

Ich sage nichts gegen die Trennung von Design und Programm. Das Beispiel von mir oben war nur für ein kleines Projekt und eben halt ein Beispiel, weil es die Trennung von Design und Progamm auch in einer Datei so erreicht.

Es ist damit kein Problem das Layout in einem WYSIWIG-Editor zu machen. Bei HTML das nur mit Echos ausgegeben wird hingegen schon. Einzig die Stelle die dynamisch befüllt wird muss halt per PHP eingebunden werden (was aber auch bei einem WYSIWYS kein Problem darstellt. Das lässt sich bestimmt besser machen, über Template-Engines z.B., aber das muss man persönlich entscheiden (oder der Projektleiter) ob man das will und tut.

Und auch die Funktionen zum befüllen der Inhalte müssen ja nicht wie in dem Beispiel in der Layout Datei stehen. Mit ein bisschen Phantasie kommst du z.B darauf, dass das ganze was du da siehst auch das Ergebnis einer index.php sein könnte (das Ergebnis im Speicher dann), die nur etliche Includes ausgeführt hat.

Auch in großen Projekten werden wohl einzelne Layoutabschnitte kaum nur durch ein bloßes include eingebunden (und die eingebundene Datei kümmert sich dann selbst um die Ausgabe etc).

Ich meinte bloß, auch bei einer solchen Trennung sollte man überlegen was man trennt und nicht auf Teufel komm raus alles in eine extra Datei schreiben. Nicht das man gar nix trennen soll.

[Eupinkepank]

Da hst Du Recht...

Trennen "auf Teufel komm raus" macht sicherlich keinen Sinn.

Ist aber nun auch egal...

Dem PieDie wurde geholfen und nun kann er loslegen.