Wenn man selbst Applikationen programmiert die auf Javascript basieren und später noch diverse Erweiterungen ermöglichen sollen, dann macht es durchaus Sinn eigene Callbacks anzubieten. Sei es in einer jQuery Extension oder einer eigenen Applikation.

Die Anforderung

Zur Erfüllung meiner aktuellen Anforderung habe ich eine Javascript Klasse erstellt die mit dem Operator new erstellt werden kann:

var myObject = new FunkyObject();

Perfekt für die erste Anforderung, aber sobald weitere Entwickler involviert werden oder man Teile der Applikation sogar als OpenSource Software veröffentlicht, wäre es ja schön wenn nicht jeder im eigenen Code rum macht sondern ordentlich in seinem Script bleibt:

var myObject = new FunkyObject({
  onLoad: function() {
    //do crazy custom things
  }
});

Sieht ordentlich aus und ist ohne Kommentare selbsterklärend: Beim laden werden verrückte Sachen getan. Aber was tut das FunkyObject um die Callbacks aufzurufen?

Eine Javascript Klasse

Genau genommen ist eine Javascript Klasse nichts weiter als eine Funktion die sich selbst zurück gibt und über den new Operator erstellt wird. Meine Grundlage sieht so aus:

var FunkyObject = function(args) {
  var defaults = {};
  this.args = $.extend(defaults, args);
  this.goCrazy();
  return this;
};

Dieser Code setzt jQuery voraus, das die Funktion $.extend mitbringt. Damit wird das übergebene args Objekt durch die in defaults angegebenen Werte aufgefüllt, sofern sie nicht vorhanden sind. Man kann also für das onClick Event ein Standardverhalten hinterlegen:

var FunkyObject = function(args) {
  var defaults = {
  onLoad: function() {
    //default behavior
  };
  this.args = $.extend(defaults, args);
  this.goCrazy();
  return this;
};

Die Funktion goCrazy() wird ausgeführt sobald die Klasse initialisiert wird. Um dem nächsten Entwickler die Möglichkeit zu geben auch diese Funktion zu überschreiben, werden alle Grundlagen in der prototype Eigenschaft der Klasse definiert:

var FunkyObject = function(args) { /* ... */ };
FunkyObject.prototype.goCrazy = function() {
  // do the init stuff
};

Mit diesem Konstrukt könnte ein Entwickler im eigenen Script jene Klasse überschreiben ohne in den eigentlichen Quelltext eingreifen zu müssen.

myObject.goCrazy = function() {
  // custom constructor
}

Das als kleine Anmerkung am Rande, das erklärte Ziel ist der komfortable Aufruf des onLoad Events. Natürlich könnte man über this.args.onClick() einfach die entsprechende Funktion aufrufen, aber sieht das schön aus? Ist das variabel?

Die Antwort lautet nein.

Schön und variabel

Viel cooler ist eine total schöne und variable trigger() Funktion zu schreiben, die in den Parametern nach einem Callback sucht und diesen ggf. ausführt.

FunkyObject.prototype.trigger = function(action) {
  var callback = 'on'+this.ucfirst(action);
  if(typeof this.args[callback] == 'function') {
    this.args[callback]();
  };
}

In der goCrazy Funktion sieht der Aufruf dann so aus:

var FunkyObject = function(args) { /* ... */ };
FunkyObject.prototype.goCrazy = function() {
  this.trigger('load');
};

Die trigger Funktion baut sich den Eventnamen aus einem on und dem Parameter action zusammen und prüft anschließend ob eine Funktion mit diesem Namen vorhanden ist. Ist dies der Fall wird sie ausgeführt.

Leider gibt es keine Javascript Funktion mit dem Namen ucfirst, aber über die Prototype Eigenschaft kann man das String Objekt entsprechend aufrüsten:

String.prototype.ucfirst = function() {
  return this.substr(0,1).toUpperCase() + this.substr(1,this.length);
};

Mit diesen zwei Funktionen baut man sich sehr schnell eine Grundlage um variable Scripte zu schreiben die komplett erweitert werden können.

Parameter für den Callback

Oft muss der Callback über einen gewissen Zustand informiert werden. Für das benutzte Beispiel könnte es die Information sein ob das Laden erfolgreich war. Bei der Definition des Callbacks muss ein Parameter akzeptiert werden:

var myObject = new FunkyObject({
  onClick: function(success) {
    alert(success ? 'hat geklappt!' : 'fehler');
  }
});

Die goCrazy Funktion muss den Status an die trigger Funktion weitergeben:

FunkyObject.prototype.goCrazy = function() {
  success = true;
  this.trigger('load', success);
};

Wir gehen mal von einem grundlegenden Erfolg aus. Das wird es auch sofern die trigger Funktion beigebracht bekommt was sie mit zusätzlichen Parametern anfangen soll:

FunkyObject.prototype.trigger = function(action) {
  var callback = 'on'+this.ucfirst(action);
  if(typeof this.args[callback] == 'function') {
    this.args[callback](arguments.shift());
  };
}

Viele Änderungen sind es nicht. In der vordefinierten Variable arguments sind sämtliche Parameter vom Aufruf der Funktion gespeichert. Die Array Funktion shift entfernt das erste Element aus dem Array und gibt den Rest zurück. So wird nicht der Callbackname sinnloser Weise an den Callback gegeben sondern alle andere Parameter. So kann man auch mehr als ein Wert an den Callback schicken:

FunkyObject.prototype.goCrazy = function() {
  success = true;
  this.trigger('load', success, 'ready', {hello: 'world'});
};

Fazit

Ich mag Callbacks. Wenn man ein gutes Grundgerüst hat kann man auf alle Events individuell reagieren. Sollte es ein Callback nicht geben den man wirklich dringend und sofort benötigt kann man mit dem Überschreiben der prototype Funktion kurzfristig neue Callbacks hinzufügen und später in die Core Anwendung übernehmen.

Wichtig ist aber darauf zu achten keine unendlichen Scripte in den Callbacks unterzubringen. Spätestens nach 20 Zeilen sollte man sich überlegen den Code in einzelne Häppchen aufzuteilen.

Und in eigener Sache noch die Warnung vor gedankenlosem Copy and Paste: Durch Unterschrift auf dem NDA musste ich alle Funktionen umbenennen. Also nachdenken und gute Funktionsnamen benutzen.

Es geht natürlich um den heißen Scheiß: Ajax. Mit aktiviertem JavaScript soll bei einem Klick auf einen Eintrag der Eintrag dynamisch nachgeladen werden anstatt auf die Einzelansicht zu verlinken. Mit TYPO3 und Typoscript baut man sich dafür ein weiteres Page Objekt und passt die Ausgabe an, darüber hatte ich schon berichtet. Bei WordPress gibt es aber kein Typoscript.

Mein erster Gedanke war ein alternatives Template per URL Parameter zu laden in dem nur die Inhalte angezeigt werden. Die Anleitungen waren allerdings allesamt nicht besonders ergiebig. Der nächste Ansatz war den gesamten Inhalt abzufragen und per jQuery nur den entsprechenden Container mit den Inhalten auszugeben. Das finde ich aber irgendwie unelegant.

Und nach einmal drüber schlafen kam dann der rettende und sehr simple Einfall.

functions.php

Mit meinem CakePHP verwöhntem Blick würde ich die functions.php mal mit einer Art Controller vergleichen. Der Aufruf geht also durch diese Datei, in der Variablen gesetzt und Funktionen definiert werden können, die anschließend in den Views zur Verfügung stehen.

Und hier steckt schon das ganze Geheimnis, ist die Servervariable HTTP_X_REQUESTED_WITH gesetztz, handelt es sich um eine asynchrone Anfrage:

if(isset($_SERVER['HTTP_X_REQUESTED_WITH'])) {
  $ajax = true;
}
else {
  $ajax = false;
}

Die Views

In den üblichen Verdächtigen des Themes, damit meine ich die single.php, page.php, index.php usw. steht jetzt die Variable $ajax zur Verfügung. Bisher fand ich die Arbeitsweise von WordPress nicht sehr elegant in jeder Datei Header, Sidebar und Footer einbinden zu müssen, aber jetzt finde ich sie gut. Denn wenn bei einem Ajaxaufruf nur der Inhalt zurück gegeben werden soll, dann lässt man das überflüssige HTML Gerüst einfach draußen:

if(!$ajax) {
  get_header();
}

Fazit

Das war einfach. WordPress ist ein tolles System und ich kann es kaum erwarten endlich die neue Version 3.0 stable zu sehen. Wie das ganze drum herum mit jQuery funktioniert, steht im bereits oben erwähnten Eintrag zu TYPO3. Frohes bloggen!

Anders als bei TYPO3 wird der Inhalt nicht über Marker in den HTML Code transportiert, sondern direkt über dynamischen PHP Code. Diese Art der Templates finde ich sehr gut, weil man auf verschiedene Bedingungen einfacher reagieren kann als, z.B. mit Typoscript.

Allerdings erfordern solche Templates auch mehr Konsequenz vom Entwickler, denn Präsentation und Logik gehören nicht vermischt.

Jetzt kommt eine Übersicht der praktischen Kurzschreibweisen zum Verwenden in eigenen Projekten, WordPress oder TYPOlight.

Ausgaben

Um Variablen auszugeben wird das = Zeichen benutzt.

<?=$welcome_msg?>

<? echo $welcome_msg; ?>

Bedingungen

Die gute alte If-Abfrage kann auf zwei Weisen dargestellt werden. Die erste ist für Fälle in denen mehr Inhalt ausgegeben werden soll.

<? if($user == "admin"): ?>
  Hallo <b>Admin</b>, hier sind deine <a href="#" class="admin">Optionen</a><br>
  <div id="status"><h1>Projektstatus</h1></div> <!-- usw. usf. -->
<? endif; ?>

Alternativen lassen sich darin natürlich auch einbauen

<? if($user == "admin"): ?>
  ... viele Ausgaben ...
<? elseif($user == "redakteur"): ?>
  --- andere Ausgaben ----
<? else: ?>
  ___ alternative Ausgaben ___
<? endif; ?>

Die zweite ist noch kürzer. Wenn man keine komplexen Ausgaben hat sondern nur, z.B. einzelne Worte ausgeben möchte

<?=$owner == $user ? "meins" : "fremd"?>

Die Syntax ist etwas gewöhnungsbedürftig, aber schnell gelernt: Der erste Block ist die Abfrage, sie wird beendet vom Fragezeichen welches auch gleichzeitig den Block einleitet der bei erfüllter Bedingung ausgeführt wird. Abgeschlossen und gleichbedeutend mit else folgt dann der Doppelpunkt und die Else-Anweisung. Alle Teile müssen vorhanden sein, sonst funktioniert es nicht.

Ausgeschrieben ist die Abfrage gleichbedeutend mit:

<? if($owner == $user) {
  echo "meins";
}
else {
  echo "fremd";
}

Ein praktisches Beispiel wäre z.B. innerhalb einer Schleife:

<li class="<?=$i%2 == 0 ? "even" : "odd"?>"><=$content?></li>

Gut, dann weiter mit

Schleifen

Die Syntax der Schleifen ist im Prinzip genau die selbe. Die For-Schleife:

<? for($i = 0; $i < 10; $i++): ?>
  Zeile <?=$i?> von 10
<? endfor; ?>

hat die gleiche Syntax wie die Foreach-Schleife:

<? foreach($array as $key => $value): ?>
  Array: <?=$key?> = <?=$value?><br>
<? endforeach; ?>

Und die While-Schleife darf natürlich auch nicht fehlen:

<? while($row = mysql_fetch_object($hdl)): ?>
  Zeile <?=$row->uid?> gehört <?=$row->name?><br>
<? endwhile; ?>

Fazit

Das waren Kurzschreibweisen in PHP. Sind schon sehr schmal und können für ein übersichtliches Template sorgen, wenn der fleißige Entwickler sich an die Einrückung hält und Logik mit Präsentation nicht vermischt wird. Frohes Nachdenken!

UPDATE: Aufgrund von unendlich vielen unverständlichen, russichen Spamkommentaren habe ich die Kommentare geschlossen. Bei Fragen einfach bei der Ape Unit GmbH melden.

Zugegeben, ich bin nicht der größte Mathefan und bin heilfroh, dass soviel im Internet ohne funktioniert. Aber man darf sich bekanntlich nicht vor Wissen verschließen und wenn man dahinter gekommen ist, macht es ja auch Spaß!

So kürzlich geschehen mit der Funktion Modulo! Ich erinnere mich an all die dunklen Stunden, in denen ich halbherzig versucht habe das zu verstehen, aber es wollte einfach nicht so wie ich. Aber jetzt habe ich es raus und kann nur empfehlen: lest den Beitrag wenn ihr diese Operation noch nicht kennt oder versteht.

Einfach gesagt ist Modulo teilen durch ganze Zahlen und den Rest zurück kriegen. Der Operator ist in PHP und JavaScript das Prozentzeichen (%). So kann das Ergebnis aussehen:

0 modulo 5 = 0
1 modulo 5= 1
2 modulo 5= 2
3 modulo 5 = 3
4 modulo 5 = 4
5 modulo 5 = 0
6 modulo 5 = 1
7 modulo 5 = 2
8 modulo 5 = 3
9 modulo 5 = 4

Der PHP Code der das erzeugt hat ist der hier:

<?
  for($i = 0; $i < 10; $i++) {
    echo "$i modulo 5 = ". ($i%5). "<br>";
  }
?>

Wenn einem jetzt nicht auf Anhieb ein Anwendungsfall einfällt, dann sollte man sich überlegen was dieser Code tut:

<?
  $a = 0;
  $class = "";
  for($i = 0; $i < 10; $i++) {
    $a++;
    if($a > 1)
      $a = 0;
    $class = $a == 1 ? "even" : "odd";
    echo "$i modulo 5 = ". ($i%5). " ($class)<br>";
  }
?>

<?
  $class = "";
  for($i = 0; $i < 10; $i++) {
    $class = $i%2 ? "even" : "odd";
    echo "$i modulo 2 = ". ($i%2). " ($class)<br>";
  }
?>

dd

$("ul li:even").addClass("even");

Und wenn dieses Funktion bei mehreren Listen die verändert werden sollen anfängt rumzuspinnen, dann muss man sich klar machen, dass der Selektor $("ul li:even") alle zweiten Listenelemente auf der Seite trifft. Unabhängig davon in welcher Liste sie sich befinden.

Die Lösung ist mal wieder einfach: $("ul") selektiert alle Listen und dann behandeln wir jedes Listenelement einzelnd:

$("ul").find("li:even").addClass("zebra");

Viel Spaß und mit Mathe jQuery!

Diesmal gehts um den Location Hash. Das ist der Teil der URL der mit einer Raute (#) von der restlichen Adresse getrennt ist. Bekannt von Sprungmakern (interne Seitenverweise) gewinnt er im Zusammenspiel mit neusten JavaScripttechnologien immer mehr an Bedeutung.

HTML Grundlagen

Erstmal eine kurze Betrachtung ohne JavaScript. Der einfache Hash einer URL wird vom Browser interpretiert und der sichtbare Bereich der Seite springt zu dem Element dessen ID angegeben ist. Zum Beispiel für Überschriften praktisch.

<h1 id="wichtig">Es ist wichtig</h1>
<p>bla bla bla ...</p>
<h1 id="unten">Weiter unten</h1>
<p>noch mehr bla bla ...</p>

<a href="#wichtig">Zur wichtigen Überschrift</a>
<a href="#unten">Zur unteren Überschrift</a>

<a href="zweite-seite.html#irgendwo">Gehe nach irgendwo</a>

Zusammenspiel mit jQuery

Jetzt kommt das Lieblingsframework ins Spiel! Hier steht der Wert aus dem Hash als Attribut zur Verfügung! Ich benutze die gleiche HTML Grundlage wie im ersten Tutorial (man beachte den Sprungmarker ).

jQuery(function($) {
  $(".menu a").click(function() {
    alert($(this).attr("hash"));
    return false;
  });
});

Und was soll man damit machen? Ajaxanwendungen bauen!! Wenn für jeden Link ein aussagekräftiger Hashwert zur Verfügung steht, dann wird der einfach an ein serverseitiges Script weitergeleitet und das kann damit tun was immer notwendig ist. Ich bevorzuge das Folgende: Es gibt einfach alle übergebenen Variablen aus.

<?
  echo "<pre>", print_r($_REQUEST), "</pre>";
?>

Jetzt ohne viel Gerede die komplette Klickfunktion.

$(".menu a").click(function() {
  $(".menu a.active").removeClass("active");
  $(this).addClass("active").blur();
  
  $.ajax({
    url: "remote.php",
    data: {gib_mir: $(this).attr("hash").substr(1)},
    type: "POST",
    dataType: "HTML",
    
    success: function(remote_html) {
      $("#response").hide().html(remote_html).fadeIn();
    },
    error: function() {
      alert("Mist verdammter, etwas hat nicht geklappt  ");
    }
  });
});

Die ersten zwei Zeilen stammen aus dem ersten Tutorial und dienen nur der besseren Darstellung.
Dann kommt die Ajaxanfrage. Das ist ein Objekt mit einer ganzen Reihe Eigenschaften, die da wären:

• url gibt die aufzurufende Datei an.
• data ist ein neues Objekt mit allen Daten die übergeben werden sollen. jQuery kümmert sich, je nach Typ der Anfrage, um das korrekte verpacken und verschicken.
  Das Objekt hat eine Eigenschaft: gib_mir steht dann als Name im PHP Script zur Verfügung ($_POST["gib_mir"]). Der Wert ist das Attribut hash aus dem angeklickten Link. Substr(1) schneidet das erste Zeichen ab - das ist immer die Raute und die brauchen wir nicht mehr.
• type gibt den Datenübertragungsform an. Man könnte sagen GET bei kurzen Inhalten, POST bei langen. Mehr Informationen darüber bringt Google.
• dataType sagt jQuery welche Daten erwartet werden. Das sollte man nie vergessen, denn nach dieser Angabe wird die Variable für die Funktion hinter success formatiert.
• success ist die Funktion die ausgeführt wird wenn alles geklappt hat. In den Parametern ist die Antwort vom Script, hier also in remote_html.
  In dieser Funktion steht nur eine Zeile, die mal wieder die ganze Schönheit und Macht von jQuery demonstriert. Stück für Stück:
  $("#response") wählt das Element mit der ID response aus (z.B. ein DIV Container)
  hide() blendet ihn aus
  html() schreibt neuen HTML Code hinein
  und mit fadeIn() wird er sanft dem Benutzer wieder eingeblendet.
• error ist schließlich noch eine Funktion die ausgelöst wird wenn etwas nicht geklappt hat.

Das war Ajax! Ganz einfach. Die Ausgabe sieht z.B. so aus:

Array
(
  [gib_mir] => punkt4
)
1

$(location).attr("hash", $(this).attr("hash"));
return false;

Das Tolle an der Sache

Indem der Hash verändert wird, ist es möglich die URL zu verschicken, zu speichern und im Blog zu verlinken. Blöd allerdings, dass dabei nichts passiert.

Doch keine Panik, zwei Zeilen helfen weiter!

if($(location).attr("hash"))
  $("a[hash="+$(location).attr("hash")+"]").click();

Die (ich nenne sie mal) Event-Funktionen, z.B. click, mouseover, mouseup, dblclick usw., funktionieren auf zwei Arten: wird eine Funktion als Parameter übergeben, wird diese ausgeführt wenn das Event vom Benutzer ausgelöst wird (siehe oben $("a").click(function() { alert("Hallo A!"); });). Wird kein Parameter übergeben, löst jQuery die Funktion aus - wie als hätte der Benutzer darauf geklickt.

Und das hat zur Folge: Alle Links funktionieren! Die Seite reagiert auf den Hash und einem Verschicken steht nichts mehr im Wege!

Fazit

Mit Hilfe des Location Hash kann man Ajaxanwendungen bauen, die wissen an welcher Position der Benutzer einsteigen will. War das Tutorial verständlich?

Das Erste dreht sich um Menüs, bzw. Navigationen. Das JavaScript ist unaufdringlich und ermöglicht dem Nutzer durch ein paar einfache Tricks ein besseres Erlebnis. Benutzer ohne aktiviertes JavaScript werden nicht ausgeschlossen. Es geht um die Funktionen hover und click und ein bisschen CSS3. Fragen sind gern gesehen in den Kommentaren und jQuery auf jeder Seite!

Ziele festlegen

Bevor man mit einem IT-Projekt beginnt, ist es immer sinnvoll sich darüber klar zu werden, was erreicht werden soll. Und wenn mit Kunden gearbeitet wird, dann sollte man das schriftlich festhalten und solange darüber reden bis allen Parteien klar ist, was an welcher Stelle gemeint ist. Schwierig, aber man muss es versuchen!

In diesem Tutorial soll die Navigation verbessert werden, unaufdringlich und für jedes Projekt einsetzbar. Nebenbei lernt man die Grundfunktionen von jQuery kennen.

HTML Grundgerüst

Den Anfang bildet natürlich ein Menü. Für diverse Image Replacement Techniken, sonstigem CSS Schnickschnack bis hin zur IE Kompatibilität, nehme ich mal folgendes, universelles Grundgerüst, welches aus jedem CMS herauszukriegen sein sollte, sei es TYPO3, Typolight oder Drupal.

<ul class="menu">
  <li>
    <a href="#punkt1" class="active"><span>Punkt 1</span></a>
  </li>
  <li>
    <a href="#punkt2"><span>Punkt 2</span></a>
  </li>
  <li>
    <a href="#punkt3">Punkt 3</a>
  </li>
  <li>
    <a href="#punkt4">Punkt 4</a>
    <span>Ein Hinweistext!</span>
  </li>
</ul>

Diese Menü soll funktionieren, ohne dass JavaScript benötigt wird, bevor man anfängt. Das gleiche HTML als TYPO3 Template könnte so aussehen:

<ul class="menu">
  ###MAINMENU###
</ul>
<div id="content">
  ###CONTENT###
</div>

Das jQuery Grundgerüst

Nach dem Einbinden des Frameworks (zu Testzwecken oder wenn keine aktuelle Version zur Hand ist, auch gerne vom allmächtigen Googleserver: http://ajax.googleapis.com/ajax/libs/jquery/1.3/jquery.min.js) braucht man ein Plätzchen für das eigene Script. Entweder im Kopf des HTML Dokuments oder in einer externen Datei.

Gestartet wird immer mit einem simplen Hallo Welt.

jQuery(function($) {
  alert("Hallo Welt!");
});

Wird man beim Neuladen der Seite nicht von einer fröhlichen Alertbox begrüßt, muss man prüfen, ob alle JavaScripte geladen sind. Das geht am schnellsten mit Firebug und aktiviertem Scriptmodul. Hier testet man nach und nach ob alle Scripte vorhanden sind.

Mehr Klassen

Mit :hover, :active, :focus und :link gibt es schon ein paar Möglichkeiten für Links, aber wenn es um die ganzen Listenelemente geht, hört es (z.B. im IE6) schon wieder auf. Aber nicht mit jQuery! Die Funktion hover gibt uns genau das was wir brauchen.

$(".menu li").hover(function() {
  $(this).addClass("hover");
}, function() {
  $(this).removeClass("hover");
});

Im Schlüsselwort this ist das Element gespeichert, welches die Funktion gerade ausgelöst hat. Mit der Übergabe an jQuery $(this) stehen dann wieder alle gewohnten Funktionen zur Verfügung.

CSS3 Selektoren für jeden Browser

Der Hinweistext im span soll nur bei Mouseover gezeigt werden. Das lässt sich schnell und einfach per CSS lösen.

li>span {
  display:none;
}
li:hover>span {
  display:inline;
}

Das erste Problem ist das > Zeichen. Die Anweisung trifft auf alle Spanelemente zu, die sich direkt in einem Listenelement befinden. Würde man es weglassen, würde es auf alle Spanelemente zutreffen, die sich in einem Listenelement befinden. Dies hätte zur Folge, dass Punkt 1 und 2 ebenfalls verschwinden würden.

Die Lösung ist super einfach! jQuery unterstützt die meisten Eigenschaften von CSS3 und kümmert sich alleine darum, dass sie in jedem Browser funktionieren.

$("li>span").hide();

Um den Hinweistext wieder sichtbar zu machen, wird die hover Funktion erweitert. Die meisten Funktionen haben als Rückgabewert wieder ein jQuery-Objekt. Das bedeutet man kann sie einfach verknüpfen. Bei Mouseover sieht das z.B. so aus:

$(this).addClass("hover").find(">span").show();

Die Funktion bei Mouseout sieht, bis auf die letzte Funktion, genau so aus.

Der aktive Menüpunkt

Wenn das verwendete CMS dem Link die Klase active zuweist wenn sie angezeigt wird, dann ist es ein schöner Effekt, diese Klasse schon vor dem Neuladen  der Seite zuzuweisen:

$(".menu a").click(function() {
  $(this).addClass("active");
});

$(".menu a").click(function() {
  $(".menu a.active").removeClass("active");
  $(this).addClass("active").blur();
});

Fazit

Das war ein kleiner Ausblick in das jQuery Universum. Eigentlich wollte ich noch viel mehr schreiben, aber das ging schon länger als geplant. Deshalb mache ich lieber Schluss, freue mich auf Fragen und empfehle jedem Webentwickler sich mit jQuery auseinander zu setzen. Es macht Spaß und hier kommt bald die nächste Anleitung!

Nach dem ich mal wieder über den Appell an Webentwickler gestolpert bin, beginne ich meinen ersten zweiten Eintrag dieses Jahres mit einem tollen Thema welches ich zwischen den Jahren entdeckt habe: Die effektive Kommunikation zwischen TYPO3 und jQuery dank Ajax.

Möglich macht das die Funktionalität der eID seit TYPO3 Version 4 und die geniale Handhabung vom Lieblingsframework mit JSON. Eingesetzt hab ich es in einer tollen, neuen Extension die wir entwickelt haben und die hoffentlich bald das Licht der Welt erblicken wird. Das wird dann gesondert gefeiert.

Um was geht es?

Die Eingaben eines Benutzers werden asynchron, d.h. ohne die Seite neuzuladen, an den Server übergeben. Der verarbeitet sie und liefert ein Ergebnis zurück, welches von jQuery verarbeitet und dargestellt wird.

Gebraucht wird diese Technik um zum Beispiel registrierte Benutzer anzuzeigen. Ähnliches habe ich schon beschrieben im Beitrag über das nachladen kompletter Seiteninhalte. Dort wurde ein neuer Seitentyp angelegt. Das hat allerdings den Nachteil das die ganze Seite gerendert werden muss. Wir können schon wesentlich früher den Renderingprozess abbrechen und zügig ein Ergebnis bekommen.

Vorbereitungen mit TYPO3

Als erstes bereiten wir TYPO3 darauf vor und erstellen eine neue Extension mit dem Kickstarter. Ich habe ein Frontend Plugin erstellt und die üblichen Spracheinstellungen gewählt. Was man will ist also schnell zusammen geklickt.

Und jetzt wirds spannend: In der ext_localconf.php registrieren wir die eID (das e steht für Extension):

$TYPO3_CONF_VARS['FE']['eID_include']['MEINE_eID'] = 'EXT:kiwi_database/pi1/MEINE_eId.php';

Es geht um das Frontend, eine neue eID wird eingebunden, für die eben erstellte Erweiterung. MEINE_eID ist durch einen guten Namen zu ersetzen (Extensionkey vielleicht).
Im Wert der Variable ist der Pfad zum Script angegeben welches benutzt wird. EXT: zeigt auf den Ordner in dem die Extensions gespeichert sind, dann weiter zu unserer Erweiterung und zur speziellen Datei.

Ist diese Datei angelegt, einfach mal ein <? echo "Hallo Welt"; ?> darin speichern und zum Testen aufrufen, über den neuen Parameter eID: www.mein-typo3-projekt.de/index.php?eID=MEINE_eID. Wenn das auf eine weiße (super schnelle) Seite weiterleitet auf dem die Welt begrüßt wird, hat alles geklappt.

Wenn nicht, dann lohnt sich ein Blick ins Error Log von PHP und einfach weiter probieren (viel Glück).

Drei Dinge sind für die Datei MEINE_eId.php wichtig:

1. Sicherheit

if (!defined ('PATH_typo3conf')) die ('Could not access this script directly!');

2. Datenbankzugriff

$feUserObj = tslib_eidtools::initFeUser(); // Initialize FE user object
tslib_eidtools::connectDB(); //Connect to database

echo "<pre>", print_r($GLOBALS["TYPO3_DB"]), "</pre>";

3. Die eigene Extension

Und damit kommen wir zu einer Einschränkungen. Es gibt kein cObj, da keine Seite aufgebaut wurde. Man kann zwar, ähnlich der Datenbank eins erstellen, aber das ist nicht nur kompliziert sondern hebt den Grund der Extension auf, da dann wieder eine komplette Seite gerendert wird. Das zur Folge das es nicht möglich ist die Benutzereinstellungen im Typoscript abzufragen. Ich empfehle die Auslagerung in die localconf.php.

require_once('typo3conf/ext/meine_ext/pi1/class.tx_meineext_pi1.php');
$obj = t3lib_div::makeInstance("tx_meineext_pi1");

Langsam Richtung JSON

In der Extension wird jetzt abgefragt, was abgefragt werden muss. Zugriff auf in der URL übergebenen Parameter erhählt man z.B. über $GLOBALS["_GET"]["PARAMETER_NAME"].

Am Ende sollte ein Array zur Verfügung stehen, welches alle Daten beinhaltet. Das wird in JSON umgewandelt:

$response = $obj->getAnswer($GLOBALS["_GET"]);
echo json_encode($response);

Fertig, auf zum Frontend

page.includeJS.file1 = fileadmin/template/js/jQuery.js
page.includeJS.file2 = fileadmin/template/js/jquery.meineext.js

$(document).ready(function() {
	// Das Abschicken des Formulars verhindern
	$("#assi").submit(function() {

		//Ajaxabfrage stellen
		$.ajax({
			url: "index.php",		// Achtung mit RealURL!
			type: "GET",			// Daten per GET verschicken
			data: {
				eID: "MEINE_eID",	// die erstellte eID
				input: $("#assi input[type=text]")	// Benutzereingabe
			},
			dataType: "json",		// das gibts zurück

			// Es hat funktioniert?
			success: function(response) {
				// Code der ausgeführt wenns geklappt hat
				// !! Wesentliches Ding !!
			},

			// Schade, es war ein Fehler
			error: function(error) {
				alert("Sorry, hat nicht funktioniert");
			}
		});

		//Damit das Formular nicht doch noch abgeschickt wird
		return false;
	});
});

Ich mag jQuery Code! Nach einiger Zeit hat man sich an die wilden Klammern gewöhnt und kann nicht mehr damit aufhören. Die Kommentare erläutern die einzelnen Dinge, oder die offizielle Doku, wir wenden uns lieber dem wesentlichen Ding zu!

Verarbeitung von JSON Objekten zu HTML mit jQuery

Damit die Funktionen besser nachvollzogen werden können, ein Beispiel: So sieht die Funktion getAnswer() vereinfacht aus:

function getAnswer() {
	$a = Array(
		0 => Array("name" => "paul", "like" => "Webstandards"),
		1 => Array("name" => "ramon", "like" => "Bier"),
		2 => Array("name" => "max", "like" => "Sport")
	);
	return $a;
}

Das wird als JSON Objekt sowas:

[{"name":"paul","like":"Webstandards"},{"name":"ramon","like":"Bier"},{"name":"max","like":"Sport"}]

Im wesentlichen Teil der jQuery Ajaxabfrage steht dieser String jetzt als Objekt zur Verfügung. Testen lässt sich das über die Firebug Konsole mit console.log(response). Das und alles folgende spielt sich in der Funktion success(response) ab!

Jedes Array verfügt über die Eigenschaft length, es lässt sich also herausfinden wieviele Elemente vorhanden sind.

if(response.length > 0) {
}

Angenommen es gibt auf der Seite eine Liste (<ul>) mit der ID answer, dann wird diese mit neuen Listenelementen versorgt:

var new_content = "";
$.each(response, function(i, row) {
	new_content+= "<li><strong>"+row.name+"</strong> mag "+row.like+"!</li>";
});
$("#answer").html(new_content);

Die Funktion, welche auf jede Zeile angewendet wird, erwartet zwei Parameter: i ist der Indikator welcher die aktuelle Position beinhaltet, row ist das aktuelle Objekt. Die Schlüssel aus dem PHP Array sind hier die Namen der Eigenschaften, herrlich oder?

Fertig!

Um die Besucher ohne JavaScript nicht außen vor zu lassen muss noch sichergestellt werden, dass die Extension bei "normal" erhalten der Daten die gleiche Ausgabe erzeugt. Das dürfte bekannt sein?!

Um sich den Stress mit einem Template zu sparen gibt es dann in ein paar Tagen irgendwann meine neue Extension! Bis dahin wünsche ich erfolgreiches Programmieren in 09!

Herrlich, oder? Das ist alles kein Problem mit TYPO3 und jQuery. Undzwar mit Hausmitteln, ohne ein einziges Plugin. Eine Demo gibt es auf meiner privaten Seite unter Paul-Lunow.de, die ausführliche Anleitung hier im Blog.

TYPO3 vorbereiten

In dem Beitrag zum automatischen Infofenster für TYPO3 bin ich schon auf die Technik eingegangen: Wir erstellen einen neuen Seitentyp mit Typoscript um nur die Inhalte bei einem Aufruf zu bekommen.

nurinhalt = PAGE
nurinhalt {
  typeNum = 101
}

Die neue Seite heißt nurinhalt und bekommt die Nummer 101 zugewiesen. Man achte allerdings darauf keine doppelten Nummern zu vergeben!

nurinhalt.10 < page.10

Mit dieser Anweisung wird der Inhalt von der normalen Seite in das neue Objekt kopiert.

nurinhalt.10.template.file = fileadmin/template/index-nurinhalt.html

Jetzt weisen wir der Seite ein neues Template zu. Hier kann man noch ein bisschen rumspielen und einige Extrasachen machen wenn man möchte, ist ein ganz normales Template.
In meiner Version besteht es nur aus einer Zeile:

###INHALT###

Mehr als den Inhalt will ich nicht haben.

Nach dem das Typoscript gespeichert, das neue Template erstellt und der Cache gelöscht ist, sollte man die Ausgabe einmal testen: www.meine-typo3.de/praesenz/index.php?type=101. Funktioniert? Gut.

Allerdings gibts noch eine Kleinigkeit: Die Seite kommt im kompletten HTML Gerüst daher. Zum Glück können wir das unterbinden:

nurinhalt.config {
   #entfernt diverse header angaben
   disableAllHeaderCode = 1 

   #standard doctype deaktivieren
   disableCharsetHeader = 1

   #entfern die HTML Kommentare
   disablePrefixComment = 1
}

JavaScript vorbereiten

Zurück zum "richtigen" Frontend. jQuery muss eingebunden werden und ich empfehle eine Datei Namens actions.js, für unser zu erstellendes Script. Das geschieht wieder im Standardseitentyp (bei mir stets page).

$(document).ready(function() {
	alert("Hallo!");
});

Seite neuladen und wenn wir mit einem (fröhlichen) Hallo! begrüßt werden, hats funktioniert und wir ersetzen das Alert durch unser Script.

Im ersten Schritt muss der Klick auf ein Menüpunkt abgefangen werden und verhindert das die neue Seite geladen wird:

$("#menu a").click(function() {
  url = $(this).attr("href");
  alert("Geklickt auf "+url);
  return false;
});

Drei Dinge passieren bei einem Klick auf einen Link im Objekt, welches die ID menu hat:

Der Variable url wird das Attribut href aus dem Link zugewiesen, zur späteren Verwendung (z.B. index.php?id=123).

Mit alert wird überprüft ob es funktioniert hat.

return false; verhindert das der Browser die Seite lädt. Funktionierts?

Gut! Dann laden wir den Inhalt vom Server. Dafür wird eine neue Funktion erstellt, welche eine URL erwartet und diese lädt.

$(document).ready(function() {
	//Zeug von oben...
});

function getContent(url) {
	//Hier kommt der Ajaxaufruf
}

Die neue Funktion getContent() ersetzt die Alertanweisung aus dem vorherigen Schritt. Der vollständige Aufruf sieht dann so aus:

$(document).ready(function() {
  $("#menu a").click(function() {
    url = $(this).attr("href");
    getContent(url);
    return false;
  });
});

Dann mal Ajax. Ist genauso einfach:

$.ajax({
	//erweitere aufzurufenden Link
	url: url+"&type=101",
	dataType: "html",
	//wenn es geklappt hat
	success: function(html) {
		//Inhalt reinschreiben und anzeigen
		$("#content")
			.css("display", "none")
			.html(html)
			.fadeIn();
	}
});

Das sieht doch schon wieder etwas professioneller aus. Der übergebenen url wird ein &type=101 angehängt um aus TYPO3 nur den Inhalt herauszuholen. Mit der Eigenschaft dataType zeigen wir an, dass eine HTML Seite als Rückgabewert erwartet wird.

Wenn das geklappt hat wird das Element mit der ID content ausgewählt. Dann folgt die geniale Verkettung von Funktionen:
- Das Element wird versteckt (würde auch mit hide() funktionieren)
- Das Element kriegt einen neuen Inhalt (den gerade geladenen)
- Und wird eingeblendet!

Fertig! Was für ein Erlebnis für den Benutzer. Und ohne JavaScript bleibt die Seite wie gewohnt nutzbar.

Ähmmm... nicht so ganz? Dann auf zur Fehlersuche: Der wichtigste Ansatzpunkt ist natürlich Firebug. Man aktiviert die Konsole und kann sich alle asynchronen Datenbewegungen ansehen. Vielleicht wird eine nicht vorhandene URL aufgerufen, oder der Server versteht die Anfrage nicht. Dann muss man seine Ajaxabfrage verbessern. Mehr Informationen dazu liefert die offizielle jQuery Seite (und noch dutzend andere).

Verbesserung 1: Sanftes Ausblenden

Damit der alte Inhalt nicht einfach verschwindet, benutzen wir eine Callback Funktion von jQuery: ajaxStart.

$("#content").ajaxStart(function() {
	$(this).fadeOut(function() {
		$(this).addClass("loading");
	});
});

Diese Funktion wird aufgerufen wenn eine Ajaxabfrage gestartet wird, blendet den Inhalt aus und fügt die Klasse loading hinzu was aber eigentlich nichts bringt, denn das Element ist ja ausgeblendet (aber für Vollständigkeit).

Verbesserung 2: Bookmarks und Vor- und Zurückknöpfe

Beim dynamischen nachladen hat man das Problem das sich die Adresszeile nicht ändert, der Browser also nicht mitkriegt das eine neue Seite geladen wurde. Außerdem kann man keinen Link auf eine bestimmte Seite setzen.

Das müssen wir ändern! Dafür benutzen wir Anker, die sind von der URL durch eine Raute getrennt. Mit dem JavaScript Objekt location.hash können wir die schreiben und lesen.

Als erstes schreiben: In der Success Funktion vom Ajaxaufruf fügen wir eine Zeile hinzu.

location.hash = url;

Damit kriegen wir dann folgende Adresse, nach dem ein neuer Inhalt geladen wurde:

www.meine-typo3.de/praesenz/index.php?id=123#index.php?id=321

Und diese Angabe müssen wir beim laden der Seite auch wieder abfragen:

if(location.hash) {
	x = location.hash;
	getContent(x.slice(1));
}

Ist ein Anker vorhanden, wird er der Variable x zugewiesen. Danach rufen wir unsere schon vorbereitete Funktion getContent auf und der Inhalt wird geladen!

Mit der Funktion slice(1) wird das erste Zeichen herausgeschnitten (bzw. alles andere), denn die Raute würde unser Script verwirren.

Verbesserung 3: Verwendung von RealURL

Ja, auch das ist möglich und macht die Seite noch viel schöner. Der erste Schritt dafür ist den neuen PageType über RealURL ansprechbar zu machen. Ich denke da an

www.meine-typo3.de/praesenz/start/ajax.html

Mit der Version 2.5 ist es (endlich) ein Kinderspiel: Die Datei localconf.php wird um ein paar Zeilen erweitert.

$TYPO3_CONF_VARS['EXTCONF']['realurl']['_DEFAULT'] = array(
	'pagePath' => array (
		'type' => 'user',
		'userFunc' => 'EXT:realurl/class.tx_realurl_advanced.php:&tx_realurl_advanced->main',
		'spaceCharacter' => '-',
		'expireDays' => 3,
		'rootpage_id' => '1',
	),
	'fileName' => array (
		'defaultToHTMLsuffixOnPrev' => 1,
		'index' => array(
			'ajax.html' => array(
				'keyValues' => array ('type' => 101)
			),
		),
	),
);

Anschließend sind noch ein paar Dinge im JavaScript zu verändern. Weil ich langsam genug vom Schreiben habe, kommt jetzt das komplette Script mit einigen erklärenden Kommentaren.

$(document).ready(function() {
	//Auf den ggf. übermittelten Anker reagieren
	if(location.hash) {
		x = location.hash;
		getContent(x.slice(1)+".html");
	}

	//Links per Ajax nachladen
	//$("a:not([href^='http://'])").click(function() {
	$("#menu a").click(function() {
		url = $(this).attr("href");
		getContent(url);
		$(this).blur();
		return false;
	});

	//Informieren das etwas passiert
	$("#content").ajaxStart(function() {
		$(this).fadeOut(function() {
			$(this)
				.text("")
				.addClass("loading")
				.fadeIn();
		});
	});

});

/*
 *	Holt den Inhalt vom Server
 */
function getContent(url) {
	$.ajax({
	//erweitere aufzurufenden Link
	url: url.replace(/\.html/, "/ajax.html"),
	//wenn es geklappt hat
	success: function(html) {
		//Inhalt reinschreiben und anzeigen
		$("#content")
			.removeClass("loading")
			.css("display", "none")
			.html(html)
			.fadeIn();
		//Adresszeile aktualisieren
		location.hash = url.replace(/\.html/, "");
	}
	});
}

Fazit

jQuery und TYPO3 bieten mal wieder alles an was man sich wünschen kann. Eine funktionierende Demo befindet sich auf meiner Seite.
Über Kommentare und Verbesserungsvorschläge würde ich mich sehr freuen.

Bis dahin frohes Programmieren!

Dabei konnte ich die ganze Zeit lächeln weil es mit jQuery so viel Spaß macht zu arbeiten. Und das will ich natürlich niemandem vorenthalten. Eine einzige Zeile reicht aus um eine ganze Reihe Aktionen für alle Browser (auch den IE6) auszuführen. Man kann sehr einfach abfragen ob Checkboxen angeklickt sind oder nicht.

Außerdem habe ich eine tolle Funktion entdeckt um zu verhindern das auffahrende Elemente außerhalb des sichtbaren Bereichs liegen. Viel Spaß damit!

Verkette Funktionen nutzen

Um unaufdringliches JavaScript zu schreiben ist es wichtig die Eventhandler erst mit der Laufzeit des Scripts den Elemente zuzuweisen damit nicht JavaScript-fähige Betrachter dadurch nicht verwirrt werden.

Es gibt also ein Formular welches ohne JavaScript funktioniert und mit JavaScript noch besser wird. Hier ein vereinfachter HTML Aufbau:

<form>
	<fieldset>
		<label for="auswahl">Auswahl</label>
		<select name="auswahl" id="auswahl">
			<option>Bitte auswählen...</option>
			<option value=1>Nr 1</option>
			<option value=2>Nr 2</option>
		</select>
	</fieldset>

	<fieldset class="step2">
		<label for="name">Name</label>
		<input type="text" name="name" id="name">

		<label for="stadt">Stadt</label>
		<input type="text" name="stadt" id="stadt">

		<label for="cool">
			<input type="checkbox" name="cool" id="cool" value="true"> Ich kann jQuery
		</label>
	</fieldset>
	<input type="submit" value="Eintragen" class="submit">
</form>

Die Anforderung ist, nur wenn der Benutzer Nr 2 auswählt soll er seinen Namen und die Stadt angeben. Nutzer ohne JavaScript können alles ausfüllen.
Und jetzt kommt das magische jQuery ins Spiel:

$(document).ready(function() {
	$("form").
		.find(".step2").hide().end()
		.find("#auswahl").change(function() { step2($(this).val(); ) }).end()
		.find(":input:first").focus().end()
		.submit(function() { step3(); return false; });
});

Ist das nicht schön? Was ist hier passiert? Grundlegend selektieren wir mit $("form") das komplette Formular und alle enthaltenen Elemente. Die Funktion find() sucht aus diesem Stapel die gewünschten Elemente heraus auf welche die folgenden Funktionen angewendet werden.
Mit end() am Ende jeder Zeile wird diese Auswahl wieder aufgehoben, im Stapel befinden sich jetzt wieder alle Elemente.

In der ersten Zeile wird das zweite Fieldset ausgeblendet, bzw. alles was sich im Formular befindet und die Klasse .step2 hat.
Zeile Zwei legt einen Eventhandler auf die Selectbox mit der ID auswahl. Was passiert habe ich der besseren Übersicht in eine andere Funktion ausgelagert.
Zeile drei ist richtig cool. Mit dem Doppelpunkt werden Psydoklassen eingeleitet. :input steht für sämtliche Eingabefelder und :first für das erste Element. Wir selektieren also das erste Eingabefeld im Formular und geben diesem den Fokus. Aber vorsicht, auch Eingabefelder von Typ hidden fallen hier runter. Daran muss man denken.
Anschließend wird dem Formular noch ein Eventhandler zugewiesen der das Abschicken auffängt. Hier ist das return false; wichtig damit das Formular nicht wirklich abgeschickt wird.

Herrlich, oder?

Der richtige Umgang mit Checkboxen

Wenn man auf die Checkbox klickt soll was passieren. Mein erster Gedanke war einen Eventhandler auf die Checkbox zu legen: change(). Verändert sie sich, soll eine Aktion ausgeführt werden. Funktioniert so aber nur halb im Internet Explorer, weil der Event erst ausgelöst wird wenn sich der Fokus nicht mehr im Element befindet.
Lösung: nicht change() benutzen sondern click(). Das war einfach.

Eine Funktion wird aufgerufen, allerdings weiß man nicht ob die Box nun angehakt ist oder nicht. Also frage ich einfach mit $(this).val() den Inhalt ab, aber denkste: der ist immer gleich!
Lösung: Wir bedienen uns der Psydoklassen. Das geniale jQuery bringt zum einen die Psydoklasse :checked mit, zum anderen die Funktion is(). Das könnte man doch super kombinieren, oder?

$("#cool").click(function() {
	if($(this).is(":checked"))
		//Ist angehakt - mach was
	else
		//Ist nicht angehakt - machs wieder rückgängig (bitte)
});

Firefox machts, aber der Internet Explorer hält den abgefragen Ausdruck immer für wahr (leichtgläubig). Glücklicherweise ist der Workaround einfach:

if($(this).is(":checked") == "true")

Und schon macht der IE auch mit. Danke sehr!

Abfragen in den Selektoren

Eine Kleinigkeit war noch: Der Kunde wollte je nach Auswahl eine andere Beschreibung für eins der Felder. Kein Problem, da mit jQuery jedes Attribut in den Selektoren abgefragt werden kann:

if($("#einfeld").val() == "bla")) {
	$("label[for=anderesfeld]").text("Andere Bezeichnung");
}
else {
	$("label[for=anderesfeld]").text("Diese Bezeichnung");
}

Automatisch scrollen

Okay, fieldset.step2 soll sich ausrollen, wenn die richtige Option gewählt ist. Das Problem: auf kleinen Monitoren ist, dass es sich zwar schön ausrollt, aber der Benutzer kriegt davon nichts mit, weil es außerhalb des sichtbaren Bereichs liegt.

Aber es gibt nichts was mit jQuery nicht funktionieren würde. Die Lösung: Jedes Objekt besitzt eine Funktion scrollIntoView(). Die rufen wir einfach auf wenns fertig ist.

function step2() {
	$(".step2").slideDown(function() {
		$(this)[0].scrollIntoView();
	});
}

Zu beachten ist das [0], denn die Funktion steht nur einem einzelnen Objekt zur Verfügung, nicht einem ganzen Stapel von Objekten. Wenn man sich unsicher ist, einfach console.log($(this)); und solange rumklicken bis man die Funktion gefunden hat (im Firebug).

Da im Fieldset lauter Eingabefelder vorhanden sind, können wir die Zeile sogar noch ein bisschen schöner machen:

$(this).find(":input:first").focus()[0].scrollIntoView();

Geht es noch effektiver?!?!?! Ich glaube kaum. Und jetzt lächelnd wieder an die Arbeit.

Aber purer Inhalt ist noch nicht alles. Die Seite soll besser werden und die Besucher sollen etwas geboten kriegen. Deshalb dreht sich dieser Artikel darum wie man eine Seite besser machen kann. Es gibt ein paar Tipps und Tricks und Anleitungen die sich im täglichen "Netzleben" bewährt haben.

Mein neuer Freund Firebug

Firebug ist eine Extension für unseren Lieblingsbrowser: den Firefox. Sie erlaubt es eine Seite zu untersuchen, den Quelltext zu entdecken und verknüpfte CSS Regeln anzuzeigen. Es ist auch möglich Regeln zu deaktivieren, zu verändern oder neue hinzuzufügen (und noch viel mehr, das kann ich hier aber nicht alles beschreiben).

Also: Firebug installieren! Danach gibt es ein kleines Symbol rechts unten in der Statuszeile des Browsers. Ein Klick darauf öffnet das Fenster.

Hier ist das nützlichste Tool das sog. Untersuchen. Ein Klick darauf und anschließend auf ein Element in der Webseite zeigt es an, den Pfad und auf der rechten Seite die verknüpften CSS Regeln. Ein sehr praktisches Tool um zu sehen wie andere Leute etwas hinbekommen haben.

Es lohnt sich aufjedenfall mit diesem Ding rumzuspielen, ein optimales Tool um jede Menge zu lernen und auszuprobieren.

Statische Seiten imitieren

Ein tolles Programm bei der Webseitenerstellung ist mod_rewrite. Das ist ein Modul für den Apache Webserver. Mit dessen Hilfe ist es möglich die Adressen einer Seite zu verändern. Zur Zeit ist z.B. die Kontaktseite über folgende Adresse aufrufbar:

http://www.domain.de/index.php?page=kontakt

Aber es wäre viel schöner wenn es so aussieht:

http://www.domain.de/kontakt/

oder? Und genau dafür ist mod_rewrite gedacht. Wir machen aus dynamischen URLs statische. Dazu müssen wir eine neue Datei im Rootverzeichnis anlegen (dort wo die index.php liegt). Die neue Datei heißt .htaccess. Man beachte den führenden Punkt, das bedeutet die Datei ist versteckt. Im verwendeten FTP Programm muss man vielleicht noch angeben das versteckte Dateien angezeigt werden sollen.

Ist das geschafft, die neue Datei öffnen und folgende Zeilen hinein kopieren.

RewriteEngine on
RewriteRule ^([a-z0-9_-]*)/?$ index.php?page=$1

Folgendes passiert: in der ersten Zeile wird das Modul angeschaltet. Anschließend können soviele Regeln wie benötigt hinzugeschrieben werden.
Regeln beginnen immer mit RewriteRule, einem regulären Ausdruck der auf die aufgerufene Adresse angewendet wird und einem Ergebnis welches angezeigt wird. Möchte man also hallo zu hello umwandeln genügt RewriteRule hallo hello.
Aber so einfach machen wir es uns natürlich nicht! Mit der oben aufgeschriebenen Regel werden alle Aufrufe an die index.php weitergeleitet. Man kann auch Unterseiten unterstützen:

RewriteRule ^([a-z0-9_-]*)/([a-z0-9_-]*)/?$ index.php?page=$1&subpage=$2

Damit wird der erste Teil in die Variable page geschrieben, der zweite in subpage. Wer bei Google nach Anleitungen und Informationen sucht wird jede Menge finden.

Um zu überprüfen was an PHP übergeben wird, kann man sich das globale Array GET ausgeben lassen:

<?
  echo "<pre>", print_r($_GET), "</pre>";
?>

Dabei sollte dann etwas in diese Richtung bei rauskommen:

Array
(
    [page] => fotos2
    [subpage] => bla
)
1

Je nach dem was man aufgerufen hat.

Einen absoluten Pfad definieren

Wenn man eine externe CSS Datei eingebunden hat oder Bilder, wird man feststellen das diese mit aktiviertem URL Rewriting nicht mehr funktionieren. Das liegt daran, dass die HTML Seite jetzt "denkt" wir befänden uns in einem Ordner auf dem Webserver (http://www.domain.de/fotos/ sieht aus als wäre "fotos" ein Ordner).
Um das zu verhindern müssen wir bei sämtlichen Resourcen die von externen Quellen eingebunden werden einen absoluten Pfad vergeben. Der beginnt immer mit http:// und sollte nur einmal definiert werden, und das ganz am Anfang der index.php:

<?
  define("PFAD", "http://www.domain.de/");
?>

Mit diesem PHP Befehl definieren wir eine Konstante PFAD die jetzt überall zur Verfügung steht. Es ist wichtig sich zu merken ob man einen Slash am Ende schreibt oder nicht

Jetzt muss die Seite durchsucht werden und Links und externe Resourcen herausgefunden werden. Hier zwei Beispiele:

<link rel="stylesheet" href="style.css">
<a href="index.php?page=kontakt">Kontakt</a>

Beide Elemente sind relativ eingebunden (sie fangen nicht mit http:// an). Um die Konstante PFAD auszugeben bedienen wir uns der PHP Kurzschreibweise. Diese beginnt mit dem gewohnten PHP Tag <?, gefogt vom einem Ist-Gleich-Zeichen =, dem Konstantennamen und einem schließenden Tag.

<link rel="stylesheet" href="<?=PFAD?>style.css">
<a href="<?=PFAD?>kontakt">Kontakt</a>

Damit wird die oben eingegebene Adresse einfach an der entsprechenden Stelle ausgegeben und schon sind alle Verknüpfungen absolut. Um zu testen ob es funktioniert, ändern und den Quelltext der Seite anschauen. Man beachte auch die geänderte Adresse vom Link (nur noch kontakt - cool, oder?).

Warum wird nicht überall einfach die Domain eingetragen? In den ersten Teilen haben wir gelernt nichts doppelt zu schreiben. Und wenn jetzt überall http://www.domain.de steht, man dann aber feststellt, dass man domain.de ja mit der eigenen Adresse austauschen sollte, dann ärgert man sich über hunderte Stellen an der Änderungen vorgenommen werden müssen. Genauso wenn man eine neue Domain hat.
Sehr viel besser also wenn man in der ersten Zeile seiner index.php einmal die Änderung vornimmt und schon ist es für den gesamten Webauftritt erledigt.

Also nicht vergessen: Bei allen Verknüpfungen diese Kurzschreibweise voranstellen!

Hervorheben der aktuellen Seite

Wir haben ja unser Mini CMS, d.h. es wird eigentlich immer die gleiche Seite aufgerufen und nur dynamisch neuer Inhalt eingebunden. Trotzdem müssen wir den geneigten Besucher darüber informieren auf welcher Seite er sich gerade befindet.
Dafür bedienen wir uns wieder der Kurzschreibweise von PHP und fragen für jeden Link ab, ob er augerufen wurde. Ist dies der Fall fügen wir eine Klasse "aktiv" zum Link hinzu, über welche per CSS der Link entsprechend formatiert werden kann.

<a href="<?=PFAD?>kontakt" class="<?=$_GET["page"]=="kontakt" ? "aktiv" : ""?>">Kontakt</a>

So, das sieht jetzt schon relativ kompliziert aus, aber man gewöhnt sich daran. Von Anfang an:
<?= ist die einleitende Kurzschreibweise für einen PHP Befehl.
$_GET["page"] ist die Variable die wir im URL Rewriting angegeben haben und welche den Namen der aktuellen Seite beinhaltet.
== ist ein Vergleichsoperator. Der verknüpft zwei Werte miteinander und gibt true (=wahr) zurück, wenn beide Werte gleich sind (das ist eine Wissenschaft für sich).
"kontakt" ist der aktuelle Link und der Wert mit dem die Variable verglichen wird.
? "fragt" ob der vorangegangene Ausdruck wahr ist. Ist dies der Fall wird der nächste Ausdruck zurück gegeben:
"aktiv" ist der zurückgegebene Wert wenn die Variable den Inhalt kontakt hat.
: kennzeichnet den alternativen Teil, d.h. wenn der Ausdruck nicht wahr ist.
"" ist einfach nur ein leerer Ausdruck, weil wenn die Seite nicht gerade aufgerufen wird, dann kriegt der Link auch keine Klasse zugewiesen.
?> beendet den PHP Befehl wieder.

In der CSS Datei wird dann in einer weiteren Regel das Aussehen des aktiven Links definiert.

a.aktiv {
  font-weight:bold;
  font-size:20px;
}

In diesem Beispiel also fett und riesen groß.

Besucher zählen

Als Webmaster möchte man ja wissen wie viele Menschen sich auf der eigenen Seite herumtreiben. Dafür empfehle ich Google Analytics. Es wird gemunkelt das das Ranking einer Seite verbessert wird wenn man Google Analytics einsetzt, aber wie dem auch sei, es ist ein wirklich gutes Programm mit vielen interessanten Möglichkeiten.

Der erste Schritt ist ein Google Account anzulegen und diesen für Google Analytics zu aktivieren (bei der Datenkracke ist das alles leichter als es sich anhört).
Wenn das geschafft ist, muss man ein neues Webseitenprofil anlegen mit der eigenen Domain (einfach den Anleitungen folgen).
Abschließend gibt es einen JavaScript Code den man auf die eigene Seite, unmittelbar vor dem schließenden Body-Tag einfügt.
Geschafft! Google braucht ein paar Stunden um die Seiten zu indizieren, aber dann wird gezählt.

Die Hilfe von GA ist gut gemacht und bietet viele, viele Informationen. Wer ein paar Minuten Zeit hat sollte da unbedingt einmal reingucken.

Das wars für heute. Viel Spaß beim probieren und Webseite optimieren! Wenn noch etwas fehlt, dann hinterlass einen Kommentar, und vielleicht wird es in der nächsten Folge besprochen