TYPO3 Explained
master (9-dev)
Introduction
About this document
Intended Audience
Code examples
Feedback and Contribute
Credits
Dedication
Further Documentation
TCA
Reference
TypoScript
Reference
TSconfig
Reference
System Overview
A basic installation
Extension Architecture
Introduction
Extensions and the Core
Notable system extensions
Extension Management
Installing extensions
Package Manager
Files and Locations
Files
Reserved File Names
Reserved Folders
System and Local extensions
Local extensions
System extensions
Loading precedence
Choosing an extension key
About GPL and extensions
Security
Registering an extension key
Naming conventions
Note on “old” extensions:
Extending “extensions classes”
Declaration File
Deprecated Configuration
Configuration Files
ext_localconf.php
Should Not Be Used For
Should Be Used For
ext_tables.php
Should Not Be Used For
Should Be Used For
Best Practices for
ext_tables.php
and
ext_localconf.php
Configuration Options
Extending the TCA Array
Storing the Changes
Storing in Extensions
Storing in the Overrides Folder
Storing in ext_tables.php Files
Changing the TCA “on the Fly”
Customization Examples
Example 1: Extending the fe_users Table
Example 2: Extending the tt_content Table
Verifying the TCA
Creating a new Extension
Kickstarting the Extension
Creating a new Distribution
Concept of Distributions
Kickstarting the Distribution
Configuring the Distribution Display in the EM
Fileadmin Files
Database Data
Distribution Configuration
Delivering Custom Dependencies
Test Your Distribution
More Information
Adding Documentation
Sphinx Project
Other Formats
README.rst
Other resources
API Overview
Directory Structure
PHP Namespaces
Core Example
Usage in Extensions
Namespaces in Extbase
Namespaces for Test Classes
Creating Instances
include and required
References
Autoloading
Autoloading Classes Since TYPO3 7.x
Loading Classes Without Composer Mode
Loading Classes With Composer Mode
Best Practices
Bootstrapping
Initialization
1. Define Legacy Constants
2. Initialize Class Loader
3. Set Request Type
4. Perform base setup
5. Define Class Loading Information
6. Check Essential Configuration
7. Register Request Handlers
8. More Configuration
9. Dispatch
10. Initialization of the TYPO3 Backend
Application Context
Variables and Constants
Constants
Table 1: Traditional List
Table 2: Base Constants
This Version, Branch and Copyright
TYPO3 External Links
String Constants
Security Related Constant
Operating System Identifier
Service Error Constants
Filetypes
HTTP Status Codes
Global Variables
Exploring Global Variables
TYPO3_CONF_VARS
File LocalConfiguration.php
File AdditionalConfiguration.php
File DefaultConfiguration.php
Backend Modules
Backend Interface
The Backend Template View
Backend Module API
Registering new Modules
Registering a Toplevel Module
$TBE_MODULES
Configuration With TypoScript
TYPO3 CMS Shell Scripts (CLI Mode)
1. The Command-line Dispatcher (Symfony)
Creating a new Symfony Command in Your Extension
2. Extbase Command Controllers
Creating an Extbase Command Controller
Example
Calling an Extbase Command Controller From the Command Line
Backend Routing
More Information
Backend User Object
Checking User Access
Checking Access to Current Backend Module
Checking Access to any Backend Module
Access to Tables and Fields?
Is “admin”?
Read Access to a Page?
Is a Page Inside a DB Mount?
Selecting Readable Pages From Database?
Saving Module Data
Getting Module Data
Getting TSconfig
Getting the Username
Get User Configuration Value
Context API and Aspects
Introduction
DateTime Aspect
Example
Language Aspect
Example
User Aspect
Example
Visibility Aspect
Example
Workspace Aspect
Example
TYPO3 Core Engine (TCE)
Introduction
Database
Files
Database: DataHandler Basics (Formerly Known as TCEmain)
Commands Array
Command Keywords and Values
Examples of Commands:
Data Array
Examples of Data Submission
Clear Cache
Hook for Cache Post-processing
Flags in DataHandler
Using DataHandler in Scripts
DataHandler Examples
Submitting Data
Executing Commands
Clearing Cache
Complex Data Submission
Both Data and Commands Executed With Alternative User Object
The “/record/commit” Route
File Functions Basics
Files Array
Command Keywords and Values
The “tce_file.php” API
FormEngine
Introduction
Main Rendering Workflow
Data Compiling
Data Groups and Providers
Extending Data Groups With Own Providers
Adding Data to Data Array
Rendering
Class Inheritance
NodeFactory
Result Array
Node Expansion
Add fieldControl Example
Database
Introduction
Doctrine-Dbal
Understanding Doctrine-Dbal and Doctrine-Orm
Low-level and High-Level Database Calls
Credits
Configuration
Database Structure
The “pages” Table
Other Tables
Upgrade Table and Field Definitions
The ext_tables.sql Files
Basic CRUD
INSERT a Row
SELECT a Single Row
SELECT Multiple Rows With Some WHERE Magic
UPDATE Multiple Rows
DELETE a Row
Class Overview
ConnectionPool
Pooling
QueryBuilder
select() and addSelect()
Default Restrictions
count()
delete()
update() and set()
insert() and values()
from()
where(), andWhere() and orWhere()
join(), innerJoin(), rightJoin() and leftJoin()
orderBy() and addOrderBy()
groupBy() and addGroupBy()
setMaxResults() and setFirstResult()
add()
getSQL()
getParameters()
execute()
expr()
createNamedParameter()
quoteIdentifier() and quoteIdentifiers()
escapeLikeWildcards()
getRestrictions(), setRestrictions(), resetRestrictions()
Connection
insert()
bulkInsert()
update()
delete()
truncate()
count()
select()
lastInsertId()
createQueryBuilder()
ExpressionBuilder
Junctions
Comparisons
Aggregate Functions
Various Expressions
TRIM
LENGTH
RestrictionBuilder
Rationale
Main Construct
Restrictions
QueryRestrictionContainer
Examples
Statement
fetch()
fetchAll()
fetchColumn()
rowCount()
Re-use Prepared Statement()
QueryHelper
parseOrderBy()
parseGroupBy()
parseTableList()
parseJoin()
stripLogicalOperatorPrefix()
getDateTimeFormats()
quoteDatabaseIdentifiers()
Migrating from TYPO3_DB
Compare Raw Queries
enableFields() and deleteClause()
From ->exec_UDATEquery() to ->update()
Result Set Iteration
sql_insert_id()
fullQuoteStr()
ext_tables.sql
TCA and TypoScript
Extbase QueryBuilder
Various Tips and Tricks
Internationalization and Localization
Introduction
Label Access in PHP
Managing Translations
The TYPO3 Translation Server
Fetching Translations of TER Extensions
Translating Locally
Custom Translations
Custom Languages
Custom Translation Servers
XLIFF Format
Basics
File Locations and Naming
Site Handling
Basics
Site Configuration Storage
The Configuration File
site identifier
rootPageId
base
languages
errorHandling
routes
routeEnhancers
Creating a new Site
Base Variants
Properties
typo3.version
typo3.branch
typo3.devIpMask
applicationContext
Functions
ip
compatVersion
like
getenv
Adding Languages
Configuration Properties
languageId
title
navigationTitle
base
baseVariants
locale
iso-639-1
hreflang
direction
typo3Language
flagIdentifier
fallbackType
fallbacks
Error Handling
Properties
errorCode
errorHandler
errorFluidTemplate
errorFluidTemplatesRootPath
errorFluidPartialsRootPath
errorFluidLayoutsRootPath
errorContentSource
errorPhpClassFQCN
Writing a Custom Page Error Handler
Static Routes
StaticText
TYPO3 URL (t3://)
Using Environment Variables in Site Configuration
Using Site Configuration in TypoScript
getText
FLUIDTEMPLATE
Using Site Config in Conditions
TypoScript Examples
EXT:form Examples
CLI Tools for Site Handling
PHP API: Accessing Site Configuration
Accessing the Current Site Object
Finding a Site Object
The Site Object
The SiteLanguage Object
Pages Without Site Configuration
Extending Site Configuration
Adding Custom / Project Specific Options to Site Configuration
Extending the Form / GUI
Versioning and Workspaces
Frontend Challenges in General
Summary
Frontend Implementation Guidelines
Frontend Scenarios Impossible to Preview
Backend Challenges
Workspace-related API for Backend Modules
Backend Module Access
Detecting Current Workspace
Using DataHandler With Workspaces
Moving in Workspaces
Digital Assets Management (FAL)
Introduction
Basic Concepts
Storages and Drivers
Files and Metadata
File References
Architecture
Overview
Folders
Processed Files
Migrated Files
Database Structure
sys_file
sys_file_metadata
sys_file_reference
sys_file_processedfile
sys_file_collection
sys_file_storage
sys_filemounts
Components
Files and Folders
File References
Storage
Drivers
The File Index
Collections
Services
Signals and Slots
\TYPO3\CMS\Core\Resource\ResourceStorage
\TYPO3\CMS\Core\Resource\ResourceFactory
\TYPO3\CMS\Core\Resource\Index\FileIndexRepository
\TYPO3\CMS\Core\Resource\Index\MetaDataRepository
\TYPO3\CMS\Core\Resource\Service\FileProcessingService
Administration
Permissions
System Permissions
File Mounts
User Permissions
User Permissions per Storage
User Permissions Details
Default Upload Folder
Frontend Permissions
File Storages
Maintenance
Scheduler Tasks
Processed Files
Using FAL
Using FAL in the Frontend
TypoScript
Fluid
The ImageViewHelper
Get File Properties
FLUIDTEMPLATE
TCA Definition
The ResourceFactory Class
Getting the Default Storage
Getting any Storage
Working With Files, Folders and File References
Getting a File
Copying a File
Adding a File
Creating a File Reference
In the Backend Context
In the Frontend Context
Getting Referenced Files
Listing Files in a Folder
Working With Collections
Searching for Files
Caching Framework
Quick Start for Integrators
Change Specific Cache Options
Garbage Collection Task
Configuration
Cache Configurations
How to Disable Specific Caches
Caching Framework Architecture
Basic Knowhow
About the Identifier
About Tags
Caches in the TYPO3 Core
Garbage Collection Task
Cache API
Cache Frontends
Frontend API
Available Frontends
String Frontend
Variable Frontend
PHP Frontend
Cache backends
Backend API
Common Options
Database Backend
InnoDB Issues
Options
Memcached Backend
Warning and Design Constraints
Options
Redis Backend
Options
APC Backend
Xcache Backend
Wincache Backend
File Backend
Options
Simple File Backend
PDO Backend
Options
Transient Memory Backend
Null Backend
Developer Information
Cache Registration and Usage
Cache Access Logic
Locking API
Locking Strategies
Capabilities
Priorities
Examples
Usage in the Core
Extend Locking in Extensions
Caveats
FileLockStrategy & NFS
Multiple Servers & Cache Locking
Related Information
Using the System Log
Logging with TYPO3
Quickstart
Instantiate a Logger for the Current Class
Log
Set Logging Output
Logger
Instantiation
Log() Method
Shorthand Methods
Configuration of the Logging System
Writer Configuration
Processor Configuration
The LogRecord Model
Log Writers
Built-in Log Writers
DatabaseWriter
FileWriter
PhpErrorLogWriter
SyslogWriter
Custom Log Writers
Log Processors
Built-in Log Processors
IntrospectionProcessor
MemoryUsageProcessor
MemoryPeakUsageProcessor
WebProcessor
Custom Log Processors
Error and Exception Handling
Configuration
Error Handler
Production Exception Handler
Debug Exception Handler
Examples
Debugging and development setup
Production setup
Performance setup
How to extend the error and exception handling
Using the System Registry
The Registry Table (sys_registry)
The registry API
Examples
Password hashing
Introduction
Basic Knowledge
How does it look like?
Configuration
Configuration Options
Available Hash Algorithms
Argon2i
bcrypt
PBKDF2
phpass
blowfish
md5salt
PHP API
Creating a Hash
Checking a Password
Adding a new hash mechanism
Mail API
Configuration
mail
smtp
sendmail
mbox
<classname>
How to Create and Send Mails
How to Add Attachments
How to Add Inline Media
How to Set and Use a Default Sender
SwiftMailer Documentation
Services
Introduction
Two Reasons to Use Services
1. Freedom of Implementation
2. Extend Functionality with Extensions
Using Services
Service Precedence
Simple Use
Use With Subtypes
Calling a Chain of Services
Configuration
Registration Changes
Service Configuration
Service Type Configuration
Developer’s Guide
Introducing a New Service Type
Implementing a Service
Service Registration
PHP Class
Service API
Service Implementation
Getter Methods for Service Information
Error Handling
General Service Functions
I/O Tools
I/O Input and I/O Output
Service-related API
\TYPO3\CMS\Core\Utility\ExtensionManagementUtility
\TYPO3\CMS\Core\Utility\GeneralUtility
Authentication
Why Use Services?
The Authentication Process
The Login Data
The “auth” Services API
The Service Chain
Developing an Authentication Service
Advanced Options
Access Control
Users and Groups
Users
Groups
The “admin” User
Location of Users and Groups
Roles
Access Control Options
Access Lists
Mounts
Page Permissions
User TSconfig
Other Options
Backend Users
Backend Groups
More About File Mounts
Paths for Local Driver Storage
Home Directories
Backend Users Module
Form Protection Tool
Usage in the Backend
Usage in the Install Tool
Flash Messages
Flash Messages API
Flash Messages Severities
Flash Messages Renderer
Flash Messages in Extbase
JavaScript-based Flash Messages (Notifications API)
System Categories
Using Categories
Managing Categories
Making a Table Categorizable
Using Categories in FlexForms
System Categories API
Category Collections
Usage With TypoScript
System Collections
Record Collections
File Collections
Collections API
Example
Enumerations
How To Use Enumerations
Create an Enumeration
Use an Enumeration
Exceptions
Implement Custom Logic
Environment
getProjectPath()
getPublicPath()
getVarPath()
getConfigPath()
getLabelsPath()
HTTP Request Library / Guzzle / PSR-7
Basic Usage
Icon API
Registration
IconProvider
Use Icons in Your Code
The PHP Way
The Fluid ViewHelper
The JavaScript way
Available Icons
Install Styleguide Extension
Use TYPO3.Icons
Hooks and Signals
The Concept of “Hooks” and “Signals”
Hooks and Signals vs. XCLASS Extensions
Proposing Hooks or Signals
Using Hooks
Using Signals
Finding Signals
Hook Configuration
$GLOBALS[‘TYPO3_CONF_VARS’][‘EXTCONF’]
$GLOBALS[‘TYPO3_CONF_VARS’][‘SC_OPTIONS’]
$GLOBALS[‘TYPO3_CONF_VARS’][‘TBE_MODULES_EXT’]
Creating Hooks
Using TYPO3CMSCoreUtilityGeneralUtility::makeInstance()
Using with TYPO3CMSCoreUtilityGeneralUtility::callUserFunction()
Update Wizards
The concept of Update Wizards
Best Practice
Examples
Creating Generic Update Wizards
Marking wizard as done
Registering wizard
Executing wizard
class.ext_update.php
Extending Classes (XCLASSes)
Introduction
How Does it Work?
Limitations
Declaration
Coding Practices
Feature Toggles
Naming of Feature Toggles
Using the API as Extension Author
Core Feature Toggles
Enable / Disable Feature Toggle
JavaScript in TYPO3 Backend
AJAX in TYPO3 Backend
In-depth Presentation
Client-Side Programming
Server-side Programming
Different Content Formats
Plain Text
XML
JSON
Developing With AJAX in the TYPO3 Backend
RequireJS in the TYPO3 Backend
Credits
Use RequireJS in Your Own Extension
Dependency Handling
Loading Your Own or Other RequireJS Modules
Shim Library to Use it as Own RequireJS Modules
Soft References
Default soft reference parsers
substitute
notify
images
typolink
typolink_tag
ext_fileref
email
url
User-defined Soft Reference Parsers
Session Storage Framework
Database Storage Backend
Using Redis to Store Sessions
Writing Your Own Session Storage
References
Rich Text Editors (RTE)
Rich Text Editors in the TYPO3 Backend
Introduction
Plugging a RTE
API for Rich Text Editors
Transformations
Introduction
Hybrid Modes
In Database
In RTE
Configuration
Where Transformations are Performed
Process Illustration
Step 1: The RTE Applications
Step 2: The RTE-specific Transformation
Step 3: The Main Transformation
Step 4: The Database
Step 5: Rendering the Website
Step 6: The Website
Content Examples
Transformation Overview
Transformation Filters
Meta Transformations
Custom Transformations API
Custom Transformation Key
Registering the Transformation Key in the System
Code Listing
Historical Perspective on RTE Transformations
Properties and Transformations
RTE Transformations in Content Elements
Conclusion
TypoScript Syntax
Introduction
About This Chapter
What Is TypoScript?
PHP Arrays
TypoScript Syntax, Object Paths, Objects and Properties
Note About Perceived Semantics
Note About the Internal Structure When Parsed Into a PHP Array
Credits
Syntax
Introduction
Example
Contexts
TypoScript syntax
Example:
object path
operator
value
Comments
Example:
Comment blocks
Rules:
Example:
Value assignment: The “=” operator
Rules:
Value modifications: The “:=” operator
Rules:
Example:
Code blocks: The { } signs
Rules:
Example:
Multi-line values: The ( ) signs
Rules:
Example:
Object copying: The “<” sign
Example:
References: the “=<” sign
Example
Object unsetting: The “>” Sign
Example:
Conditions: Lines starting with “[“
Rules:
Example:
Conditions
Where Conditions Can Be Used
The Syntax of Conditions
Combining Conditions
The Special [ELSE], [END] and [GLOBAL] Conditions
Where to insert conditions in TypoScript?
The [GLOBAL] Condition
Custom Conditions With Symfony Expression Language
Summary
Includes
Alternative, traditional Syntax
Conditions
Best practices
Sorting out Details
Parsing, Storing and Executing TypoScript
Parsing TypoScript
Storing Parsed TypoScript
Executing TypoScript
Myths, FAQ and Acknowledgements
Myth: “TypoScript Is a Scripting Language”
Myth: “TypoScript has the Same Syntax as JavaScript”
Myth: “TypoScript Is a Proprietary Standard”
Myth: “TypoScript Is very Complex”
Why not XML Instead?
The TypoScript Parser API
Introduction
Parsing Custom TypoScript
Root Level
->COLORS
->ADMINFO
A Case Story
Implementing Custom Conditions
Page Types
Create new Page Type
User Settings Configuration
[‘columns’] Section
[‘showitem’] Section
Extending the User Settings
Checking the Configuration
Context Sensitive Help (CSH)
The $TCA_DESCR Array
Keys in $TCA_DESCR
The Language Files for CSH
Syntax for Type Keys
Extending an Existing Label
Implementing CSH
For new Tables and Fields
Adding CSH for Fields Added to Existing Tables
For Modules
Extension Scanner
Introduction
Quick Start
Goals and non Goals
Limits
Extension Authors
Project Developers
Core Developers
Connection to Changelog RST Files
Extension Scanner PHP Configuration
Various
Debugging
Rendering Page Trees
Accessing the Clipboard
Putting Elements Into the Clipboard
Context-Sensitive Menus
Context Menu Rendering Flow
Markup
ContextMenuController
Item providers registration
Gathering items
Menu rendering in JavaScript
API usage in the Core
Adding Context Menu to Elements in Your Backend Module
Disabling Context Menu Items from TSConfig
Tutorial: How to Add a Custom Context Menu Item
Step 1: Item Provider Registration
Step 2: Implementation of the Item Provider Class
Step 3: JavaScript Actions
Parsing HTML
Extracting Blocks From an HTML Document
Extracting Single Tags
Cleaning HTML Content
Advanced Processing
Links to Edit Records
Editing a Record
Editing Only a Few Fields From a Record
Creating a Form for New Elements
Support for Custom Tables in the Page Module
Adding Elements to the Content Element Wizard
Add Your Plugin to Different Tab
Using Custom Permission Options
Registration
Evaluation
Keys for Options
User and Page TSconfig
User TSconfig
Page TSconfig
MetaTag API
Using the Meta Tag API
Creating Your Own MetaTagManager
TypoScript and PHP
PageTitle API
Create Your Own PageTitleProvider
Define Priority of PageTitleProviders
XML Sitemap
Installation
How to Access Your XML Sitemap
XmlSitemapDataProviders
Create Your Own XmlSitemapDataProvider
Security Guidelines
Introduction
Reporting a security issue
Target audience
The TYPO3 Security Team
Report a security issue
Review of your extension
Incident handling
TYPO3 core system
TYPO3 extensions
General Information
TYPO3 versions and lifecycle
Difference between core and extensions
Announcement of updates and security fixes
Security bulletins
Public Service Announcements
Common Vulnerability Scoring System (CVSS)
Types of Security Threats
Information disclosure
Identity theft
SQL injection
Code injection
Authentication bypass
Cross Site Scripting (XSS)
Cross Site Request Forgery (XSRF)
General Guidelines
Secure Passwords
Operating System and Browser Version
Communication
React Quickly
Keep the TYPO3 Core up-to-date
Keep TYPO3 Extensions Up-to-date
Use Staging Servers for Developments and Tests
Guidelines for System Administrators
Role definition
General rules
Integrity of TYPO3 packages
File/directory permissions
Restrict access to files on a server-level
Verification of access restrictions
Apache and Microsoft IIS web servers
NGINX web servers
Directory indexing
Database access
Encrypted client/server communication
Other services
Further actions
Guidelines for TYPO3 Integrators
Role definition
General rules
Install Tool
TYPO3 core updates
Encryption key
Global TYPO3 configuration options
cookieSecure
displayErrors
devIPmask
enabledBeUserIPLock
fileDenyPattern
lockIP
lockSSL
IPmaskList
trustedHostsPattern
warning_email_addr
warning_mode
Security-related warnings after login
Reports and Logs
Users and access privileges
Backend
Frontend
TYPO3 extensions
Stable and reviewed extensions
Executable binaries shipped with extensions
Remove unused extensions and other code
Low-level extensions
Check for extension updates regularly
Security-related core extensions
Other security-related extensions
TypoScript
SQL injection
Cross-site scripting (XSS)
External file inclusion
Clickjacking
Integrity of external JavaScript files
Risk of externally hosted JavaScript libraries
Content elements
Guidelines for Editors
Role definition
General rules
Backend access
Username
Password
Administrator privileges
Notify at login
Lock to IP address(es)
Restriction to required functions
Secure connection
Logout
Backup Strategy
Components included in the backups
Time plan and retention time
Backup location
Further considerations
Detect, Analyze and Repair a Hacked Site
Detect a hacked website
Manipulated frontpage
Malicious code in the HTML source
Embedded elements in the site’s content
Unusual traffic increase or decrease
Reports from visitors or users
Search engines or browsers warn about your site
Leaked credentials
Take the website offline
Analyze
Repair/restore
Further actions
Testing
History
Introduction
2009
2012
2013
2014
2015
2016
2017
2018
2019
Core testing
Introduction
System dependencies
Quick start
Overview
A runTests.sh run
Examples
Debugging
Extension testing
Introduction
Scope
General strategy
Testing enetcache
Starting point
Preparing composer.json
runTests.sh and docker-compose.yml
Travis CI
Testing styleguide
Basic setup
Functional testing
Acceptance testing
travis-ci
Project testing
Introduction
Project site-introduction
Local acceptance testing
Travis CI
Summary
Writing unit tests
Introduction
When to unit tests
When not to unit tests
Unit test conventions
Keep it simple
Extending UnitTestCase
General hints
A casual data provider
Mocking
Static dependencies
Exception handling
Writing functional tests
Introduction
Overview
Simple Example
Extending setUp
Loaded extensions
Database fixtures
Asserting database
Loading files
Setting TYPO3_CONF_VARS
Frontend tests
Writing acceptance tests
Introduction
Set up
Backend login
Frames
PageTree
ModalDialog
FAQ
Introduction
Why do you docker everything?
Docker consumes too much hard disk
Why do you need runTests.sh?
Is a generic runTests.sh available?
Why don’t you use runTests.sh in bamboo?
Why do you not use native PHP on Travis CI?
Functional tests set up own instances in typo3temp?
Can I provide more hardware for bamboo?
Testing is slow on macOS
Can i run tests with Windows?
Coding Guidelines
Introduction
The CGL as a Means of Quality Assurance
General Recommendations
Setup IDE / Editor
EditorConfig
PHP Coding Guidelines
PHP File Formatting
General Requirements for PHP Files
File Names
PHP Tags
Line Breaks
Line Length
Whitespace and Indentation
Character Set
File Structure
Namespace
Copyright Notice
Namespace Imports
Class Information Block
PHP Class
Optional Module Execution Code
PHP Syntax Formatting
Identifiers
Comments
Debug Output
Curly Braces
Conditions
Switch
Loops
Strings
Booleans
NULL
Arrays
PHP Features
Global Variables
Functions
Using phpDoc
Class Information Block
Function Information Block
Short and Long Description
PHP Architecture
Modeling Cross Cutting Concerns
Static Methods, static Classes, Utility Classes
Characteristica
Rationale
Good Examples
Bad Examples
Red Flags
Traits
Characteristica
Rationale
Good Examples
Bad Examples
Further Reading
Services
Characteristica
Rationale
Good Examples
Bad Examples
Further Reading
Working With Exceptions
Introduction
Exception Types
Typical Cases for Exceptions That are Designed to be Caught
Typical Cases for Exceptions That Should not be Caught
Typical Exception Arguments
Exception Inheritance
Extending Exceptions
Good Examples
Bad Examples
General Links
Coding: Best practices
Accessing the Database
Singletons
Static Methods
Example
Localization
Defining Localized Strings
Unit Tests
Unit Test Files
Using Unit Tests
Adding Unit Tests
Conventions for Unit Tests
Handling Deprecation
Namespaces and Class Names of User Files
Hook Naming
JavaScript Coding Guidelines
Directories and Filenames
Format
More Information
TypeScript Coding Guidelines
Directories and File Names
Format
More information
TypoScript Coding Guidelines
Directory and file Names
Format
More Information
Xliff Coding Guidelines
Directory and File Names
Format
More Information
Yaml Coding Guidelines
Directory and File Names
Format
More Information
reStructuredText (reST)
Directory and File Names
Format
More Information
Data Formats
<T3DataStructure>
Elements
Elements Nesting Other Elements (“Array” Elements)
Elements Containing Values (“Value” Elements)
Example
Sheet References
Example
Parsing a Data Structure
Sitemap
Link Targets
TYPO3 Explained
Docs
»
Coding Guidelines
»
PHP Coding Guidelines
Edit me on GitHub
Next
Previous
PHP Coding Guidelines
¶
PHP File Formatting
General Requirements for PHP Files
File Structure
PHP Syntax Formatting
Using phpDoc
PHP Architecture
Modeling Cross Cutting Concerns
Static Methods, static Classes, Utility Classes
Traits
Services
Working With Exceptions
General Links
Coding: Best practices
Accessing the Database
Singletons
Static Methods
Localization
Unit Tests
Handling Deprecation
Namespaces and Class Names of User Files
Hook Naming
Versions
Project
Contact
Issues
Repository
Downloads
Related Links
v: master (9-dev)