5 Wege, TYPO3-Version, Composer-Modus & Site-Root zuverlässig zu prüfen

Published on : 20 May 2025

Wolfgang Weber

Development

5 Wege, TYPO3-Version, Composer-Modus & Site-Root zuverlässig zu prüfen

Jeder TYPO3 Entwickler kennt diesen Moment: Sie tauchen in ein bestehendes Projekt ein und müssen schnell verstehen, mit was Sie arbeiten. Läuft darauf TYPO3 v11, v12, v13 oder sogar die neueste v14? Wird der Composer-Modus verwendet? Wo genau ist die Stammseite? Diese grundlegenden Fragen müssen beantwortet werden, bevor Sie mit der produktiven Arbeit beginnen können.

In diesem umfassenden Leitfaden werden wir die verschiedenen Methoden untersuchen, um Ihre TYPO3-Version zu überprüfen, zu ermitteln, ob die Installation Composer verwendet, und den Standort der Stammseite in verschiedenen TYPO3-Versionen zu lokalisieren. Ob Sie Fehler beheben, Erweiterungen entwickeln, mit einer TYPO3 Vorlage arbeiten oder ein Upgrade durchführen – diese Techniken sparen Ihnen wertvolle Zeit und helfen Ihnen, Kompatibilitätsprobleme zu vermeiden.

Was ist TYPO3 Version?

Eine TYPO3-Version bezieht sich auf die spezifische Freigabenummer des TYPO3 CMS, das Sie verwenden. Jede Version kommt mit ihrem eigenen Satz an Funktionen, Leistungsverbesserungen, Sicherheitsupdates und Kompatibilitätsanforderungen.

TYPO3 verwendet ein Versionsformat wie v12 LTS oder v13.1, wobei:

Die Zahl die Haupt- oder Nebenfreigabe anzeigt
LTS steht für Langzeitunterstützung und bietet erweiterte Updates für bis zu 3 Jahre

Warum die Versionsprüfung wichtig ist

Bevor wir in den Code eintauchen, verstehen wir, warum die Überprüfung der TYPO3-Version entscheidend ist:

Kompatibilität: Erweiterungen und benutzerdefinierter Code funktionieren möglicherweise nur mit bestimmten TYPO3-Versionen
Sicherheit: Ältere Versionen könnten bekannte Schwachstellen haben
Funktionsverfügbarkeit: Neuere Versionen bieten zusätzliche Funktionen
Upgrade-Planung: Die Kenntnis Ihrer aktuellen Version ist für die Planung von Migrationen unerlässlich

Um sicherzustellen, dass Ihr System auf dem neuesten Stand bleibt, können Sie einen Versionsprüfer verwenden, um schnell Ihre aktuelle TYPO3-Version und den Supportstatus zu ermitteln.

5 beste Methoden, um Ihre TYPO3-Version zu überprüfen

Methode 1: Verwendung des Admin-Panels

Der einfachste Weg, Ihre TYPO3-Version zu überprüfen, ist über das TYPO3 Backend:

Melden Sie sich im TYPO3 Backend an
Schauen Sie unten auf der Seite, wo die Versionsnummer angezeigt wird
Für weitere Details gehen Sie zu System → Hilfe → Über Modul

Hinweis: Diese Methode erfordert Backend-Zugriff und hilft nicht, wenn Sie programmatischen Zugriff auf Versionsinformationen benötigen.

Methode 2: Mit PHP-Code (TYPO3 v11+)

Für TYPO3 v11 und neuer wird der empfohlene Ansatz die TYPO3Version-Klasse verwendet:

use TYPO3\CMS\Core\Utility\GeneralUtility;
use TYPO3\CMS\Core\Information\Typo3Version;

// Get version information object
$versionInformation = GeneralUtility::makeInstance(Typo3Version::class);

// Get major version (e.g., "11" from "11.5.0")
$majorVersion = $versionInformation->getMajorVersion();

// Get branch (e.g., "11.5")
$branch = $versionInformation::BRANCH;

// Get full version (e.g., "11.5.0")
$fullVersion = $versionInformation::VERSION;

// Output the information
echo "TYPO3 Major Version: " . $majorVersion . PHP_EOL;
echo "TYPO3 Branch: " . $branch . PHP_EOL;
echo "TYPO3 Full Version: " . $fullVersion . PHP_EOL;

use TYPO3\CMS\Core\Utility\GeneralUtility;
use TYPO3\CMS\Core\Information\Typo3Version;

// Get version information object
$versionInformation = GeneralUtility::makeInstance(Typo3Version::class);

// Get major version (e.g., "11" from "11.5.0")
$majorVersion = $versionInformation->getMajorVersion();

// Get branch (e.g., "11.5")
$branch = $versionInformation::BRANCH;

// Get full version (e.g., "11.5.0")
$fullVersion = $versionInformation::VERSION;

// Output the information
echo "TYPO3 Major Version: " . $majorVersion . PHP_EOL;
echo "TYPO3 Branch: " . $branch . PHP_EOL;
echo "TYPO3 Full Version: " . $fullVersion . PHP_EOL;

Methode 3: Verwendung von Konstanten (TYPO3 v11 und älter)

In TYPO3 v11 und früheren Versionen können Sie auch Konstanten verwenden:

// The TYPO3 branch (e.g., "11.5")
echo "TYPO3 Branch: " . TYPO3_branch . PHP_EOL;

// The full TYPO3 version (e.g., "11.5.0")
echo "TYPO3 Version: " . TYPO3_version . PHP_EOL;

// The TYPO3 branch (e.g., "11.5")
echo "TYPO3 Branch: " . TYPO3_branch . PHP_EOL;

// The full TYPO3 version (e.g., "11.5.0")
echo "TYPO3 Version: " . TYPO3_version . PHP_EOL;

Profi-Tipp: Wenn Sie versionskompatiblen Code schreiben, verwenden Sie immer version_compare() anstelle von direkten Vergleichen. Zum Beispiel: version_compare(TYPO3_branch, '12.0', '>=') um zu überprüfen, ob die TYPO3-Version 12.0 oder höher ist.

Methode 4: Befehlszeilenschnittstelle (CLI)

Wenn Sie Terminalzugriff auf Ihre TYPO3-Instanz haben, können Sie die CLI verwenden:

# For TYPO3 v9+
./vendor/bin/typo3 --version

# For TYPO3 v8 and earlier
./typo3/cli_dispatch.phpsh extbase version:show

# For TYPO3 v9+
./vendor/bin/typo3 --version

# For TYPO3 v8 and earlier
./typo3/cli_dispatch.phpsh extbase version:show

Wie man den Komponistenmodus in TYPO3 erkennt

Warum der Komponistenmodus wichtig ist

TYPO3 kann entweder traditionell oder mit Composer installiert werden. Welche Installationsmethode verwendet wird, beeinflusst:

Workflows zur Installation von Erweiterungen
Dateipfade und Verzeichnisstrukturen
Update- und Wartungsverfahren
Abhängigkeitsmanagement

3 Methoden zur Überprüfung des Komponistenmodus in TYPO3

Methode 1: Dateisystemstruktur

Eine schnelle visuelle Überprüfung:

Wenn es eine composer.json Datei im Projektverzeichnis und im Vendor-Verzeichnis gibt, wird wahrscheinlich Composer verwendet
Traditionelle Installationen haben die meisten Dateien direkt im Web-Verzeichnis

Methode 2: Mit PHP-Code (TYPO3 v9+)

Für TYPO3 v9 und neuere Versionen:

verwende TYPO3\CMS\Core\Core\Environment;

$isComposerMode = Environment::isComposerMode();
echo "Is Composer Mode: " . ($isComposerMode ? 'Yes' : 'No');

$isComposerMode = Environment::isComposerMode();
echo "Is Composer Mode: " . ($isComposerMode ? 'Yes' : 'No');

Methode 3: Verwendung von PHP-Code (TYPO3 v8 und früher)

Für ältere TYPO3-Versionen:

verwenden Sie TYPO3\CMS\Core\Core\Bootstrap;

$isComposerMode = Bootstrap::usesComposerClassLoading();
echo "Is Composer Mode: " . ($isComposerMode ? 'Yes' : 'No');

$isComposerMode = Bootstrap::usesComposerClassLoading();
echo "Is Composer Mode: " . ($isComposerMode ? 'Yes' : 'No');

Den TYPO3 Site Root lokalisieren

Verständnis von Site Root in verschiedenen Kontexten

Der Site Root in TYPO3 kann sich auf folgendes beziehen:

1. Öffentlicher Web Root - wo öffentlich zugängliche Dateien gespeichert sind2. Projekt Root - wo sich das gesamte TYPO3-Projekt befindet (besonders wichtig bei Composer-Installationen)

Methoden zur Bestimmung von Site Root

Methode 1: Verwendung der Environment-Klasse (TYPO3 v9+)

Für TYPO3 v9 und neuer:

use TYPO3\CMS\Core\Core\Environment;

// Get the public web root
$publicPath = Environment::getPublicPath();
echo "Public Path: " . $publicPath . PHP_EOL;

// Get the project root (important for Composer mode)
$projectPath = Environment::getProjectPath();
echo "Project Path: " . $projectPath . PHP_EOL;

// Get the public web root
$publicPath = Environment::getPublicPath();
echo "Public Path: " . $publicPath . PHP_EOL;

// Get the project root (important for Composer mode)
$projectPath = Environment::getProjectPath();
echo "Project Path: " . $projectPath . PHP_EOL;

Methode 2: Verwendung von PATH-Konstanten (TYPO3 v8 und früher)

Für TYPO3 v8 und frühere Versionen:

// The web root path
echo "Site Root: " . PATH_site . PHP_EOL;

// The web root path
echo "Site Root: " . PATH_site . PHP_EOL;

Methode 3: Vollständige Implementierung über Versionen hinweg.

Dieser Code übernimmt sowohl die Überprüfung des Composer-Modus als auch die Bestimmung von Site-Roots in verschiedenen TYPO3-Versionen:

// Check composer/non-composer mode and site root across versions
if (version_compare(TYPO3_branch, '9.0', '>')) {
    // TYPO3 v9 and later
    $siteRoot = \TYPO3\CMS\Core\Core\Environment::getPublicPath() . '/';
    $composerSiteRoot = \TYPO3\CMS\Core\Core\Environment::getProjectPath() . '/';
    $isComposerMode = \TYPO3\CMS\Core\Core\Environment::isComposerMode();
} else {
    // TYPO3 v8 and earlier
    $siteRoot = PATH_site;
    $isComposerMode = \TYPO3\CMS\Core\Core\Bootstrap::usesComposerClassLoading();
    if ($isComposerMode) {
        $commonEnd = explode('/', \TYPO3\CMS\Core\Utility\GeneralUtility::getIndpEnv('TYPO3_DOCUMENT_ROOT'));
        unset($commonEnd[count($commonEnd) - 1]);
        $composerSiteRoot = implode('/', $commonEnd) . '/';
    }
}

echo "Site Root: " . $siteRoot . PHP_EOL;
echo "Is Composer Mode: " . ($isComposerMode ? 'Yes' : 'No') . PHP_EOL;
if ($isComposerMode) {
    echo "Composer Site Root: " . $composerSiteRoot . PHP_EOL;
}

// Check composer/non-composer mode and site root across versions
if (version_compare(TYPO3_branch, '9.0', '>')) {
    // TYPO3 v9 and later
    $siteRoot = \TYPO3\CMS\Core\Core\Environment::getPublicPath() . '/';
    $composerSiteRoot = \TYPO3\CMS\Core\Core\Environment::getProjectPath() . '/';
    $isComposerMode = \TYPO3\CMS\Core\Core\Environment::isComposerMode();
} else {
    // TYPO3 v8 and earlier
    $siteRoot = PATH_site;
    $isComposerMode = \TYPO3\CMS\Core\Core\Bootstrap::usesComposerClassLoading();
    if ($isComposerMode) {
        $commonEnd = explode('/', \TYPO3\CMS\Core\Utility\GeneralUtility::getIndpEnv('TYPO3_DOCUMENT_ROOT'));
        unset($commonEnd[count($commonEnd) - 1]);
        $composerSiteRoot = implode('/', $commonEnd) . '/';
    }
}

echo "Site Root: " . $siteRoot . PHP_EOL;
echo "Is Composer Mode: " . ($isComposerMode ? 'Yes' : 'No') . PHP_EOL;
if ($isComposerMode) {
    echo "Composer Site Root: " . $composerSiteRoot . PHP_EOL;
}

Versionspezifische Überlegungen

TYPO3 v14-Spezifika

TYPO3 v14 (LTS, veröffentlicht im Jahr 2026) setzt den modernen API-Ansatz fort, der in v12 und v13 eingeführt wurde, mit weiterer Bereinigung von Legacy-Code und einem stärkeren Fokus auf Composer-basierte Setups und PHP 8.2+.

use TYPO3\CMS\Core\Utility\GeneralUtility;
use TYPO3\CMS\Core\Information\Typo3Version;
use TYPO3\CMS\Core\Core\Environment;

// Get TYPO3 version info
$versionInformation = GeneralUtility::makeInstance(Typo3Version::class);

echo "TYPO3 v14 Version: " . $versionInformation::VERSION;

// Environment-based checks (standard approach)
$context = Environment::getContext();
$isDevMode = $context->isDevelopment();

echo "Application Context: " . $context;
echo "Is Development Mode: " . ($isDevMode ? 'Yes' : 'No');

// Get paths (Composer-friendly structure)
$projectPath = Environment::getProjectPath();
$publicPath = Environment::getPublicPath();

echo "Project Path: " . $projectPath;
echo "Public Path: " . $publicPath;

use TYPO3\CMS\Core\Utility\GeneralUtility;
use TYPO3\CMS\Core\Information\Typo3Version;
use TYPO3\CMS\Core\Core\Environment;

// Get TYPO3 version info
$versionInformation = GeneralUtility::makeInstance(Typo3Version::class);

echo "TYPO3 v14 Version: " . $versionInformation::VERSION;

// Environment-based checks (standard approach)
$context = Environment::getContext();
$isDevMode = $context->isDevelopment();

echo "Application Context: " . $context;
echo "Is Development Mode: " . ($isDevMode ? 'Yes' : 'No');

// Get paths (Composer-friendly structure)
$projectPath = Environment::getProjectPath();
$publicPath = Environment::getPublicPath();

echo "Project Path: " . $projectPath;
echo "Public Path: " . $publicPath;

Was in TYPO3 v14 wichtig ist

PHP 8.2+ ist erforderlich (moderne Basis)
Die Environment API ist Standard für Pfade, Kontext und Systemprüfungen
Der Composer-first-Ansatz ist jetzt die Norm (Nicht-Composer-Setups sind selten)
Weitere Entfernung veralteter / Legacy-APIs aus älteren Versionen
Verbesserte Konsistenz über v12 → v14 hinweg (einfachere Upgrades)

Profi-Tipp

Verlasse dich in TYPO3 v14 immer auf die Typo3Version-Klasse und die Environment API.

Vermeide Legacy-Konstanten wie TYPO3_version oder TYPO3_branch, da sie veraltet sind und in modernen Setups möglicherweise nicht zuverlässig funktionieren.

TYPO3 v13 Spezifika

TYPO3 v13 (veröffentlicht im Jahr 2023) verwendet weiterhin die gleichen APIs zur Versionsprüfung wie v12, hat jedoch einige wichtige Änderungen:

use TYPO3\CMS\Core\Utility\GeneralUtility;
use TYPO3\CMS\Core\Information\Typo3Version;

$versionInformation = GeneralUtility::makeInstance(Typo3Version::class);
echo "TYPO3 v13 Version: " . $versionInformation::VERSION;

// Additional v13-specific environment check
$isDevMode = Environment::getContext()->isDevelopment();
echo "Is Development Mode: " . ($isDevMode ? 'Yes' : 'No');

use TYPO3\CMS\Core\Utility\GeneralUtility;
use TYPO3\CMS\Core\Information\Typo3Version;

$versionInformation = GeneralUtility::makeInstance(Typo3Version::class);
echo "TYPO3 v13 Version: " . $versionInformation::VERSION;

// Additional v13-specific environment check
$isDevMode = Environment::getContext()->isDevelopment();
echo "Is Development Mode: " . ($isDevMode ? 'Yes' : 'No');

Profi-Tipp: In TYPO3 v13 wurden viele veraltete Methoden entfernt. Überprüfen Sie immer den offiziellen Migrationsleitfaden, wenn Sie Ihren Code aktualisieren.

TYPO3 v12 Besonderheiten

TYPO3 v12 hat einige Verbesserungen in der Environment-Klasse eingeführt:

Verwenden Sie TYPO3\CMS\Core\Core\Environment;

// Check for container usage (Docker/Kubernetes) - new in v12
$containerized = Environment::isRunningInContainer();
echo "Running in Container: " . ($containerized ? 'Yes' : 'No');

// Get application context
$context = Environment::getContext();
echo "Application Context: " . $context;

// Check for container usage (Docker/Kubernetes) - new in v12
$containerized = Environment::isRunningInContainer();
echo "Running in Container: " . ($containerized ? 'Yes' : 'No');

// Get application context
$context = Environment::getContext();
echo "Application Context: " . $context;

TYPO3 v11 Spezifika

TYPO3 v11 hat die Environment-Klasse vollständig übernommen, unterstützt aber immer noch einige ältere Methoden:

verwenden Sie TYPO3\CMS\Core\Core\Environment;

// Get the var path (for caches, logs, etc.)
$varPath = Environment::getVarPath();
echo "Var Path: " . $varPath . PHP_EOL;

// Check if running on Windows
$isWindows = Environment::isWindows();
echo "Is Windows: " . ($isWindows ? 'Yes' : 'No') . PHP_EOL;

// Get the var path (for caches, logs, etc.)
$varPath = Environment::getVarPath();
echo "Var Path: " . $varPath . PHP_EOL;

// Check if running on Windows
$isWindows = Environment::isWindows();
echo "Is Windows: " . ($isWindows ? 'Yes' : 'No') . PHP_EOL;

Überprüfung von Extbase-Klassen in TYPO3

Wenn Sie mit Extbase in TYPO3 arbeiten, müssen Sie möglicherweise die Verfügbarkeit bestimmter Klassen überprüfen. So geht's:

Methode 1: Überprüfung der Klassenexistenz

// Check if an Extbase class exists
$extbaseClassExists = class_exists('TYPO3\\CMS\\Extbase\\Mvc\\Controller\\ActionController');
echo "Extbase Action Controller exists: " . ($extbaseClassExists ? 'Yes' : 'No');

// Check if an Extbase class exists
$extbaseClassExists = class_exists('TYPO3\\CMS\\Extbase\\Mvc\\Controller\\ActionController');
echo "Extbase Action Controller exists: " . ($extbaseClassExists ? 'Yes' : 'No');

Methode 2: Verwendung des Erweiterungsmanagers

Sie können auch überprüfen, ob die Extbase-Erweiterung geladen ist:

verwenden Sie TYPO3\CMS\Core\Utility\ExtensionManagementUtility;

$extbaseLoaded = ExtensionManagementUtility::isLoaded('extbase');
echo "Extbase extension loaded: " . ($extbaseLoaded ? 'Yes' : 'No');

$extbaseLoaded = ExtensionManagementUtility::isLoaded('extbase');
echo "Extbase extension loaded: " . ($extbaseLoaded ? 'Yes' : 'No');

Methode 3: Reflexion für Klassendetails

Für eine detailliertere Untersuchung von Extbase-Klassen:

verwenden Sie TYPO3\CMS\Core\Utility\GeneralUtility;

if (class_exists('TYPO3\\CMS\\Extbase\\Reflection\\ReflectionService')) {
    $reflectionService = GeneralUtility::makeInstance('TYPO3\\CMS\\Extbase\\Reflection\\ReflectionService');
    
    // Example: Check if a specific class has a certain method
    $hasMethod = $reflectionService->hasMethod(
        'TYPO3\\CMS\\Extbase\\Domain\\Model\\FileReference',
        'getOriginalResource'
    );
    echo "FileReference has getOriginalResource method: " . ($hasMethod ? 'Yes' : 'No');
}

if (class_exists('TYPO3\\CMS\\Extbase\\Reflection\\ReflectionService')) {
    $reflectionService = GeneralUtility::makeInstance('TYPO3\\CMS\\Extbase\\Reflection\\ReflectionService');
    
    // Example: Check if a specific class has a certain method
    $hasMethod = $reflectionService->hasMethod(
        'TYPO3\\CMS\\Extbase\\Domain\\Model\\FileReference',
        'getOriginalResource'
    );
    echo "FileReference has getOriginalResource method: " . ($hasMethod ? 'Yes' : 'No');
}

Beste Praktiken und häufige Fallstricke

Best Practices

Version Kompatibilität: Verwenden Sie immer Versionsprüfungen, wenn Sie Code schreiben, der über mehrere TYPO3-Versionen hinweg funktionieren muss
Pfadverwaltung: Verwenden Sie Methoden der Environment-Klasse anstelle von fest codierten Pfaden
Fehlerbehandlung: Fügen Sie eine ordnungsgemäße Fehlerbehandlung für versionsabhängige Codepfade hinzu
Dokumentation: Kommentieren Sie Ihren versionsabhängigen Code gründlich für zukünftige Wartungspersonal

Häufige Fallstricke

Direkter Vergleich: Vermeiden Sie den direkten String-Vergleich von Versionen (TYPO3_branch == '12.4'). Verwenden Sie stattdessen version_compare().
Fest codierte Pfade: Vermeiden Sie fest codierte Pfade, die sich zwischen Composer- und Nicht-Composer-Installationen unterscheiden könnten
Veraltete Methoden: Seien Sie sich veralteter Methoden bewusst, die in zukünftigen Versionen entfernt werden könnten

Hinweis: Testen Sie Ihren Code immer in allen anvisierten TYPO3-Versionen (v11–v14). Selbst kleinere Upgrades können zu Breaking Changes führen, insbesondere ab v12, wo veraltete APIs entfernt und moderne Standards (wie die Environment API und Composer-basierte Setups) durchgesetzt werden.

Fazit

Das Verständnis, wie man die TYPO3-Version, den Composer-Modus und die Site-Root überprüft, ist für jeden TYPO3-Entwickler essenziell. Diese Prüfungen bilden die Grundlage für kompatibilitätsbewussten Code und helfen, Probleme bei der Arbeit mit verschiedenen TYPO3 Installationen zu vermeiden.

Durch die Verwendung der in diesem Leitfaden beschriebenen Methoden können Sie sicher mit TYPO3-Versionen von v11 bis v14 arbeiten, unabhängig davon, ob das Projekt Composer oder ein traditionelles Setup verwendet. Da sich TYPO3 kontinuierlich weiterentwickelt, insbesondere ab v12, ist es wichtig, sich auf moderne APIs wie die Typo3Version-Klasse und die Environment API zu verlassen, um eine konsistente und zukunftssichere Entwicklung zu gewährleisten.

Verwenden Sie stets versionsgerechte Methoden, berücksichtigen Sie Sonderfälle sorgfältig und testen Sie Ihren Code in allen anvisierten Versionen, um unerwartete Probleme zu vermeiden.

Für fortgeschrittene TYPO3 Entwicklung techniken und Best Practices folgen Sie unserem Blog oder abonnieren Sie ihn, um über die neuesten TYPO3-Trends und Updates informiert zu bleiben. Viel Spaß beim Programmieren!

Your One-Stop Solutions for Custom TYPO3 Development

A Decade of TYPO3 Industry Experience
350+ Successful TYPO3 Projects
87% Repeat TYPO3 Customers

TYPO3 Service

Wolfgang Weber

Brand & Communication Lead

Wolfgang Weber gestaltet TYPO3 mit Leidenschaft und Expertise. Als langjähriger TYPO3-Enthusiast hat er zu zahlreichen Projekten beigetragen, die Websites schneller und sicherer machen. Abseits von TYPO3 findet man ihn…

5 Wege, TYPO3-Version, Composer-Modus & Site-Root zuverlässig zu prüfen

Was ist TYPO3 Version?

Warum die Versionsprüfung wichtig ist

5 beste Methoden, um Ihre TYPO3-Version zu überprüfen

Methode 1: Verwendung des Admin-Panels

Methode 2: Mit PHP-Code (TYPO3 v11+)

Methode 3: Verwendung von Konstanten (TYPO3 v11 und älter)

Methode 4: Befehlszeilenschnittstelle (CLI)

Wie man den Komponistenmodus in TYPO3 erkennt

Warum der Komponistenmodus wichtig ist

3 Methoden zur Überprüfung des Komponistenmodus in TYPO3

Methode 3: Verwendung von PHP-Code (TYPO3 v8 und früher)

Den TYPO3 Site Root lokalisieren

Verständnis von Site Root in verschiedenen Kontexten

Methode 2: Verwendung von PATH-Konstanten (TYPO3 v8 und früher)

Methode 3: Vollständige Implementierung über Versionen hinweg.

Versionspezifische Überlegungen

TYPO3 v14-Spezifika

Was in TYPO3 v14 wichtig ist

Profi-Tipp

TYPO3 v13 Spezifika

TYPO3 v12 Besonderheiten

TYPO3 v11 Spezifika

Überprüfung von Extbase-Klassen in TYPO3

Methode 2: Verwendung des Erweiterungsmanagers

Methode 3: Reflexion für Klassendetails

Beste Praktiken und häufige Fallstricke

Fazit

Your One-Stop Solutions for Custom TYPO3 Development

Wolfgang Weber

Wie T3AA TYPO3-Barrierefreiheit mit KI mühelos macht

TYPO3 auf Rocky Linux installieren - Vollständige Einrichtungsanleitung

Post a Comment

T3Planet von NITSAN

5 Wege, TYPO3-Version, Composer-Modus & Site-Root zuverlässig zu prüfen

Warum die Versionsprüfung wichtig ist

Methode 2: Mit PHP-Code (TYPO3 v11+)

Verständnis von Site Root in verschiedenen Kontexten

TYPO3 v14-Spezifika

Was in TYPO3 v14 wichtig ist

Profi-Tipp

TYPO3 v13 Spezifika

TYPO3 v12 Besonderheiten

Your One-Stop Solutions for Custom TYPO3 Development

Wolfgang Weber

Wie T3AA TYPO3-Barrierefreiheit mit KI mühelos macht

TYPO3 auf Rocky Linux installieren - Vollständige Einrichtungsanleitung

Post a Comment

You May Also Like

Claude Code & TYPO3: Ein praktischer Entwicklerleitfaden

Migration von Drupal zu TYPO3: Eine Schritt-für-Schritt-Anleitung

Vom CMS zum Intranet: Aufbau mit dem TYPO3 nativen Backend