Innerhalb der kleinen Spielerei sind diverse Anpassungen für Media Queries drin, so dass die Seite auch einen Effekt hat, wenn man die Größe des Browsers ändert bzw. mit verschiedenen Geräten auf die Seite gelangt. Dabei habe ich keinen Wert auf Schönheit gelegt, sondern eher Pragmatismus und Effekthascherei genutzt. So nutze ich Transition via CSS3 um das Verändern etwas animiert zu gestalten und so die Darstellung zu hübschen.
Schaut euch den Code einfach an, entweder direkt auf der Seite oder im Projekt auf github, wo ich alles abgelegt habe.

Für alle, denen noch der Zusammenhang fehlt; bitte einfach die Seite besuchen und den Browser in der Größe ändern; dabei die Ausgabe am oberen Rand beachten. Alternativ dieses kleine Video.

Mir ist klar, dass dies nicht die beste Lösung ist, da Media Queries in jeder erdenklichen Form auftauchen können und die Ausgabe den größten Nutzwert hat, wenn man die Ausgabe der optimierten Größe anpasst. Aber es stellt eine einfache und schnell Lösung dar. Alternativen sind vermutlich via JavaScript denkbar, die das Stylesheet parsen und anhand der gefunden Anweisungen zu Media Queries den Viewport auswerfen – aber diese Form erfordert etwas mehr zeit und Kraft; also schnell überzogen und in meinem Fall ist die vorgestellte Lösung vollkommen ausreichend; durch die Erweiterungen von Frederic sind auch noch andere Viewports eingeflossen und in diesem Zusammenhang habe ich mir bekannte typische Größen und Ausrichtungen integriert – Portrait und Landscape. Alles weitere seht ihr in der angesprochenen debug.css und direkt auf der Seite, die den Source des Stylesheets ausgibt.

© Frank Bültge, All rights reserved / Alle Rechte vorbehalten. (ID: 6e8b33de4342c4f2ca76b245199aeee8)

Danke für das Abonnieren meines Feed! Inhalt gefällt? Danke sagen · Kommentieren

Spread some developer love and promote the docs

© Frank Bültge, All rights reserved / Alle Rechte vorbehalten. (ID: 6e8b33de4342c4f2ca76b245199aeee8)

Danke für das Abonnieren meines Feed! Inhalt gefällt? Danke sagen · Kommentieren

Ich habe ein freies Script erstellt, welches nichts leistet, aber die kleine Auswahl an Schriften schön demonstriert und als Umgebung nutze ich die IDE Aptana, in der ich gerne arbeite; aktuell noch Version 2.*; wobei die neue Version 3 mit vielen Features aufwartet und aktuell als Beta genutzt werden kann.

Ich habe alle Fonts mit der gleichen Größe übernommen und auch die Screenshots sind gleich, so dass ihr euch ein Bild machen könnt. Weitere Vorschläge und Vorlieben bitte in den Kommentaren.

Während ich auf dem System mit der Droid sehr zufrieden bin, nutze ich im Editor in der Regel die Monospace. Unter Windows nutze ich die Consolas, 11 Punkte Regular.

Monospace 11 Regular

Andale mono 11 Regular

Courier New 11  Regular

Verdana 11 Regular

Inconsolata 11 Regular

Free mono 11 Regular

Droid 11 Regular

DejaVu 11 Regular

© Frank Bültge, All rights reserved / Alle Rechte vorbehalten. (ID: 6e8b33de4342c4f2ca76b245199aeee8)

Danke für das Abonnieren meines Feed! Inhalt gefällt? Danke sagen · Kommentieren

The debugConsole is a tool for debugging and tracing PHP5 applications on productive servers without compromising the live-traffic.

Warum also nicht auch hier und darum hier eine kleiner Hinweis und ein kleines erstes Plugin zum spielen und testen der Konsole.

Aktuell habe ich nur ein Demo-Plugin erstellt, was die Funktion zeigt. Es wird auch nicht gepflegt, kann aber hier herunter geladen werden. Als kleiner Start quasi und schneller Blick auf die Möglichkeiten. Ich habe dabei die Beispiele des Autors der debugConsole integriert.

Das Plugin hat folgenden Quellcode und ihr könnt an jeder URL aus der WP-Installation den String ?debug=true anhängen, so dass das Popup mit den Informationen der Konsole aufgerufen wird. Aktuell ist dies für Frontend und Backend möglich.

<?php
/*
Plugin Name: debugConsole
Plugin URI: http://bueltge.de/
Text Domain: debugconsole
Domain Path: /languages
Description: The <a href="http://www.debugconsole.de/">debugConsole</a> is a tool for debugging and tracing PHP5 applications on productive servers without compromising the live-traffic. Add <code>?debug=true</code> to the URL for see the Popup-Window with debugConsole
Author: Frank B&uuml;ltge
Version: 0.1
Author URI: http://bueltge.de/
Donate URI: http://bueltge.de/wunschliste/
License: Apache License
Last change: 14.10.2010 11:30:51
*/ 

/**
License:
==============================================================================
Copyright 2010 Frank Bueltge  (email : frank@bueltge.de)

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

Requirements:
==============================================================================
This plugin requires WordPress >= 2.7 and tested with PHP Interpreter >= 5.2.9
*/

/* PHP5 required */
if (version_compare(PHP_VERSION, '5.0.0') < 0) {
	die('The debugConsole requires PHP 5.x.x or greater.');
}

/* load debugConsole functionality */
require_once 'debugconsole-1.3.0/debugConsole.php';

// add ?debug=true to the URL
if ( isset($_GET['debug']) && $_GET['debug'] == 'true') {
	add_action( 'wp_footer', 'wp_debug_console' );
	add_action( 'admin_footer', 'wp_debug_console' );
}

function wp_debug_console() {

	/**
	* debugConsole demonstration
	*
	* This script demonstrates each feature of the debugConsole. The
	* debugConsole is a PHP5 class using JavaScripts to show debug
	* information in a popup window. The popup has IP-based access
	* control. Configurate everything in debugConsole.config.php.
	* Additionally, PHP's default errorhandler is replaced.
	*
	* @author Andreas Demmer <mail@andreas-demmer.de>
	* @version 1.0.1
	* @package debugConsole_1.2.0
	*/

	/*
	Now you got an extended commandset:

	dc_watch()           watch variable changes in console
	dc_dump()            var_dump variables in console
	dc_here()            mark checkpoints in console
	dc_start_timer()     measure a timespan
	dc_stop_timer()      output timespan in console
	*/

	/* test watches */
	dc_watch('foo');

	declare (ticks = 1) {
		$foo = '1';
		$foo++;

		/* test checkpoints */
		dc_here('The interpreter passed through here!');

		/* test timer clock */
		$myTimer = dc_start_timer('Measure an one second sleep:');
		sleep(1);
		dc_stop_timer($myTimer);

		/* test variable debugging */
		$bar = 42.0;
		dc_dump($bar, '$bar tells us the meaning of life:');

		$foobar = array (
				'foo' => $foo,
				'bar' => $bar
		);

		dc_dump($foobar, '$foobar is a neat array!');

		/* test errorhandling */
		echo $notSet;
		fopen('not existing!', 'r');
	}

}
?>

Download:

Ist die Arbeit nicht 1 Euro wert?
Jede Spende wird dankbar angenommen und ermöglicht das weitere Arbeiten an freier Software.
Möchtest du mehr oder anders spenden, so besuche meine Wunschliste.
Download als zip-Datei: debugConsole.zip - 131 kByte

© Frank Bültge, All rights reserved / Alle Rechte vorbehalten. (ID: 6e8b33de4342c4f2ca76b245199aeee8)

Danke für das Abonnieren meines Feed! Inhalt gefällt? Danke sagen · Kommentieren

Plattform

Aktuell arbeite ich unter Windows und Linux, so dass sich meine Tools vorrangig auf beiden Plattformen anwenden lassen sollten. Dies ist mir wichtig, da ich eine heterogene Arbeitsumgebung für förderlich halte und es die Umgewöhnung am Client reduziert.

Browser

In meinem täglichen Umfeld der Webentwicklung arbeite ich vorrangig im Browser und im Editor, demzufolge sind diese beiden Werkzeuge für mich auch das Zentrum der Arbeit und bekommen den größten Zugriff.

Beim Browser vertraue ich auf Firefox, was vorrangig an den erstklassigen Erweiterungen liegt. In diesem Umfeld muss das Add on FireBug erwähnt werden, ohne das ich mir die Arbeit nicht mehr vorstellen könnte. Für dieses Add on gibt es wieder diverse Erweiterungen, die ich ebenso nützlich empfinde, dazu zählen vor allem YSlow, FirePHP und Page Speed.

Im weiteren nutze ich sehr gern das Add on im Firefox - Web Developer um diverse Inhalte einer Website zuzugreifen, sei es Cookies oder JavaScript auszuwerten, oder live CSS zu schreiben. Die Vielfalt ist sehr mächtig und damit ist das Add on ein wunderbares Werkzeug. Einige Punkte überschneiden sich mit dem FireBug - hier muss man einfach sehen, was man lieber mag.

In diesem Zusammenhang gibt es einige wunderbare Erweiterungen für den Browser, die die Arbeit erleichtern und ebenso die Synchronisation verschiedener Clients übernehmen kann. Daher kommt mein Firefox nicht nur mit diesen beiden Add ons aus, sondern es gibt einige wenige mehr, die aber in diesem Zusammenhang keinen erhöhten Wert haben.

Editor

Ein weiteres wichtiges Werkzeug ist der Editor, wobei ich hier auf UltraEdit setze. Ein Editor der leider meinem Grundgedanken zu Open Source nicht entspricht, der mir aber über die vielen Jahre am Rechner ans Herz gewachsen ist. Hier schätze ich vorrangig die Geschwindigkeit des Editors und die wunderbare Erweiterbarkeit mit eigenen Tools. So nutze ich das Parsen von PHP und das validieren von HTML und CSS direkt im Editor. Für das Parsen von CSS kommt CSSTidy zum Einsatz, auch online verfügbar. PHP parse ich via Webserver, der im Editor integriert ist und zusätzlich via PHPLint, auch in den zusätzlichen Werkzeugen des Editors integriert.

Unter Linux kann ich mich noch nicht ganz entscheiden und nutze dort Geany und NetBeans, wobei mir NetBeans eigentlich schon wieder zu träge ist und ich in Geany das eine oder andere vermisse. UE habe ich aktuell noch in der Test- und Betaphase und mal sehen, eventuell kann ich mich doch nicht von diesem Editor lösen.

Webserver & Tools

In diesem Zusammenhang gibt es zwei weitere wichtige Tools, die im Rahmen der Webentwicklung einsetze. Ich setze zum Arbeiten auf der lokalen Umgebung unter Windows XAMPP ein und unter Linux ist die lokale Webumgebung via Paketverwaltung installiert. Somit habe ich auf jedem Client eine Umgebung um mit PHP und mySQL zu arbeiten.

Wichtig bei der Entwicklung mit PHP ist für die Fehler- und Hinweisausgabe und das Debuggen. Unter PHP gibt es dabei diverse Ansätze und ich setze auf das Modul xDebug und eine entsprechende Ausgabe der Fehler und Hinweise in PHP.
Im weiteren schreibe ich in dem Zusammenhang die Errorlogs und werte diese aus. Als letztes Tool möchte ich auf Webgrind hinweisen, was als Webanwendung genutzt wird. Alternativ gibt es auch Desktop-Tools, die diese Arbeit erledigen, bspw. WinCacheGrind unter Windows. Damit lässt sich hervorragend das Profiling von xDebug auswerten und der eigene Code optimieren. Einen Beitrag zur Konfiguration und diverse hinweise habe ich bereits in der Vergangenheit erstellt.

FTP

Um die Entwicklung auf den Server zu bekommen, bedarf es meist einem Tool, welches das FTP Protokoll beherrscht und möglichst eine Oberfläche für die Verwaltung der Accounts liefert. Hierbei setze ich unter Windows auf den Total Commander, den man hervorragend an seine Bedürfnisse anpassen kann und wo ich vorrangig schätze, dass ich Tabs verschiedene Verbindungen öffnen kann. Unter Linux nutze ich für die Übertragung via FTP das Add on für den Firefox FireFTP. Hier gibt es diverse Tools, allerdings habe ich noch nie die Zeit gefunden, um mir diverse andere Tools anzusehen.

Für die Verbindung von SSH kommt PuTTY als Hilfe zum Einsatz und damit kann ich im Total Commander via SSH arbeiten. Unter Linux gibt es ebenso tolle Erweiterungen.

WordPress

Da ich vorrangig in und für WordPress entwickle, habe ich einige kleine Plugins in der Testumgebung aktiv, die mir die Sicht auf bestimmte Daten erleichtern, und die mir speziell für WordPress die Fehler speichern oder ausgeben. So teste ich beispielsweise auf nicht mehr aktuelle Funktionen von WordPress, um veraltetet Funktionen mit den neuen zu erkennen und zeitnah zu ersetzen. Eine kleine Liste mit kurzer Erläuterung von Plugins dazu, auch wenn ich nicht alle einsetze, so findet vielleicht der eine oder andere Gefallen.

• WP Offline - da ich die ständigen Verbindungsversuche nicht brauche
• WP Developer Assistant - weil es einige Auswertungen und Hilfen hat, die so schnell zur Hand sind
• CodeStyling Localization - weil jedes Plugin mehrsprachig erstellt wird und ich damit wunderbar neue Sprachfiles erstellen kann
• Log Deprecated Calls - nicht immer dabei, kann aber nützlich sein
• Error Reporting - für die, die nicht die Auswertung der Logs via Webungebung steuern
• Debug Queries - Analyse der Queries
• Debug Objects - Auswertung über sehr viele Werte
• Adminer - oft für den schnellen Zugriff auf einem Webspace oder als Plugin direkt in WordPress
• FirePHP - als Plugin für WordPress um an diverse Inhalte zu kommen und nicht immer im Source zu wühlen
• Core Control

Damit genug, auch wenn es sicher noch mehr gibt. Entscheidend aus meiner Sicht sind aber nicht die Plugins, sondern die Umgebung mit xDebug und die Settings, die WordPress im Standard in diesem Zusammenhang bietet. Daher kann ich nur empfehlen, folgende Zeilen in der wp-config.php der Umgebung zu haben.

/** Debugging WP */
define('WP_DEBUG', true); //enable the reporting of notices during development - E_ALL
define('WP_DEBUG_DISPLAY', true); //use the globally configured setting for display_errors and not force errors to be displayed
define('WP_DEBUG_LOG', true); //error logging to wp-content/debug.log
define('SCRIPT_DEBUG', true); //loads the development (non-minified) versions of all scripts and CSS and disables compression and concatenation,
define('E_DEPRECATED', false); //E_ALL & ~E_DEPRECATED & ~E_STRICT

define('AUTOSAVE_INTERVAL', '300');    // Autosave interval
define('SAVEQUERIES', true);    // Analyse queries
define('WP_POST_REVISIONS', false);

Diese Definitionen machen die Arbeit mit WordPress einfach und es gibt viele Hinweise von WP zu einem sauberen Code und aktuellen Funktionen. Den Autosave-Intervall ändere ich nur dann auf kleine Werte, wenn ich diesem Segment arbeite, wenn ich also möglichst schnell das Script brauche.

Webzugriffe

Im Web gibt es eine Vielzahl von Tools, die nützlich sind - ich möchte mal kurz einige vorstellen, die ich oft nutze und auch damit meinen Dank an die Leute sagen, die diese Dienste bereit stellen.

• php.net - weil man nie schnell genug an Infos kommt, daher habe ich auch im Firefox eine Erweiterung für das interne Suchfeld, was direkt in den Funktionen von php.net sucht (kann gern genutzt werden, habe ich abgelegt)
• wpseek.com - die Suche zu WordPress, auch eine Sucherweiterung für Firefox steht zur Verfügung (@Oliver: einzig und allein - ich wünschte mir mehr Übersicht, weniger Design )
• PHP Cross Reference of WordPress Source - weil ich manchmal so schneller bin als über den Editor
• bueltge.de - mein eigenes Blog ist gestartet und meine Lösungen fest zu halten und zu teilen, ich nutze die Suche massiv und auch die gibt es als Browsererweiterung

Fazit

Um UpToDate zu bleiben, nutze ich viele Anwendungen, die ich hier auch genannt habe, via SVN - dies gilt für WordPress ebenso wie für die genannten Tools, wenn es den seitens des Entwicklers angeboten wird. Ebenso ist die Arbeit mit SVN unumgänglich, wenn man Plugins auf dem Server von WordPress ablegen will. Unter Windows (z.B. Tortoise) und Linux (z.B. RapidSVN) ist die Arbeit mit einem SVN kein Problem und es stehen ausreichend gute Tools zur Verfügung.

Ein kleines Ausblick meiner aktuellen Tools und vielleicht findet einer von Euch Anregungen und hat ebenso Anregungen für mich.

© Frank Bültge, All rights reserved / Alle Rechte vorbehalten. (ID: 6e8b33de4342c4f2ca76b245199aeee8)

Danke für das Abonnieren meines Feed! Inhalt gefällt? Danke sagen · Kommentieren

function is_sidebar_active($index) {
	global $wp_registered_sidebars;

	$widgetcolums = wp_get_sidebars_widgets();

	if ($widgetcolums[$index])
		return true;

	return false;
}

Damit wird die Ausgabe des Widget-Bereiches nur genutzt, wenn es auch Inhalte gibt.
Im Template könnte die Abfrage beispielsweise wie folgt aussehen.

<?php if ( function_exists('is_sidebar_active') && is_sidebar_active('sidebar') ) { ?>
	<div id="sidebar">
		<ul>
			<?php dynamic_sidebar('sidebar'); ?>
		</ul>
	</div>
<?php } ?>

Das obige Beispiel lädt den Inhalt nur, wenn der Widget-Bereich mit der ID sidebar Inhalte hat, also wenn Widgets in diesem Bereich genutzt werden.

Seit WordPress Version 2.8 gibt es dazu auch eine Funktion im Core und man muss die obige Funktion nicht eigens hinzu bringen is_active_sidebar(). Damit geht die Prüfung ebenso einfach und sicher.

<?php if ( function_exists('is_active_sidebar') && is_active_sidebar('sidebar') ) { ?>
	<div id="sidebar">
		<ul>
			<?php dynamic_sidebar('sidebar'); ?>
		</ul>
	</div>
<?php } ?>

© Frank Bültge, All rights reserved / Alle Rechte vorbehalten. (ID: 6e8b33de4342c4f2ca76b245199aeee8)

Danke für das Abonnieren meines Feed! Inhalt gefällt? Danke sagen · Kommentieren

Aber hier handelt es sich nicht nur um ein wunderbares Cover, sondern um ein Buch für Leute, die schon immer einen handlichen Überblick im Rahmen von Tool-Empfehlungen haben wollten.
Aktuell kann ich keine Rezension zum Buch abgeben - das Buch ist aber auf dem Weg zu mir und daher hole ich das sicher nach - denn ich habe ich einen kleinen Teil im Buch beigetragen. Ein wenig macht mich dieser Anteil stolz, denn die Autoren schreiben:

Die Wahl der Interviewpartner war nicht willkürlich, sondern es handelt sich durchweg um erfahrene Kollegen, die seit vielen Jahren im und mit dem Web arbeiten. Die Interviews wurden nicht »persönlich« geführt, sondern bestanden in einer Art Fragebogen, den wir allen zugesendet hatten.
Die Platzierung im Buch richtet sich nach der hauptsächlichen Webtätigkeit der Interviewpartner und erfolgt immer am Ende des thematisch passenden Abschnitts.

Perun und Frau bezeichnen die Interviewpartner als erfahrene Kollegen. Da ich im großen Ganzen das Thema Webentwicklung als Hobby betreibe, auch wenn ich mein Wissen bei Inpsyde einbringen kann, und in der festen Anstellung im Alltag komplett anderen Themen nachgehe, freut es mich natürlich, wenn man mich in diesem Zusammenhang nennt und ich mich mit diesen großen Kollegen auf eine Stufe stellen darf. Als Autodidakt ist der Lernprozess nicht immer einfach, aber zielführend, zumindest in meinem Anspruch.

Besonders freue ich mich auf die Informationen zum Thema Linux, die direkt aus der Quelle Peter Kröner stammen. Peter ist bekannter Linux-Nutzer und als Webworker definitiv ein Lesetipp. Seit meinem Umstieg auf Linux mit einem Client, der maßgeblich das Thema Webentwicklung bedient, lerne ich wieder viel dazu und kann nur begrüßen: Lasst euch auf Linux ein - es lohnt.

© Frank Bültge, All rights reserved / Alle Rechte vorbehalten. (ID: 6e8b33de4342c4f2ca76b245199aeee8)

Danke für das Abonnieren meines Feed! Inhalt gefällt? Danke sagen · Kommentieren

Egal aus welchem Grund man Plugins entwickelt, ob Hobbycoder, Profi oder Agentur mit Auftragsarbeit, die Vielzahl der Plugins sorgt zumindest für das weitere Wachsen der WordPress Community. Trotzdem ist gerade ein Event im Jahr den Plugins für WordPress gewidmet - der Plugin Competition. Hier kann man sein Plugin der Community vorstellen und Preise gewinnen.

Wieso, weshalb, warum

Aktuell läuft der diesjährige Wettbewerb noch bis Ende Juli und es sind gerade mal 13 Plugins eingetragen. Darunter sind einige tolle Ideen. Obwohl jeden Tag neue Plugins im SVN von WordPress erscheinen, sind dort so wenig gelistet. Entwickler - traut euch, stellt euch der Konkurrenz. Dieser Event ist ein Mehrwert für Nutzer und Entwickler, beide Seiten können nur Vorteile davon gewinnen. Klar, einem Profi in PHP das Wasser reichen ist nicht leicht - aber auch im SVN steht euer Code der Öffentlichkeit zur Verfügung und kann daher immer eingelesen werden. Der Plugin Competition ist nur eine andere Plattform und sollte daher von Einsteigern und Profis genutzt werden.
Er macht das Plugin nicht besser, aber es kann dazu kommen, dass man mehr Aufmerksamkeit zum Plugin bekommt, damit mehr Rückmeldungen und, so habe ich es im letzten Jahr erfahren, auch viele Ideen, Verbesserungen und direkte Lösungen zum Plugin. In diesem Jahr soll es zumindest die gleich Rückmeldung geben wie im letzen Jahr, wo Otz jedes Plugin bewertet hat, nach Idee und Umsetzung. Auch in diesem Jahr wird man wieder Feedback von Ozh erwarten können, siehe sein Beitrag zum Plugin Competition. Klar, die Meinung von Ozh ist nicht in jedem Interesse und sicher wird es die eine oder andere differenzierte Meinung geben, aber die Rückmeldung ist entscheidend. Damit hat nicht nur der Nutzer etwas davon, sondern als Entwickler habe ich dadurch viel gelernt, meine Kenntnisse erweitert und die Hinweise ergänzt.

Ebenso kann der Competition zeigen, wie engagiert Entwickler mit WordPress arbeiten, kann die Aufmerksamkeit auf WordPress erhöhen und Entwicklern, die eventuell Aufträge generieren wollen, eine Plattform bieten.

Der Wettbewerb ist kein Mehraufwand für euch Plugin-Schreiber. Euer Plugin bekommt nur eine zusätzliche Plattform und wird bewertet. Alles in allem also Vorteile. Zusätzlich könnt ihr noch diverse Preise abräumen. Daher - mitmachen!

Sponsoring

Ebenso ist der Wettbewerb eine wunderbare Plattform für Leute, die ihr Produkt für WordPress bewerben wollen. Daher gilt es für Theme & Plugin-Autoren, Agenturen und Hostingservices, etc. - melden, Sponsore den Wettbewerb und hole dir die Aufmerksamkeit. Sicher auch eine gute Idee für WordPress Deutschland - aber dazu braucht WPD Sponsoren und Entwickler, die entweder ihre Arbeit, ihr Plugin oder ihre finanziellen Mittel einbringen.

Aus deutscher Sicht

Aktuell sind 2 Plugins von deutschen Entwicklern drin, das dritte Plugin sollte hoffentlich bald folgen, denn es verdient mehr Aufmerksamkeit. In diesem Zusammenhang ein Aufruf an meine deutschen Leser - Votet für uns, zeigt das deutsche Entwickler im Bereich WordPress ein Wörtchen mitzureden haben, auch wenn wir sonst bei WordPress eine untergeordnete Rolle spielen, da unser Sprachraum für viele dort nicht existent zu sein scheint.

• Changelogger von Oliver Schlöbe
• Debug Objects von mir

Die Entwickler von WordPress werden sicher den Plugin Competition verfolgen und lunsen, was es für Ideen gibt und wie man sie umsetzt. Nicht nur einmal ist bisher ein Plugin in den Core von WordPress gewandert und nicht nur einmal war die Lösung eines Pluginautors besser, als die Lösung im Core.

© Frank Bültge, All rights reserved / Alle Rechte vorbehalten. (ID: 6e8b33de4342c4f2ca76b245199aeee8)

Danke für das Abonnieren meines Feed! Inhalt gefällt? Danke sagen · Kommentieren

Die Erklärung ist dem einen oder anderen eventuell zu dürftig? Ich möchte aber auch nicht weit ausholen und erklären, da es auch nur dann angefasst werden sollte, wenn man einige Kenntnisse mit bringt. Einige Konstanten sind auch nur für Entwicklerplattformen relevant und sollten in einem Live-System nur mit besonderer Vorsicht genutzt werden.
Alternativ kann die Suche im Core von WP helfen, da es öfter dokumentiert ist, als man denkt.

• WP_MEMORY_LIMIT — WordPress Speicher Limit, siehe Beitrag (Wert)
• AUTOSAVE_INTERVAL — Intervall der automatischen Speicherung in Sekunden (60 Wert in Sekunden)
• WP_POST_REVISIONS — Umfang der gespeicherten Versionen zum Beitrag, zur Seite bzw. mögl. Deaktivierung der Versionierung (false oder Wert)
• SAVEQUERIES — Mögl. Ausgabe der Queries, so dass eine Analyse statt finden kann, siehe Beitrag (true)
• CONCATENATE_SCRIPTS — Deaktiviere die Kombination und Kompression alle JavaScript-Dateien; ab 2.8 verfügbar (false)
• COMPRESS_SCRIPTS — Komprimiere JavaScript; ab 2.8 verfügbar (true)
• COMPRESS_CSS — Komprimiere CSS; ab 2.8 verfügbar (true)
• ENFORCE_GZIP — Erzwinge GZIP für die Kompression, erst ab 2.8 verfügbar (true)
• FORCE_SSL_LOGIN — verschlüsselte Übertragung im Bereich WP Admin (true)
• WP_HOME — WordPress Addresse (URL), Installationsverzeichnis, siehe Beitrag
• WP_SITEURL — Blog Addresse (URL), siehe Beitrag
• WP_DEBUG — Aktiviert die Ausgabe der Fehler und Hinweise auf Fehler (true)
• SCRIPT_DEBUG — Lade die Entwicklerversionen, unkomprimiert, der JavaScript-Dateien (true)

Konstanten werden mit Hilfe der PHP_Funktion define() definiert, zum Beispiel:

define('WP_HOME', 'http://example.org/wordpress');
define('WP_SITEURL', 'http://example.org');
define('AUTOSAVE_INTERVAL', '180') // in sekunden
define('WP_POST_REVISIONS', 3);

Aus meiner Sicht, sind das Konstanten, die man wissen kann; für Entwickler gelten noch einige mehr, die beim Schreiben von Plugins und Themes von Relevanz sein können und sollten. Die obige Liste soll aber in diesem Hinblick keine Relevanz haben und vernachlässigt daher die Konstanten.

© Frank Bültge, All rights reserved / Alle Rechte vorbehalten. (ID: 6e8b33de4342c4f2ca76b245199aeee8)

Danke für das Abonnieren meines Feed! Inhalt gefällt? Danke sagen · Kommentieren

Immer wieder kamen Fragen rein, ob das alte Theme aktualisiert wird und wann - daher hier nun die Info, ich habe einen Stand erreicht, der stabil ist und das Theme ist mit der aktuellen Version 2.7 und der kommenden Version 2.8 von WordPress kompatibel. Ebenso ist es abwärtskompatibel, getestet bis Version 1.5 von WordPress. Daher hier nun offiziell die Freigabe zum Download und Nutzen.

• Projektsite
• SVN Repository mit Diskussionsplattform

Ein Hinweis, das Theme ist kein Framework es ist ein einfaches Theme, welches lediglich die Grundlagen eines Theme enthält und diverse Vorzüge aus meiner Arbeit mir WordPress vereint. Es dient also wirklich dazu, dass man ein Theme für Kunden oder sich selbst erstellt, angepasst auf die Anforderungen. Es bringt keinerlei überflüssiges Markup mit, was man dann nicht braucht und wie bei Frameworks zum Teil üblich, mitschleift. Es soll auch so bleiben, keine Child-Themes oder ähnliches, auch keine Hooks zum komfortablen erweitern mit Code. Ich mag diese Art der Arbeit, schlank und schnell, direkt auf die Aufgabe zugeschnitten und daher kann ich mich nicht sonderlich mit Frameworks im WordPress-Theme-Sektor anfreunden; heißt aber nicht, dass andere Entwickler das auch tun sollten!

Wenn euch diese Arbeit liegt und ihr ebenfalls das Theme in erster Linie selbst schreibt, dann steht euch damit eine Grundlage bereit. Durch die Verwaltung im SVN steht euch ebenso eine Möglichkeit zur Verfügung Fehler und Hinweise zu melden, worüber ich mich sehr freuen würde.

© Frank Bültge, All rights reserved / Alle Rechte vorbehalten. (ID: 6e8b33de4342c4f2ca76b245199aeee8)

Danke für das Abonnieren meines Feed! Inhalt gefällt? Danke sagen · Kommentieren

WordPress benutzt eine ganze Reihe von Konstanten und Variablen, die nützlich sein können. Um so besser, wenn man weis, was sich darin befindet. Eine saubere Ausgabe der Inhalte lässt sich hervorragend mit der Firefox-Erweiterung FirePHP für Firebug realisieren.

Um die Arbeit in meinen Entwicklungen zu erleichtern und zu beschleunigen habe ich immer ein Plugin aktiv, mit dem ich mir diverse Inhalte ausgebe, direkt über die Ausgabe von FirePHP. Dabei ist ein kleines Plugin entstanden, welches nun eine ganze Reihe von Konstanten und Variablen enthält, die ich auf Basis der kommenden Version 2.8 von WordPress realisiert habe. Da ich denke, dass das nützlich sein kann, hier der Download zum Plugin und die Inhalte, die ich ausgebe, falls jemand selbst eine Lösung hat und nur die Konstanten und Variablen benötigt.

Plugin WP FirePHP

Um einfach und schnell in WordPress mit FirePHP zu arbeiten kann das Plugin genutzt werden. Es setzt keine Einstellungen oder ähnliches in der Datenbank, der Code ist beispielhaft, so dass man einfach erweitern kann und Bereiche auskommentieren kann, die man nicht benötigt. Aktuell sind diverse Inhalte drin, die in WordPress nützlich sind, dazu gehören die Konstanten, globale Variablen und von PHP vordefinierte Variablen.

Das Plugin im SVN von WordPress geladen werden: WP FirePHP. Die Installation ist wie gewohnt, ab in den Plugin-Ordner und im Backend der Umgebung aktivieren.

Das Plugin arbeitet mindestens mit WordPress Version 1.5, getestet bis 2.9-rare.

Download:

Ist die Arbeit nicht 1 Euro wert?
Jede Spende wird dankbar angenommen und ermöglicht das weitere Arbeiten an freier Software.
Möchtest du mehr oder anders spenden, so besuche meine Wunschliste.

Download als zip-Datei:
downloads.wordpress.org/plugin/wp-firephp.zip - ~80 kByte

WordPress Konstanten und Variablen

$wp_constants = array(
'ABSPATH'                            => ABSPATH,
'ADMIN_COOKIE_PATH'                  => ADMIN_COOKIE_PATH,
'APP_REQUEST'                        => APP_REQUEST,
'ARRAY_A'                            => ARRAY_A,
'ARRAY_N'                            => ARRAY_N,
'ATOM'                               => ATOM,
'AUTH_COOKIE'                        => AUTH_COOKIE,
'AUTH_KEY'                           => AUTH_KEY,
'AUTOSAVE_INTERVAL'                  => AUTOSAVE_INTERVAL,
'COMMENTS_TEMPLATE'                  => COMMENTS_TEMPLATE,
'COOKIEHASH'                         => COOKIEHASH,
'COOKIEPATH'                         => COOKIEPATH,
'COOKIE_DOMAIN'                      => COOKIE_DOMAIN,
'CRLF'                               => CRLF,
'CUSTOM_TAGS'                        => CUSTOM_TAGS,
'DB_CHARSET'                         => DB_CHARSET,
'DB_COLLATE'                         => DB_COLLATE,
'DB_HOST'                            => DB_HOST,
'DB_NAME'                            => DB_NAME,
'DB_PASSW'                           => DB_PASSW,
'DB_PASSWORD'                        => DB_PASSWORD,
'DB_USER'                            => DB_USER,
'DOING_AJAX'                         => DOING_AJAX,
'DOING_AUTOSAVE'                     => DOING_AUTOSAVE,
'DOING_CRON'                         => DOING_CRON,
'EP_ALL'                             => EP_ALL,
'EP_ATTACHMENT'                      => EP_ATTACHMENT,
'EP_AUTHORS'                         => EP_AUTHORS,
'EP_CATEGORIES'                      => EP_CATEGORIES,
'EP_COMMENTS'                        => EP_COMMENTS,
'EP_DATE'                            => EP_DATE,
'EP_DAY'                             => EP_DAY,
'EP_MONTH'                           => EP_MONTH,
'EP_NONE'                            => EP_NONE,
'EP_PAGES'                           => EP_PAGES,
'EP_PERMALINK'                       => EP_PERMALINK,
'EP_ROOT'                            => EP_ROOT,
'EP_SEARCH'                          => EP_SEARCH,
'EP_TAGS'                            => EP_TAGS,
'EP_YEAR'                            => EP_YEAR,
'EZSQL_VERSION'                      => EZSQL_VERSION,
'FORCE_SSL_ADMIN'                    => FORCE_SSL_ADMIN,
'FORCE_SSL_LOGIN'                    => FORCE_SSL_LOGIN,
'FTP_ASCII'                          => FTP_ASCII,
'FTP_AUTOASCII'                      => FTP_AUTOASCII,
'FTP_BINARY'                         => FTP_BINARY,
'FTP_FORCE'                          => FTP_FORCE,
'IS_PROFILE_PAGE'                    => IS_PROFILE_PAGE,
'JSON_BOOL'                          => JSON_BOOL,
'JSON_END_ARRAY'                     => JSON_END_ARRAY,
'JSON_END_OBJ'                       => JSON_END_OBJ,
'JSON_FLOAT'                         => JSON_FLOAT,
'JSON_INT'                           => JSON_INT,
'JSON_IN_ARRAY'                      => JSON_IN_ARRAY,
'JSON_IN_BETWEEN'                    => JSON_IN_BETWEEN,
'JSON_IN_OBJECT'                     => JSON_IN_OBJECT,
'JSON_KEY'                           => JSON_KEY,
'JSON_NULL'                          => JSON_NULL,
'JSON_SKIP'                          => JSON_SKIP,
'JSON_START_ARRAY'                   => JSON_START_ARRAY,
'JSON_START_OBJ'                     => JSON_START_OBJ,
'JSON_STR'                           => JSON_STR,
'LANGDIR'                            => LANGDIR,
'LOGGED_IN_COOKIE'                   => LOGGED_IN_COOKIE,
'LOGGED_IN_KEY'                      => LOGGED_IN_KEY,
'MAGPIE_CACHE_AGE'                   => MAGPIE_CACHE_AGE,
'MAGPIE_CACHE_DIR'                   => MAGPIE_CACHE_DIR,
'MAGPIE_CACHE_FRESH_ONLY'            => MAGPIE_CACHE_FRESH_ONLY,
'MAGPIE_CACHE_ON'                    => MAGPIE_CACHE_ON,
'MAGPIE_DEBUG'                       => MAGPIE_DEBUG,
'MAGPIE_FETCH_TIME_OUT'              => MAGPIE_FETCH_TIME_OUT,
'MAGPIE_INITALIZED'                  => MAGPIE_INITALIZED,
'MAGPIE_USER_AGENT'                  => MAGPIE_USER_AGENT,
'MAGPIE_USE_GZIP'                    => MAGPIE_USE_GZIP,
'MAX_EXECUTION_TIME'                 => MAX_EXECUTION_TIME,
'MAX_RESULTS'                        => MAX_RESULTS,
'MC_LOGGER_DEBUG'                    => MC_LOGGER_DEBUG,
'MC_LOGGER_ERROR'                    => MC_LOGGER_ERROR,
'MC_LOGGER_FATAL'                    => MC_LOGGER_FATAL,
'MC_LOGGER_INFO'                     => MC_LOGGER_INFO,
'MC_LOGGER_WARN'                     => MC_LOGGER_WARN,
'OBJECT'                             => OBJECT,
'OBJECT_K'                           => OBJECT_K,
'PASS_COOKIE'                        => PASS_COOKIE,
'PCLZIP_ATT_FILE_NAME'               => PCLZIP_ATT_FILE_NAME,
'PCLZIP_ATT_FILE_NEW_FULL_NAME'      => PCLZIP_ATT_FILE_NEW_FULL_NAME,
'PCLZIP_ATT_FILE_NEW_SHORT_NAME'     => PCLZIP_ATT_FILE_NEW_SHORT_NAME,
'PCLZIP_CB_POST_ADD'                 => PCLZIP_CB_POST_ADD,
'PCLZIP_CB_POST_DELETE'              => PCLZIP_CB_POST_DELETE,
'PCLZIP_CB_POST_EXTRACT'             => PCLZIP_CB_POST_EXTRACT,
'PCLZIP_CB_POST_LIST'                => PCLZIP_CB_POST_LIST,
'PCLZIP_CB_PRE_ADD'                  => PCLZIP_CB_PRE_ADD,
'PCLZIP_CB_PRE_DELETE'               => PCLZIP_CB_PRE_DELETE,
'PCLZIP_CB_PRE_EXTRACT'              => PCLZIP_CB_PRE_EXTRACT,
'PCLZIP_CB_PRE_LIST'                 => PCLZIP_CB_PRE_LIST,
'PCLZIP_ERROR_EXTERNAL'              => PCLZIP_ERROR_EXTERNAL,
'PCLZIP_ERR_ALREADY_A_DIRECTORY'     => PCLZIP_ERR_ALREADY_A_DIRECTORY,
'PCLZIP_ERR_BAD_CHECKSUM'            => PCLZIP_ERR_BAD_CHECKSUM,
'PCLZIP_ERR_BAD_EXTENSION'           => PCLZIP_ERR_BAD_EXTENSION,
'PCLZIP_ERR_BAD_EXTRACTED_FILE'      => PCLZIP_ERR_BAD_EXTRACTED_FILE,
'PCLZIP_ERR_BAD_FORMAT'              => PCLZIP_ERR_BAD_FORMAT,
'PCLZIP_ERR_DELETE_FILE_FAIL'        => PCLZIP_ERR_DELETE_FILE_FAIL,
'PCLZIP_ERR_DIRECTORY_RESTRICTION'   => PCLZIP_ERR_DIRECTORY_RESTRICTION,
'PCLZIP_ERR_DIR_CREATE_FAIL'         => PCLZIP_ERR_DIR_CREATE_FAIL,
'PCLZIP_ERR_FILENAME_TOO_LONG'       => PCLZIP_ERR_FILENAME_TOO_LONG,
'PCLZIP_ERR_INVALID_ARCHIVE_ZIP'     => PCLZIP_ERR_INVALID_ARCHIVE_ZIP,
'PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE' => PCLZIP_ERR_INVALID_ATTRIBUTE_VALUE,
'PCLZIP_ERR_INVALID_OPTION_VALUE'    => PCLZIP_ERR_INVALID_OPTION_VALUE,
'PCLZIP_ERR_INVALID_PARAMETER'       => PCLZIP_ERR_INVALID_PARAMETER,
'PCLZIP_ERR_INVALID_ZIP'             => PCLZIP_ERR_INVALID_ZIP,
'PCLZIP_ERR_MISSING_FILE'            => PCLZIP_ERR_MISSING_FILE,
'PCLZIP_ERR_MISSING_OPTION_VALUE'    => PCLZIP_ERR_MISSING_OPTION_VALUE,
'PCLZIP_ERR_NO_ERROR'                => PCLZIP_ERR_NO_ERROR,
'PCLZIP_ERR_READ_OPEN_FAIL'          => PCLZIP_ERR_READ_OPEN_FAIL,
'PCLZIP_ERR_RENAME_FILE_FAIL'        => PCLZIP_ERR_RENAME_FILE_FAIL,
'PCLZIP_ERR_UNSUPPORTED_COMPRESSION' => PCLZIP_ERR_UNSUPPORTED_COMPRESSION,
'PCLZIP_ERR_UNSUPPORTED_ENCRYPTION'  => PCLZIP_ERR_UNSUPPORTED_ENCRYPTION,
'PCLZIP_ERR_USER_ABORTED'            => PCLZIP_ERR_USER_ABORTED,
'PCLZIP_ERR_WRITE_OPEN_FAIL'         => PCLZIP_ERR_WRITE_OPEN_FAIL,
'PCLZIP_OPT_ADD_COMMENT'             => PCLZIP_OPT_ADD_COMMENT,
'PCLZIP_OPT_ADD_PATH'                => PCLZIP_OPT_ADD_PATH,
'PCLZIP_OPT_BY_EREG'                 => PCLZIP_OPT_BY_EREG,
'PCLZIP_OPT_BY_INDEX'                => PCLZIP_OPT_BY_INDEX,
'PCLZIP_OPT_BY_NAME'                 => PCLZIP_OPT_BY_NAME,
'PCLZIP_OPT_BY_PREG'                 => PCLZIP_OPT_BY_PREG,
'PCLZIP_OPT_COMMENT'                 => PCLZIP_OPT_COMMENT,
'PCLZIP_OPT_EXTRACT_AS_STRING'       => PCLZIP_OPT_EXTRACT_AS_STRING,
'PCLZIP_OPT_EXTRACT_DIR_RESTRICTION' => PCLZIP_OPT_EXTRACT_DIR_RESTRICTION,
'PCLZIP_OPT_EXTRACT_IN_OUTPUT'       => PCLZIP_OPT_EXTRACT_IN_OUTPUT,
'PCLZIP_OPT_NO_COMPRESSION'          => PCLZIP_OPT_NO_COMPRESSION,
'PCLZIP_OPT_PATH'                    => PCLZIP_OPT_PATH,
'PCLZIP_OPT_PREPEND_COMMENT'         => PCLZIP_OPT_PREPEND_COMMENT,
'PCLZIP_OPT_REMOVE_ALL_PATH'         => PCLZIP_OPT_REMOVE_ALL_PATH,
'PCLZIP_OPT_REMOVE_PATH'             => PCLZIP_OPT_REMOVE_PATH,
'PCLZIP_OPT_REPLACE_NEWER'           => PCLZIP_OPT_REPLACE_NEWER,
'PCLZIP_OPT_SET_CHMOD'               => PCLZIP_OPT_SET_CHMOD,
'PCLZIP_OPT_STOP_ON_ERROR'           => PCLZIP_OPT_STOP_ON_ERROR,
'PCLZIP_READ_BLOCK_SIZE'             => PCLZIP_READ_BLOCK_SIZE,
'PCLZIP_SEPARATOR'                   => PCLZIP_SEPARATOR,
'PCLZIP_TEMPORARY_DIR'               => PCLZIP_TEMPORARY_DIR,
'PLUGINDIR'                          => PLUGINDIR,
'PLUGINS_COOKIE_PATH'                => PLUGINS_COOKIE_PATH,
'RSS'                                => RSS,
'SECURE_AUTH_COOKIE'                 => SECURE_AUTH_COOKIE,
'SECURE_AUTH_KEY'                    => SECURE_AUTH_KEY,
'SITECOOKIEPATH'                     => SITECOOKIEPATH,
'STATUS_INTERVAL'                    => STATUS_INTERVAL,
'STYLESHEETPATH'                     => STYLESHEETPATH,
'TEMPLATEPATH'                       => TEMPLATEPATH,
'TEST_COOKIE'                        => TEST_COOKIE,
'USER_COOKIE'                        => USER_COOKIE,
'WPINC'                              => WPINC,
'WPLANG'                             => WPLANG,
'WP_ADMIN'                           => WP_ADMIN,
'WP_CONTENT_DIR'                     => WP_CONTENT_DIR,
'WP_CONTENT_URL'                     => WP_CONTENT_URL,
'WP_IMPORTING'                       => WP_IMPORTING,
'WP_INSTALLING'                      => WP_INSTALLING,
'WP_LANG_DIR'                        => WP_LANG_DIR,
'WP_MEMORY_LIMIT'                    => WP_MEMORY_LIMIT,
'WP_PLUGIN_DIR'                      => WP_PLUGIN_DIR,
'WP_PLUGIN_URL'                      => WP_PLUGIN_URL,
'WP_USE_THEMES'                      => WP_USE_THEMES,
'WXR_VERSION'                        => WXR_VERSION,
'XMLRPC_REQUEST'                     => XMLRPC_REQUEST
);

$wp_globals_a_l = array(
'$admin_page_hooks'                  => $admin_page_hooks,
'$ajax_results'                      => $ajax_results,
'$all_links'                         => $all_links,
'$allowedposttags'                   => $allowedposttags,
'$allowedtags'                       => $allowedtags,
'$authordata'                        => $authordata,
'$bgcolor'                           => $bgcolor,
'$cache_categories'                  => $cache_categories,
'$cache_lastcommentmodified'         => $cache_lastcommentmodified,
'$cache_lastpostdate'                => $cache_lastpostdate,
'$cache_lastpostmodified'            => $cache_lastpostmodified,
'$cache_userdata'                    => $cache_userdata,
'$category_cache'                    => $category_cache,
'$class'                             => $class,
'$comment'                           => $comment,
'$comment_cache'                     => $comment_cache,
'$comment_count_cache'               => $comment_count_cache,
'$commentdata'                       => $commentdata,
'$current_user'                      => $current_user,
'$day'                               => $day,
'$debug'                             => $debug,
'$descriptions'                      => $descriptions,
'$error'                             => $error,
'$feeds'                             => $feeds,
'$id'                                => $id,
'$is_apache'                         => $is_apache,
'$is_IIS'                            => $is_IIS,
'$is_macIE'                          => $is_macIE,
'$is_winIE'                          => $is_winIE,
'$l10n'                              => $l10n,
'$locale'                            => $locale,
'$link'                              => $link
);
$wp_globals_m_r = array(
'$m'                                 => $m,
'$map'                               => $map,
'$max_num_pages'                     => $max_num_pages,
'$menu'                              => $menu,
'$mode'                              => $mode,
'$month'                             => $month,
'$month_abbrev'                      => $month_abbrev,
'$monthnum'                          => $monthnum,
'$more'                              => $more,
'$multipage'                         => $multipage,
'$names'                             => $names,
'$newday'                            => $newday,
'$numpages'                          => $numpages,
'$page'                              => $page,
'$page_cache'                        => $page_cache,
'$paged'                             => $paged,
'$pagenow'                           => $pagenow,
'$pages'                             => $pages,
'$parent_file'                       => $parent_file,
'$preview'                           => $preview,
'$previousday'                       => $previousday,
'$previousweekday'                   => $previousweekday,
'$plugin_page'                       => $plugin_page,
'$post'                              => $post,
'$post_cache'                        => $post_cache,
'$post_default_category'             => $post_default_category,
'$post_default_title'                => $post_default_title,
'$post_meta_cache'                   => $post_meta_cache,
'$postc'                             => $postc,
'$postdata'                          => $postdata,
'$posts'                             => $posts,
'$posts_per_page'                    => $posts_per_page,
'$previousday'                       => $previousday,
'$request'                           => $request,
'$result'                            => $result,
'$richedit'                          => $richedit
);
$wp_globals_s_v = array(
'$single'                            => $single,
'$submenu'                           => $submenu,
'$table_prefix'                      => $table_prefix,
'$targets'                           => $targets,
'$timedifference'                    => $timedifference,
'$timestart'                         => $timestart,
'$timeend'                           => $timeend,
'$updated_timestamp'                 => $updated_timestamp,
'$urls'                              => $urls,
'$user_ID'                           => $user_ID,
'$user_email'                        => $user_email,
'$user_identity'                     => $user_identity,
'$user_level'                        => $user_level,
'$user_login'                        => $user_login,
'$user_pass_md5'                     => $user_pass_md5,
'$user_url'                          => $user_url
);
$wp_globals_w = array(
'$weekday'                           => $weekday,
'$weekday_abbrev'                    => $weekday_abbrev,
'$weekday_initial'                   => $weekday_initial,
'$withcomments'                      => $withcomments,
'$wp'                                => $wp,
'$wp_broken_themes'                  => $wp_broken_themes,
'$wp_db_version'                     => $wp_db_version,
'$wp_did_header'                     => $wp_did_header,
'$wp_did_template_redirect'          => $wp_did_template_redirect,
'$wp_file_description'               => $wp_file_description,
'$wp_filter'                         => $wp_filter,
'$wp_importers'                      => $wp_importers,
'$wp_plugins'                        => $wp_plugins,
'$wp_themes'                         => $wp_themes,
'$wp_object_cache'                   => $wp_object_cache,
'$wp_query'                          => $wp_query,
'$wp_queries'                        => $wp_queries,
'$wp_rewrite'                        => $wp_rewrite,
'$wp_roles'                          => $wp_roles,
'$wp_similiesreplace'                => $wp_similiesreplace,
'$wp_smiliessearch'                  => $wp_smiliessearch,
'$wp_version'                        => $wp_version,
'$wpcommentspopupfile'               => $wpcommentspopupfile,
'$wpcommentsjavascript'              => $wpcommentsjavascript
);

© Frank Bültge, All rights reserved / Alle Rechte vorbehalten. (ID: 6e8b33de4342c4f2ca76b245199aeee8)

Danke für das Abonnieren meines Feed! Inhalt gefällt? Danke sagen · Kommentieren

Aktuell macht Jane Wells im WordPress Team sich einige Gedanken zum Backend Design und ruft zu Ideen auf, die das Backend nicht neu gestalten, nur optimieren, so dass Nutzer nicht verschreckt werden. Aus meiner Sicht ist es gerade da sinnvoll, dass man die Hooks in WordPress nutzt und optionale Design einbringt, die der jeweilige Nutzer wählen kann. SO hole ich auch diverse Designs in Backend und überlasse die Wahl dem Nutzer. Lediglich die übergeordneten Themen, wie Farben und Logo, gebe ich im Rahmen des Corporate Designs vor. Da ich Adminimize in den letzten Nächten erweitert haben, besonders gepuscht durch den Spendenmarathon der lieben Leserin Samantha Phoumarath.

Der obige Screenshot mag auf den ersten Blick nicht sonderlich das Design von WordPress verändern, aber es ist anders, anders in der Arbeitsweise - Header und Menu sind fix, so dass man aus jeder Scrollposition darauf zugreifen kann. Eine ganze Reihe von Nutzern empfinden das Arbeiten so besser und angenehmer. Als Hinweis sei aber vermerkt, dass meine jetzige Lösung nur in Browsern funktioniert, die fixed via CSS akzeptieren.

Im weiteren habe ich diverse Bereiche verkleinert, so sind Meta Boxen wesentlich schmaler; es ist mehr Platz ohne den Whitespace zu reduzieren.

Im weiteren habe ich ein alternatives Design im Plugin untergebracht, welches den Header verändert und die Navi damit um 50 Pixel nach oben holt. Auch dies wird gern genutzt, wobei hier schon der Wunsch des fixed Menu aufkam, aber bisher nicht umgesetzt wurde.

Vielleicht hat der eine oder andere Ideen, Wünsche und Hinweise zum Plugin, zum Design, die Kommentarfunktion steht offen.

Das Plugin selbst ist vorrangig für andere Zwecke erstellt und verfügt aktuell über sehr viele Optionen, so kann man den Bereich Schreiben Beitrage und Seiten einschränken, die Oberfläche der Links beeinflussen, globale Bereiche verändern, HEader-Bereiche einschränken, verändern, Dashboard und Footer deaktivieren, umleiten mit eigenen Inhalten befüllen oder auch eigene Optionen hinzubringen, in dem man Klassen und IDs hinterlegt, einen Namen vergibt und diese dann wieder abhängig von der Benutzerrolle, wobei auch eigene Rollen unterstützt werden, deaktivierbar sind.

© Frank Bültge, All rights reserved / Alle Rechte vorbehalten. (ID: 6e8b33de4342c4f2ca76b245199aeee8)

Danke für das Abonnieren meines Feed! Inhalt gefällt? Danke sagen · Kommentieren

Der klare Umschwung ist bei mir nach dem Lesen des Buches „High Performance Websites“ von Steve Souders, Chief Performance Yahoo! bei Yahoo!, gefallen und ich löse nun alles per <link.
Nun ist mir aber die öffentlich zugängliche Seite des Buchautors wieder unter gekommen und dort publiziert Steve einen Beitrag zum Thema. Diesen Link möchte ich damit einfach mal als Begründung, Rechtfertigung oder Lesetipp hier präsentieren.

Die klare Aussage: Kein @import nutzen.

Spannender Artikel, der sicher bei dem einen oder anderen Veränderungen hervorruft. Daher der Tipp, den Beitrag don’t use @import zum Buch zu lesen.

© Frank Bültge, All rights reserved / Alle Rechte vorbehalten. (ID: 6e8b33de4342c4f2ca76b245199aeee8)

Danke für das Abonnieren meines Feed! Inhalt gefällt? Danke sagen · Kommentieren

Um so schöner, dass es auch für die neue Version (alte Version) ein übersichtliches CheatSheet gibt, was beim Umgang ein leichten Zugriff erlaubt. Einfach mal drüber schauen.
Alternativ kann man noch immer auf das Firefox Add-on oder die Air-Applikation zurückgreifen.

Aufgefallen bei Technikwürze 132

Update: Cheat Sheet für jQuery Version 1.4 gibt es unter neuen Adresse

© Frank Bültge, All rights reserved / Alle Rechte vorbehalten. (ID: 6e8b33de4342c4f2ca76b245199aeee8)

Danke für das Abonnieren meines Feed! Inhalt gefällt? Danke sagen · Kommentieren

Das folgende kleine Bespiel bindet die Datei ein und gibt Markup und Design des aktiven Themes aus, somit nutz ich hier also den Zugriff auf die Inhalte und Einstellungen von WordPress, da ich die Funktionen von WordPress einbinde. Das wiederum geht nun, da die wp-load.php die Brücke zu allen anderen Funktionen in WordPress ist.

<?php
require( '../my_wordpress_install_root/wp-load.php' );
get_header();

echo 'neuer Inhalt außerhalb von WordPress';

get_footer();
?>

Je nach dem, wo man die Daten benötigt, kann es sein, das man den absoluten Pfad von WordPress benötigt. Diesen kann man ermitteln, in dem man eine php-Datei erstellt mit folgendem Inhalt, im Root der Installation ablegt und direkt aufruft. Die Ausgabe ist der Pfad zur Datei.

<?php echo $_SERVER['DOCUMENT_ROOT']; ?>

Diesen verwendet man dann in der require-Anweisung und kann nun wie gewohnt die Funktionen von WordPress nutzen.

© Frank Bültge, All rights reserved / Alle Rechte vorbehalten. (ID: 6e8b33de4342c4f2ca76b245199aeee8)

Danke für das Abonnieren meines Feed! Inhalt gefällt? Danke sagen · Kommentieren

Im Entwicklungsprozess kann so schnell, einfach und unkompliziert die Sicherheit erhöht werden. Das Tool ist schnell als Lesezeichen im Browser abgelegt und scannt Links und Pfade. Alternativ kann man neue Angriffsvektoren hinzufügen. Definitiv ein Bookmark wert. Download und Anwendung finden sich auf der Webseite zum Tool XSS Rays.

© Frank Bültge, All rights reserved / Alle Rechte vorbehalten. (ID: 6e8b33de4342c4f2ca76b245199aeee8)

Danke für das Abonnieren meines Feed! Inhalt gefällt? Danke sagen · Kommentieren

Aus meiner Sicht ist die deutsche Sprache aber ein wenig komplexer und die bekannten Lorem ipsum-Texte bilden daher nicht immer alle eventuellen Probleme ab. Hintergründe und Infos zu diesem Thema werden sehr schön in dem Artikel „Blindtexte als Chance“ der Webkrauts dargestellt.

Zu diesem Zweck habe ich mir eine Seite erstellt, die mir diverse Auswahlbereiche mit HTML-Tags und Blindtexten in deutscher Sprache zur Verfügung stellt. Dabei habe ich die Idee des HTML-Impus von Chris Coyier genutzt und einzelne Bereiche angelegt, die die Übersicht ein wenig wahren. Ebenso kann man via Klick auf den Titel einer Box den Inhalt in die Zwischenablage kopieren.

Wer also ebenso ab und dann diverse Inhalte und Tags benötigt, gern kann es genutzt werden. Ebenso freue ich mich über Ideen zur Verbesserungen.

© Frank Bültge, All rights reserved / Alle Rechte vorbehalten. (ID: 6e8b33de4342c4f2ca76b245199aeee8)

Danke für das Abonnieren meines Feed! Inhalt gefällt? Danke sagen · Kommentieren

... natürlich ist in dem Zusammenhang die Übersicht von Peter Kröner zu HTML5 nicht zu vergessen.

© Frank Bültge, All rights reserved / Alle Rechte vorbehalten. (ID: 6e8b33de4342c4f2ca76b245199aeee8)

Danke für das Abonnieren meines Feed! Inhalt gefällt? Danke sagen · Kommentieren

Alternativ kann man diesen Hook aber auch zu anderen Sachen benutzen. Auch dazu möchte ich hier einige Worte verlieren.

Der Hook posts_where ist eine wichtige Möglichkeit um auf den Query von WordPress Einfluss zu nehmen und daher ein Bestandteil des Query: $where = apply_filters('posts_where', $where);. Er dient beispielsweise dazu, den Query von WordPress zu erweitern. Dabei wird immer ein Parameter übergeben. Dieser kann mit jede Art von SQL-Anweisungen befüllt werden.

Ein bekanntes Beispiel ist eventuell mein Artikel zum verspäteten Veröffentlichen von Feeds: „WordPress Feed zeitversetzt befüllen“.

Eine weitere Möglichkeit ist es, wie schon im Eingang angesprochen, dass bei der Ausgabe innerhalb von Kategorien die Unterkategorien nicht gelistet werden sollen. Die folgende Syntax tut genau dies.

if ( !function_exists('fb_filter_child_cats') ) {
	function fb_filter_child_cats( $cats= '' ) {
		global $wp_query, $wpdb;

		if ( is_category() ) {

			// get children ID's
			if ( $excludes = get_categories( "child_of=" . $wp_query->get('cat') ) ) {

				// set array with ID's
				foreach ( $excludes as $key => $value ) {
					$exclude[] = $value->cat_ID;
				}
			}

			// remove child cats
			if ( isset($exclude) && is_array($exclude) ) {
				$cats .= " AND " . $wpdb->prefix . "term_taxonomy.term_id NOT IN (" . implode(",", $exclude) . ") ";
			}
		}

		return $cats;
	}

	if ( !is_admin() ) {
		add_filter( 'posts_where', 'fb_filter_child_cats' );
	}
}

Um ein stabileres Ergebnis zu erzielen, sollte man möglichst SQL Selects umgehen und damit stabiler in WP zu bleiben. Daher hier eine weitere Lösung für die Filterung der Kinder-Kategorien:

function fb_filter_child_cats($query) {

	$cat = get_term_by('name', $query->query_vars['category_name'], 'category');
	$child_cats = (array) get_term_children( &$cat->term_id, 'category' );

	if ( !$query->is_admin )
		$query->set( 'category__not_in', array_merge($child_cats) );

	return $query;
}
add_filter( 'pre_get_posts', 'fb_filter_child_cats' );

Ein weiteres Beispiel soll zeigen, wie man den Query erweitert. Dabei beziehe ich mich auf einige Fragen aus der WP Hacker Mailingliste, die eigentlich dort nicht hingehören, dazu ist das Forum da.
In die Funktion habe ich mal drei Beispiele integriert.

• Beiträge der Zukunft im Loop
• Seiten im Loop
• Nur Beiträge im Loop, die älter als 5 Tage sind

Ich hoffe, dass die Möglichkeiten damit recht gut dargestellt werden.

if ( !function_exists('fb_filter_where') ) {
	function fb_filter_where( $where = '' ) {
		global $wpdb;

		// allow future posts in loop
		$where .= " OR $wpdb->posts.post_status = 'future' ";

		// show pages in loop
		$where .= " OR $wpdb->posts.post_type = 'page' ";

		// only older (<) as 5 days
		$where .= " AND post_date < '" . date('Y-m-d', strtotime('-5 days')) . "'";

		return $where;
	}

	if ( !is_admin() ) {
		add_filter( 'posts_where', 'fb_filter_where' );
	}
}

Die Möglichkeiten sind sehr flexibel und im Grunde nur abhängig von den SQL-Abfragen. Damit sollte der Hook ein wenig verständlicher sein und seine vielseitigen Möglichkeiten lassen sich nur annähernd darstellen. Dieser Hook ist nur einer von vielen Hooks, die die Flexibilität von WordPress auszeichnen.

© Frank Bültge, All rights reserved / Alle Rechte vorbehalten. (ID: 6e8b33de4342c4f2ca76b245199aeee8)

Danke für das Abonnieren meines Feed! Inhalt gefällt? Danke sagen · Kommentieren

Das Thema spricht mich gerade wieder an, denn diverse Kundenanfragen zeigen, wie wenig man sich mit diesen Themen beschäftigt und man sich eher um die Farbe des Logos streitet. Der Leser des Blog wird viel zu oft nicht oder erst am Ende beachtet. Da in der Regel das Blog aber für Leser gemacht ist, sollte es auch auf ihn zugeschnitten sein. Beachtet daher die Wünsche der Nutzer, lasst sie mitreden und hört nie auf, das Blog in Frage zu stellen.
Ein weiterer Punkt, der mich zu diesem Artikel bewegte, ist der Beitrag „10 Features That Will Make Twitter Better“ von Jacob Gube, der einschlägige Punkte zeigt, die Twitter besser machen würden. Auch wenn man Twitter nicht direkt mit einem Blog vergleichen kann, so gibt es doch hinreichende Parallelen und die Punkte sprechen für sich und gehören in den Wissensstand eines jedes Nutzers, der sich mit Themen rund um Blogs und Usability beschäftigt.
Aus diesem Zusammenhang hier mal meine Liste von Punkten, die ich für relevant halte, ohne Wertung in der Priorität und sicher nicht vollständig. Aber dazu steht die Kommentarfunktion weit offen und ich danke schon jetzt für jede sinnvolle Erweiterung und konstruktive Kritik.

• Besucher stehen im Mittelpunkt

  Verliere niemals den Leser des Blog aus den Augen. Die Website wird nur besser, wenn man Veränderung zulässt, Ziele definiert und kontrolliert. Das Thema ist vielschichtig und sollte daher nicht unterschätzt werden.

• Text Links im Artikel

  Links sollten ein Aussage treffen und nicht nur unter versteckten Silben zu finden sein. Ebenso gehören Links sichtbar gekennzeichnet. Das Suchen mit der Mouse nach Veränderung ist nicht der Sinn von Links. Das title-Attribut kann einen erhöhten Mehrwert darstellen und sollte nicht vergessen werden.

• Kommentar Threading

  Die Baumansicht der Kommentare kann die Zusammenhänge der Diskussion besser darstellen, sie kann aber auch den Lesefluss nehmen und die Lust am Kommentieren vernichten. Hier gilt es den Spagat zu finden und dem Leser eine nützliche und überschaubare Lösung zu präsentieren. Das Thema ist für mich auch unter dem Gesichtspunkt der Zielgruppe zu beachten.

• Kommentare nutzerfreundlich gestalten

  Kommentieren im Blog ist in der Regel erwünscht – daher ist es wichtig, dass die Barriere so klein wie möglich ist. Unnütze Registrierung ohne Mehrwert und Captchas sind dafür nicht geeignet. Je einfaches es ist, seine Meinung in den Kommentaren abzugeben, um so mehr wird es geben. Auch das Weglassen von Pflichtfeldern kann dazu beitragen, so wie es schon Robert getan hat, nach dem wir es besprochen hatten. Die Pflichtfelder sind kein Spam-Schutz, sie haben andere Vorzüge. So nutze ich sie beispielsweise, um mit den Lesern über Mail ab und dann zu kommunizieren. So komme ich an sie und nutze sie. Aber auch hier ist der Block auf die Zielgruppe wichtig, techn. aversierte Nutzer sind da offen, kenne das Spiel mit den Pflichtfeldern.

• Wiedererkennung des Kommentierenden

  Sind Kommentare eindeutig der Person zuzuordnen, dann fühlen sich viele Kommentierende wohler. Nutze diesen Aspekt und gib einen gewissen Wiedererkennungswert zurück, sei es in Form der Avatare als auch spezifischen Content für den bekannten User zurück zu geben. Je nach Leserkreis kann das unterschiedlich ausfallen und sehr verschieden im Mehrwert sein.

• Sidebar für mehr Information nutzen

  Der Sidebar ist ein Element des Blog, welches sich durchgesetzt hat und übergreifend anerkannt ist. Darum nutzt den Sidebar um Mehrwert für den Leser zu generieren, sei es statisch oder dynamisch. Je besser der Inhalt auf den Besucher zugeschnitten ist, desto länger wird er bleiben und sich wohl fühlen. Beispiele dafür gibt es viel im Netz, die bekannteste Plattform und die, bei der man es am deutlichsten sieht ist sicher Amazon. Allerdings kommt hier wieder der Spagat zum Tragen - Registrierung, Speicherung von Nutzerdaten. Aber auch ohne diese Hürde kann man etwas tun - ich denke nur an die Übergabe der Suchbegriffe und die damit verbunden Landing Page (mehr zum Thema in Verbindung mit WordPress) für Besucher, die von Suchmaschinen kommen.

• Hervorheben des Autors

  Autoren eines Artikels sollten auch in der Diskussion zum Artikel hervorgehoben sein – dies kann den Lesefluss bestärken und eindeutig signalisieren, wer hier für Freischaltung und Beitrag verantwortlich ist. Eine kleine Spielerei im Stylesheet, die einen hohen Mehrwert haben kann. Gerade bei Bezug auf den Artikel und damit den Autor kann diese Möglichkeit viel Übersicht schaffen

• Suche nicht vergessen

  Für mich sind Sitemaps noch immer nicht aus dem Alltag weg zu denken, trotzdem ist die Suche immer mehr das elementare Werkzeug um explizit auf das Blog etwas zu finden. Daher gehört sie zum Umfang eines jedes Blog. Je nach Anforderung und Können kann diese Suche verschieden mächtig ausfallen. Unterstütze die Leser beim Suchen, helfe mit Ergebnissen, die sinnvoll sind und halte trotzdem das Suchen recht einfach. Hier ist Google Vorzeigeobjekt und man kann viele Bereiche auf das eigene Blog beziehen.

• Text/Raum

  Blogs sind für Leser – daher unterstützt das Lesen auch. Lesen heißt Arbeit für die Augen, Arbeit für den Geist und den Willen. Alle Punkte sollten optimiert für den Leser sein und schon liest der eine oder andere mehr und bis zum Ende. Inhalt ist immer noch der König einer Website für mich, egal ob es sich um techn. Tutorials, spannende Alltagsgeschichten, Videos oder Photos handelt. Daher sollte die Site für die jeweilige Zielgruppe optimiert sein. Viel Text braucht Raum – Whitespaces ist hier das Schlagwort in der Scene. Gib dem Leser die Möglichkeit das Lesen zu genießen.

• Druckoptimierung

  Leider noch immer kein Standard – was mir unverständlich ist. Nicht immer will man am Rechner lesen und der Druck ist ein Prozess den man nur dem Besucher überlassen sollte. Die Unterstützung eines sauberen Druck ist für mich daher elementar und gehört zu jedem guten Design eines Webprojektes. Auch wenn es nicht tagtäglich im Vordergrund ersichtlich ist, gehört es zum Erarbeiten eines Design. In den Artikeln „Design für den Druck mit CSS“ und „WordPress Druckversion“ habe ich mich dazu umfassend geäußert und stelle Lösungen zur Vergütung, die das Erstellen eines Print-Stylesheets vereinfache. Durchdachte CSS-Frameworks stellen ebenso eine Vorlage dazu bereit, in YAML beispielsweise ist es elementar und ist dabei um genutzt zu werden.

Wie sicher erkennbar ist, habe ich zu jedem Punkt nur eine kurze Ausführung gegeben. Dies ist Absicht und zu jedem einzelnen Punkt könnte man Artikel schreiben und Diskussionen anzetteln. Ich möchte, dass man als Betreiber des Blog über seinen Blog nachdenkt, ihn vergleicht und die Nutzer im Bezug auf das Blog beachtet. Ebenso sind hier nur 10 Punkte zum Tragen gekommen, aber eventuell nimmt der eine oder andere Leser das Thema auf und vervollständigt es. Die Vernetzung von Blogs kann dann ihr übriges tun und weitere Artikel zum Thema können nur Bewusstsein schaffen. In einem anderen Artikel, in dem ich die Betreiber von Websites zu FullFeed bitte, war nicht so angelegt, zeigt aber schön, wie ein Thema die Runde machen kann, was für ein Benefit die Kommentarfunktion hat und wie ein Thema aus der Vielzahl von Themen heraus stechen kann.

Zu fast allen Themen und oft im Bezug mit WordPress gibt es hier im Blog Artikel, nutzt die Suche und nutzt das Wissen, was ich in den Artikeln zur Verfügung stelle. Viele Artikel aus diesem Themenspektrum sind schon älter, was aber nicht heißt, dass sie nicht mehr nutzbar sind. Schaut euch um, nutzt das Suchfeld im oberen Drittel des Blog oder nutzt die erweiterte Suche. Alternativ könnt ihr euch die Suche in den Browser holen, was ich mit Open Search realisiert habe.

© Frank Bültge, All rights reserved / Alle Rechte vorbehalten. (ID: 6e8b33de4342c4f2ca76b245199aeee8)

Danke für das Abonnieren meines Feed! Inhalt gefällt? Danke sagen · Kommentieren

Mein Umsetzungen, wo ich einen Teil hier im Blog als Plugin veröffentliche oder auch nur Teillösungen als Beitrag zur Diskussion stelle basieren immer auf Anforderungen aus meinem Kopf oder aus den Ideen und Wünschen von Kontakten. Um aber in eine Nische zu stoßen und Plugins zu einem Einkommen zu deklarieren, gehört mehr Überlegung. So spielt nicht nur das Nichtvorhandensein von Konkurrenz eine Rolle, sondern auch die Planung von WordPress im Core, denn kommt diese Funktionalität in den Standard, dann kann eine Quelle schnell versiegen.

Aber ebenso lässt sich die Statistik nutzen um das Interesse der Nutzer zu analysieren. SEO und Statistik sind hier führend, was schnell nahe legt, dass es sich bei den meisten Nutzern im Interessenten handelt, die ihre Blogs weit nach oben in den Ergebnissen der Suchmaschinen katapultieren wollen, ob Businessinteresse oder rein privat sei erst mal dahin gestellt. Zum Glück können auch Plugins nicht alles und noch immer ist Content der Schlüssel zum Erfolg, was mich als Consumer der Suchergebnisse sehr freut. Bisher komme ich allen Installationen ohne SEO Plugin aus und auch Statistiken überlasse ich den Inhabern.

Dahingehend zeigt mir diese Statistik wieder, dass man auch in diesem Bereich auf seinen Bauch hören sollte und Spaß am Entwickeln haben muss. Was nützt mir die beste Nische, wenn ich keinen Spaß am Coden habe - oft sind die absurdesten Anforderungen die spannendsten und meist haben die das größte Feedback, die, die dem Nutzer Vorteile verschaffen.

In diesem Sinne wünsche ich mir weiterhin, dass die Community weiterhin so freiwillig gibt und dazu lernt und nicht mit dem Ziel eines kommerziellen Erfolges die Entwicklung eines Plugins startet.

© Frank Bültge, All rights reserved / Alle Rechte vorbehalten. (ID: 6e8b33de4342c4f2ca76b245199aeee8)

Danke für das Abonnieren meines Feed! Inhalt gefällt? Danke sagen · Kommentieren

Im Grunde kann man das recht einfach machen und nicht immer muss man dazu eine umfangreiche Abfrage in die Templates bauen oder gar verschieden Installation von WordPress einrichten. Ebenso kann man sich mit der folgenden gezeigten Lösung mehr Übersicht der getrennten Themes erarbeiten. Im Zuge eines individuellen Designs, wie es beispielsweise bei Nico oder Gerrit diskutiert wird, hat man so recht viele Möglichkeiten.

Mit WordPress 2.8

Mit der kommenden Version von WordPress wird es dazu einen Template Tag geben - body_class(), der diverse Klassen dem body-Tag zuordnet, damit wird die Induvidialität gefördert, oder auch die Syntaxmenge. Hintergründe hat Michael berichtet, inklusive aller möglichen Klassen. Alternativ kann man bei Andrew nachlesen, der die neue Funktion auch schon analysiert hat.

<body <?php body_class(); ?>>

Die Ausgabe könnte dann beispielsweise wie folgt aussehen.

<body class="page-template page-template-tutorial-php logged-in">

Alles anders

Aber auch ohne das Warten auf WordPress 2.8 und das Suchen der Klassen gibt es eine schöne und saubere Lösung, wie ich finde. Ich trenne dazu die entsprechenden Themes, wenn es sich um extreme Unterschiede handelt, so zum Beispiel zwischen Weblog und Photoblog. In diesem Fall frage ich die Kategorie ab, die nur für Bilder da ist und aktiviere dann ein anderes Theme für die Ausgabe im Frontend.

Mit dieser Grundidee kann man recht viel anstellen und so habe ich mal einige Beispiele aus meinen bisherigen Anwendungen gelistet, wählt selbst, welche Möglichkeiten ihr nutzen möchtet.

Um die Möglichkeit zu nutzen, lagert ihr die Funktion entweder in die functions.php des Themes aus, welches im Backend von WordPress auf Aktiv gesetzt ist, oder ihr speichert es als Plugin. Auch dafür habe ich ein wenig vorbereitet und so findet ihr mein kleines Plugins, welches nur via Code zu ändern ist, also keine Options-Oberfläche mitbringt, auf der entsprechenden Seite zum Plugin „User Theme“.

function fb_user_theme( $template = '' ) {

	// de_DE: Leerzeichen im Namen des Themes muessen mit _ (underline) ersetzt werden!

	// when Profil-ID
	if ( get_profile('ID') == 123 ) {
		$template = 'default';
	}

	// when IP
	if ( $_SERVER['REMOTE_ADDR'] == '127.0.0815.1' ) {
		$template = 'classic';
	}

	// when User_Level
	// @see http://codex.wordpress.org/Roles_and_Capabilities#Roles
	if ( current_user_can('level_10') ) {
		$template = 'classic';
	}

	elseif ( current_user_can('level_5') ) {
		$template = 'classic';
	}

	elseif ( current_user_can('level_2') ) {
		$template = 'default';
	}

	// when category with ID
	if ( in_category('1') ) {
		$template = 'default';
	}

	return $template;
}

add_filter('template', 'fb_user_theme');
add_filter('stylesheet', 'fb_user_theme');

Im Grunde ist es ganz einfach: wenn eine entsprechende Bedingung wahr ist, wie zum Beispiel Kategorie mit der ID 1, dann wird das default-Theme geladen, ansonsten wird immer das Theme geladen, welches im Backend aktiv ist.
In der Funktion wird als der Name des Themes an die Variable $template übergeben und mit Hilfe der beiden Filter wird das Template und das Stylesheet des übergebenen Theme-Namen aktiviert.

Der übergeben Name des Themes kann in der Beschreibung Leerzeichen enthalten, die hier in der Funktion mit _ (underline) ersetzt werden, bitte daran denken, sonst erkennt WordPress das Theme nicht.

Mit diesen kleinen und einfachen Möglichkeit kann man viele Umwege sparen, Installationen von WordPress zusammenfassen und behält trotzdem eine saubere Trennung der Themes. In der Funktion können natürlich alle Arten von Conditional Tags (Hinweise dazu: hier und hier) genutzt werden und so ist auch denkbar, dass statische Seiten oder Beiträge mit bestimmten Tags ein anderes Design erhalten.

© Frank Bültge, All rights reserved / Alle Rechte vorbehalten. (ID: 6e8b33de4342c4f2ca76b245199aeee8)

Danke für das Abonnieren meines Feed! Inhalt gefällt? Danke sagen · Kommentieren

Auch ich möchte meine Sicht der Dinge ein wenig darlegen und rufe zur Diskussion auf. WordPress ist aus meiner Sicht eine Applikation die Spaß macht und das Potential in sich trägt, weiterhin nutzbar und zukunftsträchtig zu sein. Diese kurze und einfache Form meiner Meinung meine ich aus der Sicht eines Anwenders und ebenso eines Entwicklers. Ich will nur kurz und bündig Möglichkeiten zeigen, die ich mir in dem Punkt wünsche und wie ich mir ein WordPress der Zukunft vorstellen könnte, ohne den jetzigen Pfad zu verlassen und die Nutzung parallel zu gewährleisten - quasi ohne einen Start bei Null.

Core Plugins

Core Plugins erlauben es, dass der eigentliche Core von WordPress schlank bleibt und man sich die notwendigen Erweiterungen mit Hilfe der Core Plugins holt. Damit schaltet man nur Funktion zu, die man auch wirklich benötigt bzw. die von anderen Erweiterungen, zum Beispiel Plugins aus der Community, gebraucht werden.

Fahrplan

Bisher ist die Philosophie von WordPress: wachse, erweitere mehr und mehr; wie ich das auch in den Gedanken zu 2009 schon veröffentlicht habe. Dies liegt aus meiner Sicht sicher daran, dass der Großteil der Benutzer immer mehr Funktionen möchte, was auch schon an der Wunschliste von WordPress zu sehen ist.

Pro & Kontra

Das Entwicklerteam um WordPress tut sich schwer mit Entscheidungen, was kommt in den Core und was nicht. Zum Teil werden ewige Diskussionen geführt, bis man es umsetzt. WordPress ist bekannt für ein schnelles Wachstum und Funktionsvielfalt. Aus diesem Aspekt heraus ist es sicher schwer, zu sagen, wir nehmen bestimmte Bereiche heraus und stellen sie als Plugin zur Verfügung. Dies bedeutet aber eine angekoppelte Entwicklung, was mehr Zeit kostet und die scheint WordPress nie zu haben. Ich stimme zu - damit wird die Entwicklung träger, der Aufwand des Testens höher und die Vielfalt hat keinen gemeinsamen Standard. Aber ist es nicht ein Mehrwert, wenn man ein schlankes stabiles System hat, welches man mit den den entsprechenden Plugins um die benötigten Funktionen erweitert?

Aus meinem Umfeld der eigenen Entwicklungen, veröffentlicht oder nicht, rund um und mit WordPress weiß ich, wie viel Aufwand es bedeuten kann, Plugins aktuell zu halten und entsprechend zu testen. Ich kann verstehen, wenn man sich gegen Core Plugins ausspricht. Aus dem Blick der unterschiedlichen Anwendungen und Lösungen, die ich mit WordPress umgesetzt habe, kann ich aber die Entwicklung in die Richtung Core Plugin nur unterstreichen.

Core Plugin oder klassisches Plugin?

In diesem Zusammenhang stellt sich aber dann auch unwiderruflich die Frage, warum Core Plugins, warum nicht die klassischen Modelle der Plugins im wordpress.org Plugin Repository? In diesem Verzeichnis zeigt sich besonders stark, wie aktiv die Community um WordPress ist und die Vielfalt der Plugins ist unüberschaubar, eine Prüfung des Code ist für die einzelnen Plugins nicht zu gewährleisten (was ich im Grunde auch unterstützte, so lange sie GPL sind; aber das ist eine andere Diskussion). Die Möglichkeit der Core Plugins sehe ich da anders, denn sie könnten diese Sicherheit geben und den gleichen Standard wie der Core selbst haben.

Versionsaufwand

Durch die vielen Versionen von WordPress, die auch nicht wenig im Umlauf sind, ist es schwer Plugins an alle Versionen anzupassen. Seit Version 2.7 ist die Bereitstellung von Schnittstellen und Möglichkeiten für Entwickler viel konsistenter und übergreifender geworden. Ich selbst tue mich schwer auf Systeme mit niedrigeren Versionen zu portieren und ich kenne diese Meinung auch von anderen Entwicklern, die viel mehr von Code verstehen als ich - es macht einfach keinen Spaß ist mein Grund. Aber es ist nicht der einzige, es sind auch die Möglichkeiten und die saubere Implementierung, die seit 2.7 übergreifender und durchgängiger umgesetzt wurde.
Ähnlich ist die Diskussion zu PHP5, die ich auch hier nicht anschneiden will - schauen wir, was WordPress 2.8 bringt oder Matt am 14.Februar in Jena dazu sagt. Die WP Hacker Mailing Liste hat auch dazu eine umfangreiche Diskussion.

Nochmal Core Plugin

Mit Hilfe der Core Plugins, um wieder zum Thema zurück zu finden, sehe ich Chancen für stabilen Code mit mehr Aufwand aber ebenso großen Feedback. Plugins können sich darauf beziehen, können diese abfragen und die Performance könnte davon profitieren. Die Vielfalt der Möglichkeiten, die WordPress jetzt schon bietet, wäre noch größer und leichter zu begründen. Jedes Core Plugin ist einzelnen erhältlich oder komfortabel über einen Builder für eine Komplettversion zu bekommen.

Ein Beispiel

Um das ganze ein wenig plakativer zu gestalten, soll ein Beispiel dienen, welches in der Vergangenheit zu viel Ärger und Diskussionen geführt hat, nicht nur bei Entwicklern - die Revision in WordPress seit Version 2.5.
Diese Funktion ist für die Nutzung als CMS und mit unterschiedlichen Autoren in WordPress unumgänglich. Sie stellt aus dieser Sicht einen Mehrwert her - gibt aber gleichzeitig sehr viele Datenmengen in die Datenbank. Dies ist vor allem dann unnötig, wenn man das Blog allein betreibt und auf diese Bereicherung im CMS-Sektor verzichten kann. Aus meiner Sicht stellt gerade die Revision in WP ein typisches Produkt für ein Core Plugin dar. Wer es benötigt, der aktiviert es und fertig. Ich kenne so viele WordPress-Nutzer, die diese Funktion noch nicht mal kennen, sich nur über das Feld im Backend wundern und die großen Datenmengen beim Backup bestaunen. Im Standard gibt es keine Möglichkeit diese Funktion einzuschränken oder zu deaktivieren - dazu ist ein Eingriff in die Konfigurationsdatei notwendig oder das Nutzen eines Plugins. Dank der großen und freien Community wird so was kommuniziert - erreichen kann man damit trotzdem nie alle und Dienstleister bereinigen dann die Daten, wenn der Kunde es wünscht.

Fazit

Daher stimme ich für Core Plugins, parallel entwickelt mit und für den Core, gern in Abhängigkeit der Version des Core. Ebenso bin ich für die eigenständige Form der Core Plugins und die Freiheit für Entwickler in den bekannten Plugins aus dem wp.org Plugin Repository.

Geschafft

Wunderbar, du hast es bis hier gelesen? Schon dafür danke ich und sage Entschuldigung: Nun sind es doch einige Zeichen mehr geworden, gesagt habe ich trotzdem nicht alles und vielleicht bin ich auch komplett auf dem Holzweg, aber es ist eine Meinung und Open Source ist aus meiner Sicht eben mehr als Nehmen und Geben von Source Code, es ist auch die Freiheit mitzumachen, mitzudenken und zu diskutieren - ja geradezu Anregen zum Diskutieren.

© Frank Bültge, All rights reserved / Alle Rechte vorbehalten. (ID: 6e8b33de4342c4f2ca76b245199aeee8)

Danke für das Abonnieren meines Feed! Inhalt gefällt? Danke sagen · Kommentieren

Um die Tags in seine Liste zu bekommen, muss man die folgenden Einträge in die taglist.txt einfügen. Wo diese sich befindet, dass erfährt man durch das Kontextmenu auf der Liste im Editor - also rechte Mousetaste auf die Tagliste und Tags anpassen wählen.

Sind die einzelnen Tags dann in der Liste gespeichert, so gilt es diese auch UltraEdit mitzuteilen. Dazu muss die „Group List“ erweitert werden. Das könnte wie folgt aussehen.

[Group List]
0=CSSDoc
1=HTML - Special Characters
2=HTML - Tags
3=jQuery 1.2.6
4=jQuery 1.2.6 Ajax
5=jQuery 1.2.6 Attributes
6=jQuery 1.2.6 Core
7=jQuery 1.2.6 CSS
8=jQuery 1.2.6 Effects
9=jQuery 1.2.6 Events
10=jQuery 1.2.6 Internals
11=jQuery 1.2.6 Manipulation
12=jQuery 1.2.6 Traversing
13=jQuery 1.2.6 Utilities
14=UE/UES Macro Commands
15=UE/UES Script Commands
16=

Im Anschluss nochmal das Kontextmenu aufrufen und die neue Liste wird aktualisiert.

Bevor es nun nur noch die Syntax gibt, ein kleiner Tipp ab Rande zu jQuery. Besonders schön und schnell ist der Zugriff auf die Dokumentation mit Hilfe des Add on für den Firefox jQuery Menu.

Aufgeteilte Liste

[Tag Group - jQuery 1.2.6 Core]
0="jQuery(expression, context)"
1="jQuery(html)"
2="jQuery(elements)"
3="jQuery(callback)"
4=".each(callback)"
5=".eq(position)"
6=".get()"
7=".get(index)"
8=".index(subject)"
9=".data(name)"
10=".data(name, value)"
11=".removeData(name)"
12="jQuery.fn.extend(object)"
13="jQuery.extend(object)"
14="jQuery.noConflict()"
15="jQuery.noConflict(extreme)"
16=

[Tag Group - jQuery 1.2.6 Attributes]
0=".attr(name)"
1=".attr(properties)"
2=".attr(key, value)"
3=".attr(key, fn)"
4=".removeAttr(name)"
5=".addClass(class)"
6=".hasClass(class)"
7=".removeClass(class)"
8=".toggleClass(class)"
9=".html()"
10=".html(val)"
11=".text()"
12=".text(val)"
13=".val()"
14=".val(val)"
15=".val(val)"
16=

[Tag Group - jQuery 1.2.6 Traversing]
0=".eq(index)"
1=".hasClass(class)"
2=".filter(expr)"
3=".filter(fn)"
4=".is(expr)"
5=".map(callback)"
6=".not(expr)"
7=".slice(start, end)"
8=".add(expr)"
9=".children(expr)"
10=".contents()"
11=".find(expr)"
12=".next(expr)"
13=".nextAll(expr)"
14=".parent(expr)"
15=".parents(expr)"
16=".prev(expr)"
17=".prevAll(expr)"
18=".siblings(expr)"
19=".andSelf()"
20=".end()"
21=".html()"
22=".html(val)"
23=".text()"
24=".text(val)"
25=

[Tag Group - jQuery 1.2.6 Manipulation]
0=".append(content)"
1=".appendTo(content)"
2=".prepend(content)"
3=".prependTo(content)"
4=".after(content)"
5=".before(content)"
6=".insertAfter(content)"
7=".insertBefore(content)"
8=".wrap(html)"
9=".wrap(elem)"
10=".wrapAll(html)"
11=".wrapAll(elem)"
12=".wrapInner(html)"
13=".wrapInner(elem)"
14=".replaceWith(content)"
15=".replaceAll(selector)"
16=".empty()"
17=".remove(expr)"
18=".clone()"
19=".clone(true)"
20=

[Tag Group - jQuery 1.2.6 CSS]
0=".css(name)"
1=".css(properties)"
2=".css(name, value)"
3=".offset()"
4=".height()"
5=".height(val)"
6=".width()"
7=".width(val)"
8=

[Tag Group - jQuery 1.2.6 Events]
0=".ready(fn)"
1=".bind(type, data, fn)"
2=".one(type, data, fn)"
3=".trigger(type , data )"
4=".triggerHandler(type , data )"
5=".unbind(type , data )"
6=".hover(over, out)"
7=".toggle(fn, fn1)"
8=".blur()"
9=".blur(fn)"
10=".change()"
11=".change(fn)"
12=".click()"
13=".click(fn)"
14=".dblclick()"
15=".dblclick(fn)"
16=".error()"
17=".error(fn)"
18=".focus()"
19=".focus(fn)"
20=".keydown()"
21=".keydown(fn)"
22=".keypress()"
23=".keypress(fn)"
24=".keyup()"
25=".keyup(fn)"
26=".load (fn)"
27=".mousedown (fn)"
28=".mousemove(fn)"
29=".mouseout(fn)"
30=".mouseover(fn)"
31=".mouseup(fn)"
32=".resize(fn)"
33=".scroll(fn)"
34=".select()"
35=".select(fn)"
36=".submit()"
37=".submit(fn)"
38=".unload(fn)"
39=

[Tag Group - jQuery 1.2.6 Effects]
0=".show()"
1=".show(speed, callback)"
2=".hide()"
3=".hide(speed, callback)"
4=".toggle()"
5=".slideDown(speed, callback)"
6=".slideUp(speed, callback)"
7=".slideToggle(speed, callback)"
8=".fadeIn(speed, callback)"
9=".fadeOut(speed, callback)"
10=".fadeTo(speed, opacity, callback)"
11=".animate(params, duration, easing, callback)"
12=".animate(params, options)"
13=".stop()"
14=".queue()"
15=".queue(callback)"
16=".queue(queue)"
17=".dequeue()"
18=

[Tag Group - jQuery 1.2.6 Ajax]
0="jQuery.ajax(options)"
1=".load(url, data, callback)"
2="jQuery.get(url, data, callback)"
3="jQuery.getJSON(url, data, callback)"
4="jQuery.getScript(url, callback)"
5="jQuery.post(url, data, callback, type)"
6=".ajaxComplete(callback)"
7=".ajaxError(callback)"
8=".ajaxSend(callback)"
9=".ajaxStart(callback)"
10=".ajaxStop(callback)"
11=".ajaxSuccess(callback)"
12="jQuery.ajaxSetup(options)"
13=".serialize()"
14=".serializeArray()"
15=

[Tag Group - jQuery 1.2.6 Utilities]
0="jQuery.each(object, callback)"
1="jQuery.extend(target, object1, objectN)"
2="jQuery.grep(array, callback, invert)"
3="jQuery.makeArray(obj)"
4="jQuery.map(array, callback)"
5="jQuery.inArray(value, array)"
6="jQuery.unique(array)"
7="jQuery.isFunction(obj)"
8="jQuery.trim(str)"
9=

[Tag Group - jQuery 1.2.6 Internals]
0="jQuery.data(elem)"
1="jQuery.data(elem, name)"
2="jQuery.data(elem, name, value)"
3="jQuery.removeData(elem)"
4="jQuery.removeData(elem, name)"
5="jQuery.param(obj)"
6=

Komplett in einer Liste

[Tag Group - jQuery 1.2.6]
0=".add(expr)"
1=".addClass(class)"
2=".after(content)"
3=".ajaxComplete(callback)"
4=".ajaxError(callback)"
5=".ajaxSend(callback)"
6=".ajaxStart(callback)"
7=".ajaxStop(callback)"
8=".ajaxSuccess(callback)"
9=".andSelf()"
10=".animate(params, duration, easing, callback)"
11=".animate(params, options)"
12=".append(content)"
13=".appendTo(content)"
14=".attr(key, fn)"
15=".attr(key, value)"
16=".attr(name)"
17=".attr(properties)"
18=".before(content)"
19=".bind(type, data, fn)"
20=".blur()"
21=".blur(fn)"
22=".change()"
23=".change(fn)"
24=".children(expr)"
25=".click()"
26=".click(fn)"
27=".clone()"
28=".clone(true)"
29=".contents()"
30=".css(name)"
31=".css(name, value)"
32=".css(properties)"
33=".data(name)"
34=".data(name, value)"
35=".dblclick()"
36=".dblclick(fn)"
37=".dequeue()"
38=".each(callback)"
39=".empty()"
40=".end()"
41=".eq(index)"
42=".eq(position)"
43=".error()"
44=".error(fn)"
45=".fadeIn(speed, callback)"
46=".fadeOut(speed, callback)"
47=".fadeTo(speed, opacity, callback)"
48=".filter(expr)"
49=".filter(fn)"
50=".find(expr)"
51=".focus()"
52=".focus(fn)"
53=".get()"
54=".get(index)"
55=".hasClass(class)"
56=".hasClass(class)"
57=".height()"
58=".height(val)"
59=".hide()"
60=".hide(speed, callback)"
61=".hover(over, out)"
62=".html()"
63=".html()"
64=".html(val)"
65=".html(val)"
66=".index(subject)"
67=".insertAfter(content)"
68=".insertBefore(content)"
69=".is(expr)"
70=".keydown()"
71=".keydown(fn)"
72=".keypress()"
73=".keypress(fn)"
74=".keyup()"
75=".keyup(fn)"
76=".load (fn)"
77=".load(url, data, callback)"
78=".map(callback)"
79=".mousedown (fn)"
80=".mousemove(fn)"
81=".mouseout(fn)"
82=".mouseover(fn)"
83=".mouseup(fn)"
84=".next(expr)"
85=".nextAll(expr)"
86=".not(expr)"
87=".offset()"
88=".one(type, data, fn)"
89=".parent(expr)"
90=".parents(expr)"
91=".prepend(content)"
92=".prependTo(content)"
93=".prev(expr)"
94=".prevAll(expr)"
95=".queue()"
96=".queue(callback)"
97=".queue(queue)"
98=".ready(fn)"
99=".remove(expr)"
100=".removeAttr(name)"
101=".removeClass(class)"
102=".removeData(name)"
103=".replaceAll(selector)"
104=".replaceWith(content)"
105=".resize(fn)"
106=".scroll(fn)"
107=".select()"
108=".select(fn)"
109=".serialize()"
110=".serializeArray()"
111=".show()"
112=".show(speed, callback)"
113=".siblings(expr)"
114=".slice(start, end)"
115=".slideDown(speed, callback)"
116=".slideToggle(speed, callback)"
117=".slideUp(speed, callback)"
118=".stop()"
119=".submit()"
120=".submit(fn)"
121=".text()"
122=".text()"
123=".text(val)"
124=".text(val)"
125=".toggle()"
126=".toggle(fn, fn1)"
127=".toggleClass(class)"
128=".trigger(type , data )"
129=".triggerHandler(type , data )"
130=".unbind(type , data )"
131=".unload(fn)"
132=".val()"
133=".val(val)"
134=".val(val)"
135=".width()"
136=".width(val)"
137=".wrap(elem)"
138=".wrap(html)"
139=".wrapAll(elem)"
140=".wrapAll(html)"
141=".wrapInner(elem)"
142=".wrapInner(html)"
143="jQuery(callback)"
144="jQuery(elements)"
145="jQuery(expression, context)"
146="jQuery(html)"
147="jQuery.ajax(options)"
148="jQuery.ajaxSetup(options)"
149="jQuery.data(elem)"
150="jQuery.data(elem, name)"
151="jQuery.data(elem, name, value)"
152="jQuery.each(object, callback)"
153="jQuery.extend(object)"
154="jQuery.extend(target, object1, objectN)"
155="jQuery.fn.extend(object)"
156="jQuery.get(url, data, callback)"
157="jQuery.getJSON(url, data, callback)"
158="jQuery.getScript(url, callback)"
159="jQuery.grep(array, callback, invert)"
160="jQuery.inArray(value, array)"
161="jQuery.isFunction(obj)"
162="jQuery.makeArray(obj)"
163="jQuery.map(array, callback)"
164="jQuery.noConflict()"
165="jQuery.noConflict(extreme)"
166="jQuery.param(obj)"
167="jQuery.post(url, data, callback, type)"
168="jQuery.removeData(elem)"
169="jQuery.removeData(elem, name)"
170="jQuery.trim(str)"
171="jQuery.unique(array)"
172=

© Frank Bültge, All rights reserved / Alle Rechte vorbehalten. (ID: 6e8b33de4342c4f2ca76b245199aeee8)

Danke für das Abonnieren meines Feed! Inhalt gefällt? Danke sagen · Kommentieren

Mit PHP gibt es eine ganze Reihe von Möglichkeiten um die Ausgabe von Variablen während des Entwickeln zu gestalten, print_r() und var_dump() sind sicher die meist genutzten. Diese Möglichkeiten geben die Inhalte als HTML aus, direkt and er Stelle, wo sie eingebunden sind. Das hat den Nachteil, dass das Layout eventuell zerstört ist, dass die Ausgabe unübersichtlich wird und wenn man in einem Livebetrieb diese Möglichkeiten nutzt, dann is tdas nur schwer vor den anderen Usern zu verbergen. Mit dem Add on FirePHP bekommt der Entwickler ein Werkzeug, ohne Entwicklungsumgebung, welches diese Arbeit erleichtern kann und direkt im Browser verfügbar ist.
Nun aber in wenigen Schritten, wie man zur Integration des Firebug und der Ausgabe der Werte kommt.

Installation

Das Add on benötigt ein weiters Add on und ist nur im Browser Firefox verfügbar. Wer also nicht mit diesem Browser unterwegs ist, darum kommt man beim Entwickeln aktuell nicht dran vorbei, auch wenn sich andere Hersteller redlich bemühen. Installiert also den Browser Firefox und das Add on Firebug. Wer Firebug noch nicht kennt - damit kann man im Standard HTML, CSS und JavaScritp debuggen, analysieren und live editieren. Ist das abgeschlossen, so kann die Erweiterung FirePHP installiert werden. Die einzelnen Links führen euch zu den Installationen, welche einfach und schnell erledigt sind.

Ein Hinweis, FirePHP und dessen Library funktioniert nur mit PHP 5.

Nach dem alles installiert ist, findet man die Tools in der Systemleiste des Browser (zu erkennen am kleinen Käfer), per Klick oder F12 kann der Firebug aufgerufen werden. Nun kann schon mit den Standard-Tools gearbeitet werden; für die Verwendung von FirePHP muss man noch das PEAR-Paket bereit stellen. Die wenigsten Nutzer werden wohl einen eigenen Server haben, so dass die Umgebung für das Entwickeln von PHP-Anwendungen eher ein lokaler Server sein wird. Daher erkläre ich mal am Beispiel XAMPP, wie man FirePHP zum reden bringt.

1. Als erstes muss die Code-Libarary herunter geladen werden, zu finden auf der Webseite von FirePHP.
2. In diesem Download-Paket gibt es einen Ordner FirePHPCore, den man nach …\xampp\php\PEAR kopiert.
3. Hat man dies erledigt, dann muss man lediglich den Server starten bzw. neu starten, falls er schon lief.

Vorbereitung der Ausgabe

Nach dem nun die Bibliothek beriet steht, können wir sie in das Projekt implementieren. Dazu inkludet man die Datei und schon steht die wichtigste Funktion fb() bereit.

require('FirePHPCore/fb.php');

Nun empfiehlt sich noch das Puffern der Ausgabe und dann kann es schon los gehen. Aktuell steht also im Projekt die folgenden Zeilen.

<?php
require('FirePHPCore/fb.php');
ob_start();
?>

Die erste Ausgabe „Hello World“

Als erstes soll das gewohnte Neuland betreten werden, in dem wir „Hello World“ im FireBug ausgeben. Dazu erweitert man die obigen Zeilen um ein einfache Ausgabe mit der Funktion fb() von FirePHP.

<?php
require('FirePHPCore/fb.php');
ob_start();
fb('Hello World');
?>

Mit F12 den Firebug aktivieren und die Seite neu laden, dann sollte es ähnlich dem folgendem Screenshot bei euch aussehen.

Log Meldungen gestalten

Firebug kann aber mehr als pur die Meldungen ausgeben; dabei gibt es verschiedene Design-Möglichkeiten, die das Lesen der Ausgabe von Meldungen erleichtern und so verschiedene Typen für unterschiedliche Ausgaben zulassen.
Dazu den Code wieder ein wenig erweitern:

<?php
require('FirePHPCore/fb.php');
ob_start();
fb('Hello World');

fb('Log Mitteilung', FirePHP::LOG);
fb('Info Mitteilung', FirePHP::INFO);
fb('Warn Mitteilung', FirePHP::WARN);
fb('Error Mitteilung', FirePHP::ERROR);
?>

Array ausgaben

Nun aber weg von den kleinen Spielereien, zu einem sehr mächtigen Werkzeug, die Ausgabe von Arrays. Die Ausgabe soll an einer bekannten Variable gezeigt werden - $_SERVER.

$_SERVER ist ein Array, das Informationen wie Header, Pfade und die verschiedenen Wege, das Skript anzusprechen. Die Einträge in diesem Array werden vom Webserver erstellt.

Diese Variable wird nun mittels der Funktion fb() in FirePHP geloggt und kann daher inhaltlich gelesen werden. Bisher wurde die Funktion lediglich mit Text gefüttert und dieser wurde dann ausgeben, dass ändert sich nur soweit, dass man anstatt Text nun die Variable übergibt.
Der Syntax wird wieder erweitet:

<?php
require('FirePHPCore/fb.php');
ob_start();

fb($_SERVER, FirePHP::LOG);
?>

Nun wird im Firebug ein Array angezeigt, mit dem Wert 36. Ein MouseOver zeigt die Inhalte des Array in einem Extra Fenster, ein Klick stellt das Fenster permanent dar.

Erstellt man später mehrere Ausgaben, so ist es sinnvoll, wenn man eine Zuordnung hat. Daher lässt die Funktion fb() auch dafür einen Parameter zu.

fb($_SERVER, 'Server Variables', FirePHP::LOG);

Trace loggen

Als nächstes soll ein Trace erfolgen, so dass man alle Verbindungen sehen kann. Die WordPress-Nutzer sehen spätestens jetzt, dass ich für das Beispiel in einem WordPress-Theme debugge, was eigentlich schön zeigt, wie gut sich FirePHP integrieren lässt.

Dafür die folgende Erweiterung in den Code übernehmen.

<?php
require('FirePHPCore/fb.php');
ob_start();

fb('Backtrace to here', FirePHP::TRACE);
?>

Sehr schön kann man nun die Verbindungen sehen, die tabellarische Sicht gibt sehr schnell Auskunft und macht die Analyse zum Kinderspiel.

Fazit

Dieser kleine Einstieg zeigt die für mich wichtigsten Funktionen. FirePHP kann mehr und informiert darüber ausführlich auf der zugehörigen Website.
Ebenso lohnend ist das Tutorial von Dirk Henn „PHP mit Firebug debuggen“.

© Frank Bültge, All rights reserved / Alle Rechte vorbehalten. (ID: 6e8b33de4342c4f2ca76b245199aeee8)

Danke für das Abonnieren meines Feed! Inhalt gefällt? Danke sagen · Kommentieren