2 Programme hintereinander aufrufen.

[Torsten.E]

Ich möchte aus einem Link heraus ein PHP-Datei aufrufen.
Diese arbeitet einige Routinen durch und danach wird eine
andere PHP-Datei aufgerufen mit entsprechenden Parametern.

Pseudo-Code:

Beim Klick wird also "php1.php" aufgerufen.
<a href="php1.php">Klickmich</a>


--php1.php--
mach einige Routinen und soll dann

php2.php?Name=Hans&Vorname=Mueller

automatisch aufrufen.
Erst php2.php zeigt also dann auch wieder was
für den Benutzer an.


Ich hoffe das war einigermaßen verständlich.

Torsten.E

[Gaert]

Hallo,

du hast mehrere Möglichkeiten.
Einerseits kannst du mit der Funktion header() arbeiten.

header("Location: skript2.php?var1=xy");

Da du die Header manipulierst, darf vor dem Aufruf der Funktion keine Ausgabe sein - auch keine Zeilenumbrüche oder Leerzeichen.

Eine andere Möglichkeit ist das 2. Skript zu inkludieren... das kannst du auch auf 2 Arten tun:
entweder
include("http://www.example.com/skript2.php?var2=xy");
oder
include("skript2.php")
dann musst du die Variablen die du übergeben willst einfach im Skript verfügbar machen.

Eine weitere (unelegante) Möglichkeit ist auch eine JavaScript Weiterleitung mit location.href="skript2.php?var1=xy"

Gruß,

Gaert

[Torsten.E]

Hi Gaert,

so ganz gefällt mir das nicht.

Grund: Der ganze Programmablauf wird von der index.php
aus gesteuert.

So jetzt müssen aber für bestimmte Aktionen auch mal andere
Dateien zur "Abarbeitung" aufgerufen werden. Und danach sollte
einfac wieder die index.php aufgerufen werden.

Der einzige Weg ist vermutlich, dass ich in der index.php ziemlich
am anfang einfach die andere Datei dynamisch, also über eine Variable
mit include einbinde, abarbeite und dann in der index.php weitermache.

Dachte es geht halt einfacher.

Torsten.E

[undefined]

So etwas macht man auch nicht mit Headern ;)
Kann sein das Fehler drinne sind ich habe es jetzt mal so hingetipt. Du gibst mit GET, SESSION,COOKIE oder POST den Array Key zu weiteren verarbeitung. Du kannst so viele Funktionen oder Methoden ansprechen wie du möchtest.

<?php
//$ = array( $_GET['blah']=start = array(include(Seite) - Diverse andere Parameter));
$Steuerung = array("start" => array("A_Seite.php", "getparam"),
"news" => array("B_Seite.php", "setparam"));

if (isset($_GET['blah']) && $_GET['blah'] != "" ) {
$incDatei = $Steuerung[$_GET['href']][0];
$execFunktion = $Steuerung[$_GET['blah']][1];
unset($Steuerung);

if ( chop($incDatei) != "" )
include_once($incDatei);

// !!! Das ist ein Funktions Aufruf !!!!
if ($execFunktion != "")
$execFunktion();
}
?>

[Gaert]

Original geschrieben von undefined
So etwas macht man auch nicht mit Headern ;)

Also nach seiner ersten Frage kann man das sehr wohl mit headern machen...
Ich verwende übrigens einen ähnlichen Ansatz wie du für solche Dinge, aber da er ein PHP Anfänger ist wollte ich ihn nicht verwirren...

Mein Ansatz mit OOP:

Index Seite:


<?PHP
/* Master Includes */
require_once("./config.inc.php");
require_once("./master.inc.php");

$exec = $_REQUEST['exec'];
if ($exec == "") {
$exec = "Index";
}

//Start session
SPT_DBSession::startSession();

//Parse URL string
$execdata = SPT_Execute::parseExec($exec);

//Include requested class
require_once("./class/".$execdata['class'].".class.php");

//Create new application class and execute constructor
$application = new $execdata['class'];


//Execute requested method
if ($execdata['method'] != "") {
SPT_Execute::execMethod($application,$execdata);
}

//Render output
$application->render();
?>

SPT_Execute.class.php:


....
public static function parseExec($exec) {
if (Execute::$crypt) {
$exec = $_SESSION['exec'][$exec];
}

$result = array();

$r1 = explode(".",$exec);

if (!in_array($r1[0],$GLOBALS['_APP']['classes'])) {
echo "Class is not registered: <b>".$r1[0]."</b>";
die();
}

$result['class'] = $r1[0];

$exec = $r1[1];

$exec = str_replace("(",",",$exec);
$exec = str_replace(")","",$exec);

$arr = explode(",",$exec);
if (count($arr)) {
$result['method'] = $arr[0];
$result['args'] = array_slice ($arr, 1);
}

return $result;
}
...

public static function execMethod($object,$execdata) {
if (!method_exists($object, $execdata['method'])) {
echo "Method does not exist: <b>".$execdata['class'].".".$execdata['method']."()</b>";
die();
}
return call_user_func_array(array(&$object,$execdata['method']),$execdata['args']);
}
....


Aufgerufen wird das ganze z.B. mit:
index.php?exec=Klasse.methode(arg1,arg2,arg3)
bzw
index.php?exec=Klasse
wenn man das Skript komplett ohne argumente über den Konstruktor starten möchte.

Damit keiner rumpfuscht wird exec im produktiven Einsatz mit md5 gehasht und in der Session registriert.

Wer an den kompletten Skripten interessiert ist kann mir ne PM schreiben - ich verschicke das ganze gerne - wurde allerdings für PHP5 entwickelt!

[undefined]

Wie ich sehe arbeitest du auch fleissig an PHP5, sind viele neue und hilfreiche Verbesserungen enthalten greade im OOP bereich, nur leider immer noch sehr Buggy. Hatte heute erst wieder zwei bei ctype und libXml entdeckt :rolleyes:

[Torsten.E]

Gaert die Lösung ist wirklich gut gemeint,

aber im Augenblick für mich noch leider ein wenig
zu "hoch". Ich beschäftige mich zwar schon ein
wenig mit den Classen, bin aber erst noch am
Anfang der ganzen Sache.

Mal gucken, wie ich weiterkomme :-)

Torsten.E

[Gaert]

Die war ja auch eigentlich nicht für dich gedacht ;) .
Ich hab das ganze auch schon mal für PHP4 gemacht, aber PHP5 ist für OOP einfach besser geeignet (aber noch Welten weg von einer wirklich gescheiten OOP).
Wenn du kleine Fragen hast kannst du auch gerne mal per ICQ anfragen... hab meine Nummer gerade eingetragen.

[elrond]

ich bevorzuge aus verschiedenen Gründen die Variante, dass, egal was der benutzer macht, er in jedem Fall die index.php aufruft.

Das Vorgehen ist dabei sehr einfach:
Ich habe am ende der index.php ein switch, das in verschiedene unterfunktionen verzweigt. die können dann Ihrerseits in der index.php selbst stehen oder aber auch in einer anderen zu Beginn eingebundenen Datei.

Kann sein dass das nicht sonderlich elegant ist, aber dafür leicht zu verstehen und zu pflegen (wenn man ein wenig Disziplin bei der Vergabe der Funktionsnamen hält).

[Gaert]

@elrond:
Das ist sicherlich ne feine Sache, allerdings sollte man darauf achten, dass man unnötige Includes unbedingt vermeidet... das frisst Performance wie Sau (hab ich vom Großmeister Rasmus Lerdorf persönlich)!
Ich hatte daher eine Zeitlang das Konzept alles in die Index Datei zu packen. Sobald aber mehrere Leute an einem Projekt arbeiten wirds echt unübersichtlich und schwer Änderungen zu koordinieren.
Daher hab ich mich entschlossen jeder Funktionalität meiner Applikationen eine eigene Klasse zu spendieren und nur diese zu inkludieren.
Die Erfahrung Zeigt, dass die Entwicklung der Applikationen dadurch erheblich leichter und strukturierter vorangeht - mittlerweile haben sich sogar Leute die aus dem Java Umfeld kommen damit angefreundet.

[elrond]

da hast du sicherlich recht. Ich binde immer eine datei *_functions.php ein, die eine Sammlung der wichtigsten immer wieder benötigten funktionen darstellt. Bei sehr speziellen sachen mache ich das include natürlich erst an der stelle wo's gebraucht wird.

[Torsten.E]

Die Includes verwende ich auch nur dort, wo es unbedingt
nötigt ist. Am Anfang die wichtigsten Dateien und dann nur
noch bei Bedarf.

Klassen verwende ich für verschiedene Aktionen.
Z.B. Adress-Eingabe, Adress-Suche, Adress-WasWeisIch.
Alles in einer Datei und über die Klassen wir der ganze Rums
dann aufgerufen.

Der Weg über die INDEX.PHP gehe ich im Augenblick auch.
Nur dachte ich mir halt, ich könnte mir den Weg sparen,
einen "riesen" CASE am Anfang aufzurufen um die unterschiedlichen
Dateien aufzurufen.

Torsten.E

[elrond]

den großen Vorteil für einen zentralen Einstieg über die index.php sehe ich in der garantierten authentifizierung und dem expliziten herstellen einer programmumgebung bzgl. Datenbankverb. , Setzen von Pfaden usw.