sitemap b

Das Script: "gen_sitemap.php"


<?php

Zunächst wird geprüft, ob bereits Feldinhalte übermittelt sind: isset(...),
wenn ja, dann werden die Feldinhalte übernommen
und bei leeren Inhalten mit Stellvertretern "aaaa" belegt

if(isset($_REQUEST['dont_show_1'])){

  $host         = $_REQUEST['host'];

  $dont_show_1  = $_REQUEST['dont_show_1'];
  if($dont_show_1=="")$dont_show_1="aaaa";
  $dont_show_2  = $_REQUEST['dont_show_2'];
  if($dont_show_2=="")$dont_show_2="aaaa";
  $dont_show_3  = $_REQUEST['dont_show_3'];
  if($dont_show_3=="")$dont_show_3="aaaa";
  $dont_show_4  = $_REQUEST['dont_show_4'];
  if($dont_show_4=="")$dont_show_4="aaaa";
  $dont_show_5  = $_REQUEST['dont_show_5'];
  if($dont_show_5=="")$dont_show_5="aaaa";
  $dont_show_6  = $_REQUEST['dont_show_6'];
  if($dont_show_6=="")$dont_show_6="aaaa";
  $dont_show_7  = $_REQUEST['dont_show_7'];
  if($dont_show_7=="")$dont_show_7="aaaa";
  $dont_show_8  = $_REQUEST['dont_show_8'];
  if($dont_show_8=="")$dont_show_8="aaaa";
  $dont_show_9  = $_REQUEST['dont_show_9'];
  if($dont_show_9=="")$dont_show_9="aaaa";
  $dont_show_10 = $_REQUEST['dont_show_10'];
  if($dont_show_10=="")$dont_show_10="aaaa";
  $filespec_1 = $_REQUEST['filespec_1'];
  if($filespec_1=="")$filespec_1="HTML";
  $filespec_2 = $_REQUEST['filespec_2'];
  if($filespec_2=="")$filespec_2="aaaa";
  $filespec_3 = $_REQUEST['filespec_3'];
  if($filespec_3=="")$filespec_3="aaaa";
  $filespec_4 = $_REQUEST['filespec_4'];
  if($filespec_4=="")$filespec_4="aaaa";
  $filespec_5 = $_REQUEST['filespec_5'];
  if($filespec_5=="")$filespec_5="aaaa";
  $filespec_6 = $_REQUEST['filespec_6'];
  if($filespec_6=="")$filespec_6="aaaa";
  $priority_1 = $_REQUEST['priority_1'];
  $priority_2 = $_REQUEST['priority_2'];
  $priority_3 = $_REQUEST['priority_3'];
  $comeback   = $_REQUEST['comeback'];

$all_files ist ein Array, in welches alle Rückgabewerte
der Funktion show_all_files(...) (also die gefundenen Dateien)
eingetragen werden.

  $all_files = array();
  function show_all_files($ordner, $sub = FALSE) {

Mit global wird dafür gesorgt, dass die Variablen und deren Inhalte
nicht nur innerhalb der Funktion show_all_files(...),
sondern im gesamten Script zur Verfügung stehen.

    global $all_files;
    global $dont_show_1;
    global $dont_show_2;
    global $dont_show_3;
    global $dont_show_4;
    global $dont_show_5;
    global $dont_show_6;
    global $dont_show_7;
    global $dont_show_8;
    global $dont_show_9;
    global $dont_show_10;
    global $filespec_1;
    global $filespec_2;
    global $filespec_3;
    global $filespec_4;
    global $filespec_5;
    global $filespec_6;
    global $priority_1;
    global $priority_2;
    global $priority_3;
    global $comeback;
    global $act_path;
    $handle = opendir($ordner);

Die while(...)-Schleife - der eigentliche "Spurenleser" - prüft nun anhand der
angewiesenen Aus- und Einschlusskriterien die vorhandenen Dateien und
schreibt diese mit Pfadangaben in das Array $all_files (Diskussion folgt)

    while ($file = readdir ($handle)) {
      if($file != "." && $file != "..") {
        if(is_dir($ordner . "/" . $file)) {
          show_all_files($ordner . "/" . $file, TRUE);
        } else {
          if(strpos(strtoupper($file), strtoupper($filespec_1))>0
            || strpos(strtoupper($file), strtoupper($filespec_2))>0
            || strpos(strtoupper($file), strtoupper($filespec_3))>0
            || strpos(strtoupper($file), strtoupper($filespec_4))>0
            || strpos(strtoupper($file), strtoupper($filespec_6))>0
            || strpos(strtoupper($file), strtoupper($filespec_6))>0
            ){
            if(!strpos(strtoupper($ordner),strtoupper($dont_show_1))
              && !strpos(strtoupper($ordner),strtoupper($dont_show_2))
              && !strpos(strtoupper($ordner),strtoupper($dont_show_3))
              && !strpos(strtoupper($ordner),strtoupper($dont_show_4))
              && !strpos(strtoupper($ordner),strtoupper($dont_show_5))
              && !strpos(strtoupper($ordner),strtoupper($dont_show_6))
              && !strpos(strtoupper($ordner),strtoupper($dont_show_7))
              && !strpos(strtoupper($ordner),strtoupper($dont_show_8))
              && !strpos(strtoupper($ordner),strtoupper($dont_show_9))
              && !strpos(strtoupper($ordner),strtoupper($dont_show_10))
              ){
              $replace      = array ('./' => '/');

              $new_file     =  $host . $ordner . '/' . $file;

              $new_file     = strtr($new_file, $replace);
              $all_files[]  = $new_file;
            }
          }
        }
      }
    }
    closedir($handle);
    return $all_files;
  }

Der eigentliche Funktionsaufruf show_all_files('.') mit Pfadangabe:
direkt von dieser Ebene mit allen Unterebenen '.'

  show_all_files('.');

show_all_files(...) ist abgearbeitet,
das globale Array $all_files ist erzeugt.
Nun kann die Erstellung der Sitemap gemäß Sitemap-Protokoll begonnen werden

  $sitemap    = '<?xml version="1.0" encoding="UTF-8"?>' . chr(13);
  $sitemap    = $sitemap . '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">' . chr(13);
  $sitemap    = $sitemap . '   <url>' . chr(13);
  $sitemap    = $sitemap . '    <loc>' . $_SERVER['HTTP_HOST'] . '</loc>' . chr(13);
  $sitemap    = $sitemap . '    <lastmod>' . date('Y-m-d') . '</lastmod>' . chr(13);
  $sitemap    = $sitemap . '    <changefreq>' . $comeback . '</changefreq>' . chr(13);
  $sitemap    = $sitemap . '    <priority>1.0</priority>' . chr(13);
  $sitemap    = $sitemap . '   </url>' . chr(13);
  foreach( $all_files as $key => $value){
    $act_file = $value;
    $sitemap  = $sitemap . '   <url>' . chr(13);
    $sitemap  = $sitemap . '    <loc>' . $act_file . '</loc>' . chr(13);
    $act_path = 0;
    $act_path = substr_count($act_file,'/');
    $act_path = $act_path - 1;
    $sitemap  = $sitemap . '    <lastmod>' . date('Y-m-d') . '</lastmod>' . chr(13);
    $sitemap  = $sitemap . '    <changefreq>' . $comeback . '</changefreq>' . chr(13);
    if($act_path==0)
      $sitemap  = $sitemap . '    <priority>' . $priority_1 . '</priority>' . chr(13);
    if($act_path==1)
      $sitemap  = $sitemap . '    <priority>' . $priority_2 . '</priority>' . chr(13);
    if($act_path>1)
      $sitemap  = $sitemap . '    <priority>' . $priority_3 . '</priority>' . chr(13);
    $sitemap  = $sitemap . '   </url>' . chr(13);
  }
  $sitemap = $sitemap . '</urlset>';

Die Sitemap ist nun im Arbeitsspeicheer im String $sitemap erzeugt
und wird im letzten Schritt als Datei auf die Festplatte geschrieben

  $datei_name   = 'sitemap.xml';
  $fp           = fopen($datei_name, "w");
  fwrite($fp, $sitemap);
  fclose($fp);

?>

Das PHP-Script ist abgearbeitet,
die Sitemap mit dem Namen sitemap.xml wurde geschrieben und
nun mit einem Javascript im Browser (document.location.href="sitemap.xml";) angezeigt

<script language="JavaScript">
<!--
document.location.href="sitemap.xml";
//-->
</script>
<noscript></noscript>

Hier zunächst einmal die verwendeten PHP-Funktionen (Anweisungen und Schleifenoperatoren):

1. isset();

Prüft, ob mit dem Aufruf der PHP-Datei bereits eine Information mitgegeben wurde. Dies erfolgt im Script aus dem setzen der Feldwerte im Formular "gen_sitemap" mit der Methode "post". Beim Aufruf direkt aus der Browser-Adresse werden keine Feldinformationen mitgegeben und somit antwortet isset() mit false und leitet durch die oben bereits beschriebene if-else-Schleife die Ausgabe zur Anzeige des Formulars. Sie können ganz einfach "Verwirrung stiften", wenn Sie in die Browserzeile folgendes eintippen: "http://www.irgend_ein_host/gen_sitemap.php?dont_show_1=x". Damit wurde die Variable "dont_show_1" im Request gesetzt und das Script zeigt auf den falschen Abschnitt. Da in der Vorbelegung im Script das Default für die Variable $dont_show_1 auf "HTML" gesetzt ist, werden alle HTML-Dateien Ihres gesamten Servers ausgelesen.

2. $_REQUEST['x'];

Prinzipiell wid mit jeder Anforderung an den Server ein "Request" gestartet (Englisch: request = Anforderung). Diese Anforderung kann nun verschiedene Informationen beinhalten. PHP liest mit $_REQUEST['x,y,z...'] gezielt Inhalte dieses requests aus und schreibt sie in die zugewiesenen Variablen (x,y,z...).

3. if($x==""){}

Simple Bedingungsanweisung: wenn eine Bedingung zutrifft -> dann... und ansonsten eben nicht - Ende ("==" bedeutet übrigens: guck' ganz genau! - ein einfaches "=" bewirkt nahezu das gleiche).

4. $all_files = array();

Ein Array stellen wir uns am besten als Zeile einer Tabelle vor, in welcher jede Spalte einen, mit der Spaltennummer abrufbaren Wert besitzt. Sobald diese "vorgestellte Tabelle" mehr als eine Zeile besitzt, wird das Array "multidimensional", wobei PHP nicht nur die Richtungen "links und rechts" für Spalten und "oben und unten" für Zeilen kennt, sondern im wahrsten Sinne des Wortes "Multidimensionen" bereit hält. $all_files = array() meldet nun zunächst einmal formlos ein Array an, wobei insbesondere über die Zahl der Spalten noch keine Aussage gemacht werden kann, da wir ja die Anzahl der gesuchten Dateien nicht kennen.

5. foreach(...){}

Nach Erstellung des Arrays $all_files und ohne zu wissen, wieviele Spalten es besitzt, sagen wir einfach: "jetzt schau mal in jede Spalte rein, bis keine mehr da ist bzw. keine mit Inhalten" und mit den Werten mache folgendes...

6. global $all_files;

Damit Variablen nicht nur in einem Teilabschnitt des Scripts (z.B.: innerhalb einer Funktion) zur Verfügung stehen, werden diese mit global als universal bzw. überall innerhalb des Scriptes verfügbar angemeldet. "global" wird in der Funktion ("show_all_files()") angemeldet, damit die Variablen auch ausserhalb der Funktion verfügbar werden.

7. readdir (...);

Liest den Inhalt eines Ordners aus. Diese Funktion kann sowohl das Boolsche FALSE zurückliefern, als auch einen nicht-Boolschen Wert, wie zum Beispiel "0" oder "" zurückgeben, der von einem einfachen if-Statement als FALSE ausgewertet wird. Findet readdir(...) Inhalte, kann es sich um weitere Unterordner oder aber um Dateien handeln. Das Script wird die Rückgabewerte im Sinne der zugeschriebenen Anweisungen behandeln (z.B.: "Bist du ein Ordner, dann schau ich auch hier mal rein - bist du eine Datei, dann sag mir, ob du (z.B.: eine HTML-Datei) bist - und wenn ja, dann ab mit dir ins Array $all_files".

8. while (...){}

Ein Schleifenoperator der sagt: "solange diese Bedingung noch zutrifft (Ordner oder Dateien gefunden werden) machst du weiterhin folgendes:..." und wenn nicht, dann wird die Schleife beendet und das Script weiter abgearbeitet.

9. is_dir(...);

Die Funktion is_dir(...) überprüft, ob der Name ein Verzeichnis (und damit keine Datei) ist, da sich dies aus der Bezeichnung alleine nicht erkennen läßt. Falls es sich um ein existierendes Verzeichnis handelt wird TRUE (bzw. 1), ansonsten FALSE (bzw. 0) zurückgegeben. In unserem Script wird diese Rückmeldung benötigt, damit bei der Rückgabe von "TRUE oder 1" nach weiteren Dateien, die der Anweisung entsprechen, gesucht werden kann.

10. strpos(Heuhaufen, Nadel);

Da mit den Variablen filespec... Einschluss-Kriterien übergeben werden, muss geprüft werden, ob Dateien mit dieser Endung zu finden sind. Wenn ja, dann ist diese Endung im String vorhanden und da eine Dateiendung, wie dies der Name besagt, nicht am Anfang steht, muss die jeweiligen Position - falls vorhanden - größer wie 0 sein. (Heuhaufen ist dabei der gesamte String und Nadel ein Teilabschnitt, nachdem gesucht werden soll).

11. strtoupper(...);

Ist eine einfache Anweisung, einen String in das Format seiner Großbuchstaben um zu formen, damit man unabhängig von den Datei- und Ordnerbezeichnungen und den Eingaben der Anwender und Anwenderinnen eine eindeutige Vergleichsmöglichkeit hat. Durch den Einsatz von strpos() kombiniert mit strtoupper() baut man eine sehr zuverlässige Prüfroutine ein, die Fehler weitestgehend ausschließt.

12. strtr($x, $y);

Ist eine Umformungsanweisung an den String $x, wobei im Array $y die Umformungsanweisung beschrieben wird. Ein typisches Beispiel wäre etwa die Umformung in "entities" (HTML-Codierung von Umlauten und Sonderzeichen). Umformung von "ä": $y = array("ä" => "ä") würde als Funktion aufgerufen: $x = strtr($x, $y).

13. $all_files[] = $x;

Wie oben bereits zu Arrays ausgeführt wurde, kennen wir die Anzahl der "Spalten" (Zahl der Dateien unserer Sitemap) nicht. $all_files[] = $x; legt einfach eine neue "Spalte" im Array $all_files an und weist dabei der neuen "Spalte" den Wert $x zu.

14. substr_count(Heuhaufen, Nadel);

Eine sehr nützliche Funktion auch hier bei der Erstellung unserer Sitemap. "Heuhaufen" ist wieder der zu befragende String und "Nadel" der Suchausdruck. substr_count($y,$x) gibt uns an, wie oft $x in $y vorkommt. Da jeder Slash in unserem Server eine Ebene tiefer führt kann man mit substr_count($y,'/') einfach ermitteln, in welcher Ebene die augenblicklich ausgewerteten Dateien liegen und entsprechende "Prioritäten" zuweisen (übrigens: Prioritäten fehlen natürlich bei einem willkürlichen Abruf des PHP-Scripts, wie oben ausgeführt ("Verwirrung stiften"). Ebenso fehlen die "Frequenzen".).

15. $fp = fopen($datei, "w");

Nun hätten wir die Funktionen zur inhaltlichen Erstellung unserer Sitemap-Datei soweit besprochen - fehlt noch: das Zurückschreiben in eine physikalische Datei.

Bitte beachten: eine etwaig vorhandene Datei gleichen Namens wird tatsächlich überschrieben!

fopen(...) - übergeben mit dem Parameter "w" öffnet eine Datei (vorhanden oder nicht - nicht vorhanden => wird neu erstellt) mit Schreibzugriff. Voraussetzung: Sie müssen tatsächlich Schreibrechte auf dem Server besitzen.

16. fwrite($fp, $x);

Schreibt den Inhalt $x in die mit fopen(..., "w") geöffnete Datei.

17. fclose($fp);

Der Inhalt ist übertragen und nun muss die "offene" Datei auch noch geschlossen werden, was fclose(...) übernimmt. Nun ist die physikalische Erzeugung unserer Sitemap-Datei abgeschlossen und kann im folgenden Javascript bereits angezeigt werden.

18. $x = $_SERVER['HTTP_HOST'];

Kleiner Nachtrag:

$_SERVER['HTTP_HOST'] wurde eingesetzt, um Schreibarbeit zu ersparen. Hier wird einfach der verweisende Server abgefragt, den wir zur protokollgerechten Erstellung unserer Sitemap-Datei benötigen.

Hat leider nicht geklappt (siehe oben), deshalb müssen Sie eben den host händisch einsetzen - leider.

Auf der nächsten - in diesem Tutorial letzten - Seite finden Sie noch eine Überlegung zum Verständnis der Logik rekursiver Funktionen (wie z.B.: show_all_files() und das vollständige Script zum kopieren und abspeichern.

<<< Zurück zur letzten Seite Weiter zum Sitemap-Script >>>