|
Systemvoraussetzung
- Linux
- Windows
- PHP 3
- PHP 4
- PHP 5
Datei(en)
suchmaschine.php, blaettern_grafik.php, suchmaschine.sql
Problem
Die zuvor beschriebene Problematik stellt sich auch hier bei diesem Beispiel ein.
Allerdings wollen wir diesmal die Ausgabe der Seiten mit grafischen Elementen
darstellen. Zusätzlich wird noch eine einfache Suchmaschine eingebaut.
Lösung
Wir werden in unserem Beispiel eine sehr einfache Suchmaschine erstellen,
die innerhalb einer Datenbank nach einem Suchwort sucht und die Treffer
auflistet. Zusätzlich soll sie selbstverständlich auch die Gesamtmenge der
Treffer, die aktuelle Auflistungsmenge (z. B. 33 bis 48) und die Suchzeit für
unsere Datenbankabfrage aufzeigen.
Im unteren Teil der Auflistung soll neben einer Textverlinkung für die einzelnen
Seiten jeweils eine Grafik für jede Seite angezeigt werden. Sie kennen
sicherlich die Funktionsweise von Google. Genau diesen Mechanismus werden
wir hier vereinfacht nachbauen.
Sie sehen nachfolgend eine Grafik mit der möglichen Ausgabe. Aus Darstellungsgründen
wurde die Webseite in der Breite so klein gezogen, dass sie hier
im Buch noch einigermaßen gut dargestellt werden kann.
Das Beispielskript im beiliegenden ZIP-Archiv
ist allerdings so konzipiert,
dass die Ausgabe über die komplette Webseite geht. Sie müssen allerdings die
Ausgabe der Treffer selbst modifizieren, indem Sie die Verlinkungen mit Ihrer
Datenbank verknüpfen. Dieses sollte aber keinerlei Probleme darstellen, weil
dafür nur wenige Zeilen Programmcode zu ändern sind.
Abbildung 5.2: Suche
function startTime()
@param void
@return float $time
Die Funktion startTime() erwartet keinen Parameter, sondern gibt lediglich
die aktuelle Zeit in Sekunden zurück. Dafür wird zuerst die aktuelle Zeit
in Sekunden und Mikrosekunden zerlegt (40). Im Anschluss daran werden
beide Werte addiert (41) und das Ergebnis (also die Zeit als Fließkommazahl)
zurückgegeben (43).
Dieser Wert dient uns als Startwert für die spätere Anzeige der Laufzeit unserer
Suchanfrage. Daher wird auch diese Funktion bereits zum Anfang der Suche
aufgerufen und der Wert zwischengespeichert.
038:
039:
040:
041:
042:
043:
044:
045:
| function startTime(){
$timeExplode = explode(" ", microtime());
$time = $timeExplode[1] + $timeExplode[0];
return $time;
} |
Beispiel 5.5: blaettern_grafik.php
function endTime($timer)
@param float $timer
@return float $endTime
Die Funktion endTime() berechnet die gesamte Laufzeit der Suchanfrage. Sie
erwartet als Parameter den Startwert für die Suchanfrage. Dieser Startwert
wurde bereits am Anfang der Datei mit der Funktion startTime() ermittelt.
Wieder zerlegen wir die aktuelle Zeit in Sekunden und Mikrosekunden (49),
addieren die beiden Werte (50) und subtrahieren ()
vom Ergebnis (51) den
Startwert.
Bevor wir das Ergebnis, also die Laufzeit der Suchanfrage, zurückgeben (54)
formatieren wir diesen Wert (52). Da die meisten Suchanfragen weit unter einer
Sekunde liegen, kürzen wir das Ergebnis auf drei Stellen hinter dem Komma.
047:
048:
049:
050:
051:
052:
053:
054:
055:
056: | function endTime($timer){
$timeExplode = explode(" ", microtime());
$time = $timeExplode[1] + $timeExplode[0];
$finish = $time - $timer;
$endTime = sprintf("%4.3f", $finish);
return $endTime;
} |
Beispiel 5.6: blaettern_grafik.php
function makeInfo($endTime,$seiteAktuell,$maxEintraege,$Eintraege,
$infoText)
@param float $endTime
@param integer $seiteAktuell
@param integer $maxEintraege
@param integer $Eintraege
@param string $infoText
@return string $infoText
Die Funktion makeInfo() ist für unseren Infotext zuständig, also wie viele
Treffer es gab, wie lange die Suche gedauert hat und welche Ergebnisse gerade
angezeigt werden. Eine mögliche Ausgabe könnte folgendermaßen aussehen:
| Ergebnisse 1 - 16
von ungefähr 125. (0.001 Sekunden) |
Die Funktion erwartet die Laufzeit der Suchanfrage, die per $GET übermittelte
aktuelle Seite, die maximalen Ergebnisse pro Seite, die Menge der gesamten
Ergebnisse der Suchanfrage und den Infotext. Der Infotext wird bei den Konfigurationsparametern
(später mehr dazu) festgelegt und hat die Form:
| Ergebnisse {ERGEBNIS} von ungefähr {MENGE}. ({SEKUNDEN} Sekunden) |
Im ersten Schritt ersetzen wir (59) in unserem Infotext den Flag {SEKUNDEN}
durch die Laufzeit. Danach wird der Flag {MENGE} durch die Gesamtzahl der
gelieferten Ergebnismenge ersetzt (60).
Wir berechnen im Anschluss daran, welche Ergebnisse momentan angezeigt
werden (62-63)
und ersetzen (65) die beiden Werte durch den Flag {ERGEBNIS}.
Der Infotext ist somit fertig und kann an die aufgerufene Stelle zurückgegeben
werden (67).
058:
059:
060:
061:
062:
063:
064:
065:
066:
067:
068:
069: |
function makeInfo($endTime,$seiteAktuell,$maxEintraege,$Eintraege,$infoText)
{
$infoText = preg_replace("/{SEKUNDEN}/", $endTime, $infoText);
$infoText = preg_replace("/{MENGE}/", $Eintraege, $infoText);
$start = $seiteAktuell * $maxEintraege - $maxEintraege + 1;
$end = $seiteAktuell * $maxEintraege;
$infoText = preg_replace("/{ERGEBNIS}/", "$start - $end", $infoText);
return $infoText;
}
|
Beispiel 5.7: blaettern_grafik.php
function navigationsLeiste($SitesComplete,$seiteAktuell)
@param integer $SitesComplete
@param integer $seiteAktuell
@return array $ausgabe
Die Funktion navigationsLeiste() berechnet die Gesamtzahl der anzuzeigenden
Seiten, aktiviert oder deaktiviert die Seitennummer für die Verlinkungen
und stellt die Möglichkeiten für „Eine Seite zurück“ oder „Eine Seite vor“
in einem Array dar.
Die Funktion erwartet als Parameter die kompletten anzuzeigenden Seiten,
die aktuelle per GET übermittelte Seite und die Menge der anzuzeigenden
Seitenzahlen.
Zuerst dividieren wir die anzuzeigenden Seitenzahlen durch 2 und runden
das Ergebnis ab (83). Mit diesem Wert bauen wir links und rechts um unsere
aktuelle Seitenzahl das Menü auf.
Nachfolgend ein Beispiel mit elf Seitenzahlen. Die aktuelle Seite ist hier 9.
| 11 / 2 = 5.5 abgerundet 5 |
Angenommen, wir können 30 Seitenzahlen darstellen, so wird die Ausgabe
folgendermaßen aussehen – also auf jeder Seite fünf Seitenzahlen.
4 5 6 7 8 9 10 11 12 13 14 |
Die nächsten Schritte sind lediglich Überprüfungen, ob eine Zahl oder Grafik
verlinkt oder angezeigt werden muss.
Sollte die aktuelle Seitenzahl größer als 1 sein (87), so könnte man die Darstellung
„Eine Seite zurück“ anzeigen. Daher speichern wir den Wert (Aktuelle Seite
– 1) in unser mehrdimensionales Array (89). Zusätzlich wird die Möglichkeit
gespeichert, direkt zur ersten Seite zu springen (88).
In unserem Beispiel wird diese Variable später allerdings nicht berücksichtigt.
Sie können diese aber problemlos einbinden. Sollten wir uns bereits auf der
ersten Seite befinden, so setzen wir den Wert auf FALSE (91).
Im zweiten Teil formulieren wir die Seitenzahlen (1 2 3 4 5 etc.). Wir nehmen
als Beispiel wie vorhin eine Menge von elf Seitenzahlen und die aktuelle Seite
9 als Grundlage für unsere Erklärung. Die FOR-Schleife
(95) darf bei so einer
Navigation nicht bei 0 beginnen, sondern richtet sich jeweils nach der aktuellen
Seite. In unserem Fall beginnt die Schleife bei 4 (9-5)
und durchläuft sie 11-mal
(9+5).
Falls $x größer als 0 (Null) und $x kleiner als die aktuelle Seite ist, wird
die anklickbare Seitenzahl in unser Array (98) gespeichert. Ist $x größer als
die aktuelle Seitenzahl und $x kleiner als die komplette Seitenzahl, wird die
anklickbare Seitenzahl ebenfalls in unser Array (98) gespeichert.
Trifft keines der beiden Auswahlkriterien zu, handelt es sich um eine nicht
anklickbare Seitenzahl und die Abfrage des Vergleichs (102) wird ausgeführt.
Der Wert wird dann als nicht klickbar gespeichert (103).
Falls die aktuelle Seite kleiner als die komplette Seitenzahl ist, könnte man die
Darstellung „Eine Seite vor“ darstellen. Daher speichern wir den Wert (Aktuelle
Seite + 1) in unser mehrdimensionales Array (110).
Zusätzlich wird die Möglichkeit gespeichert, direkt zur letzten Seite zu springen
(111). In unserem Beispiel wird diese Variable später allerdings nicht
berücksichtigt. Sie können diese aber problemlos einbinden. Sollten wir uns
bereits auf der letzten Seite befinden, so setzen wir den Wert auf FALSE (113).
Wir geben zum Schluss unser mehrdimensionales Array an die aufrufende
Stelle zurück (116).
080:
081:
082:
083:
084:
085:
086:
087:
088:
089:
090:
091:
092:
093:
094:
095:
096:
097:
098:
099:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118: | function navigationsLeiste($SitesComplete,$seiteAktuell,$navLeiste){
// Die Menge der angezeigten Links für die Seiten werden errechnet
$NavCeil = floor($navLeiste / 2);
// Eine Seite zurück oder zum Anfang nur anzeigen, wenn mindestens eine Seite zurück
// geblättert werden kann
if($seiteAktuell > 1){
$ausgabe['begin']['second'] = 1;
$ausgabe['begin']['first'] = $seiteAktuell-1;
} else {
$ausgabe['begin']['first'] = FALSE;
}
// Baut die Seitennavigation aúf (1 2 3 4 5 6 ... n)
for($x=$seiteAktuell-$NavCeil;$x<=$seiteAktuell+$NavCeil;$x++){
// Alle Seitenzahlen vor und nach der aktuellen Seite verlinken
if(($x>0 && $x<$seiteAktuell) || ($x>$seiteAktuell && $x<=$SitesComplete)){
$ausgabe['middle']['site'][] = $x;
}
// Die Seitenzahl der aktuellen Seite nicht verlinken
if($x==$seiteAktuell) {
$ausgabe['middle']['site'][][0] = $seiteAktuell;
}
}
// Eine Seite vor oder zum Ende nur anzeigen, wenn mindestens eine Seite weiter
// geblättert werden kann
if($seiteAktuell < $SitesComplete){
$ausgabe['end']['first'] = $seiteAktuell+1;
$ausgabe['end']['second'] = $SitesComplete;
} else{
$ausgabe['end']['end'] = FALSE;
}
return $ausgabe;
}
|
Beispiel 5.8: blaettern_grafik.php
function makeText($ausgabe,$seiteAktuell,$href)
@param array $ausgabe
@param integer $seiteAktuell
@param array $href
@return string $string
Die Funktion makeText() erstellt jetzt mit dem eben erstellten mehrdimensionalen
Array die Textausgabe der Seitenzahlen. Als Parameter erwartet die
Funktion das mehrdimensionale Array, die aktuelle Seite und den Aufbau der
Linkstruktur als Array. Diese Linkstruktur wird bei den Konfigurationsparametern
gesetzt. Wir möchten Ihnen an dieser Stelle ein Beispiel liefern.
| |
$href[0] = '<a href="'.$_SERVER["SCRIPT_NAME"].'?site={SITE}'.$extVariables.'">Zurück</a>';
$href[1] = '<a href="'.$_SERVER["SCRIPT_NAME"].'?site={SITE}'.$extVariables.'">{SITE}</a>';
$href[2] = '<a href="'.$_SERVER["SCRIPT_NAME"].'?site={SITE}'.$extVariables.'">Vorwärts</a>'; |
Wir durchlaufen wie in der vorherigen Funktion beschrieben unser Array und
füllen es mit den Tabellen und Text-Verlinkungen.
Sollte der ausgelesene ArrayInhalt
(122) größer oder gleich 1 (Eins) sein, so
könnten wir die Ausgabe „Eine Seite zurück“ anzeigen. Da wir in unserer Funktion
navigationsLeiste() den Wert für die erste Seite auf FALSE gesetzt
haben, greift hier erst bei der zweiten Seite die Abfrage.
Ist also die Seite größer oder gleich, so ersetzen wir in unserer Linkstruktur
(siehe obiges Beispiel) die notwendigen Parameter (123) für die Seitenzahl. Ist
die Seite kleiner, so speichern wir lediglich ein Leerzeichen.
Wir begeben uns wieder in die FOR-Schleife
(129) und durchlaufen das Array,
um die Seitenzahlen zu verlinken. Falls es sich bei dem Wert in dem Array
um ein weiteres Array handeln sollte (130), so handelt es sich um die aktuelle
Seite und wird daher nicht verlinkt, sondern nur als Text angezeigt.
Handelt es sich bei dem Wert nicht um ein Array (133), so müssen wir den
Wert als Seitenzahl verlinken. Wir suchen in unserem Array $href[1] nach den Flags {SITE} und ersetzen (134) diese durch die aktuelle Seitenzahl. Das
Ergebnis dieser Ersetzung hängen wir der Variablen $string an.
Sollte die aktuelle Seite kleiner als der Wert im ausgelesenen Array-Inhalt
(138) sein, könnten wir die Ausgabe „Eine Seite vor“ anzeigen. Ist die aktuelle
Seite kleiner, ersetzen wir in unserem Array $href[2] (siehe obiges Beispiel)
die notwendigen Parameter (139) für die Seitenzahl. Ist die Seite größer oder
gleich, speichern wir lediglich ein Leerzeichen (141).
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147: |
function makeText($ausgabe,$seiteAktuell,$href)
{
$string .= '<tr>';
if($ausgabe['begin']['second'] >= 1 || $ausgabe['begin']['first'] >= 1) {
$string .= '<td align="right">'.preg_replace("/{SITE}/i", $seiteAktuell-1,
$href[0]).'</td>';
} else {
$string .= '<td align="right"> </td>';
}
foreach($ausgabe['middle']['site'] as $key => $value) {
if(is_array($value)) {
$string .= '<td align="center">'.$ausgabe['middle']['site'][$key][0].
'</td>';
} else {
$string .= '<td align="center">'.preg_replace("/{SITE}/i", $value,
$href[1]).'</td>';
}
}
if($seiteAktuell < $ausgabe['end']['second'] ||
$seiteAktuell < $ausgabe['end']['first']){
$string .= '<td align="left">'.preg_replace("/{SITE}/i", $seiteAktuell+1,
$href[2]).'</td>';
} else {
$string .= '<td align="left"> </td>';
}
$string .= '</tr>';
return $string;
}
|
Beispiel 5.9: blaettern_grafik.php
function makeGraph($ausgabe,$seiteAktuell,$link,$grafik)
@param array $ausgabe
@param integer $seiteAktuell
@param string $link
@param array $grafik
@return string $string
Die Funktion makeGraph() erstellt mit dem eben erstellten mehrdimensionalen
Array die Grafikausgabe der Seitenzahlen. Als Parameter erwartet die
Funktion das mehrdimensionale Array, die aktuelle Seite, den Aufbau der
Linkstruktur und die einzelnen Grafiken als Array-Element
für die Darstellung
der Seitennavigation. Die Linkstruktur sowie die Grafiken werden bei den
Konfigurationsparametern gesetzt. Auch an dieser Stelle liefern wir Ihnen ein
Beispiel.
| |
$link = '<a href="'.$_SERVER["SCRIPT_NAME"].'?site={SITE}'.$extVariables.'">{LINK}</a>';
$grafik['backS'] = '<img src="pfeil_links.gif" border="0">';
$grafik['back'] = '<img src="s.gif" border="0">';
$grafik['site'] = '<img src="u_blau.gif" border="0">';
$grafik['none'] = '<img src="u_bbraun.gif" border="0">';
$grafik['next'] = '<img src="che.gif" border="0">';
$grafik['nextE'] = '<img src="pfeil_rechts.gif" border="0">'; |
Zuerst definieren wir ein Array (150) mit den zu ersetzenden Flags, die bereits
in der übergebenen Variable $link gesetzt wurden. Anhand dieser Flags
werden nachher die einzelnen Links für die Seitennavigation aufgebaut.
Falls wir uns auf einer größeren Seite als 1 (eins) befinden (155), können wir
die Grafiken für „Eine Seite zurück“ anzeigen. Wir ersetzen (159) daher in
unserem übergebenen Link die Flags {SITE} und {LINK} durch den jeweiligen
Wert für „Eine Seite zurück“ und speichern den String in unsere Variable (159).
Befinden wir uns auf der ersten Seite (161), so dürfen wir die Grafik nicht
verlinken, da sie sonst auf 0 (Null) zeigen und es zu einem Fehler kommen
würde. Wir speichern daher nur die Grafik ohne Verlinkung in unsere Variable
(162).
Wir müssen nun die Grafiken für die einzelnen Seiten aufbauen, also für jede
Seite eine eigene kleine Grafik. Wir durchlaufen das Array und speichern
entweder eine nicht verlinkte Grafik für unsere aktuelle Seite (168) oder eine
verlinkte Grafik (173).
Anschließend müssen wir nur noch das Ende der Seitenverlinkung herstellen.
Wenn also unsere aktuelle Seite kleiner (177) ist als die Gesamtmenge, können
wir auch „Eine Seite vor“ anzeigen. Wir speichern eine verlinkte Grafik (180) in
unsere bestehende Variable (180). Sollten wir uns bereits auf der letzten Seite
befinden, müssen wir lediglich die Grafik ohne Verlinkung in unsere Variable
speichern (183).
Nachdem wir die komplette Verlinkung erstellt haben, müssen wir diese Variable
der aufrufenden Stelle zurückgeben (188).
149:
150:
151:
152:
153:
154:
155:
156:
157:
158:
159:
160:
161:
162:
163:
164:
165:
166:
167:
168:
169:
170:
171:
172:
173:
174:
175:
176:
177:
178:
179:
180:
181:
182:
183:
184:
185:
186:
187:
188:
189: |
function makeGraph($ausgabe,$seiteAktuell,$link,$grafik)
{
$search = array(
"/{SITE}/",
"/{LINK}/"
);
$string .= '<tr>';
if($ausgabe['begin']['second'] >= 1 || $ausgabe['begin']['first'] >= 1) {
$replace[0] = $seiteAktuell-1;
$replace[1] = $grafik['backS'].$grafik['back'];
$string .= '<td align="right">'.preg_replace($search, $replace, $link).'</td>';
} else {
$string .= '<td align="right">'.$grafik['back'].'</td>';
}
foreach($ausgabe['middle']['site'] as $key => $value) {
if(is_array($value)) {
$string .= '<td align="center">'.$grafik['none'].'</td>';
} else {
$replace[0] = $value;
$replace[1] = $grafik['site'];
$string .= '<td align="center">'.preg_replace($search, $replace,
$link).'</td>';
}
}
if($seiteAktuell < $ausgabe['end']['second'] ||
$seiteAktuell < $ausgabe['end']['first']){
$replace[0] = $seiteAktuell+1;
$replace[1] = $grafik['next'].$grafik['nextE'];
$string .= '<td align="left">'.preg_replace($search, $replace, $link).'</td>';
} else {
$string .= '<td align="right">'.$grafik['next'].'</td>';
}
$string .= '</tr>';
return $string;
}
|
Beispiel 5.10: blaettern_grafik.php
Die Konfigurationsparameter für unser Beispiel sind relativ simpel und schnell
geschehen. Wir benötigen dabei folgende Parameter:
- die maximalen Suchergebnisse (4)
- die Anzahl der Seitenzahlen bei der Seitenverlinkung (9)
- den MySQL-Hostnamen
(12)
- die MySQL-Datenbank
(13)
- der MySQL-User
(14)
- das MySQL-Passwort
(15)
Zusätzlich benötigen wir die verschiedenen Verlinkungen, zum einen für die
Textverlinkung (19) und zum anderen die Verlinkungen für die einzelnen
Grafiken. Dabei gibt es folgende Zustände für die Textverlinkungen:
- Eine Seite zurück (21)
- Die einzelnen Seiten selbst (22)
- Eine Seite vor (23)
Für die Verlinkung der einzelnen Grafiken benötigen wir lediglich eine Variable,
um nachher alle Grafiken verlinken zu können (24). Die einzelnen Grafiken
können Sie über die einzelnen Variablen (27-32)
steuern oder austauschen.
Wir müssen jetzt lediglich den Connect zur Datenbank herstellen, um die
späteren Datenbankabfragen stellen zu können (35, 36).
001:
002:
003:
004:
005:
006:
007:
008:
009:
010:
011:
012:
013:
014:
015:
016:
017:
018:
019:
020:
021:
022:
023:
024:
025:
026:
027:
028:
029:
030:
031:
032:
033:
034:
035:
036:
|
<?PHP
// Wieviel Einträge pro Seite sollen dargestellt werden?
$maxEintraege = 16;
// Wieviel Seitenzahlen in der Navigationsleiste angezeigt werden. Ausgabe kann sein
// << < 2 3 4 5 6 7 8 9 10 11 12 > >>
// Die Berechnung erfolgt nur für ungerade Zahlen!!!
$navLeiste = 13;
// Definiert die Parameter für den Datenbank Connect
define("DB_HOST","localhost"); // MySQL hostname
define("DB_NAME","db151892537"); //MySQL db-name
define("DB_USER","dbo151892537"); //MySQL User
define("DB_PASS","FDvmhU8E"); // MySQL Passwort
// Weitere Variablen den Seitenzahlem mit übergeben in Form:
// &var1=wert1&var2=wert2
$extVariables = '&textfield='.urlencode($_GET['textfield']);
$href[0] = '<a href="'.$_SERVER["SCRIPT_NAME"].'?site={SITE}'.
$extVariables.'">Zurück</a>';
$href[1] = '<a href="'.$_SERVER["SCRIPT_NAME"].'?site={SITE}'.
$extVariables.'">{SITE}</a>';
$href[2] = '<a href="'.$_SERVER["SCRIPT_NAME"].'?site={SITE}'.
$extVariables.'">Vorwärts</a>';
$link = '<a href="'.$_SERVER["SCRIPT_NAME"].'?site={SITE}'.
$extVariables.'">{LINK}</a>';
$infoText = 'Ergebnisse {ERGEBNIS} von ungefähr {MENGE}. ({SEKUNDEN} Sekunden) ';
$tableNavi = '<div align="center"><table>{TABLENAVI}</table></div>';
$grafik['backS'] = '<img src="pfeil_links.gif" border="0">';
$grafik['back'] = '<img src="s.gif" border="0">';
$grafik['site'] = '<img src="u_blau.gif" border="0">';
$grafik['none'] = '<img src="u_bbraun.gif" border="0">';
$grafik['next'] = '<img src="che.gif" border="0">';
$grafik['nextE'] = '<img src="pfeil_rechts.gif" border="0">';
// Datenbank Connect herstellen
$db = @MYSQL_CONNECT(DB_HOST,DB_USER,DB_PASS) or
die("Datenbank-Connect fehlgeschlagen");
$db_check = @MYSQL_SELECT_DB(DB_NAME) or
die("Datenbank momentan nicht erreichbar");
|
Beispiel 5.11: blaettern_grafik.php
Wir müssen zu Beginn als Erstes den Timer für die spätere Anzeige setzen
(192). Hierbei wird die aktuelle Zeit gespeichert. Wurde eine Seitenzahl durch
den Besucher angeklickt, ist unsere Variable $_GET[’site’] mit einem Wert
gefüllt (195). Da wir nur IntegerWerte
benötigen, erzwingen wir mit der Addition
von 0 (Null) eine Konvertierung der Variable in einen IntegerWert.
Falls die Variable leer ist oder Null (198), setzen wir den Startwert auf 1 (Eins)
(199). Wir errechnen jetzt den Wert für unsere spätere Datenbankabfrage. Wir
wollen erreichen, dass ab einer bestimmten Position in der Datenbank die
Datensätze ausgelesen werden. Wenn wir also z. B. 16 Einträge anzeigen lassen
wollen, so müssen wir den Wert folgendermaßen berechnen:
- Seite 1 1 * 16 – 16 = 0
- Seite 2 2 * 16 – 16 = 16
- Seite 3 3 * 16 – 16 = 32
Dies geht dann bis zur maximalen Anzahl so weiter. Wir haben somit den
jeweiligen Startwert für unsere Abfrage (205). Es kann so ein Limit bei der
Abfrage gesetzt werden, da wir den Startwert und die maximalen Einträge
vorliegen haben. Als Ergebnis erhalten wir nur die maximale Menge, mehr
nicht.
Wir müssen jedoch vor der Abfrage die übermittelte Suchanfrage für die Datenbank sicher machen (SQL Injection Angriffen)(206), sodass kein schadhafter Befehl an die Datenbank gesendet werden kann
Was jetzt noch fehlt, sind die gesamten Suchtreffer, da wir diese ebenfalls
anzeigen möchten. Wir setzen also nochmals die gleiche Abfrage ab (210),
allerdings diesmal ohne ein Limit und ohne Werte aus der Datenbank.
Wir speichern den gefundenen Wert der Gesamtmenge (212) und berechnen
daraus die maximalen Seitenzahlen (215). Wir müssen lediglich darauf achten,
diesen Wert noch aufzurunden, um alle Datensätze anzeigen zu können.
Wir übergeben die Werte an die Funktion navigationsLeiste() (218) und
erhalten als Rückgabewert ein Array mit allen Navigationselementen. Dieses
Array geben wir anschließend an die Funktion makeText() (220) für die Textverlinkung und an die Funktion makeGraph() (222) für die Grafikverlinkung.
Wir erhalten jeweils als Rückgabewert einen String mit der formatierten
Seitennavigation.
Im nächsten Schritt müssen wir unsere Datenbankabfrage mit den Ergebnissen
ausgeben (225-228)
und danach nochmals den Timer für die Gesamtzeit
aufrufen (231). Dabei übergeben wir der Funktion endTime() den Startwert
und erhalten als Rückgabewert die komplette Suchzeit.
Jetzt haben wir alle Informationen zusammen, um unseren Hinweistext für
die Ausgabe vorzubereiten (233). Dieser Text beinhaltet z. B. die Suchzeit, die
aktuellen Datensätze als Zahl und die Suchtreffer. Zum Schluss müssen wir
nur noch die Navigationsleiste in unserer Variablen ersetzen (235).
191:
192:
193:
194:
195:
196:
197:
198:
199:
200:
201:
202:
203:
204:
205:
206:
207:
208:
209:
210:
211:
212:
213:
214:
215:
216:
217:
218:
219:
220:
221:
222:
223:
224:
225:
226:
227:
228:
229:
230:
231:
232:
233:
234:
235: |
// Startet den Timer
$timer = startTime();
// Die aktuell angeforderte Seite
$seiteAktuell = $_GET['site'] + 0;
// Falls noch keine Seitenzahl übergeben wurde, den Wert auf die erste Seite setzen
if(empty($seiteAktuell))
$seiteAktuell = 1;
// Berechnet die nächsten Eintraege aus MAX_EINTRAEGE
$start = $seiteAktuell * $maxEintraege - $maxEintraege;
// Holt die aktuellen Datensätze aus - define("MAX_EINTRAEGE",10)
//$result = @mysql_query("SELECT * FROM suchmaschine LIMIT $start, ".$maxEintraege);
$textfieldSecure = @mysql_real_escape_string(stripslashes($_GET['textfield']));
$result = @mysql_query("SELECT * FROM suchmaschine WHERE words LIKE('%".
$textfieldSecure."%') LIMIT $start, ".$maxEintraege);
// Ermittelt die Gesamtzahl der Datensätze
//$resultGesamt = @mysql_query("SELECT COUNT(*) AS menge FROM suchmaschine");
$resultGesamt = @mysql_query("SELECT COUNT(*) AS menge FROM suchmaschine WHERE words
LIKE('%".$textfieldSecure."%')");
$Eintraege = @mysql_result($resultGesamt,0,"menge");
// Errechnet die kompletten Seiten
$SitesComplete = ceil($Eintraege / $maxEintraege);
// Navigation mit in Ausgabe einfügen
$ausgabe = navigationsLeiste($SitesComplete,$seiteAktuell,$navLeiste);
$ausgabeText = makeText($ausgabe,$seiteAktuell,$href);
$ausgabeGraph = makeGraph($ausgabe,$seiteAktuell,$link,$grafik);
// Ausgabe der Seite
while($row = @mysql_fetch_row($result)){
// Hier findet die Ausgabe des Seiteninhalts statt
$contentWeb .= $row[2] . '<br>';
}
// Beendet den Timer
$endTime = endTime($timer);
$infoText = makeInfo($endTime,$seiteAktuell,$maxEintraege,$Eintraege,$infoText);
$leisteBottom = preg_replace("/{TABLENAVI}/", $ausgabeGraph . $ausgabeText, $tableNavi); |
Beispiel 5.12: blaettern_grafik.php
Wie Sie sehen, haben Sie jetzt eine fast fertige Lösung für eine Suchmaschine à
la Google. Sie müssen selbstverständlich noch einige Dinge anpassen, werden
dies aber relativ einfach lösen können.
Dieses Skript aus dem SELFPHP KOCHBUCH wurde von SELFPHP unter dem "Tarif Mc500" von McAc.net-Webhosting erfolgreich ausgeführt und getestet!
Auf der Übersichtseite unter "McAc.net – Webhosting zu diesem Buch" finden Sie weitere Informationen zu dem Webhostingpaket, dass durch SELFPHP getestet wurde.
|
SELFPHP
SELFPHP OHG, info@selfphp.de, Impressum, Kontakt