Typo3 - Extensions programmieren

Ab V6 sollte man für Extensions Extbase und das MVC Schema nutzen. Deshalb gibts eine neue Seite:

TYPO3 - Extensions mit Extbase programmieren

Viele Dinge (Backend, Flexforms etc.) gibt es aber weiterhin, nicht mehr nutzen sollte man die pi Library.

Weiterführende Links:

http://wiki.typo3.org/Extension_Developers_Guide

Typo3 - Backend Module programmieren (Extensions)

http://typo3.org/documentation/api/

http://wiki.typo3.org/De:Create_your_own_extension

http://typo3.org/documentation/document-library/core-documentation/doc_core_api/4.2.0/view/3/2/#id4144512

(High Priority Functions)

Templates

Typo3 Extension Developer Templates

Wie fange ich an ?

Was möchtest du tun? Ein vorhandenes Inhaltselement verändern, z.B. Felder hinzufügen oder ein neues Erstellen.

Typo3 Extensions - Inhaltstypen anlegen und bearbeiten

Ein Beispiel dafür ist die Extension metatags die den Inhaltselementen Text mit Bild und Bild zusätzliche Felder für Alt und Title Tag hinzufügt.

Extensions Programmieren in der Praxis

TYPO3 Extensions - Links richtig anlegen

TYPO3 Extensions programmieren - Links

Typo3 Extensions - Sicherheit

Typo3 Extensions programmieren - Security Tipps

JavaScript in Typo3 Extensions

Typo3 - JavaScript einbinden

Typo3 und AJAX

AJAX in TYPO3 Extensions

TypoScript in Extensions

TypoScript Einstellungen in Extensions auslagern

Frontend Plugin

Typo3 Extensions - ein Frontend Plugin Programmieren

IRRE

Typo3 Extensions mit IRRE

Das IRRE Konzept hilft beim erstellen von Extensions mit "echten" relationalen Datenbankabfragen

FlexForms

Typo3 Extensions mit FlexForms

Backendformulare

Typo3 Extensions - Backend Formulare und TCA Konfiguration

siehe auch

http://wiki.zone30.info/wikizone/index.php/Typo3_-_Extensions_programmieren#Formulare_im_Backend

Erweitern von Funktionalitäten mit Hooks

Ein Beispiel findet sich hier unter Funktionen vor oder nach der Backendeingabe ausführen:

Typo3 Extensions - Backend Formulare und TCA Konfiguration

Eine schöne Einführung von Typo3 Blogger: Typo3 - Alles über Hooks

Arbeiten mit Templates

Typo3 Extensions - Arbeiten mit Templates

Typo3 Extensions programmieren - Snippets

Typo3 Extensions programmieren - Snippets

Typo3 Extensions programmieren - Rich Text Editor (RTE)

Typo3 Extensions programmieren - RTE

Typo3 Extensions programmieren - Session Verwaltung

Siehe auch Sessions in Typo3

Standardmäßig gibt es Sessions für eingeloggte Frontend User Session und Browser Sessions

Browser Session Variable setzen

$GLOBALS["TSFE"]->fe_user->setKey("ses","zaehler", $wert);

und auslesen:

$GLOBALS["TSFE"]->fe_user->getKey("ses","zaehler");

Bei der User Session wird statt 'ses' 'user' als 1. Parameter verwendet Beispiele User Session:

 $this->lastSelection['filters']['sem'] = 0;
 //User SEssion Data lesen
 $this->lastSelection = $GLOBALS["TSFE"]->fe_user->getKey("user","lastSelection");
 // User Session Data schreiben
 $GLOBALS["TSFE"]->fe_user->setKey("user","lastSelection",$this->lastSelection);

Ein weiterer netter Artikel von Tim Lochmüller aus typo3weblog.de

Diesmal geht es um die Benutzung der Session in TYPO3. In der Regel genügt nur eine Zeile Code um einen Wert in die Session zu schreiben oder wieder heraus zu holen. Schauen wir uns erstmal an, wie man etwas in die Session schreibt:

$GLOBALS["TSFE"]->fe_user->setKey("ses", "tx_myext", $data);

Die Funktion setKey() erwartet drei Parameter:

1. Type: Dieser kann "ses" oder "user" sein.
2. Key: Eindeutiger Ident für eine Session Variable
3. Data: Die Daten die gespeichert werden sollen.

Die beiden Typen "ses" und "user" unterscheiden sich wesentlich. Während der Typ "ses" nur temporär die Daten speichert, also genau so lange, wie die Session besteht (Session-Cookie), ist es mit dem Key "user" möglich, die Daten auch über mehrere Sessions hinweg zu speichern, wobei diese an den FE-User gekoppelt werden.

Der Key sollte so gewählt werden, dass man nicht in Konflikt mit anderen Extensions kommt. Am besten benutzt man seinen Extension-Key dafür.

Die Daten die man speichern will kann jede beliebige PHP Variable sein, sogar komplette Objekte kann man ablegen.

So, nun wollen wir uns den Wert mal wieder raus holen, auch dies geht sehr schnell und einfach:

$data = $GLOBALS["TSFE"]->fe_user->getKey("ses", "tx_myext");

Die Methode getKey erwartet nur zwei Parameter, die Bedeutung ist die gleiche wie bei setKey().

Das Leben kann so einfach sein, wenn es nicht ab und an diese kleinen fiesen Sonderfälle gibt ;)

Nehmen wir mal an, man erzeugt ein PDF oder eine AJAX-Antwort, dann gibt man das PDF aus und steigt mit einem exit() oder die() aus. In diesen Fällen, reicht ein einfacher Aufruf von setKey() nicht aus. Denn TYPO3 kann dann die Daten nicht automatisch speichern. Aber hier schafft der folgende Code Abhilfe:

$GLOBALS["TSFE"]->fe_user->setKey("ses", "tx_myext", $data);
$GLOBALS["TSFE"]->fe_user->storeSessionData();

Mit storeSessionData() sorgen wir dafür, dass TYPO3 umgehend die Werte speichert. Sehr häufig wird gerade auf die letzte Zeile verzichtet, was in der Regel auch funktioniert, jedoch nur so lange, wie kein Fehler auftritt oder das Script vorzeitig beendet wird.

Fröhliches Session-Handling Euch allen :)

Caching in Typo3 Extensions - Cache Mechanismen

Typo3 - Caching in Extensions

Typo3 Extensions programmieren - Nützliche Funktionen

Aus Adventskalender 2008 typo3blog

Interessante Funktionen aus der Klasse t3lib_div vor.

1. t3lib_div::array2json($data) Mit dieser Funktion kann man sehr einfach seine Daten in ein JSON Objekt konvertieren. Die Funktion erwartet ein Array mit den Daten, dieses kann beliebig verschachtelt sein. Natürlich gibt es auch noch die PHP native Funktion json_encode, jedoch muss dies von der installierten PHP Installation unterstüzt werden.

2. t3lib_div::convUmlauts($str) Eine sehr nützliche Funktion ist convUmlauts, welche die deutschen Umlaute konvertiert, dabei wird aus einem Ä eine Ae oder aus einem ü ein ue. Groß und Klein-Schreibung wird also berücksichtigt.

3. t3lib_div::rmFromList($element, $list) Auch diese Funktion ist sehr nützlich. Möchte man aus einer kommaseparierten Liste ein Element entfernen, ist dies mit einem Funktionsaufruf getan. Gerade bei TYPO3 ist diese Funktion sehr hilfreich, wenn man z.B. eine Benutzergruppe eines FE-Users entfernen möchte.

Typo3 Extensions programmieren - Sprachlabels

Probleme mit Umlauten

Bei den Sprachdateien locallang.xml etc. kann es Probleme mit Umlauten geben, wenn die Codierung der Datei nicht mit der der Typo3 Installation zusammen passt. Es funktioniert aber automatisch, wenn man die Codierung der xml Datei im Header angibt angibt. Also oben z.B. reinschreiben:

<?xml version="1.0" encoding="utf-8" standalone="yes" ?>

Typo3 Extension - Sicherheit

Typo3 Extensions programmieren - Sicherheit

Typo3 Extensions - JavaScript Frameworks nutzen

Nutzen von jquery, extJS und Konsorten in Typo3 Typo3 Extensions - JavaScript Frameworks nutzen

Wichtige Variablen

$_EXTKEY 

bzw. im Array... Enthält den Extension Key. Immer die Variable benutzen, dann kann man den Code leichte wieder verwenden.

$TYPO3_CONF_VARS

Wie arbeitet eine Extension

Laden: Extension Manager (EM) ruft ext_emconf.php (enthält nur das Array: $EM_CONF[$_EXTKEY]) bei allen Extensions auf die in der localconf.php aufgeführt sind.

Aufruf von Backend oder Frontend: ext_localconf.php wird ausgeführt (oder eine gecachete Kopie) In dieser wird die /typo3conf/localconf.php erweitert. Funktion: weitere Klassen includieren (require_once())

Wichtige Dateien einer Extension

ext_emconf.php

Metadaten wie Name, Kategorie, Status einer Extension - muß vorhanden sein sonst wird die Extension nicht geladen. Die Informationen landen in $EM_CONF[$_EXTKEY] = ARRAY

ext_localconf.php

TCA Konfiguration für das Backend. (Werte für das Array $TYPO3_CONF_VARS). Z.B. Namen der zu ladenden Klassen, statische TSFiles etc.

Wird immer geladen wenn ein Aufruf in Frontend oder Backend erfolgt. Kann deshalb dazu benutzt werden wichtige Klassendaten zu laden oder Skripte zu inkludieren.

Optional - wird genutzt wenn Sie gefunden wird.

ext_tables.php

Erweiterungen für $TCA(Table Configuration Array). Beschreibungen von Tabellen und Formularen.

Wird außerdem genutzt um den Code von Frontend-Plugins, Modulen oder statischem TypoScript zu laden

Optional - wird genutzt wenn Sie gefunden wird.

Weitere häufige Dateien

ext_tables.sql - SQL Statements für die Datenbank-Tabellen beim Installieren der Extension.

ext_tables_static+adt.sql - SQL Insert Statements für statische Werte in Tabellen (z.B. PLZ Liste).

ext_conf_template.txt

tca.php - Anpassungen für $TCA, Informationen für die Behandlung von Datenbanktabellen

locallang[...].xml und locallang[...].php - Sprachdateien (Begriffe).

Typische Unterordner (optional)

pi1, pi2 - Enthalten Frontend Plugins

mod1, mod2 - Backend Module

sv1, sv2 - Services

Wichtige Globale Variablen

$_EXTKEY - der Extension Key

Formulare im Backend

Das $TCA (Table Configuration Array) bestimmt welche Formularfelder verwendet werden. Das Array ist in ext_tables.php(Bereiche: ctrl und feinterface s.u.) und tca.php gespeichert

• Jeder Eintrag im $TCA ist an eine Datenbanktabelle geknüpft
• Der erste Index ist der Tabellenname.
• Im zweiten Index gibt es 6 Bereiche:

 ctrl -> Informationen zur Tabelle
 interface -> Konfiguration für die Auflistung und Darstellung im Backend
 feInterface -> Eigenschaften für das Frontend Editing
 columns -> Informationen zu den Feldtypen der Tabelle und der Verarbeitung der Daten (zweiter Index ist hier der Spaltenname)
 types -> legt fest welche der in columns definierten Spalten dargestellt werden und in welcher Reihenfolge, 
          außerdem Zusatzinfo wie alternative Feldbezeichnung, Palettennummer, style codes...
 palettes -> Zum Zusammenfassen von mehreren Eingabefeldern, Zusammenstellungen wiederverwenden, Hilfsfelder definieren

Daten bearbeiten mit TCE und TCEforms

Die im $TCA definierten Daten müssen in irgend einer Form bearbeitet werden. Ein umfangreiches Modul dazu befindet sich in der Extension CMS (typo3/sysext/cms/layout/db_layout.php. DDas Modul greift auf die Typo3 Core Engine (TCE) zurück, die zum Verarbeiten und Speichern von Daten dient. Die Formulare werden mit der Klasse TCEforms erzeugt. Bearbeitet wird hierbei im Backend.

Immer dann, wenn man die im $TCA eingetragenen Tabellen über Eingabemasken manipulieren will ist des sinnvoll die TCE zu nutzen.

t3lib_TCEmain -> t3lib/class.t3lib_tce-main.php
t3lib_TCEforms -> TCEforms

Einsatz in Extensions

Instanz von t3lib_TCEmain erzeugen:

require_once(PATH_t3lib."class.t3lib_tcemain.php");
$tce=t3lib_div::makeInstance('t3lib_TCEmain');

Arrays für Daten und Kommandos erzeugen:

$data[tabelle][uid][feld] = wert

um neue Daten zu schreiben bevor man eine uid hat belegt man uid mit NEW und einem Zufallsstring z.B. NEWo1amh

$cmd[tabelle][uid][befehl] = wert

dabei stehen verschiedene Befehle zur Verfügung:

copy, move, delete, localize, version, new

Die beiden Arrays werden dann mittels

$tce->start($data,$cmd) 

an die TCE übergeben und von $tce->process_cmdmap() abgearbeitet.

Wo finde ich welche Funktionen - Bibliotheken von TYPO3 einbinden und nutzen

Oft sucht man nach benötigten Funktionen. Z.B. wenn man im Backend oder über das alternative Rendering (eid) Core Funktionen braucht. Hier mal ein paar Ansätze zum gucken. Dies ist kein zusammenhängender Code nur ein paar Schnipsel um die Hirnwindungen anzuregen

ToDo

require_once(PATH_t3lib.'class.t3lib_page.php');
require_once(PATH_tslib."class.tslib_content.php");
require_once(PATH_t3lib."class.t3lib_stdgraphic.php");
require_once(PATH_tslib."class.tslib_gifbuilder.php"); 
require_once (PATH_t3lib . 'class.t3lib_htmlmail.php');

$pid = intval(t3lib_div::_GET('pid'));

// create object instances:

//$temp_TSFEclassName = t3lib_div::makeInstanceClassName('tslib_fe');

$TSFE = new $temp_TSFEclassName($TYPO3_CONF_VARS, $page, 0, true);
$TSFE->sys_page = t3lib_div::makeInstance('t3lib_pageSelect');
$TSFE->tmpl = t3lib_div::makeInstance('t3lib_tstemplate');
$TSFE->tmpl->init();

// fetch rootline and extract ts setup:
$TSFE->rootLine = $TSFE->sys_page->getRootLine(intval($pid));
$TSFE->getConfigArray();

// return ts setup array:
$setup = $TSFE->tmpl->setup;
$conf = $setup['plugin.']['tx_rgcarousel_pi1.'];

$myCObj = new tslib_cObj();

Funktionen in Klassendateien auslagern

Oft ist es übersichtlicher Funktionen in eigene Dateien auszulagern. Im tt_news Frontend-Plugin wird das z.B. so gemacht.

require_once (t3lib_extMgm::extPath('tt_news') . 'lib/class.tx_ttnews_catmenu.php');
require_once (t3lib_extMgm::extPath('tt_news') . 'lib/class.tx_ttnews_helpers.php');
require_once (t3lib_extMgm::extPath('tt_news') . 'lib/class.tx_ttnews_cache.php');

Die Klassendateien liegen also im Ordner lib.

Die Dateien enthalten gleichnamige Klassen. Das Objekt dazu wird dann z.B. so erzeugt:

$catTreeObj = t3lib_div::makeInstance('tx_ttnews_catmenu');

Typo3 hat also eine eigene Funktion um die Instanz zu erzeugen. Man muß also nicht mit new arbeiten. Der Vorteil ist mir noch nicht klar. Evtl. wird hier noch etwas anderes ausgeführt etwa um die Klasse zu registrieren o.ä.

Drauf zugegriffen wird dann ganz normal z.B.:

$catTreeObj->init($this);

Wie kann ich eine eigene Extension debuggen?

Hilfreiche Extensions zur Entwicklung von Extensions

devlog -> schreibt log Einträge in eine Datenbanktabelle. Dazu ruft man an in seiner Extension die Funktion TODO auf und übergibt die Werte die man loggen will.

Extension Development Evaluator (extdeveval) -> Referenzen aufrufen, Autmatisch Funktionsinfos schreiben u.v.m.

permalink

Wenn man eine eigene Extension schreibt benutzt man zum größten Teil Array, und um den Überblick zu behalten was nach den ganzen schritten in einem Array noch so drin steht hat man die möglichkeit mit einer Funktion das Array schön und sauber in einer tabelle anzeigen zu lassen.

Beispiel:

PHP-Code:

$data = array("Name" => "Peter KeineAhnung", "Alter" => 22, "Wohnort" => "Ratingen");
t3lib_div::debug($data);

Ergebnis:

je nach devIPMask Einstellungen ist auch nur

PHP-Code:

debug();

nützlich, vor allem wenn ein Kundenprojekt Online ist einfach im Installtool und devIpMask deine IP eingeben und dann mit debug(); arbeiten, so kannst nur du den debug sehen und nicht irgendwelche User die grade auf der Site sind.

Kleiner Zusatz Tip:

Ihr lasst euch gleichzeitig mehrere Debugs ausgeben und verliert den überblick welcher debug welcher ist... Beispiel Ihr lasst euch ein Array vor einer funktion debugen und anschliessend...

da habt ihr dann die möglichkeit euerem Debug einen Namen zu geben..

Beispiel: PHP-Code:

$data = array("Name" => "Peter KeineAhnung", "Alter" => 22);
t3lib_div::debug(,'Array vorher');
       
$data['Name'] = 'T.uX';
$data['Alter'] = 32;

t3lib_div::debug(,'Array nachher');

Auch bei der Verwendung der integrierten DB-Abstraktionsschicht können eine Reihe von Fehlern auftreten, die teilweise nur sehr magere Fehlermeldungen produzieren. Um eine etwas explizitere Fehlerausgabe zu erzwingen sollte man folgende Zeile in seine Extension integrieren*:

PHP-Code:

$GLOBALS['TYPO3_DB']->debugOutput = true;

So wird z.B. das SQL-Stement Ausgegeben, das zu einem Fehler geführt hat.

Datenbankabfrage in Extensions

TYPO3 - Datenbankabfragen in Extensions

Struktur einer Extension

ext_emconf.php

Informationen und Metadaten zur Extension. Etwa die Infos die im Kickstarter unter General Info stehen.

• Root-Verzeichnis
  • ext_localconf.php Enthält Konfigurationsdaten ($TYPO3_CONF_VARS) für das Backend und Frontend. Hier kann über die Extension API auch TypoScript eingebunden werden. Hier können auch Klassendateien aufgerufen werden (require_once() ) die bei jedem Aufruf zur Verfügung stehen sollen.
  • ext_tables.php Konfiguration von Datenbanktabellen. Plugins und Module über die Extension API einbinden. (Alles über Kickstarter)
  • ext_tables.sql SQL-Daten für die Tabellendefinition. Die Auswertung erfolgt über den Extension Manager und das Install-Tool.
  • ext_tables_static+adt.sql SQL-Tabellendefinition inkl. Daten. Z.B. für statische Daten (Länderinfos etc.)Die Tabellen müssen zusätzlich in ext_tables.sql definiert sein.
  • ext_typoscript_*.txt Globaler TypoScript-Code. Steht nicht üver Template-Datensätze zur Auswahl (siehe /static)
  • ext_conf_template.txt Hier werden Optionen zur Konfiguration angelegt, die der Benutzer im Extensionmanager einstellen kann.
  • *icon*.gif Symbol-Dateien für Extension,DB-Tabellen,Plugins, Module...
  • locallang*.php Texte für die Lokalisierung in verschiedenen Sprachen
  • class.ext_update.php Funktionen für ein Update der Extension (Beispiel siehe newloginbox).

• pi1/ Verzeichnis für Skripte und Daten des Plugin
  • class*.php PHP-Klassen z.B. für Plugins oder Submodule

• cm1/ Verzeichnis für Dateien die das Kontext-Menü betreffen

• mod1/ Verzeichnis für ein Modul.
  • conf.php Konfigurationsdatei für ein Modul zum einbinden ins Backend.
  • index.php Hauptscript eines Moduls.

• modfunc1/ Skripte und Daten für Submodul-Funktionen

• static/ TypoScript-Template-Dateien. Diese werden über die Extension-API eingebunden und stehen dann in Template-Datensätzen, ähnlich den Standard Templates zur Auswahl.

• sv1/ Verzeichnis für Services

• res/ Verzeichnis für beliebige 'recourcen'.

• doc/ Verzeichnis der Dokumentation.

Wo werden Extensions installiert ?

typo3/sysext/ (System)

System Extensions wie cms und lang. Hier können keine Extensions mit dem Extension Manager installiert werden.

typo3/ext/ - globale Extensions (Global)

Z.B. diese die von Typo3 mitgeliefert werden. Mit der Option allowGlobalInstall kann man die Installation in dieses Verzeichnis erlauben. Das ist dann nicht sinnvoll wenn sich mehrere Typo3 WEbsites eine Installation teilen, weil es hier zu Versionskonflikten kommen kann.

typo3conf/ext - lokale Extensions (Local)

Hier werden normalerweise alle Extensions installiert. Die Lokale Installation hat immer Vorang vor einer globalen.

Typolinks richtig in Extensions einsetzen

In diesem kurzem Tutorial möchte ich zeigen, wie man Typolinks in eigenen Erweiterungen erstellt, die das Feature 'Simulate Static Documents' unterstützen und eine Ausgabe erstellen, die von Typo3 gecached wird und so auch mit der Indexed search verwendet werden können. Diese Informationen wurden aus anderen Erweiterungen zusammengetragen, speziell aus der Erweiterung tt_board. Typoscript Zuerst erstelle in der Datei 'ext_typoscript_setup.txt' eine Eigenschaft, die deiner Erweiterung mitteilt, ob caching genutzt werden soll oder nicht:

plugin.tx_myextension_pi1 {
allowCaching = 1
}

Wenn das später auf 0 gesetzt wird, werden diese Seiten nicht mehr gecached.

Vorbereitung

Bereite in der main() Funktion den Typolink vor und konfiguriere das caching:

class tx_myextension_pi1 extends tslib_pibase {
...
var $allowCaching = "";
function main($content,$conf) {
$this->conf=$conf;
...
// Preconfigure the typolink
$this->local_cObj = t3lib_div::makeInstance("tslib_cObj");
$this->local_cObj->setCurrentVal($GLOBALS["TSFE"]->id);
$this->typolink_conf = $this->conf["typolink."];
$this->typolink_conf["parameter."]["current"] = 1;
$this->typolink_conf["additionalParams"] =
$this->cObj->stdWrap($this->typolink_conf["additionalParams"],
$this->typolink_conf["additionalParams."]);
unset($this->typolink_conf["additionalParams."]);
// Configure caching
$this->allowCaching = $this->conf["allowCaching"]?1:0;
if (!$this->allowCaching) {
$GLOBALS["TSFE"]->set_no_cache();
}
...
}
}
Links erstellen
Um nun Links in der Erweiterung zu erstellen, benutze das folgende Code Fragment:
$temp_conf = $this->typolink_conf;
$temp_conf["additionalParams"] .= "&tx_myextension_pi1[key]=value";
$temp_conf["useCacheHash"] = $this->allowCaching;
$temp_conf["no_cache"] = !$this->allowCaching;
$the_link = $this->local_cObj->typolink("Linktext", $temp_conf);

Danach kann man '$the_link' zu der Ausgabe hinzufügen. Das '$temp_conf' Array kann man mit allen Eigenschaften des typolink Objektes erweitern.

Tutorial by typo3.hachmeister.org Von:fruit-lab.de

Datei Uploads in Backend Extensions

Feld im Kickstarter anlegen. in der tca.php kannst du den uploadfolder festlegen.

Komplizierter wirds in folgendem Fall (aus typo3.net 12-2007)

stimmt schon, dass man da den ordner ändern kann, aber was wenn ich nicht alle dateien in einen ordner speichern will?

ich brauche 2 ordner. einen für normale downloads und in den anderen würden die dateien reinkommen, die kostenpflichtig downzuloaden sind. diesen ordner muss ich also per htaccess schützen. darum wärs nötig, dass der upload-ordner für den späteren redakteur frei wählbar, oder zumindest 2 ordner auswählbar sind.

irgendwelche ideen?

alles kein Problem.

Man kann in der ext_emconf.php unter createDirs die benötigten Verzeichnisse angeben. Für Fileupload gibts auch einige Typofunktionen die man nutzen kann, so helfen einem folgende Klassen weiter: t3lib_basicFileFunctions t3lib_extFileFunctions

Debug Methode

Typo3 | Debug Methode :: Hilfe bei der Programmierung

Wenn man eine eigene Extension schreibt benutzt man zum größten Teil Array, und um den Überblick zu behalten was nach den ganzen schritten in einem Array noch so drin steht hat man die möglichkeit mit einer Funktion das Array schön und sauber in einer tabelle anzeigen zu lassen.

Beispiel:

$data = array("Name" => "Peter KeineAhnung", "Alter" => 22, "Wohnort" => "Ratingen");
echo t3lib_div::debug($data);

Ergebnis:

Datei:TS debug01.gif

je nach devIPMask Einstellungen ist auch nur

debug($sonstwas);

nützlich, vor allem wenn ein Kundenprojekt Online isteinfach im Installtool und devIpMask deine IP eingeben und dann mit debug($sonstwas); arbeiten, so kannst nur du den debug sehen und nicht irgendwelche User die grade auf der Site sind.

Kleiner Zusatz Tip:

Ihr lasst euch gleichzeitig mehrere Debugs ausgeben und verliert den überblick welcher debug welcher ist...

Beispiel

Ihr lasst euch ein Array vor einer funktion debugen und anschliessend... da habt ihr dann die möglichkeit euerem Debug einen Namen zu geben..

Beispiel:

$data = array("Name" => "Peter KeineAhnung", "Alter" => 22, "Wohnort" => "Ratingen");
echo t3lib_div::debug($data,'Array vorher');
$data['Name'] = 'T.uX';
$data['Alter'] = 32;
echo t3lib_div::debug($data,'Array nachher');

Ergebnis:

Datei:TS debug02.gif

Hinweis: läst du dir eine Variable im debug ausgeben erscheint [b]|debug|[/b]. das funzt nur mit Arrays ;-) Auch bei der Verwendung der integrierten DB-Abstrktionsschicht können eine Reihe von Fehlern auftreten, die teilweise nur sehr magere Fehlermeldungen produzieren. Um eine etwas explizitere Fehlerausgabe zu erzwingen sollte man folgende Zeile in seine Extension integrieren*: $GLOBALS['TYPO3_DB']->debugOutput = true;

So wird z.B. das SQL-Stement Ausgegeben, das zu einem Fehler geführt hat. Tutorial by typo3.kj187.de

PHP-Skripte einbinden

mit PHP_SCRIPT

Im Typo Script:

##############################
### temporäres Test Script ###
##############################

temp.phpScript = PHP_SCRIPT
temp.phpScript {
   file = demo/test.inc.php
   myVerySpecialOwnParameter = Hallo Welt
   myParamArray {
      a = 2
      b = 5
   }
}

Im Skript text.inc.php

<?php
// Use the debug-function to view the config
// array $conf given by TypoScript:
debug( $conf );

$contentArr[] = "Test";
$contentArr[] = $conf['file'];
$contentArr[] = $conf['myVerySpecialOwnParameter'];
$contentArr[] = implode( $conf['myParamArray.'], ', ' );

// Put all your output to $content,
// that TYPO3 will display for you:
$content = implode( $contentArr, '< br />' );
?>

mit PHP_SCRIPT_EXT

Typo3 | Externe PHP Scripte einbinden

Haben Sie ihr Projekt auf Typo3 umgestellt und wollen dennoch ihre eigenen PHP-Scripte verwenden? Dann machen Sie folgendes.

Schreiben Sie in das SETUP Feld des Templates:

tt_content.script = CASE
tt_content.script {
key.field = select_key
test = PHP_SCRIPT_EXT
test.file = fileadmin/dein_script.php
}

Um das Script jetzt als Contentelement in die Seite einzubinden, legen Sie einen neuen Seiteninhalt an. Wechseln Sie von Typ = Text auf Typ = Skript. In das CODE Feld müssen Sie jetzt nur noch test eintragen und sie sind fertig.

Dies ist die einfachste Methode. Die Ausgabe des Scripts wird aber nicht in den Cache aufgenommen! Diese Funktion wird leider nicht unterstützt.

Tutorial by typo3.kj187.de

Anmerkung Steff: Für die Cache Funktion kann man z.B. eine Einfache Extension basteln.

Beispiele

Einträge aus Bildausrichtungen im Backend entfernen

aus cron_cssstyledimgtext

<?php
if (!defined ('TYPO3_MODE'))     die ('Access denied.');

t3lib_extMgm::addPItoST43($_EXTKEY,'pi1/class.tx_croncssstyledimgtext_pi1.php','_pi1','',1);

$_EXTCONF = unserialize($_EXTCONF);
if ($_EXTCONF['addPageTS'])	{
	t3lib_extMgm::addPageTSConfig('
TCEFORM.tt_content.imageorient.types.image.removeItems = 8,9,10,17,18,25,26
');
}

$TYPO3_CONF_VARS['FE']['XCLASS']['tslib/class.tslib_content.php']=t3lib_extMgm::extPath($_EXTKEY).'class.ux_tslib_content.php';
?>

Bilder in eigener Extension rendern

In diesem Beispiel benutzte Variablen:

$BildAdresse
$ParameterFuerImgTag
$Alttext

In PHP-Datei der Extension:

$this->conf["imageBeispiel."]["file"]="uploads/pics/".$BildAdresse;
$this->conf["imageBeispiel."]["params"]=$ParameterFuerImgTag;
$this->conf["imageBeispiel."]["altText"]=$Alttext;
$Bild=$this->cObj->IMAGE($this->conf["imageBeispiel."]);
$Content.=$Bild;

In Typoscript Setup

plugin.tx_hoTest_pi1 {     //hier Plugin-Name
imageArtikel{
    file.maxW = {$ho_Test.BildWidthNews}  
    imageLinkWrap = 1
    imageLinkWrap {
      enable = 1
      bodyTag = <BODY bgColor=white>
      wrap = |
      width = 400m
      height = 400
      JSwindow = 1
      JSwindow.newWindow = 1
      JSwindow.expand = 17,20
    }
  }
}

Der Wert {$ho_Test.BildWidthNews} kann aus Constants übernommen werden.

Siehe dazu auch Konstanten von Constants im Setup verwenden und Konstanten für Constant-Editor bereitstellen

(aus www.easy-office4you.de/ 10.1.2006)

Spalten der Seiten umbenennen

Um die Spalten der Seite im Backend beliebig umzubenennen und/oder zusätzliche eigene Spalten zu verwenden, muß die Extension zed_more_columns installiert werden und dann in der Datei ext_tables.php die Spalten-Namen eingeben werden.

Beispiel:

$TCA["tt_content"]["columns"]["colPos"]["config"]["items"] = array (
"0" => array ("Mitte||Mitte||||||||","0"),
"1" => array ("Links||Links||||||||","1"),
"2" => array ("Rechts||Rechts||||||||","2"),
"3" => array ("Teaser||Teaser||||||||","3"),
"4" => array ("Fusszeile||Fusszeile||||||||","4")
);

Bei Extension dafür sorgen, daß im Backend kein Sortierungs-Button entsteht

In der Datei ext_tables.php der Extension folgende Zeile ändern

"sortby" => "name",

ändern in

"default_sortby" => "ORDER BY name",

Anstatt "name" kann natürlich auch ein anderes Suchkriterium verwendet werden.

Ausgaben im HTML-Header in Extensions programmieren

Manchmal möchte man bestimmte Angaben in den Header schreiben, um zum Beispiel ein JavaScript einzubinden o.ä.

Man könnte im statischen TypoScript für das Objekt page etwas hernehmen. Das funktioniert aber nur wenn das PAGE Objekt auch wirklich page heißt.

Also besser mit einer Typo3 Eigenen Funktion.

Beispiel - JavaScript einbinden

function includeJavaScript() {
  $js .= '<script src="'.t3lib_extMgm::siteRelPath($this->extKey).dirname($this->scriptRelPath).'/JS-Verzeichnis/js-file.js" type="text/javascript"><!-- //--></script>';
  $GLOBALS['TSFE']->additionalHeaderData[$this->extKey] = $js;
}


//Aufruf der Funktion:
$content=$this->includeJavaScript(); 

Die Variable $this->extKey wird normalerweise immer in der Klassendefinition der Extensiongesetzt und enthält den Namen der Extension (z.B. meineextension)

Für $this->scriptRelPath gilt das gleiche. Hier steht der Pfad ab dem Extension Ordner (z.B. pi1/class.tx_meineExtension_pi1.php)

Mehrsprachige Extensions

Seit der Version 4 hat sich die Vorgehensweise bei der Lokalisierung geändert. Um zu verstehen wie die Lokalisierung von Backend, Frontend etc. funktioniert gibt es hier eine kleine Übersicht: Sprachverwaltung und Lokalisierung in Typo3

$GLOBALS['TSFE']

TSFE ist ein Abbild der Klasse tslib_fe, die kannst Du auch untersuchen.