Contents¶

Preface

• CakePHP at a Glance
  • Conventions Over Configuration
  • The Model Layer
  • The View Layer
  • The Controller Layer
  • CakePHP Request Cycle
  • Just the Start
  • Additional Reading
    • Where to Get Help
      • The Official CakePHP website
      • The Cookbook
      • The Bakery
      • The API
      • The Test Cases
      • The IRC Channel
      • Official CakePHP Forum
      • Stackoverflow
      • Where to get Help in your Language
        • Danish
        • French
        • German
        • Iranian
        • Dutch
        • Japanese
        • Portuguese
        • Spanish
    • CakePHP Conventions
      • Controller Conventions
        • URL Considerations for Controller Names
      • File and Class Name Conventions
      • Database Conventions
      • Model Conventions
      • View Conventions
      • Plugins Conventions
      • Summarized
      • Database Convention Summary
    • CakePHP Folder Structure
      • The src Folder
• Quick Start Guide
  • Content Management Tutorial
    • Getting CakePHP
    • Checking our Installation
  • CMS Tutorial - Creating the Database
    • Database Configuration
    • Creating our First Model
  • CMS Tutorial - Creating the Articles Controller
    • Create the Article List Template
    • Create the View Action
    • Create the View Template
    • Adding Articles
    • Create Add Template
    • Adding Simple Slug Generation
    • Add Edit Action
    • Create Edit Template
    • Update Validation Rules for Articles
    • Add Delete Action
• Migration Guides
  • 5.0 Upgrade Guide
    • Fix Deprecation Warnings
    • Upgrade to PHP 8.1
    • Use the Upgrade Tool
    • Update CakePHP Dependency
    • Update app files based upon latest app template
  • 5.0 Migration Guide
    • Deprecated Features Removed
    • Breaking Changes
      • Global
      • Auth
      • Cache
      • Console
      • Connection
      • Controller
      • Core
      • Database
      • Datasource
      • Event
      • Error
      • Filesystem
      • Http
      • I18n
      • Log
      • Mailer
      • ORM
      • Routing
      • TestSuite
      • Validation
      • View
    • Deprecations
      • Database
      • ORM
    • New Features
      • Improved type checking
      • Collection
      • Core
      • Database
      • Http
      • ORM
      • Required Entity Fields
      • Typed Finder Parameters
      • TestSuite
      • Plugin Installer
  • PHPUnit 10 Upgrade
    • phpunit.xml adjustments
      • New event system
    • ->withConsecutive() has been removed
    • data providers have to be static
• Tutorials & Examples
  • Content Management Tutorial
    • Getting CakePHP
    • Checking our Installation
  • CMS Tutorial - Creating the Database
    • Database Configuration
    • Creating our First Model
  • CMS Tutorial - Creating the Articles Controller
    • Create the Article List Template
    • Create the View Action
    • Create the View Template
    • Adding Articles
    • Create Add Template
    • Adding Simple Slug Generation
    • Add Edit Action
    • Create Edit Template
    • Update Validation Rules for Articles
    • Add Delete Action
  • CMS Tutorial - Tags and Users
    • Adding Tagging to Articles
    • Updating Articles to Enable Tagging
    • Finding Articles By Tags
      • Creating the Finder Method
      • Creating the View
    • Improving the Tagging Experience
      • Adding a Computed Field
      • Updating the Views
      • Persisting the Tag String
    • Auto-populating the Tag String
  • CMS Tutorial - Authentication
    • Installing Authentication Plugin
      • Adding Password Hashing
    • Adding Login
    • Logout
    • Enabling Registrations
  • CMS Tutorial - Authorization
    • Installing Authorization Plugin
    • Enabling the Authorization Plugin
    • Creating our First Policy
    • Checking Authorization in the ArticlesController
    • Fixing the Add & Edit Actions
    • Wrapping Up
• Contributing
  • Documentation
    • Translations
      • New Translation Language
      • Reminder for Docs Administrators
      • Translator tips
    • Documentation Formatting Guide
      • Line Length
      • Headings and Sections
      • Paragraphs
      • Inline Markup
      • Lists
      • Links
        • External Links
        • Links to Other Pages
          • :doc:
        • Cross Referencing Links
          • :ref:
        • Prevent Sphinx to Output Warnings
      • Describing Classes and their Contents
      • Describing Classes and Constructs
        • .. php:global::
        • .. php:function::
        • .. php:const::
        • .. php:exception::
        • .. php:class::
        • .. php:method::
        • .. php:staticmethod::
        • .. php:attr::
        • Prevent Sphinx to Output Warnings
        • Cross Referencing
          • :php:func:
          • :php:global:
          • :php:const:
          • :php:class:
          • :php:meth:
          • :php:attr:
          • :php:exc:
      • Source Code
      • Notes and Warnings
        • Samples
  • Tickets
    • Reporting Bugs
    • Reporting Security Issues
  • Code
    • Initial Setup
    • Working on a Patch
    • Submitting a Pull Request
      • Choosing Where Your Changes will be Merged Into
  • Coding Standards
    • Adding New Features
    • IDE Setup
    • Indentation
    • Line Length
    • Control Structures
      • Ternary Operator
      • Template Files
    • Comparison
    • Function Calls
    • Method Definition
    • Bail Early
      • Typehinting
      • Anonymous Functions (Closures)
    • Method Chaining
    • Commenting Code
      • Variable Types
    • Including Files
    • PHP Tags
      • Short Echo
    • Naming Convention
      • Functions
      • Classes
      • Variables
      • Member Visibility
      • Example Addresses
      • Files
      • Casting
      • Constants
    • Careful when using empty()/isset()
  • Backwards Compatibility Guide
    • Migration Guides
    • Using CakePHP
      • Interfaces
      • Classes
    • Working on CakePHP
    • Deprecations
    • Experimental Features
• Release Policy
  • Major Releases
  • Minor Releases
  • Patch Releases
  • Experimental Features

Getting Started

• Installation
  • Installing CakePHP
    • Installing Composer
    • Create a CakePHP Project
    • Keeping Up To Date with the Latest CakePHP Changes
    • Installation using Oven
  • Permissions
  • Development Server
  • Production
  • Fire It Up
  • URL Rewriting
    • Apache
    • nginx
    • NGINX Unit
    • IIS7 (Windows hosts)
    • Lighttpd
    • I Can’t Use URL Rewriting
• Configuration
  • Configuring your Application
    • Loading Additional Configuration Files
  • Environment Variables
    • General Configuration
    • Using a CDN
    • Database Configuration
    • Caching Configuration
    • Error and Exception Handling Configuration
    • Logging Configuration
    • Email Configuration
    • Session Configuration
    • Routing configuration
  • Additional Class Paths
    • Plugin, View Template and Locale Paths
  • Inflection Configuration
  • Configure Class
    • Configure
    • Writing Configuration data
      • Configure::write
    • Reading Configuration Data
      • Configure::read
      • Configure::readOrFail
    • Checking to see if Configuration Data is Defined
      • Configure::check
    • Deleting Configuration Data
      • Configure::delete
    • Reading & Deleting Configuration Data
      • Configure::consume
      • Configure::consumeOrFail
  • Reading and writing configuration files
    • Configure::setConfig
    • Configure::drop
    • Loading Configuration Files
      • Configure::load
    • Creating or Modifying Configuration Files
      • Configure::dump
    • Storing Runtime Configuration
      • Configure::store
    • Restoring Runtime Configuration
      • Configure::restore
    • Configuration Engines
  • Disabling Generic Tables
• Application
  • Bootstrapping your Application
    • Application::bootstrap()
• Dependency Injection
  • Adding Services
    • Adding Shared Services
    • Extending Definitions
    • Tagging Services
    • Using Configuration Data
  • Service Providers
    • Creating Service Providers
    • Using Service Providers
    • Bootable ServiceProviders
  • Mocking Services in Tests
  • Auto Wiring
• Routing
  • RouterBuilder
  • Quick Tour
  • Connecting Routes
    • Route Elements
    • Reserved Route Elements
    • Configuring Route Options
    • Passing Parameters to Action
    • Using Path Routing
    • Using Named Routes
    • Prefix Routing
      • RouterBuilder::prefix
    • Creating Links to Prefix Routes
    • Plugin Routing
      • RouterBuilder::plugin
    • Creating Links to Plugin Routes
    • SEO-Friendly Routing
    • Matching Specific HTTP Methods
    • Matching Specific Hostnames
    • Routing File Extensions
      • RouterBuilder::extensions
  • Route Scoped Middleware
    • Grouping Middleware
  • RESTful Routing
    • Creating Nested Resource Routes
    • Limiting the Routes Created
    • Changing the Controller Actions Used
    • Mapping Additional Resource Routes
    • Prefixed Resource Routing
    • Custom Route Classes for Resource Routes
    • URL Inflection for Resource Routes
    • Changing the Path Element
  • Passed Arguments
  • Generating URLs
    • RouterBuilder::url
    • RouterBuilder::reverse
    • Using Router::url()
    • Using Router::reverse()
    • Routing Arrays vs Request Parameters
  • Generating Asset URLs
  • Redirect Routing
  • Entity Routing
  • Custom Route Classes
    • Default Route Class
      • RouterBuilder::setRouteClass
    • Fallbacks Method
      • RouterBuilder::fallbacks()
  • Creating Persistent URL Parameters
• Request & Response Objects
  • Request
    • ServerRequest
    • Request Parameters
    • Query String Parameters
      • ServerRequest::getQuery()
    • Request Body Data
      • ServerRequest::getData()
    • File Uploads
      • ServerRequest::getUploadedFile()
      • ServerRequest::getUploadedFiles()
      • ServerRequest::withUploadedFiles()
    • PUT, PATCH or DELETE Data
      • ServerRequest::input()
    • Environment Variables (from $_SERVER and $_ENV)
      • ServerRequest::putenv()
    • XML or JSON Data
    • Path Information
    • Checking Request Conditions
      • ServerRequest::is()
      • ServerRequest::addDetector()
    • Session Data
    • Host and Domain Name
      • ServerRequest::domain()
      • ServerRequest::subdomains()
      • ServerRequest::host()
    • Reading the HTTP Method
      • ServerRequest::getMethod()
    • Restricting Which HTTP method an Action Accepts
      • ServerRequest::allowMethod()
    • Reading HTTP Headers
      • ServerRequest::referer()
      • ServerRequest::clientIp()
    • Trusting Proxy Headers
    • Checking Accept Headers
      • ServerRequest::accepts()
      • ServerRequest::acceptLanguage()
    • Reading Cookies
    • Uploaded Files
    • Manipulating URIs
  • Response
    • Response
    • Dealing with Content Types
      • Response::withType()
    • Sending Files
      • Response::withFile()
    • Sending a String as File
    • Setting Headers
      • Response::withHeader()
    • Setting the Body
      • Response::withStringBody()
      • Response::withBody()
    • Setting the Character Set
      • Response::withCharset()
    • Interacting with Browser Caching
      • Response::withDisabledCache()
      • Response::withCache()
    • Fine Tuning HTTP Cache
      • The Cache Control Header
        • Response::withSharable()
      • The Expiration Header
        • Response::withExpires()
      • The Etag Header
        • Response::withEtag()
      • The Last Modified Header
        • Response::withModified()
      • The Vary Header
        • Response::withVary()
      • Sending Not-Modified Responses
        • Response::checkNotModified()
    • Setting Cookies
  • Setting Cross Origin Request Headers (CORS)
  • Common Mistakes with Immutable Responses
  • Cookie Collections
    • CookieCollection
    • Creating Cookies
      • Cookie
    • Reading Cookies
• Middleware
  • Middleware in CakePHP
  • Using Middleware
    • Adding Middleware from Plugins
  • Creating Middleware
  • Routing Middleware
  • Encrypted Cookie Middleware
  • Body Parser Middleware
• Controllers
  • Controller
  • The App Controller
  • Request Flow
  • Controller Actions
  • Interacting with Views
    • Setting View Variables
      • Controller::set()
    • Setting View Options
    • Rendering a View
      • Controller::render()
      • Rendering a Specific Template
  • Content Type Negotiation
    • Controller::addViewClasses()
  • Content Type Negotiation Fallbacks
  • Using AjaxView
  • Redirecting to Other Pages
    • Controller::redirect()
    • Forwarding to an Action on the Same Controller
      • Controller::setAction()
  • Loading Additional Models
    • Controller::fetchModel()
    • Controller::fetchTable()
  • Paginating a Model
    • Controller::paginate()
  • Configuring Components to Load
    • Controller::loadComponent()
  • Request Life-cycle Callbacks
    • Event List
    • Controller Callback Methods
      • Controller::beforeFilter()
      • Controller::beforeRender()
      • Controller::afterFilter()
  • Controller Middleware
    • Controller::middleware()
  • More on Controllers
    • The Pages Controller
    • Components
      • Flash
        • FlashComponent
        • Setting Flash Messages
        • HTML in Flash Messages
      • FormProtection
        • FormProtection
        • Form tampering prevention
        • Usage
        • Disabling form tampering checks
        • Disabling form tampering for specific actions
        • Handling validation failure through callbacks
      • Checking HTTP Cache
        • CheckHttpCacheComponent
      • Configuring Components
        • Aliasing Components
        • Loading Components on the Fly
      • Using Components
      • Creating a Component
        • Including your Component in your Controllers
        • Using Other Components in your Component
        • Accessing a Component’s Controller
      • Component Callbacks
        • beforeFilter()
        • startup()
        • beforeRender()
        • afterFilter()
        • beforeRedirect()
      • Using Redirects in Component Events
• Views
  • View
  • The App View
  • View Templates
    • Alternative Echos
    • Alternative Control Structures
    • View Variables
    • Setting View Variables
      • View::set()
    • Extending Views
  • Extending Layouts
  • Using View Blocks
    • Displaying Blocks
    • Using Blocks for Script and CSS Files
  • Layouts
    • Using Layouts from Plugins
  • Elements
    • View::element()
    • Passing Variables into an Element
    • Caching Elements
    • Requesting Elements from a Plugin
    • Routing prefix and Elements
    • Caching Sections of Your View
      • View::cache()
  • View Events
    • Event List
  • Creating Your Own View Classes
  • More About Views
    • View Cells
      • When to use Cells
      • Creating a Cell
      • Implementing the Cell
      • Loading Cells
      • Passing Arguments to a Cell
      • Rendering a Cell
        • Rendering Alternate Templates
        • Caching Cell Output
      • Paginating Data inside a Cell
      • Cell Options
      • Using Helpers inside a Cell
    • Themes
      • Theme Assets
    • JSON and XML views
      • Defining View Classes to Negotiate With
      • Using Data Views with the Serialize Key
      • Using a Data View with Template Files
      • Creating XML Views
        • XmlView
      • Creating JSON Views
        • JsonView
        • JSONP Responses
      • Choosing a View Class
    • Helpers
      • Breadcrumbs
        • BreadcrumbsHelper
        • Creating a Breadcrumbs Trail
        • Rendering the Breadcrumbs Trail
          • Customizing the Output
          • Defining Attributes for the Item
        • Clearing the Breadcrumbs
      • Flash
        • FlashHelper
        • Rendering Flash Messages
        • Routing Prefix and Flash Messages
        • Flash Messages and Themes
      • Form
        • FormHelper
        • Starting a Form
          • FormHelper::create()
          • Options for Form Creation
          • Getting form values from other values sources
          • Changing the HTTP Method for a Form
          • Setting a URL for the Form
          • Using Custom Validators
          • Creating context classes
        • Creating Form Controls
          • FormHelper::control()
          • Field Naming Conventions
          • Options for Control
        • Generating Specific Types of Controls
          • Common Options For Specific Controls
        • Creating Input Elements
          • Creating Text Inputs
            • FormHelper::text()
          • Creating Password Inputs
            • FormHelper::password()
          • Creating Hidden Inputs
            • FormHelper::hidden()
          • Creating Textareas
            • FormHelper::textarea()
          • Creating Select, Checkbox and Radio Controls
            • Options for Select, Checkbox and Radio Controls
            • Using Collections to build options
            • Creating Checkboxes
              • FormHelper::checkbox()
            • Creating Radio Buttons
              • FormHelper::radio()
            • Creating Select Pickers
              • FormHelper::select()
          • Creating File Inputs
            • FormHelper::file()
          • Creating Date & Time Related Controls
            • FormHelper::dateTime()
            • Creating Date Controls
              • FormHelper::date()
            • Creating Time Controls
              • FormHelper::time()
            • Creating Month Controls
              • FormHelper::month()
            • Creating Year Controls
              • FormHelper::year()
        • Creating Labels
          • FormHelper::label()
        • Displaying and Checking Errors
          • Displaying Errors
            • FormHelper::error()
          • Checking for Errors
            • FormHelper::isFieldError()
          • Displaying validation messages in HTML5 validity messages
        • Creating Buttons and Submit Elements
          • Creating Submit Elements
            • FormHelper::submit()
          • Creating Button Elements
            • FormHelper::button()
        • Closing the Form
          • FormHelper::end()
        • Creating Standalone Buttons and POST Links
          • Creating POST Buttons
            • FormHelper::postButton()
          • Creating POST Links
            • FormHelper::postLink()
        • Customizing the Templates FormHelper Uses
          • List of Templates
            • Using Distinct Custom Control Containers
            • Using Distinct Custom Form Groups
          • Adding Additional Template Variables to Templates
          • Moving Checkboxes & Radios Outside of a Label
        • Generating Entire Forms
          • Creating Multiple Controls
            • FormHelper::controls()
          • Creating Controls for a Whole Entity
            • FormHelper::allControls()
        • Creating Inputs for Associated Data
        • Adding Custom Widgets
          • Building a Widget Class
          • Using Widgets
        • Working with SecurityComponent
          • FormHelper::unlockField()
          • FormHelper::secure()
      • Html
        • HtmlHelper
        • Inserting Well-Formatted Elements
          • Creating Charset Tags
            • HtmlHelper::charset()
          • Linking to CSS Files
            • HtmlHelper::css()
          • Creating CSS Programatically
            • HtmlHelper::style()
          • Creating meta Tags
            • HtmlHelper::meta()
          • Linking to Images
            • HtmlHelper::image()
          • Creating Links
            • HtmlHelper::link()
            • HtmlHelper::linkFromPath()
          • Linking to Videos and Audio Files
            • HtmlHelper::media()
          • Linking to Javascript Files
            • HtmlHelper::script()
          • Creating Inline Javascript Blocks
            • HtmlHelper::scriptBlock()
            • HtmlHelper::scriptStart()
            • HtmlHelper::scriptEnd()
          • Creating Nested Lists
            • HtmlHelper::nestedList()
          • Creating Table Headings
            • HtmlHelper::tableHeaders()
          • Creating Table Cells
            • HtmlHelper::tableCells()
        • Changing the Tags Output by HtmlHelper
          • HtmlHelper::setTemplates()
      • Number
        • NumberHelper
        • Formatting Currency Values
          • NumberHelper::currency()
        • Setting the Default Currency
          • NumberHelper::setDefaultCurrency()
        • Getting the Default Currency
          • NumberHelper::getDefaultCurrency()
        • Formatting Floating Point Numbers
          • NumberHelper::precision()
        • Formatting Percentages
          • NumberHelper::toPercentage()
        • Interacting with Human Readable Values
          • NumberHelper::toReadableSize()
        • Formatting Numbers
          • NumberHelper::format()
          • NumberHelper::ordinal()
        • Format Differences
          • NumberHelper::formatDelta()
      • Paginator
        • PaginatorHelper
        • Setting the paginated resultset
          • PaginatorHelper::setPaginated()
          • PaginatorHelper Templates
        • Loading Templates from a File
        • Changing Templates at Run-time
          • PaginatorHelper::setTemplates()
        • Template Names
          • Creating Sort Links
            • PaginatorHelper::sort()
            • PaginatorHelper::sortDir()
            • PaginatorHelper::sortKey()
          • Creating Page Number Links
            • PaginatorHelper::numbers()
          • Creating Jump Links
            • PaginatorHelper::prev()
            • PaginatorHelper::next()
            • PaginatorHelper::first()
            • PaginatorHelper::last()
          • Creating Header Link Tags
          • Checking the Pagination State
            • PaginatorHelper::current()
            • PaginatorHelper::hasNext()
            • PaginatorHelper::hasPrev()
            • PaginatorHelper::hasPage()
            • PaginatorHelper::total()
          • Creating a Page Counter
            • PaginatorHelper::counter()
          • Generating Pagination URLs
            • PaginatorHelper::generateUrl()
          • Creating a Limit Selectbox Control
            • PaginatorHelper::limitControl()
          • Configuring Pagination Options
            • PaginatorHelper::options()
          • Example Usage
          • Paginating Multiple Results
      • Text
        • TextHelper
        • Linking Email addresses
          • TextHelper::autoLinkEmails()
        • Linking URLs
          • TextHelper::autoLinkUrls()
        • Linking Both URLs and Email Addresses
          • TextHelper::autoLink()
        • Converting Text into Paragraphs
          • TextHelper::autoParagraph()
        • Highlighting Substrings
          • TextHelper::highlight()
        • Removing Links
          • TextHelper::stripLinks()
        • Truncating Text
          • TextHelper::truncate()
        • Truncating the Tail of a String
          • TextHelper::tail()
        • Extracting an Excerpt
          • TextHelper::excerpt()
        • Converting an Array to Sentence Form
          • TextHelper::toList()
      • Time
        • TimeHelper
        • Using the Helper
      • Url
        • UrlHelper
        • Generating URLs
          • UrlHelper::build()
          • UrlHelper::buildFromPath()
        • Customizing Asset URL generation
      • Configuring Helpers
        • Conditionally Loading Helpers
        • Configuration options
        • Aliasing Helpers
      • Using Helpers
        • Loading Helpers On The Fly
      • Callback Methods
      • Creating Helpers
        • Including Other Helpers
        • Using Your Helper
        • Accessing View Variables Inside Your Helper
        • Rendering A View Element Inside Your Helper
      • Helper Class
        • Helper
        • Callbacks
          • Helper::beforeRenderFile()
          • Helper::afterRenderFile()
          • Helper::beforeRender()
          • Helper::afterRender()
          • Helper::beforeLayout()
          • Helper::afterLayout()
• Database Access & ORM
  • Quick Example
  • More Information
    • Database Basics
      • Quick Tour
        • Running Select Statements
        • Running Insert Statements
        • Running Update Statements
        • Running Delete Statements
      • Configuration
      • Read and Write Connections
      • Managing Connections
        • ConnectionManager
        • Accessing Connections
          • ConnectionManager::get
        • Creating Connections at Runtime
      • Data Types
        • TypeFactory
        • DateTime Type
          • DateTimeType
            • DateTimeType::setTimezone()
          • DateTimeFractionalType
          • DateTimeTimezoneType
        • Enum Type
          • EnumType
        • Adding Custom Types
          • TypeFactory::map
        • Connecting Custom Datatypes to Schema Reflection and Generation
        • Mapping Custom Datatypes to SQL Expressions
      • Connection Classes
        • Connection
        • Executing Queries
          • Connection::execute()
          • Connection::selectQuery()
          • Connection::updateQuery()
          • Connection::insertQuery()
          • Connection::deleteQuery()
        • Using Transactions
          • Connection::transactional()
      • Interacting with Statements
        • Executing & Fetching Rows
        • Getting affected Row Counts
        • Checking Error Codes
      • Query Logging
      • Identifier Quoting
      • Metadata Caching
      • Creating Databases
    • Query Builder
      • SelectQuery
      • The SelectQuery Object
        • Selecting Rows From A Table
        • Selecting A Single Row From A Table
        • Getting A List Of Values From A Column
        • Resultset Are Collection Objects
        • Queries Are Lazily Evaluated
      • Selecting Data
        • Selecting Specific Fields
        • Using SQL Functions
          • Window-Only Functions
          • Custom Functions
        • Ordering Results
        • Limiting Results
        • Aggregates - Group and Having
        • Case Statements
        • Fetching Arrays Instead of Entities
        • Adding Calculated Fields
      • Advanced Conditions
        • Using Identifiers in Expressions
        • Collation
        • Automatically Creating IN Clauses
        • Automatic IS NULL Creation
        • Automatic IS NOT NULL Creation
        • Raw Expressions
        • Using Connection Roles
        • Expression Conjuction
        • Tuple Comparison
      • Getting Results
        • Returning the Total Count of Records
        • Caching Loaded Results
      • Loading Associations
        • Passing Conditions to Contain
        • Sorting Contained Associations
        • Filtering by Associated Data
        • Using innerJoinWith
        • Using notMatching
        • Using leftJoinWith
        • Adding Joins
      • Inserting Data
      • Updating Data
      • Deleting Data
      • SQL Injection Prevention
        • Binding values
      • More Complex Queries
        • Unions
        • Subqueries
        • Adding Locking Statements
        • Window Functions
        • Common Table Expressions
        • Executing Complex Queries
    • Table Objects
      • Basic Usage
        • Customizing the Entity Class a Table Uses
        • Getting Instances of a Table Class
      • Lifecycle Callbacks
        • Event List
        • initialize
          • Table::initialize()
        • beforeMarshal
          • Table::beforeMarshal()
        • afterMarshal
          • Table::afterMarshal()
        • beforeFind
          • Table::beforeFind()
        • buildValidator
          • Table::buildValidator()
        • buildRules
          • Table::buildRules()
        • beforeRules
          • Table::beforeRules()
        • afterRules
          • Table::afterRules()
        • beforeSave
          • Table::beforeSave()
        • afterSave
          • Table::afterSave()
        • afterSaveCommit
          • Table::afterSaveCommit()
        • beforeDelete
          • Table::beforeDelete()
        • afterDelete
          • Table::afterDelete()
        • afterDeleteCommit
          • Table::afterDeleteCommit()
        • Stopping Table Events
        • Callback priorities
      • Behaviors
        • Table::addBehavior()
      • Configuring Connections
      • Using the TableLocator
        • TableLocator
        • Configuring Table Objects
          • TableLocator::get()
        • Flushing the Registry
          • TableLocator::clear()
        • Configuring the Namespace to Locate ORM classes
    • Entities
      • Entity
      • Creating Entity Classes
      • Creating Entities
      • Accessing Entity Data
        • Entity::set()
        • Entity::get()
      • Accessors & Mutators
        • Accessors
        • Mutators
        • Creating Virtual Fields
      • Checking if an Entity Has Been Modified
        • Entity::dirty()
      • Validation Errors
      • Mass Assignment
        • Avoiding Mass Assignment Protection
        • Modifying the Guarded Fields at Runtime
        • Bypassing Field Guarding
        • Checking if an Entity was Persisted
      • Lazy Loading Associations
      • Creating Re-usable Code with Traits
      • Converting to Arrays/JSON
        • Exposing Virtual Fields
        • Hiding Fields
      • Storing Complex Types
    • Retrieving Data & Results Sets
      • Table
      • Debugging Queries and ResultSets
      • Getting a Single Entity by Primary Key
        • Table::get()
      • Using Finders to Load Data
        • Table::find()
      • Getting the First Result
      • Getting a Count of Results
      • Finding Key/Value Pairs
        • Customize Key-Value Output
      • Finding Threaded Data
      • Custom Finder Methods
      • Dynamic Finders
      • Retrieving Associated Data
      • Eager Loading Associations Via Contain
        • Passing Conditions to Contain
        • Sorting Contained Associations
      • Filtering by Associated Data Via Matching And Joins
        • Using innerJoinWith
        • Using notMatching
        • Using leftJoinWith
      • Changing Fetching Strategies
        • Fetching With The Subquery Strategy
      • Lazy Loading Associations
      • Working with Result Sets
        • Getting the First & Last Record From a ResultSet
        • Getting an Arbitrary Index From a ResultSet
        • Checking if a ResultSet is Empty
        • Loading Additional Associations
      • Modifying Results with Map/Reduce
        • Stacking Multiple Operations
        • Removing All Stacked Map-reduce Operations
    • Validating Data
      • Validating Data Before Building Entities
      • Creating A Default Validation Set
      • Using A Different Validation Set
        • Using A Different Validation Set For Associations
      • Combining Validators
      • Validation Providers
      • Getting Validators From Tables
      • Default Validator Class
      • Applying Application Rules
        • Creating a Rules Checker
        • Creating Unique Field Rules
        • Foreign Key Rules
        • Association Count Rules
        • Association Link Constraint Rule
        • Using Entity Methods as Rules
        • Using Conditional Rules
        • Conditional/Dynamic Error Messages
        • Creating Custom re-usable Rules
        • Creating Custom Rule Objects
        • Disabling Rules
      • Validation vs. Application Rules
        • Using Validation as Application Rules
    • Saving Data
      • A Glance Over Saving Data
        • Inserting Data
        • Updating Data
        • Saving With Associations
        • Associate Many To Many Records
        • Unlink Many To Many Records
      • Converting Request Data into Entities
        • Converting BelongsToMany Data
        • Converting HasMany Data
        • Converting Multiple Records
        • Changing Accessible Fields
        • Merging Request Data Into Entities
          • Validation and patchEntity
          • Patching HasMany and BelongsToMany
        • Modifying Request Data Before Building Entities
        • Modifying Entities After Updating From Request Data
        • Validating Data Before Building Entities
        • Avoiding Property Mass Assignment Attacks
      • Saving Entities
        • Table::save()
        • Saving Associations
        • Saving BelongsTo Associations
        • Saving HasOne Associations
        • Saving HasMany Associations
        • Saving BelongsToMany Associations
        • Saving Additional Data to the Join Table
        • Saving Complex Types
      • Strict Saving
        • Table::saveOrFail()
      • Find or Create an Entity
        • Table::findOrCreate()
      • Creating with an existing primary key
      • Saving Multiple Entities
        • Table::saveMany()
      • Bulk Updates
        • Table::updateAll()
    • Deleting Data
      • Table::delete()
      • Cascading Deletes
      • Bulk Deletes
        • Table::deleteMany()
        • Table::deleteAll()
      • Strict Deletes
        • Table::deleteOrFail()
    • Associations - Linking Tables Together
      • HasOne Associations
      • BelongsTo Associations
      • HasMany Associations
      • BelongsToMany Associations
        • Using the ‘through’ Option
        • Using Association Finders
      • Association Conventions
      • Loading Associations
    • Behaviors
      • Using Behaviors
      • Core Behaviors
        • CounterCache
          • CounterCacheBehavior
          • Basic Usage
          • Advanced Usage
          • Belongs to many Usage
        • Timestamp
          • TimestampBehavior
          • Basic Usage
          • Using and Configuring the Behavior
          • Updating Timestamps on Entities
          • Saving Updates Without Modifying Timestamps
        • Translate
          • TranslateBehavior
          • Translation Strategies
          • Shadow Table Strategy
          • Eav Strategy
          • Attaching the Translate Behavior to Your Tables
          • Quick tour
            • Using a Separate Translations Table for Eav strategy
          • Reading Translated Content
            • Retrieve All Translations For An Entity
            • Limiting the Translations to be Retrieved
            • Preventing Retrieval of Empty Translations
            • Retrieving All Translations For Associations
            • Retrieving one language without using I18n::setLocale
            • Querying Translated Fields
          • Saving in Another Language
          • Saving Multiple Translations
            • Validating Translated Entities
        • Tree
          • TreeBehavior
          • Requirements
          • A Quick Tour
            • Getting direct descendents
            • Getting formatted tree lists
            • Finding a path or branch in the tree
          • Configuration
            • Node Level (Depth)
            • Scoping and Multi Trees
            • Deletion Behavior
          • Recovering with custom sort field
          • Saving Hierarchical Data
          • Deleting Nodes
      • Creating a Behavior
        • Defining Mixin Methods
          • Limiting or Renaming Exposed Mixin Methods
        • Defining Event Listeners
        • Defining Finders
          • Limiting or Renaming Exposed Finder Methods
      • Transforming Request Data into Entity Properties
      • Removing Loaded Behaviors
      • Accessing Loaded Behaviors
        • Re-configuring Loaded Behaviors
    • Schema System
      • Schema\TableSchema Objects
        • TableSchema
        • Accessing Column Data
        • Indexes and Constraints
        • Reading Indexes and Constraints
        • Adding Table Options
        • Converting Tables into SQL
      • Schema Collections
        • Collection
    • Schema Cache Tool

Using CakePHP

• Caching
  • Cache
  • Configuring Cache Engines
    • Cache::setConfig
    • Engine Options
    • FileEngine Options
    • RedisEngine Options
    • MemcacheEngine Options
    • Configuring Cache Fallbacks
    • Removing Configured Cache Engines
      • Cache::drop
  • Writing to a Cache
    • Cache::write
    • Writing Multiple Keys at Once
      • Cache::writeMany
    • Atomic writes
      • Cache::add
    • Read Through Caching
      • Cache::remember
  • Reading From a Cache
    • Cache::read
    • Reading Multiple Keys at Once
      • Cache::readMany
  • Deleting From a Cache
    • Cache::delete
    • Deleting Multiple Keys at Once
      • Cache::deleteMany
  • Clearing Cached Data
    • Cache::clear
  • Using Cache to Store Counters
    • Cache::increment
    • Cache::decrement
  • Using Cache to Store Common Query Results
  • Using Groups
    • Cache::clearGroup()
    • Cache::groupConfigs
  • Globally Enable or Disable Cache
    • Cache::disable
    • Cache::enable
    • Cache::enabled
  • Creating a Cache Engine
    • CacheEngine
      • CacheEngine::write()
      • CacheEngine::read()
      • CacheEngine::delete()
      • CacheEngine::clear()
      • CacheEngine::clearGroup()
      • CacheEngine::decrement()
      • CacheEngine::increment()
• Console Commands
  • The CakePHP Console
  • Console Applications
  • Renaming Commands
  • Commands
    • Command Objects
      • Command
      • Creating a Command
      • Changing the Default Command Name
      • Defining Arguments and Options
      • Creating Output
      • Using Models in Commands
      • Exit Codes and Stopping Execution
      • Calling other Commands
      • Setting Command Description
      • Testing Commands
        • Testing Interactive Shells
        • Assertion methods
      • Lifecycle Callbacks
    • Command Input/Output
      • ConsoleIo
      • Command Helpers
      • Creating Helpers
      • Built-In Helpers
        • Table Helper
        • Progress Helper
      • Getting User Input
        • ConsoleIo::ask()
      • Creating Files
        • ConsoleIo::createFile()
      • Creating Output
      • Output Levels
      • Styling Output
      • Turning Off Colouring
    • Option Parsers
      • ConsoleOptionParser
      • Defining an OptionParser
      • Using Arguments
        • ConsoleOptionParser::addArgument()
        • Adding Multiple Arguments
          • ConsoleOptionParser::addArguments()
        • Validating Arguments
      • Using Options
        • ConsoleOptionParser::addOption()
        • Adding Multiple Options
          • ConsoleOptionParser::addOptions()
        • Validating Options
        • Using Boolean Options
        • Building a ConsoleOptionParser from an Array
          • ConsoleOptionParser::buildFromArray()
        • Merging Option Parsers
          • ConsoleOptionParser::merge()
      • Getting Help from Shells
        • Getting Help as XML
      • Customizing Help Output
        • Set the Description
          • ConsoleOptionParser::setDescription()
        • Set the Epilog
          • ConsoleOptionParser::setEpilog()
    • Running Shells as Cron Jobs
      • Cron Jobs on Shared Hosting
  • CakePHP Provided Commands
    • Cache Tool
    • Completion Tool
      • Sub Commands
        • Commands
        • subCommands
        • options
      • How to enable Bash autocompletion for the CakePHP Console
        • Bash Completion file content
      • Using autocompletion
        • Commands
        • Subcommands
        • Options
    • I18N Tool
      • Generating POT Files
        • Generating POT Files for Plugins
        • Extracting from multiple folders at once
        • Excluding Folders
        • Skipping Overwrite Warnings for Existing POT Files
        • Extracting Messages from the CakePHP Core Libraries
    • Plugin Tool
      • Loading Plugins
      • Unloading Plugins
      • Plugin Assets
    • Schema Cache Tool
    • Routes Tool
      • Getting a List of all Routes
      • Testing URL parsing
      • Testing URL Generation
    • Server Tool
      • Changing the Port and Document Root
    • Interactive Console (REPL)
  • Routing in the Console Environment
• Debugging
  • Basic Debugging
    • stackTrace()
    • breakpoint()
  • Using the Debugger Class
    • Debugger
  • Outputting Values
    • Debugger::dump
    • Masking Data
  • Logging With Stack Traces
    • Debugger::log
  • Generating Stack Traces
    • Debugger::trace
  • Getting an Excerpt From a File
    • Debugger::excerpt
    • Debugger::getType
  • Editor Integration
  • Using Logging to Debug
  • Debug Kit
• Deployment
  • Moving files
  • Adjusting Configuration
  • Check Your Security
  • Set Document Root
  • Improve Your Application’s Performance
  • Deploying an update
• Mailer
  • Mailer
  • Basic Usage
    • Choosing the Sender
  • Configuration
    • Configuration Profiles
  • Setting Headers
  • Sending Templated Emails
  • Sending Attachments
    • Mailer::setAttachments()
    • Relaxing Address Validation Rules
      • Mailer::setEmailPattern()
  • Sending Emails from CLI
  • Creating Reusable Emails
  • Configuring Transports
    • Mailer::drop
    • Creating Custom Transports
  • Sending emails without using Mailer
  • Testing Mailers
    • Assertion methods
• Error & Exception Handling
  • Configuration
  • Deprecation Warnings
  • Changing Exception Handling
  • Listen to Events
  • Custom Templates
    • Custom Error Page Layout
  • Custom Controller
  • Custom ExceptionRenderer
    • Changing the ErrorController Class
  • Creating your own Application Exceptions
    • Logging Exceptions
  • Built in Exceptions for CakePHP
    • HTTP Exceptions
    • Using HTTP Exceptions in your Controllers
    • Other Built In Exceptions
  • Customizing PHP Error Handling
    • Custom Error Logging
    • Custom Error Rendering
• Events System
  • Example Event Usage
  • Accessing Event Managers
    • Global Event Manager
    • Tracking Events
  • Core Events
  • Registering Listeners
    • Registering Anonymous Listeners
    • Interacting with Existing Listeners
    • Establishing Priorities
    • Getting Event Data as Function Parameters
  • Dispatching Events
    • Stopping Events
    • Getting Event Results
    • Removing Callbacks and Listeners
  • Additional Reading
• Internationalization & Localization
  • Setting Up Translations
    • Language Files
    • Extract Pot Files with I18n Shell
    • Setting the Default Locale
    • Changing the Locale at Runtime
  • Using Translation Functions
    • Using Variables in Translation Messages
    • Plurals
      • Using ICU Plural Selection
      • Using Gettext Plural Selection
  • Creating Your Own Translators
    • Creating Message Parsers
    • Creating Generic Translators
    • Plurals and Context in Custom Translators
    • Using Different Formatters
  • Localizing Dates and Numbers
    • Parsing Localized Datetime Data
    • Converting Request Data from the User’s Timezone
  • Automatically Choosing the Locale Based on Request Data
  • Translate Content/Entities
• Logging
  • Logging Configuration
  • Error and Exception Logging
  • Writing to Logs
    • Using Placeholders in Messages
    • Using Levels
    • Logging Scopes
  • Logging to Files
  • Logging to Syslog
  • Creating Log Engines
    • Logging Formatters
  • Log API
    • Log
      • Log::setConfig
      • Log::configured
      • Log::drop
      • Log::write
      • Log::levels
    • Convenience Methods
      • Log::emergency
      • Log::alert
      • Log::critical
      • Log::error
      • Log::warning
      • Log::notice
      • Log::info
      • Log::debug
  • Logging Trait
    • LogTrait
      • LogTrait::log()
  • Using Monolog
• Modelless Forms
  • Form
  • Creating a Form
  • Processing Request Data
  • Setting Form Values
  • Getting Form Errors
  • Invalidating Individual Form Fields from Controller
  • Creating HTML with FormHelper
• Pagination
  • Basic Usage
  • Advanced Usage
  • Simple Pagination
  • Paginating Multiple Queries
    • Paginating the Same Model multiple Times
  • Control which Fields Used for Ordering
  • Limit the Maximum Number of Rows per Page
  • Out of Range Page Requests
  • Using a paginator class directly
  • Pagination in the View
• Plugins
  • Installing a Plugin With Composer
  • Manually Installing a Plugin
    • Manually Autoloading Plugin Classes
  • Loading a Plugin
  • Plugin Hook Configuration
  • Plugin Loading Options
  • Loading plugins through Application::bootstrap()
  • Using Plugin Classes
  • Creating Your Own Plugins
    • Creating a Plugin Using Bake
  • Plugin Classes
  • Plugin Routes
  • Plugin Controllers
  • Plugin Models
  • Plugin Templates
    • Overriding Plugin Templates from Inside Your Application
  • Plugin Assets
    • Linking to Assets in Plugins
  • Components, Helpers and Behaviors
  • Commands
  • Testing your Plugin
  • Publishing your Plugin
  • Plugin Map File
  • Manage Your Plugins using Mixer
• REST
  • Getting Started
  • Encoding Response Data
  • Parsing Request Bodies
• Security
  • Security Utility
    • Security
    • Encrypting and Decrypting Data
      • Security::encrypt
      • Security::decrypt
    • Hashing Data
      • Security::hash
    • Getting Secure Random Data
      • Security::randomBytes
      • Security::randomString
  • Form Protection Middleware
    • FormProtection
    • Form tampering prevention
    • Usage
    • Disabling form tampering checks
    • Disabling form tampering for specific actions
    • Handling validation failure through callbacks
  • CSRF Protection
    • Cross Site Request Forgery (CSRF) Middleware
      • Cookie based CSRF middleware options
      • Session based CSRF middleware options
      • Skipping CSRF checks for specific actions
      • Integration with FormHelper
      • CSRF Protection and AJAX Requests
  • Content Security Policy
  • Security Headers
  • HTTPS Enforcer
    • Adding Strict-Transport-Security
• Sessions
  • Session Configuration
  • Built-in Session Handlers & Configuration
    • Session Handlers
    • Database Sessions
    • Cache Sessions
    • Session Locking
  • Setting ini directives
  • Creating a Custom Session Handler
    • Session
  • Accessing the Session Object
  • Reading & Writing Session Data
    • Session::read()
    • Session::readOrFail()
    • Session::write()
    • Session::delete()
    • Session::consume
    • Session::check()
  • Destroying the Session
    • Session::destroy()
  • Rotating Session Identifiers
    • Session::renew()
  • Flash Messages
• Testing
  • Installing PHPUnit
    • Install PHPUnit with Composer
    • Using the PHAR File
  • Test Database Setup
  • Checking the Test Setup
  • Test Case Conventions
  • Creating Your First Test Case
  • Running Tests
    • Filtering Test Cases
    • Generating Code Coverage
    • Combining Test Suites for Plugins
  • Test Case Lifecycle Callbacks
  • Fixtures
    • Test Connections
    • PHPUnit Configuration
    • Creating Schema in Tests
    • Creating Schema with Migrations
    • Creating Schema with Abstract Schema
    • Creating Schema with SQL Dump Files
    • Fixture State Managers
    • Creating Fixtures
    • Dynamic Data
    • Loading Fixtures in your Test Cases
    • Fixture Factories
  • Loading Routes in Tests
    • Creating Routes in Tests
    • Loading Plugins in Tests
  • Testing Table Classes
    • Creating a Test Method
    • Mocking Model Methods
  • Controller Integration Testing
    • Setting up the Request
    • Testing Actions Protected by CsrfComponent or SecurityComponent
    • Integration Testing PSR-7 Middleware
    • Testing with Encrypted Cookies
    • Testing Flash Messages
    • Testing a JSON Responding Controller
    • Testing with file uploads
    • Disabling Error Handling Middleware in Tests
    • Assertion methods
    • Comparing test results to a file
  • Console Integration Testing
  • Mocking Injected Dependencies
  • Mocking HTTP Client Responses
  • Testing Views
  • Testing Components
  • Testing Helpers
  • Testing Events
  • Testing Email
  • Creating Test Suites
  • Creating Tests for Plugins
  • Generating Tests with Bake
• Validation
  • Creating Validators
    • Validator
    • Requiring Field Presence
    • Allowing Empty Fields
    • Adding Validation Rules
    • Using Custom Validation Rules
    • Conditional/Dynamic Error Messages
    • Conditional Validation
    • Marking Rules as the Last to Run
  • Make Rules ‘last’ by default
    • Adding Validation Providers
    • Nesting Validators
    • Creating Reusable Validators
  • Validating Data
  • Validating Entity Data
  • Core Validation Rules

Utility Classes

• App Class
  • App
  • Finding Classes
    • App::className
  • Finding Paths to Resources
    • App::path
  • Finding Paths to Namespaces
    • App::classPath
    • App::core
  • Locating Themes
  • Loading Vendor Files
• Collections
  • Collection
  • Quick Example
  • List of Methods
  • Iterating
    • Collection::each()
    • Collection::map()
    • Collection::extract()
    • Collection::combine()
    • Collection::stopWhen()
    • Collection::unfold()
    • Collection::chunk()
    • Collection::chunkWithKeys()
  • Filtering
    • Collection::filter()
    • Collection::reject()
    • Collection::every()
    • Collection::some()
    • Collection::match()
    • Collection::firstMatch()
  • Aggregation
    • Collection::reduce()
    • Collection::min()
    • Collection::max()
    • Collection::sumOf()
    • Collection::avg()
    • Collection::median()
    • Grouping and Counting
      • Collection::groupBy()
      • Collection::countBy()
      • Collection::indexBy()
      • Collection::zip()
  • Sorting
    • Collection::sortBy()
  • Working with Tree Data
    • Collection::nest()
    • Collection::listNested()
  • Other Methods
    • Collection::isEmpty()
    • Collection::contains()
    • Collection::shuffle()
    • Collection::transpose()
    • Withdrawing Elements
      • Collection::sample()
      • Collection::take()
      • Collection::skip()
      • Collection::first()
      • Collection::last()
    • Expanding Collections
      • Collection::append()
      • Collection::appendItem()
      • Collection::prepend()
      • Collection::prependItem()
    • Modifiying Elements
      • Collection::insert()
    • Making Collection Methods Reusable
      • Collection::through()
    • Optimizing Collections
      • Collection::buffered()
    • Making Collections Rewindable
    • Cloning Collections
      • Collection::compile()
• Hash
  • Hash
  • Hash Path Syntax
    • Expression Types
    • Attribute Matching Types
      • Hash::get
      • Hash::extract
      • Hash::insert
      • Hash::remove
      • Hash::combine
      • Hash::format
      • Hash::contains
      • Hash::check
      • Hash::filter
      • Hash::flatten
      • Hash::expand
      • Hash::merge
      • Hash::numeric
      • Hash::dimensions
      • Hash::maxDimensions
      • Hash::map
      • Hash::reduce
      • Hash::apply
      • Hash::sort
      • Hash::diff
      • Hash::mergeDiff
      • Hash::normalize
      • Hash::nest
• Http Client
  • Client
  • Doing Requests
  • Creating Multipart Requests with Files
    • Building Multipart Request Bodies
  • Sending Request Bodies
  • Request Method Options
  • Authentication
    • Using Basic Authentication
    • Using Digest Authentication
    • OAuth 1 Authentication
    • OAuth 2 Authentication
    • Proxy Authentication
  • Creating Scoped Clients
  • Setting and Managing Cookies
  • Response Objects
    • Response
    • Reading Response Bodies
    • Reading JSON and XML Response Bodies
    • Accessing Response Headers
    • Accessing Cookie Data
    • Checking the Status Code
  • Changing Transport Adapters
  • Testing
    • HttpClientTrait
      • HttpClientTrait::newClientResponse()
• Inflector
  • Inflector
  • Summary of Inflector Methods and Their Output
  • Creating Plural & Singular Forms
    • Inflector::singularize
    • Inflector::pluralize
  • Creating CamelCase and under_scored Forms
    • Inflector::camelize
    • Inflector::underscore
  • Creating Human Readable Forms
    • Inflector::humanize
  • Creating Table and Class Name Forms
    • Inflector::classify
    • Inflector::dasherize
    • Inflector::tableize
  • Creating Variable Names
    • Inflector::variable
  • Inflection Configuration
    • Loading Custom Inflections
      • Inflector::rules
• Number
  • Number
  • Formatting Currency Values
    • Number::currency()
  • Setting the Default Currency
    • Number::setDefaultCurrency()
  • Getting the Default Currency
    • Number::getDefaultCurrency()
  • Formatting Floating Point Numbers
    • Number::precision()
  • Formatting Percentages
    • Number::toPercentage()
  • Interacting with Human Readable Values
    • Number::toReadableSize()
  • Formatting Numbers
    • Number::format()
    • Number::ordinal()
  • Format Differences
    • Number::formatDelta()
  • Configure formatters
    • Number::config()
• Plugin Class
  • Plugin
  • Locating Plugins
    • Plugin::path
  • Check if a Plugin is Loaded
  • Finding Paths to Namespaces
    • Plugin::classPath
  • Finding Paths to Resources
    • Plugin::templatePath
• Registry Objects
  • Loading Objects
  • Triggering Callbacks
  • Disabling Callbacks
• Text
  • Text
  • Convert Strings into ASCII
    • Text::transliterate
  • Creating URL Safe Strings
    • Text::slug
  • Generating UUIDs
    • Text::uuid
  • Simple String Parsing
    • Text::tokenize
    • Text::parseFileSize()
  • Formatting Strings
    • Text::insert
    • Text::cleanInsert
  • Wrapping Text
    • Text::wrap
    • Text::wrapBlock
  • Highlighting Substrings
    • Text::highlight()
  • Removing Links
    • Text::stripLinks()
  • Truncating Text
    • Text::truncate()
  • Truncating the Tail of a String
    • Text::tail()
  • Extracting an Excerpt
    • Text::excerpt()
  • Converting an Array to Sentence Form
    • Text::toList()
• Date & Time
  • DateTime
  • Creating DateTime Instances
  • Manipulation
  • Formatting
    • DateTime::setJsonEncodeFormat
    • DateTime::i18nFormat()
    • DateTime::nice()
    • Setting the Default Locale and Format String
    • Formatting Relative Times
      • DateTime::timeAgoInWords()
  • Conversion
    • DateTime::toQuarter()
  • Comparing With the Present
    • DateTime::isYesterday()
    • DateTime::isThisWeek()
    • DateTime::isThisMonth()
    • DateTime::isThisYear()
  • Comparing With Intervals
    • DateTime::isWithinNext()
    • DateTime::wasWithinLast()
  • Date
  • Mutable Dates and Times
    • Time
    • Date
  • Accepting Localized Request Data
  • Supported Timezones
• Xml
  • Xml
  • Loading XML documents
    • Xml::build
  • Loading HTML documents
  • Transforming a XML String in Array
  • Transforming an Array into a String of XML
    • Using Namespaces
    • Creating a Child

Plugins & Packages

• Standalone Packages
  • ORM
  • Database
  • Datasource
  • HTTP
  • Console
  • Collection
  • I18n
  • Cache
  • Log
  • Event
  • Utility
  • Validation
  • Form
• Authentication
• Authorization
• Bake
• Debug Kit
• Migrations
• Elasticsearch
• Phinx
• Chronos
• Queue

Other

• Constants & Functions
  • Global Functions
    • __d()
    • __dn()
    • __dx()
    • __dxn()
    • __n()
    • __x()
    • __xn()
    • collection()
    • debug()
    • dd()
    • pr()
    • pj()
    • env()
    • h()
    • pluginSplit()
    • namespaceSplit()
  • Core Definition Constants
    • APP
    • APP_DIR
    • CACHE
    • CAKE
    • CAKE_CORE_INCLUDE_PATH
    • CONFIG
    • CORE_PATH
    • DS
    • LOGS
    • RESOURCES
    • ROOT
    • TESTS
    • TMP
    • WWW_ROOT
  • Timing Definition Constants
    • TIME_START
• Appendices
  • 4.x Migration Guide
    • 5.0 Upgrade Guide
      • Fix Deprecation Warnings
      • Upgrade to PHP 8.1
      • Use the Upgrade Tool
      • Update CakePHP Dependency
      • Update app files based upon latest app template
    • 5.0 Migration Guide
      • Deprecated Features Removed
      • Breaking Changes
        • Global
        • Auth
        • Cache
        • Console
        • Connection
        • Controller
        • Core
        • Database
        • Datasource
        • Event
        • Error
        • Filesystem
        • Http
        • I18n
        • Log
        • Mailer
        • ORM
        • Routing
        • TestSuite
        • Validation
        • View
      • Deprecations
        • Database
        • ORM
      • New Features
        • Improved type checking
        • Collection
        • Core
        • Database
        • Http
        • ORM
        • Required Entity Fields
        • Typed Finder Parameters
        • TestSuite
        • Plugin Installer
  • Backwards Compatibility Shimming
  • Forwards Compatibility Shimming
  • General Information
    • CakePHP Development Process
      • Major Releases
      • Feature Releases
      • Patch Releases
      • Release Cadence
      • Deprecation Policy
    • Glossary