Vergleich dynamischer Skriptsprachen (ASP und PHP)

Kostenlos oder kommerziell ?
das ist hier die Frage
Halbjahresarbeit
Thema: Vergleich der serverseitigen Skriptsprachen ASP und PHP
von Johannes Borgwardt
Inhaltsverzeichnis
1.
Einleitung
2.
Geschichte
2.1.
Geschichte der Skriptsprache PHP
2.2.
Geschichte der Skriptsprache ASP
3.
Nutzen und Anwendungsmöglichkeiten
4.
Vergleiche
4.1.
Formularauswertung
4.2.
Schleifen
4.2.1.
if – else – Schleife
4.2.2.
while – Schleife
4.2.3.
for – Schleife
4.2.4.
case – Schleife
4.2.5.
Zusammenfassung - Schleifen
4.3.
Verbindung zu Datenbanken
4.4.
Funktionen und Prozeduren
4.5.
Zusammenarbeit zwischen Dateien
4.6.
Vergleich bei einer komplexeren Anwendung
5.
Zusammenfassung
6.
Anhang
7.
Quellen
-2-
1. Einleitung
Im 2. Halbjahr des Schuljahres 2000/2001 habe ich am Wahlfach „Informatik & Astronomie“
teilgenommen. In diesem Halbjahr habe ich HTML1 erlernt. Seitdem interessiere ich mich für
Webdesign und das Erstellen von Webseiten und Webinhalten.
Vor cirka einem Jahr, Ende 2. Halbjahr des Schuljahres 2001/2002, habe ich mich der
Homepage-AG angeschlossen die die Schulhomepage verwaltet und seit diesem Schuljahr
leite ich diese AG. Die Idee zu dieser Arbeit entstand Im Dezember 2003 als eine AG
gegründet wurde die sich mit dem Programmieren dynamischer Webinhalte beschäftigt. Dank
der Teilnahme an dieser AG habe ich ASP2 erlernt. Seitdem stelle ich mir die Frage wo der
Unterschied zwischen ASP und PHP3 liegt.
Um dies zu ergründen schreibe ich diese Arbeit. In folgenden Texten möchte ich die
Unterschiede zwischen PHP und ASP herausfiltern und mehrer direkte Vergleiche ziehen. Ich
werde mich mit der Entwicklungsgeschichte beider Skriptsprachen beschäftigen, mit dem
Nutzen und den Anwendungsbereichen beider Sprachen und mit einer Menge Vergleiche
auseinandersetzen. Um alle Vergleiche selbst zu skripten habe ich mir im Rahmen dieser
Arbeit zusätzlich PHP beigebracht, denn ich bin der Meinung das man Vergleiche nur dann
anführen kann wenn man sich in den zu vergleichenden Kategorien auskennt.
2. Geschichte
Als das World Wide Web (WWW) 1991 gegründet wurde war jeglicher Inhalt auf Webseiten
statisch, er konnte also nicht dynamisch verändert werden. Der einzige der den Inhalt
verändern konnte war der Verwalter der Webseite, der Webmaster.
Der durch das World Wide Web gegebenen Versuchung auf eine schier unendliche Anzahl
von Information zugreifen zu können konnten viele nicht widerstehen. Da die NutzerGemeinschaft des World Wide Web stetig größer wurde mussten neue Technologien
entwickelt werden um Informationen darzustellen.
Unternehmen wollten sich im Web präsentieren und dazu musste der Inhalt an den Nutzer
angepasst werden, der Inhalt von Webseiten musste dynamisch werden.
1
Hypertext Marked Language
Active Server Pages
3
PHP: Hypertext Preprocessor
2
-3-
1993 wurde CGI (Common Gateway Interface) veröffentlicht.
Mit Hilfe von CGI konnten Webseiten dynamische Inhalte vermitteln, man konnte abhängig
von festlegbaren Faktoren steuern was für Informationen ausgegeben werden. Das war ein
großer Fortschritt, nur gab es ein kleines Problem mit CGI.
CGI Skripte mussten in einer Programmiersprache geschrieben werden, die beiden
Populärsten Programmiersprachen zu dieser Zeit waren C und Perl. Da diese
Programmiersprachen sehr komplex sind war es nicht sehr einfach CGI Skripte zu erstellen.
Nur wenige Administratoren beherrschten C oder Perl, und sie waren auch nicht bereit eine so
komplexe Programmiersprache zu erlernen nur um beispielsweise das Datum auf ihren Seiten
ausgeben zu können. Mit der Zeit wurden neue Technologien und Möglichkeiten zur
dynamischen Ausgabe von Daten und Informationen gesucht und gefunden.
2.1. Geschichte der Skriptsprache PHP
1995 entwickelte der 17jährige Däne Rasmus Lerdorf eine Sammlung von Perlskripten mit
der man Zugriffe auf Webseiten erfassen konnte, diese Sammlung nannte er PHP/FI, das steht
für „Personal Home Page (Tools) / Forms Interpreter“ oder für „Professional Homepage“ (es
gibt unterschiedliche Angaben).
Lerdorf entschied sich PHP/FI im Sinne der Debian Free Software Guidelines4 freizugeben.
Damit war der Grundstein für die Weltweite Verbreitung dynamisch generierter Webseiten
gelegt.
Schon bald musste die Funktionalität von PHP/FI erweitert werden, so musste zum Beispiel
die Kommunikation mit Datenbanken ermöglicht werden, da Perl dies nicht leisten konnte
entwickelte Lerdorf eine neue Version die mit der Programmiersprache C erstellt wurde.
Die neue Version besaß eine Perl ähnliche Syntax und war in der Lage mit Datenbanken zu
kommunizieren und Formulare auszuwerten, sie war leider relativ instabil.
Im November 1997 wurde PHP/FI 2.0 offiziell veröffentlicht, die Software wurde auf rund
50.000 Webseiten eingesetzt. Obwohl PHP/FI 2.0 schon von mehreren Programmierern
erstellt wurde leistete Lerdorf immer noch den größten Teil.
Schon kurz nach der Veröffentlichung von PHP/FI 2.0 wurde die erste Alpha Version von
PHP3 ausgearbeitet.
4
siehe http://www.de.debian.org/social_contract.de.html#guidelines
-4-
Ebenfalls 1997 begannen Andi Gutmans und Zeev Suraski in Kooperation mit Rasmus
Lerdorf PHP/FI 2.0 umzubauen, das Ergebnis mit dem Namen PHP3 wurde als offizieller
Nachfolger angekündigt. Das Projekt sollte unter einem neuen Namen veröffentlicht werden
Als neuer Name wurde PHP gewählt, das für "Hypertext Preprocessor" steht.
Nach einer neunmonatigen öffentlichen Testphase wurde PHP 3.0 im Juni 1998
veröffentlicht.
Ende 1998 wurde PHP3 von mehreren Zehntausend genutzt, cirka 10% aller Webseiten
nutzen PHP3, dieser Erfolg lässt sich durch die gute Infrastruktur und Erweiterbarkeit
erklären, viele Nutzer trugen mit eigenen Modulen zur Verbreitung bei, aber auch die gute
Anbindung an eine Vielzahl von Datenbanken trug zum Erfolg von PHP3 bei.
Kurz nach der Veröffentlichung begannen Gutmans und Suraski mit der Weiterentwicklung
von PHP3. Ziel war es den PHP-Kern umzuschreiben um die Leistungsfähigkeit zu erhöhen
und einen modulareren Quelltext zu erhalten. Die neue PHP-Version sollte auf einer neuen
Engine aufbauen, der „Zend“-Engine, der Name setzt sich aus den Vornamen Zeev und Andi
zusammen.
1999 wurde die neue Engine das erste mal eingesetzt, ein Jahr später wurde PHP4
veröffentlicht. PHP4 wird von mehreren Hunderttausend Entwicklern genutzt und kommt auf
mehreren Millionen Webseiten zum Einsatz, schätzungsweise 20% aller Webseiten.
An der neuen Engine „Zend2“ und an PHP5 wird bereits gearbeitet.
Da PHP konstant von einer großen Menge Entwicklern weiter entwickelt wurde und wird
gehört es heute zu einem der größten Durchbrüche im Bereich der dynamischen
Webseitenentwicklung.
2.2. Geschichte der Skriptsprache ASP
In Redmond, Washington, USA wurde 1996 von Microsoft ein neues Projekt mit dem Namen
„Denali“ vorgestellt. Benannt nach einem Nationalpark in Alaska stellte Denali einen riesigen
Durchbruch in der dynamischen Webseiten Generierung dar. So war es zum ersten mal
möglich Inline-code zu verwenden, also Skriptcode in die bestehende HTML-Datei zu
implementieren.
-5-
Denali stellte keine eigene Skriptsprache dar, es basierte auch nicht auf Perl oder C sondern
auf Microsofts Skriptsprache Visual Basic Script (VBScript). VBScript ist der englischen
Sprache nachempfunden und soll so die Anwenderfreundlichkeit erhöhen.
Die Denali – Tester freundeten sich schnell mit der neuen Technologie an und noch im selben
Jahr wurde Denali unter dem Namen Active Server Pages (ASP) veröffentlicht.
Innerhalb von vier Jahren erschienen vier Versionen.
In ASP 2.0 wurde es vereinfacht externe Objekte einzubinden. In ASP 3.0 wurde der
Debugger verbessert um eine verbesserte Fehlerkontrolle zu gewährleisten. Außerdem wurde
das Buffer-System verbessert wodurch ASP Seiten schneller geladen wurden.
ASP wird mit dem Server Produkt von Microsoft vertrieben, dem „Internet Information
System“ (IIS) auch dieses Produkt wurde in den 4 Jahren oft verändert und ASP blieb von
diesen Veränderungen nicht verschont.
Zusätzlich gab es eine Vielzahl an kleineren Veränderungen die hier nicht aufgezählt werden,
da sie nicht weiter wichtig sind.
Die neueste Version heißt ASP.NET, da sie von der breiten Masse noch nicht genutzt wird
beziehe ich mich weiterhin auf ASP 3.0.
3. Nutzen und Anwendungsmöglichkeiten
In Bezug auf den Nutzen und die Anwendungsmöglichkeiten der Skriptsprachen PHP und
ASP stellt sich nicht die Frage ob beide Skriptsprachen genutzt werden sondern wie sie
genutzt werden, also wo die besten Anwendungsmöglichkeiten liegen.
Da beide Skriptsprachen für die gleichen Bereiche genutzt werden lohnt es nicht hier eine
Unterscheidung zu treffen, nach eigenen Beobachtungen bin ich jedoch zu dem Schluss
gekommen das ASP eher von Firmen beziehungsweise Webseiten mit einem
kommerziellen Interesse und PHP von Webseiten genutzt wird deren Betreiber kein oder
geringeres Eigenkapital haben.
Der hauptsächliche Zweck der Skripte ist die Erstellung dynamischer Inhalte, das schließt
ein riesiges Anwendungsspektrum ein. Zu diesem Spektrum gehört ein personalisiertes
Webangebot also zum Beispiel an den Leser angepasste News, Newsgroups, Termine und
sonstige Informationen aber auch an den Nutzer angepasste Werbung gemeint.
-6-
Eine sehr gute Anbindung an Datenbanken ist die am meisten genutzte
Anwendungsmöglichkeit da man somit ganze Einkaufsysteme mit Artikellisten und
Lagerbeständen anfertigen kann.
Ein Anwendungsbereich der mehr unbeäugt bleibt und doch sehr wichtig ist, ist die
Auswertung und das senden von Formularen. Aber auch der Versand von eMails oder die
Kontrolle falscher Datenausgaben ist ein Anwendungsschwerpunkt.
4. Vergleiche
Im folgenden Kapitel möchte ich anhand von konkreten Anwendungsbeispielen direkte
Vergleiche ziehen.
Zu erst werde ich ein einfaches Formular auswerten, dann möchte ich verschiedene
Schleifenarten vergleichen und schließlich mit dem wichtigsten Anwendungsbereich, der
Arbeit mit einer Datenbank und der Funktionsweise zwischen Dateien. Mit einer
schwierigeren Problemstellung, der Funktionsweise eines dynamischen Loginscript
möchte ich das Gebiet der Komplexität der Sprachen und damit die direkten Vergleiche
abschließen.
4.1. Formularauswertung
Mit dem Formular soll man raus finden ob ein Suchtext in einer angegebenen Suchmenge
vorhanden ist, die Suchmenge lege ich hier in einem Array 5 fest, im Normalfall würde
man die Suchmenge in einer Datenbank speichern aber das würde dieses Beispiel zu sehr
koplizieren. Um ein Formular auswerten zu können wird zuerst ein Formular benötigt,
dazu benötigt man nur HTML, jedoch muss man festlegen mit welcher Skriptsprache man
das Formular bearbeiten möchte, ich beginne mit PHP:
formular.html:
(1)
(2)
(3)
(4)
(5)
5
<html>
<head>
<title> Formular </title>
</head>
<body>
Ein Array ist eine Art Container in der man einer Variable mehrere Werte zuweisen kann.
-7-
(6)
(7)
(8)
(9)
(10)
(11)
(12)
<form action=’formauswert.php’ method=’post’>
Suchtext: <input type=’text’name=’suchtext’>
<br>
<input type=’submit’ name=’submit’ value=’Suche starten’>
</form>
</body>
</html>
Dieses Formular hat mit dynamischem Inhalt natürlich noch nichts zu tun. es werden
lediglich die eingetragenen Werte an die in Zeile 6 mit dem Attribut ACTION angegebene
Datei geschickt. Graphisch sieht dieses Formular so aus:
Damit gewinnt man zwar keinen Designerwettbewerb aber es erfüllt genau den Zweck
den ich hier verdeutlichen will.
Ich komme nun zur formauswert.php an die der angegebene Suchtext übermittelt wird:
(1) <?php
(2) $suchmenge = array('Heinz', 'Klaus', 'Alfred', 'Karl', 'Hannes');
(3) for($i = 0; $i<5; $i++)
(4) {
(5) if($suchmenge[$i] == $_POST['suchtext'])
(6)
{
(7)
echo($_POST['suchtext'] . "ist Bestandteil der Suchmenge und
(8)
steht an" . $i . "ter Stelle");
(9) }
(10)
else
(11)
{
(12)
echo($_POST['suchtext'] . "ist nicht Bestandteil der
(13)
Suchmenge");
(14)
}
(15) }
(16) ?>
Zuerst wird mit der Funktion array() ein Feld erstellt in dem 5 Vornamen gespeichert
werden. Dann wird mit einer for – Schleife (siehe Abschnitt 4.1.2.3.) für jedes Element
des Arrays geprüft ob das gerade gewählte Element mit dem gesuchten Text
übereinstimmt, diese Überprüfung geschieht mittels einer if – Schleife (siehe Abschnitt
4.1.2.1.). Die Variable $_POST[´suchtext´] ist ein automatisch generiertes Array das
erstellt wird wenn ein Formular abgeschickt wird, es beinhaltet alle Informationen die das
Formular übermittelt. Die Variable $i ist eine einfache Laufvariable. Per echo Befehl wird
-8-
in Form von Text ausgegeben ob der gesuchte Text Teil des Arrays ist oder nicht. Der
Punkt im echo Befehl dient als Verbindung zwischen Strings (Stringconnector).
Nun im Vergleich dazu die ASP-Variante, die HTML muss dazu nur geringfügig
verändert werden. Die einzige Veränderung die Vorgenommen werden muss ist die
Änderung der Dateiendung im ACTION Attribut von „.php“ in „.asp“.
Hier nun die formauswert.asp
(1) <%
(2) Dim suchmenge(4)
(3) Dim suchtxt
(4) Dim i
(5) suchtxt = request.form("suchtext")
(6) suchmenge = Array('Heinz', 'Klaus', 'Alfred', 'Karl', 'Hannes')
(7) for i = 0 to i = 4
(8)
if suchmenge[i] = suchtxt
(9)
response.write(suchtxt & " ist Bestandteil der Suchmenge und" &_
(10)
"steht an " & i & "ter Stelle")
(11)
else
(12)
response.write(suchtxt & " ist nicht Bestandteil der Suchmenge")
(13)
end if
(14) next
(15) %>
Am Anfang werden hier die Variablen definiert, dies geschieht mit dem Befehl Dim.
Die Variablendeklaration ist zwar nicht zwingend notwendig bietet sich jedoch an da es
ohne zu Fehlern kommen kann. Das Array wird in Zeile 2 deklariert und es werden 5
mögliche Array-Werte reserviert (0 bis 4), in Zeile 6 wird das Array mit Datensätzen
gefüllt. In Zeile 5 wird das Ergebnis aus dem Formular in einer Variable gespeichert, dies
geschieht nicht wie bei PHP automatisch. Ansonsten funktioniert alles wie bei PHP, nur
die Befehle sehen etwas anders aus, so wird eine Schleife nicht mit geschweiften
Klammern sondern mit direkten Schleifentyp spezifischen Befehlen eingeleitet und
beendet. Als Strtingconnector dient hier ein &-Zeichen. Ein Nachteil von ASP ist das
wenn ein Befehl über eine Zeile geht beide Teile mit einer &_-Zeichenkombination
verbunden werden müssen. Ein Vorteil gegenüber PHP ist das ein Befehl nicht mit einem
Semikolon beendet werden muss, welches man erfahrungsgemäß oft vergisst.
-9-
4.2. Schleifen
4.2.1. if – else – Schleife
Die if – else – Schleifen beider Sprachen wurden zwar schon in Abschnitt 4.1.1. gezeigt
sollen hier aber noch mal erläutert werden.
Eine if – else – Schleife ist in Wirklichkeit keine Schleife da sie nur einmal durchlaufen
wird, sie ist vielmehr eine Art Kreuzung, eine Entscheidungsfrage der Form „Wenn der
gewählte Parameter zutrifft dann tue das andernfalls tue jenes“.
Dabei ist zu beachten das der zweite Teil (andernfalls tue jenes) beziehungsweise else
optional ist.
In PHP sieht eine if – else – Schleife wie folgt aus:
(1)
(2)
(3)
(4)
(5)
(6)
(7)
(8)
if(Parameter)
{
tu irgendetwas
}
else
{
tu etwas anderes
}
Parameter steht hier für die Bedingung von der die if – else – Schleife abhängt.
Das Semikolon am Ende der if – else – Schleife ist optional, es kann jedoch zu schweren
Fehlern kommen wenn man das Semikolon setzt und die if – else – Schleife sich in einer
anderen Schleife befindet. Die Anweisungen in Zeile 3 beziehungsweise 7 sind natürlich
nur symbolisch und erfüllen keinerlei Zweck.
Die Anweisungen was getan werden soll wenn eine Bedingung greift oder gegebenenfalls
nicht stehen geschweiften Klammern, das hat den Nachteil das wenn mehrere Schleifen in
einander verschachtelt sind man schnell die Übersicht verliert. Vor allem da der PHPParser keine Fehlermeldung der Art Ende der Anweisung nicht gefunden sondern das ihm
eine Variable fehlt.
Dazu der ASP Vergleich:
(1) if Parameter then
(2)
tu irgendetwas
(3) else
- 10 -
(4)
tu etwas anderes
(5) end if
Abgesehen von den Befehlen der if – else – Schleife ist hier alles gleich. Es ist zu
beachten das diese Befehle vom Typ der Schleife abhängig sind, jeder Schleifentyp hat
eigene Befehle, das hat den Vorteil das man die Schleifen nicht verwechseln kann wenn
man sie in einander verschachtelt, nicht wie bei PHP wo jede Schleifenanweisung in
geschweiften Klammern steht.
4.2.2. while – Schleife
while – Schleife mit PHP umgesetzt:
(1) while(Parameter)
(2) {
(3)
tu etwas
(4) }
Da wo Parameter steht kommt dann eine Bedingung hin, dies bestimmt wann die while –
Schleife ausgeführt werden soll. Wenn die Bedingung true ergibt, wird der Schleifen-Teil
ausgeführt, wenn die Bedingung false ergibt, wird der Schleifen-Teil logischerweise nicht
ausgeführt. Wenn PHP am Ende angekommen ist springt es wieder zu while(Parameter)
und prüft die Bedingung nach. Wenn diese wieder true ist wird wieder der Schleifen-Teil
ausgeführt. Nach dem Ende des Schleifenteils prüft PHP wieder die Bedingung. Wenn
diese true ist wird wieder der Schleifenteil ausgeführt. PHP führt also solange den
Schleifenteil aus solange die Bedingung true ergibt.
While ist Englisch und bedeutet während, in der Programmiersprache eher solange.
"Solange die Bedingung wahr/true ist, führe den Schleifen-Teil aus". Die Bedingung sollte
kein konstanter Ausdruck sein, sondern ein Ausdruck mit Variablen, deren Inhalt sich in
der while – Schleife ändert. Denn sonst kann es passieren dass eine Endlosschleife
entsteht, die nicht aufhört, bis der Webserver das Script nach 30 Sekunden automatisch
beendet.
PHP kennt zusätzlich noch eine do – while – Schleife:
(1) do
- 11 -
(2) {
(3)
tu irgendetwas
(4) }
(5) while(Parameter);
Das Semikolon hinter dem while ist notwendig, bei der normalen while – Schleife ist es,
wie bei der if – Schleife, unerwünscht. Der Unterschied der do – while – Schleife zur
while – Schleife ist der, dass die do – while – Schleife mindestens 1 mal ausgeführt wird,
da die Überprüfung der Bedingung erst am Schleifenende erfolgt. Wenn in der Bedingung
false steht, wird diese Schleife genau 1 mal durchgeführt.
Die Benutzung einer do – while – Schleife kommt in einem PHP-Projekt nicht so häufig
vor, wenn nicht sogar gar nicht. Bei der while – Schleife spricht man von einer
Kopfgesteuerten – while – Schleife und bei einer do – while – Schleife von einer
Fußgesteuerten – while – Schleife.
Bei ASP beziehungsweise VBScript heißt die while – Schleife do – loop – Schleife.
Wieder gibt es eine Kopf- und eine Fußgesteuerte Variante. Wichtig im Vergleich zu PHP
ist das es hier nicht nur die Möglichkeit while (solange etwas gilt) sondern auch die
Möglichkeit until (bis etwas nicht mehr gilt) gibt, dabei muss man einfach das while durch
ein until ersetzen und den Parameter, die Bedingung, anpassen. Ich beginne mit der
Kopfgesteuerten – do – loop – Schleife:
(1) do while Parameter
(2)
tu irgendetwas
(3) exit do
(4)
tu wieder etwas
(5) loop
Die „exit do“ Anweisung ist optional, sie wird ausgeführt wenn der Parameter ein false
ergibt. Nun die Fußgesteuerte – do – loop – Schleife:
(1) do
(2)
tu irgendetwas
(3) exit do
(4)
tu wieder etwas
(5) loop while Parameter
Hier steht die Überprüfung wieder am Ende, also wird die Schleife mindestens einmal
ausgeführt.
- 12 -
Die Möglichkeit statt while ein until zu nutzen hat gegenüber PHP durchaus Vorteile da
PHP hierzu noch mehr Schleifen benötigt die sich auf die Ausführgeschwindigkeit
auswirken.
4.2.3. for – Schleife
Die for – Schleife benutzt man sehr häufig wenn man einen Programmcode genau x – mal
ausführen lassen möchte. Der Aufbau der for – Schleife ist wie folgt:
(1) for(Startanweisung; Bedingung; Durchlaufanweisung)
(2) {
(3)
tu etwas
(4) }
Diese Schleife wird auch wieder nur solange ausgeführt solange die Bedingung erfüllt ist.
Dies ist also wie eine while – Schleife. Sie hat aber noch ein paar extra Felder, in die man
Anweisungen hinein schreiben kann. In das Feld Startanweisung kommt eine Anweisung
die 1 mal ausgeführt wird, nämlich beim starten der for – Schleife. Diese Anweisung wird
auch ausgeführt, wenn die Bedingung schon vor dem Schleifeneintritt false ist. An der
Stelle Durchlaufanweisung kommt eine Anweisung die bei jedem Schleifendurchlauf
ausgeführt wird. Diese Anweisung wird immer vor einem nächsten Schleifendurchlauf
ausgeführt (außer beim 1. Durchlauf).
Eine Typische Anwendung für eine for – Schleife ist diese hier:
(1)<?php
(2) for($i=0; $i<5; $i++)
(3) {
(4)
echo("Die Zahl ist ".$i."<br>");
(5) }
(6)?>
Dieser Code gibt folgendes aus:
Die Zahl ist 0
Die Zahl ist 1
Die Zahl ist 2
Die Zahl ist 3
Die Zahl ist 4
- 13 -
Hier wird zuerst die Startanweisung ausgeführt, die Variable $i wird initialisiert und auf 0
gesetzt. Dies ist die so genannte Laufvariable für die for – Schleife.
Mit ASP umgesetzt sieht das so aus:
(1) for Startanweisung to Bedingung
(2)
tu etwas
(3) next
Für obiges Beispiel sieht die ASP – Variante so aus:
(1)
(2)
(3)
(4)
(5)
<%
for i = 0 to i = 4
response.write("Die Zahl ist " & i & "<br>")
next
%>
Die Ausgabe in Browser ist exakt dieselbe.
Im Vergleich zu PHP fehlt hier die Eingabe der Durchlaufanweisung, diese funktioniert
automatisch, das heißt das bei jedem Schleifendurchlauf die Variable i um eins erhöht
wird.
4.2.4. case – Schleife
Die case – Schleife ist eine Kontrollstruktur wie die if – Schleife. Sie führt nur bestimmte
Programmteile aus, wenn bestimmte Bedingungen erfüllt sind. Doch eine case – Schleife
macht nur bei Vergleichen von Ausdrücken und Variablen Sinn. Wenn der Ausdruck oder
die Variable den Wert xy hat, dann wird der Teil abc ausgeführt, wenn der Wert ghj ist,
wird ein anderer Teil ausgeführt.
Mit if – Schleifen würde das so aussehen:
(1) <?php
(2) $name = 3;
(3) if($name = = 0)
(4) echo("Der Wert der Variable ist 0");
(5) if($name = = 1)
(6) echo("Der Wert der Variable ist 1");
(7) if($name = = "hi")
(8) echo("Der Wert der Variable ist hi");
- 14 -
(9) if($name = = 3)
(10)
echo("Der Wert der Variable ist 3");
(11)?>
Eine case – Schleife ist etwas anders aufgebaut als mehrere if – Schleifen, hat aber auch
Vorteile gegenüber if – Schleifen denn bei einer case – Schleife steckt alles in einer
Schleife, das erhöht die Übersicht.
Eine case – Schleife ist wie folgt aufgebaut:
(1) switch(Variable)
(2) {
(3)
case Ausdruck:
(4)
tu etwas
(5)
case Ausdruck:
(6)
tu etwas anderes
(7) };
Variable steht hier für die Variable die man überprüfen möchte, In den geschweiften
Klammern kommen dann die Zeilen „case Ausdruck:“. Der PHP-Interpreter durchläuft
dann jedes case und springt dort hin wo der Inhalt der Variable gleich dem Ausdruck
hinter case ist und arbeitet dort stehenden Code ab. Wenn eine Übereinstimmung
gefunden wurde werden alle nachstehenden case – Befehle mit abgearbeitet, dies kann
man verhindern indem man vor jedes case, mit Ausnahme des ersten, ein „break;“
schreibt, mit diesem Befehl wird die Schleife vorzeitig abgebrochen.
Das war die case – Schleife für PHP nun das ASP äquivalent:
(1) select case Variable
(2)
case Ausdruck
(3)
tu etwas
(4)
case Ausdruck
(5)
tu etwas anderes
(6) end select
Hier wird kein break oder ähnliches benötigt, bei VBScript beziehungsweise ASP wird
automatisch nur das case ausgeführt bei dem der Ausdruck übereinstimmt.
- 15 -
4.2.5. Zusammenfassung – Schleifen
In Bezug auf Schleifenn und Kontrollstrukturen kann man zusammenfassend sagen das
Schleifen mit ASP etwas komfortabler umsetzbar sind während man mit PHP mehr selbst
definieren kann und muss. Wer also schnell etwas unkompliziertes skripten will der sollte
auf ASP zurückgreifen, wer selbst viel selbst definieren will oder sehr komplexe Schleifen
brauch der wird PHP bevorzugen.
4.3. Verbindung zu Datenbanken
Das wichtigste was Skriptsprachen zu leisten haben ist das auslesen von Informationen
aus Datenbanken. Wegen Softwareproblemen muss ich die Vergleichsbedingungen leicht
verändern, als Server mit PHP Unterstützung nutze ich die Software easyPHP, in diesem
Softwarepaket ist ein Apache Server sowie MySQL-Datenbank Unterstützung integriert.
Für die ASP Unterstützung benutze ich den in Windows integrierten IIS (Internet
Information System), dieser beinhaltet keine MySQL Unterstützung. Deshalb nutze ich
hier eine Microsoft Access Datenbank.
Ich beginne wieder mit PHP (und MySQL):
(1)
(2)
(3)
(4)
(5)
$dbhost="localhost"; $dblogin="root"; $dbpwd="";
$dbname="halbjahresarbeit";
mysql_connect($dbhost, $dblogin, $dbpwd);
mysql_select_db($dbname) or
die("Verbindung zur Datenbank ist fehlgeschlagen");
Die Variablen $dbhost, $dblogin und $dbpwd definieren die Logindaten für den MySQL
Server. $dbname definiert die Datenbank auf dem Server zu der die Verbindung aufgebaut
werden soll. In Zeile 3 wird die Verbindung zum MySQL Server aufgebaut, man könnte
statt den Variablen auch direkt die Daten in Form von Strings eintragen. In Zeile 4 wird
die Datenbank ausgewählt, falls die Datenbank nicht existiert oder keine Verbindung
hergestellt wurde wird die Verbindung zum MySQL Server beendet und die
Fehlermeldung „Verbindung zur Datenbank ist fehlgeschlagen“ ausgegeben.
Anschließend kann man sich die aus der Datenbank auslesen lassen:
- 16 -
(1) $sql = "SELECT
(2)
kleidung,
(3)
farbe
(4) FROM
(5)
beispiel_db;";
(6) $result = mysql_query($sql);
(7) while($row = mysql_fetch_assoc($result))
(8) {
(9)
echo($row['kleidung'] . " --> " . $row['farbe'] . "<br>");
(10) }
Die Ausgabe sieht dann so aus(abhängig von den Daten in der Datenbank):
Kleid --> blau
Hose --> rot
Hemd --> grün
Die Funktionsweise ist sehr einfach, in der Variable $sql wird ein String gespeichert der
die Anweisungen an die Datenbank enthält, mit der Funktion mysql_query, an die wir den
String übergeben der dann als Befehl interpretiert wird, wird der Inhalt der Spalten
„kleidung“ und „farbe“ aus der Tabelle „beispiel_db“ in ein Array geschrieben das ich
$result nenne. In dem Array sind die Daten zwar gespeichert jedoch noch nicht nutzbar,
mit der Funktion mysql_fetch_assoc wird das Array „aufbereitet“, mit einer while –
Schleife gebe ich das Array einfach aus.
Das gleiche nun für ASP:
(1) strAccessDB = "beispiel"
(2) Set adoCon = Server.CreateObject("ADODB.Connection")
(3) strCon = "DRIVER={Microsoft Access Driver (*.mdb)};uid=;pwd=; DBQ=" &_
(4)
& Server.MapPath(strAccessDB)
(5) adoCon.Open strCon
(6) strSQL = "SELECT tblbeispiel.id, tblbeispiel.kleidung, tblbeispiel.farbe" &_
(7)
"FROM tblbeispiel"
(8) Set rsquery = Server.CreateObject("ADODB.Recordset")
(9) rsquery.Open strSQL, strCon
(10)
for rsquery("id") = 1 to rsquery.EOF
(11)
response.write(rsquery("kleidung") & " --> " & rsquery("farbe") &_
(12)
& "<br>")
(13)
next
Das sieht erstmal kompliziert aus, ist es auch !
- 17 -
Zu erst speichere ich den Namen der MS Access Datenbank als String. Danach kreiere ich
ein Objekt mit dem Namen adoCon6, in die Variable strCon speichere ich alle Daten die
benötigt werden um eine Datenbankverbindung zu erstellen. Anschließend wird die
Verbindung zur Datenbank aufgebaut. In der Variablen strSQL steht wieder in Form eines
Strings alle Informationen für die Datenbankabfrage. In Zeile 8 wird noch eine ADO
Komponente erstellt Mit der ich in Zeile 9 die relevanten Daten aus der Datenbank
auslese. Die Ausgabe erfolgt hier mit einer for – Schleife die alle Zeilen von der ersten bis
zum Ende der Datei (EOF = end of file) ausgibt.
Die Verbindung zu Datenbanken ist wohl das wichtigste bei der Arbeit mit dynamischen
Webseiten, PHP hat dies sehr einfach und übersichtlich gelöst. Die ASP Variante ist sehr
schwierig, das mag zwar auch daran liegen das es sich hierbei nicht um eine
Datenbankverbindung zu einem Datenbankdienst handelt aber trotzdem ist es doch sehr
umständlich.
PHP bietet hier eher eine Art Komplettpaket während ASP nur die Infrastruktur bietet in
die man alles einarbeiten muss.
4.4. Funktionen und Prozeduren
Im letzten Abschnitt tauchten bereits ein paar Funktionen auf, beide Scriptsprachen geben
die Möglichkeiz Funktionen zu schreiben, ASP gibt darüber hinaus noch die Möglichkeit
Prozeduren zu schreiben. Der Unterschied zwischen einer Funktion und einer Prozedur ist
folgender:
An eine Funktion werden Variablen übermittelt mit denen etwas getan wird und ein
Ergebnis zurück kommt. Eine Prozedur ist eher eine Art Unterprogramm, Prozeduren sind
praktisch um die Übersichtlichkeit in größeren Dateien zu gewährleisten. PHP besitzt
keine Prozeduren, das Problem der Übersichtlichkeit wird anders gelöst, wie wird im
nächsten Abschnitt erklärt.
Hier ein Beispiel für eine PHP Funktion:
(1) function addition($var1, $var2)
6
In ASP können kleinere Komponenten mit ADO(Active Data Objects) erstellt werden. Somit kann man zu
jeder OLE-DB kompatiblen Datenquelle eine Verbindung aufbauen.
- 18 -
(2)
(3)
(4)
(5)
{
$ergeb = $var1 + $var2;
return $ergeb;
};
Dies ist eine ganz einfache Funktion, sie addiert die Variablen $var1 und $var2 und gibt
das ergebnis in einer neuen Variable zurück. Aufgerufen kann die Funktion mit nur einer
Zeile werden:
(1) $ergeb = addition($var1, $var2);
Mit ASP funktionieren Funktionen ganz ähnlich:
(1) function addition (var1, var2)
(2)
ergeb = var1 + var2
(3)
addition = ergeb
(4) end function
Der einzige nennenswerte Unterschied ist der das der Rückgabewert nicht per return oder
vergleichbarem definiert wird sondern damit das der Funktion der Wert zugewiesen wird.
Das aufrufen funktioniert wie bei PHP.
Des Weiteren bietet ASP noch Prozeduren oder Unterprogramme(Subprograms) diese
funktionieren ähnlich:
(1) sub gruss (username)
(2)
response.write("Hallo " & username)
(3) end sub
Wenn die Variable username beispielsweise Klaus ist würde die Prozedur „Hallo Klaus“
ausgeben. Aufgerufen wird die Prozedur so:
(1) gruss(username)
Prozeduren und Funktionen sind sehr praktisch, da sie den Schreibaufwand verringern und
die Übersichtlichkeit fördern. PHP besitzt keine Prozeduren braucht diese jedoch nicht
wie der nächste Abschnitt zeigt.
- 19 -
4.5. Zusammenarbeit zwischen Dateien
Bei großen Projekten ist es immer wichtig zu wissen wie Dateien zusammen agieren. PHP
bietet hier ein sehr einfaches Prinzip, mit einem Befehl namens include kann man den
Quelltext einer anderen Datei einfach in die aktuelle Datei einbinden. Der include Befehl
ist ein äquivalent zu ASP Prozeduren. Der include Befehl wird wie folgt genutzt:
(1) include("functions.php");
Hier würde der Quelltext der functions.php beim ausführen des Skriptes eingefügt.
ASP hat nichts Vergleichbares zum include Befehl, es gibt allerdings die Möglichkeit
direkt zu einer anderen Datei zu springen:
(1) response.redirect("part2.asp")
Mit diesem Befehl würde man zur part2.asp „weiter geschickt“ werden.
4.6. Vergleich bei einer komplexeren Anwendung
Als komplexeres Anwendungsbeispiel beschreibe ich ein Loginscript mit
Passwortkontrolle, für die PHP Variante nutze ich wieder eine MySQL Datenbank, für
ASP eine Microsoft Access Datenbank Zu erst wird wieder ein HTML Formular als
Eingabemaske benötigt:
<html><head></head><body>
<form action='login_check.php' method='post'>
<table>
<th>
<td colspan='2'>
<h2>login</h2>
</td>\n");
</th>\n");
<tr>\n");
<td>\n");
Name:
</td>
<td>
<input type='text' name='loginname'>
- 20 -
</td>;
</tr>
<tr>
<td>
Passwort:
</td>
<td>\n");
<input type='password' name='loginpasswort'>
</td>
</tr>
<tr>
<td colspan='2'>
<input type='submit' name='submit' value='login'>
</td>
</tr>
</table>
</form>
</body></html>
Nun die PHP die das Passwort überprüft und falls es richtig ist zur login_index.php
verlinkt:
(1)
(2)
(3)
(4)
(5)
(6)
(7)
(8)
(9)
(10)
(11)
(12)
(13)
(14)
(15)
(16)
(17)
(18)
(19)
(20)
(21)
(22)
(23)
(24)
(25)
<?php
mysql_connect("localhost", "root", "");
mysql_select_db("halbjahresarbeit") or
die("Verbindung zur Datenbank ist fehlgeschlagen");
$loginname = $_POST['loginname'];
$loginpass = $_POST['loginpasswort'];
$sql = "SELECT
name,
passwort
FROM
halbjahresarbeit_pwd
WHERE
name = '".$loginname."' AND
passwort = MD5('".$loginpass."');";
$result = mysql_query($sql) OR die(mysql_error());
$row = mysql_fetch_assoc($result);
if(isset($row))
{
include("login_index.php");
}
else
{
echo("falsche Logindaten <a href='login.html'>zurück</a>");
}
?>
- 21 -
Am Anfang, Zeile 2 bis 4, wird eine Verbindung zur Datenbank hergestellt (siehe 4.3.), in
Zeile 5 und 6 werden die Variablen $loginname und $loginpass aus dem automatisch
generiertem Array extrahiert, denn MySQL kann nicht mit Arrays arbeiten. In den Zeilen
7 bis 16 wird die Datenbank abgefragt, in der Tabelle wird nach einer Übereinstimmung
zwischen dem Namen und dem Passwort gesucht, es ist zu beachten das das Passwort mit
einem Algorithmus mit dem Namen MD5 verschlüsselt gespeichert wird, dies ist ein
Einwegverschlüsselungs-Algorithmus, er kann nicht dekodiert werden, um aber das
Passwort abzufragen wird die Eingabe aus dem Formular kodiert und dann werden beide
Strings verglichen (Zeile 14).
Für die ASP-Variante muss im HTML Formular nur die Dateiendung des ACTION
Attributes von .php auf .asp geändert werden.
Hier die ASP Variante:
(1)
(2)
(3)
(4)
(5)
(6)
(7)
(8)
(9)
(10)
(11)
(12)
(13)
(14)
(15)
(16)
(17)
(18)
(19)
(20)
(21)
(22)
<%
loginname = Request.Form("loginname")
strAccessDB = "halbjahresarbeit"
Set adoCon = Server.CreateObject("ADODB.Connection")
strCon = "DRIVER={Microsoft Access Driver (*.mdb)}; "&_
"uid=;pwd=; DBQ=" & Server.MapPath(strAccessDB)
adoCon.Open strCon
Set rsCheckUser = Server.CreateObject("ADODB.Recordset")
strSQL = "SELECT tblpwd.Passwort FROM tblpwd"&_
"WHERE tblpwd.name ='" & loginname & "'"
rsCheckUser.Open strSQL, strCon
If NOT rsCheckUser.EOF Then
If (Request.Form("loginpasswort")) = rsCheckUser("Passwort") Then
response.redirect("login_index.asp")
Else
response.write("ungültiges Passwort<a href="&_
"login.html>zurück</a>")
End If
else
response.write("ungültiger Name<a href= login.html>zurück</a>")
End If
%>
Zu Beginn wird der loginname aus den Formulardaten extrahiert, die Zeilen 3 bis 11
stellen eine Datenbankverbindung her (siehe 4.3.) es wird das Passwort ausgefiltert das
zum Namen des im Formular eingetragenen Namen gehört. Wenn eine Übereinstimmung
gefunden wurde wird das Passwort mit dem aus dem Formular verglichen und der
Browser bekommt die Anweisung zur login_index.asp zu springen.
- 22 -
Beide Skripte ähneln sich stark, doch haben Tests ergeben das das PHP Skript ca. 1
Sekunde und bei stark belastetem Arbeitsspeicher des Servers ca. 3 Sekunden schneller
ist. Ein Nachteil am ASP Skript ist das man das Passwort nicht so einfach verschlüsseln
kann wie bei PHP.
5. Zusammenfassung
ASP und PHP sind zwei serverseitige Skriptsprachen die dynamische Webinhalte
generieren. Beide Sprachen entstanden als die Technologie und die Entwicklung des
World Wide Web noch in den Kinderschuhen steckte, beide Sprachen ähneln sich stark
und werden auf den selben Gebieten benutzt. Doch es gibt auch eine große Zahl an
Unterschieden. Die Vergleiche in Kapitel 4 haben gezeigt das es in wichtigen Details
wichtige Unterschiede gibt, so funktionieren Schleifen zwar ähnlich, jedoch sind die
Schleifen in PHP etwas komplexer während die ASP-Schleifen komfortabler,
anwenderfreundlicher und automatisierter sind.
Des Weiteren haben alle Vergleiche gezeigt das ASP eigentlich nur eine Art Infrastruktur
ist, es bietet grundlegende Funktionen, aber schwierigere Operationen muss man in Form
von Modulen selbst einbinden. PHP dagegen ist ein Komplettpaket es enthält viele
Funktionen die man nur sehr selten brauchen wird und obwohl PHP modular aufgebaut
ist, ist es nicht so leicht zu erweitern wie ASP.
Man muss aber auch festhalten das PHP eine eigenständige Skriptsprache ist während
ASP nur eine Visual Basic Version für das Internet ist, nämlich Visual Basic Script (oder
VBScript).
Im Nachhinein muss ich zugeben das dieses Thema für eine Halbjahresarbeit zu dünner
Stoff ist, es bietet nicht genügend Tiefe und es gibt nur wenige Quellen und gute noch
weniger. Als ich das erkannte war es leider schon zu spät um auf ein anderes Thema
umzusatteln.
Zu guter letzt möchte ich noch dem Projekt Memoria Myrana danken das mir die
Möglichkeit gab mein frisch gewonnenes PHP Wissen umzusetzen. Mehrere Teile der
Skripte und viele Erkenntnisse flossen in diese Arbeit ein.
- 23 -