CakePHP
  • Documentation
    • Book
    • API
    • Videos
    • Reporting Security Issues
    • Privacy Policy
    • Logos & Trademarks
  • Business Solutions
  • Swag
  • Road Trip
  • Team
  • Community
    • Community
    • Get Involved
    • Issues (Github)
    • Bakery
    • Featured Resources
    • Training
    • Meetups
    • My CakePHP
    • CakeFest
    • Newsletter
    • Linkedin
    • YouTube
    • Facebook
    • Twitter
    • Mastodon
    • Help & Support
    • Forum
    • Stack Overflow
    • IRC
    • Slack
    • Paid Support
CakePHP

C CakePHP 3.2 Red Velvet API

  • Project:
    • CakePHP
      • CakePHP
      • Authentication
      • Authorization
      • Chronos
      • Elastic Search
      • Queue
  • Version:
    • 3.2
      • 5.2
      • 5.1
      • 5.0
      • 4.6
      • 4.5
      • 4.4
      • 4.3
      • 4.2
      • 4.1
      • 4.0
      • 3.10
      • 3.9
      • 3.8
      • 3.7
      • 3.6
      • 3.5
      • 3.4
      • 3.3
      • 3.2
      • 3.1
      • 3.0
      • 2.10
      • 2.9
      • 2.8
      • 2.7
      • 2.6
      • 2.5
      • 2.4
      • 2.3
      • 2.2
      • 2.1
      • 2.0
      • 1.3
      • 1.2

Namespaces

  • Global
  • Cake
    • Auth
    • Cache
    • Collection
    • Console
    • Controller
    • Core
    • Database
    • Datasource
    • Error
    • Event
    • Filesystem
    • Form
    • I18n
    • Log
    • Mailer
    • Network
    • ORM
    • Routing
      • Exception
      • Filter
      • Route
    • Shell
    • TestSuite
    • Utility
    • Validation
    • View

Class Router

Parses the request URL into controller, action, and parameters. Uses the connected routes to match the incoming URL string to parameters that will allow the request to be dispatched. Also handles converting parameter lists into URL strings, using the connected routes. Routing allows you to decouple the way the world interacts with your application (URLs) and the implementation (controllers and actions).

Connecting routes

Connecting routes is done using Router::connect(). When parsing incoming requests or reverse matching parameters, routes are enumerated in the order they were connected. For more information on routes and how to connect them see Router::connect().

Namespace: Cake\Routing

Constants

  • string
    ACTION ¶
    'index|show|add|create|edit|update|remove|del|delete|view|item'

    Regular expression for action names

  • string
    DAY ¶
    '0[1-9]|[12][0-9]|3[01]'

    Regular expression for days

  • string
    ID ¶
    '[0-9]+'

    Regular expression for auto increment IDs

  • string
    MONTH ¶
    '0[1-9]|1[012]'

    Regular expression for months

  • string
    UUID ¶
    '[A-Fa-f0-9]{8}-[A-Fa-f0-9]{4}-[A-Fa-f0-9]{4}-[A-Fa-f0-9]{4}-[A-Fa-f0-9]{12}'

    Regular expression for UUIDs

  • string
    YEAR ¶
    '[12][0-9]{3}'

    Regular expression for years

Property Summary

  • $_collection protected static
    Cake\Routing\RouteCollection

    The route collection routes would be added to.

  • $_defaultExtensions protected static
    array

    Default extensions defined with Router::extensions()

  • $_defaultRouteClass protected static
    bool

    Default route class.

  • $_fullBaseUrl protected static
    string

    Contains the base string that will be applied to all generated URLs For example https://example.com

  • $_initialState protected static
    array

    Initial state is populated the first time reload() is called which is at the bottom of this file. This is a cheat as get_class_vars() returns the value of static vars even if they have changed.

  • $_namedExpressions protected static
    array

    Named expressions

  • $_requestContext protected static
    array

    A hash of request context data.

  • $_requests protected static
    array

    Maintains the request object stack for the current request. This will contain more than one request object when requestAction is used.

  • $_urlFilters protected static
    array

    The stack of URL filters to apply against routing URLs before passing the parameters to the route collection.

  • $initialized public static
    bool

    Have routes been loaded

Method Summary

  • _applyUrlFilters() protected static

    Applies all the connected URL filters to the URL.

  • _loadRoutes() protected static

    Loads route configuration

  • _setContext() protected static

    Store the request context for a given request.

  • addUrlFilter() public static

    Add a URL filter to Router.

  • connect() public static

    Connects a new Route in the router.

  • defaultRouteClass() public static

    Get or set default route class.

  • extensions() public static

    Get or set valid extensions for all routes connected later.

  • fullBaseUrl() public static

    Sets the full base URL that will be used as a prefix for generating fully qualified URLs for this application. If not parameters are passed, the currently configured value is returned.

  • getNamedExpressions() public static

    Gets the named route patterns for use in config/routes.php

  • getRequest() public static

    Get the current request object, or the first one.

  • mapResources() public static

    Generate REST resource routes for the given controller(s).

  • normalize() public static

    Normalizes an URL for purposes of comparison.

  • parse() public static

    Parses given URL string. Returns 'routing' parameters for that URL.

  • parseNamedParams() public static

    Provides legacy support for named parameters on incoming URLs.

  • plugin() public static

    Add plugin routes.

  • popRequest() public static

    Pops a request off of the request stack. Used when doing requestAction

  • prefix() public static

    Create prefixed routes.

  • pushRequest() public static

    Push a request onto the request stack. Pushing a request sets the request context used when generating URLs.

  • redirect() public static

    Connects a new redirection Route in the router.

  • reload() public static

    Reloads default Router settings. Resets all class variables and removes all connected routes.

  • reverse() public static

    Reverses a parsed parameter array into a string.

  • routes() public static

    Get the route scopes and their connected routes.

  • scope() public static

    Create a routing scope.

  • setRequestInfo() public static

    Takes parameter and path information back from the Dispatcher, sets these parameters as the current request parameters that are merged with URL arrays created later in the request.

  • url() public static

    Finds URL for specified action.

Method Detail

_applyUrlFilters() ¶ protected static

_applyUrlFilters(array $url): array

Applies all the connected URL filters to the URL.

Parameters
array $url

The URL array being modified.

Returns
array
See Also
\Cake\Routing\Router::url()
\Cake\Routing\Router::addUrlFilter()

_loadRoutes() ¶ protected static

_loadRoutes(): void

Loads route configuration

Returns
void

_setContext() ¶ protected static

_setContext(Cake\Network\Request $request): void

Store the request context for a given request.

Parameters
Cake\Network\Request $request

The request instance.

Returns
void

addUrlFilter() ¶ public static

addUrlFilter(callable $function): void

Add a URL filter to Router.

URL filter functions are applied to every array $url provided to Router::url() before the URLs are sent to the route collection.

Callback functions should expect the following parameters:

  • $params The URL params being processed.
  • $request The current request.

The URL filter function should always return the params even if unmodified.

Usage

URL filters allow you to easily implement features like persistent parameters.

Router::addUrlFilter(function ($params, $request) {
 if (isset($request->params['lang']) && !isset($params['lang'])) {
   $params['lang'] = $request->params['lang'];
 }
 return $params;
});
Parameters
callable $function

The function to add

Returns
void

connect() ¶ public static

connect(string $route, array $defaults = [], array $options = []): void

Connects a new Route in the router.

Compatibility proxy to \Cake\Routing\RouteBuilder::connect() in the / scope.

Parameters
string $route

A string describing the template of the route

array $defaults optional

An array describing the default route parameters. These parameters will be used by default and can supply routing parameters that are not dynamic. See above.

array $options optional

An array matching the named elements in the route to regular expressions which that element should match. Also contains additional parameters such as which routed parameters should be shifted into the passed arguments, supplying patterns for routing parameters and supplying the name of a custom routing class.

Returns
void
Throws
Cake\Core\Exception\Exception
See Also
\Cake\Routing\RouteBuilder::connect()
\Cake\Routing\Router::scope()

defaultRouteClass() ¶ public static

defaultRouteClass(string|null $routeClass = null): string|null

Get or set default route class.

Parameters
string|null $routeClass optional

Class name.

Returns
string|null

extensions() ¶ public static

extensions(array|string|null $extensions = null, bool $merge = true): array

Get or set valid extensions for all routes connected later.

Instructs the router to parse out file extensions from the URL. For example, http://example.com/posts.rss would yield a file extension of "rss". The file extension itself is made available in the controller as $this->request->params['_ext'], and is used by the RequestHandler component to automatically switch to alternate layouts and templates, and load helpers corresponding to the given content, i.e. RssHelper. Switching layouts and helpers requires that the chosen extension has a defined mime type in Cake\Network\Response.

A string or an array of valid extensions can be passed to this method. If called without any parameters it will return current list of set extensions.

Parameters
array|string|null $extensions optional

List of extensions to be added.

bool $merge optional

Whether to merge with or override existing extensions. Defaults to true.

Returns
array

fullBaseUrl() ¶ public static

fullBaseUrl(string|null $base = null): string

Sets the full base URL that will be used as a prefix for generating fully qualified URLs for this application. If not parameters are passed, the currently configured value is returned.

Note:

If you change the configuration value App.fullBaseUrl during runtime and expect the router to produce links using the new setting, you are required to call this method passing such value again.

Parameters
string|null $base optional

the prefix for URLs generated containing the domain. For example: http://example.com

Returns
string

getNamedExpressions() ¶ public static

getNamedExpressions(): array

Gets the named route patterns for use in config/routes.php

Returns
array
See Also
\Cake\Routing\Router::$_namedExpressions

getRequest() ¶ public static

getRequest(bool $current = false): Cake\Network\Request|null

Get the current request object, or the first one.

Parameters
bool $current optional

True to get the current request, or false to get the first one.

Returns
Cake\Network\Request|null

mapResources() ¶ public static

mapResources(string|array $controller, array $options = []): void

Generate REST resource routes for the given controller(s).

Compatibility proxy to \Cake\Routing\RouteBuilder::resources(). Additional, compatibility around prefixes and plugins and prefixes is handled by this method.

A quick way to generate a default routes to a set of REST resources (controller(s)).

Usage

Connect resource routes for an app controller:

Router::mapResources('Posts');

Connect resource routes for the Comment controller in the Comments plugin:

Router::mapResources('Comments.Comment');

Plugins will create lower_case underscored resource routes. e.g /comments/comment

Connect resource routes for the Posts controller in the Admin prefix:

Router::mapResources('Posts', ['prefix' => 'admin']);

Prefixes will create lower_case underscored resource routes. e.g /admin/posts

Options:

  • 'id' - The regular expression fragment to use when matching IDs. By default, matches integer values and UUIDs.
  • 'prefix' - Routing prefix to use for the generated routes. Defaults to ''. Using this option will create prefixed routes, similar to using Routing.prefixes.
  • 'only' - Only connect the specific list of actions.
  • 'actions' - Override the method names used for connecting actions.
  • 'map' - Additional resource routes that should be connected. If you define 'only' and 'map', make sure that your mapped methods are also in the 'only' list.
Parameters
string|array $controller

A controller name or array of controller names (i.e. "Posts" or "ListItems")

array $options optional

Options to use when generating REST routes

Returns
void
See Also
\Cake\Routing\RouteBuilder::resources()

normalize() ¶ public static

normalize(array|string $url = '/'): string

Normalizes an URL for purposes of comparison.

Will strip the base path off and replace any double /'s. It will not unify the casing and underscoring of the input value.

Parameters
array|string $url optional

URL to normalize Either an array or a string URL.

Returns
string

parse() ¶ public static

parse(string $url): array

Parses given URL string. Returns 'routing' parameters for that URL.

Parameters
string $url

URL to be parsed

Returns
array
Throws
Cake\Routing\Exception\MissingRouteException
When a route cannot be handled

parseNamedParams() ¶ public static

parseNamedParams(Cake\Network\Request $request, array $options = []): Cake\Network\Request

Provides legacy support for named parameters on incoming URLs.

Checks the passed parameters for elements containing $options['separator'] Those parameters are split and parsed as if they were old style named parameters.

The parsed parameters will be moved from params['pass'] to params['named'].

Options

  • separator The string to use as a separator. Defaults to :.
Parameters
Cake\Network\Request $request

The request object to modify.

array $options optional

The array of options.

Returns
Cake\Network\Request

plugin() ¶ public static

plugin(string $name, array|callable $options = [], callable|null $callback = null): void

Add plugin routes.

This method creates a scoped route collection that includes relevant plugin information.

The plugin name will be inflected to the underscore version to create the routing path. If you want a custom path name, use the path option.

Routes connected in the scoped collection will have the correct path segment prepended, and have a matching plugin routing key set.

Parameters
string $name

The plugin name to build routes for

array|callable $options optional

Either the options to use, or a callback

callable|null $callback optional

The callback to invoke that builds the plugin routes. Only required when $options is defined

Returns
void

popRequest() ¶ public static

popRequest(): Cake\Network\Request

Pops a request off of the request stack. Used when doing requestAction

Returns
Cake\Network\Request
See Also
\Cake\Routing\Router::pushRequest()
\Cake\Routing\RequestActionTrait::requestAction()

prefix() ¶ public static

prefix(string $name, array|callable $params = [], callable|null $callback = null): void

Create prefixed routes.

This method creates a scoped route collection that includes relevant prefix information.

The path parameter is used to generate the routing parameter name. For example a path of admin would result in 'prefix' => 'admin' being applied to all connected routes.

You can re-open a prefix as many times as necessary, as well as nest prefixes. Nested prefixes will result in prefix values like admin/api which translates to the Controller\Admin\Api\ namespace.

Parameters
string $name

The prefix name to use.

array|callable $params optional

An array of routing defaults to add to each connected route. If you have no parameters, this argument can be a callable.

callable|null $callback optional

The callback to invoke that builds the prefixed routes.

Returns
void

pushRequest() ¶ public static

pushRequest(Cake\Network\Request $request): void

Push a request onto the request stack. Pushing a request sets the request context used when generating URLs.

Parameters
Cake\Network\Request $request

Request instance.

Returns
void

redirect() ¶ public static

redirect(string $route, array $url, array $options = []): void

Connects a new redirection Route in the router.

Compatibility proxy to \Cake\Routing\RouteBuilder::redirect() in the / scope.

Parameters
string $route

A string describing the template of the route

array $url

An URL to redirect to. Can be a string or a Cake array-based URL

array $options optional

An array matching the named elements in the route to regular expressions which that element should match. Also contains additional parameters such as which routed parameters should be shifted into the passed arguments. As well as supplying patterns for routing parameters.

Returns
void
See Also
\Cake\Routing\RouteBuilder::redirect()

reload() ¶ public static

reload(): void

Reloads default Router settings. Resets all class variables and removes all connected routes.

Returns
void

reverse() ¶ public static

reverse(Cake\Network\Request|array $params, bool $full = false): string

Reverses a parsed parameter array into a string.

Works similarly to Router::url(), but since parsed URL's contain additional 'pass' as well as 'url.url' keys. Those keys need to be specially handled in order to reverse a params array into a string URL.

This will strip out 'autoRender', 'bare', 'requested', and 'return' param names as those are used for CakePHP internals and should not normally be part of an output URL.

Parameters
Cake\Network\Request|array $params

The params array or Cake\Network\Request object that needs to be reversed.

bool $full optional

Set to true to include the full URL including the protocol when reversing the URL.

Returns
string

routes() ¶ public static

routes(): array

Get the route scopes and their connected routes.

Returns
array

scope() ¶ public static

scope(string $path, array|callable $params = [], callable|null $callback = null): void

Create a routing scope.

Routing scopes allow you to keep your routes DRY and avoid repeating common path prefixes, and or parameter sets.

Scoped collections will be indexed by path for faster route parsing. If you re-open or re-use a scope the connected routes will be merged with the existing ones.

Example

Router::scope('/blog', ['plugin' => 'Blog'], function ($routes) {
   $routes->connect('/', ['controller' => 'Articles']);
});

The above would result in a /blog/ route being created, with both the plugin & controller default parameters set.

You can use Router::plugin() and Router::prefix() as shortcuts to creating specific kinds of scopes.

Routing scopes will inherit the globally set extensions configured with Router::extensions(). You can also set valid extensions using $routes->extensions() in your closure.

Parameters
string $path

The path prefix for the scope. This path will be prepended to all routes connected in the scoped collection.

array|callable $params optional

An array of routing defaults to add to each connected route. If you have no parameters, this argument can be a callable.

callable|null $callback optional

The callback to invoke with the scoped collection.

Returns
void
Throws
InvalidArgumentException
When an invalid callable is provided.

setRequestInfo() ¶ public static

setRequestInfo(Cake\Network\Request|array $request): void

Takes parameter and path information back from the Dispatcher, sets these parameters as the current request parameters that are merged with URL arrays created later in the request.

Nested requests will create a stack of requests. You can remove requests using Router::popRequest(). This is done automatically when using Object::requestAction().

Will accept either a Cake\Network\Request object or an array of arrays. Support for accepting arrays may be removed in the future.

Parameters
Cake\Network\Request|array $request

Parameters and path information or a Cake\Network\Request object.

Returns
void

url() ¶ public static

url(string|array|null $url = null, bool $full = false): string

Finds URL for specified action.

Returns an URL pointing to a combination of controller and action.

Usage

  • Router::url('/posts/edit/1'); Returns the string with the base dir prepended. This usage does not use reverser routing.
  • Router::url(['controller' => 'posts', 'action' => 'edit']); Returns a URL generated through reverse routing.
  • Router::url(['_name' => 'custom-name', ...]); Returns a URL generated through reverse routing. This form allows you to leverage named routes.

There are a few 'special' parameters that can change the final URL string that is generated

  • _base - Set to false to remove the base path from the generated URL. If your application is not in the root directory, this can be used to generate URLs that are 'cake relative'. cake relative URLs are required when using requestAction.
  • _scheme - Set to create links on different schemes like webcal or ftp. Defaults to the current scheme.
  • _host - Set the host to use for the link. Defaults to the current host.
  • _port - Set the port if you need to create links on non-standard ports.
  • _full - If true output of Router::fullBaseUrl() will be prepended to generated URLs.
  • # - Allows you to set URL hash fragments.
  • _ssl - Set to true to convert the generated URL to https, or false to force http.
  • _name - Name of route. If you have setup named routes you can use this key to specify it.
Parameters
string|array|null $url optional

An array specifying any of the following: 'controller', 'action', 'plugin' additionally, you can provide routed elements or query string parameters. If string it can be name any valid url string.

bool $full optional

If true, the full base URL will be prepended to the result. Default is false.

Returns
string
Throws
Cake\Core\Exception\Exception
When the route name is not found

Property Detail

$_collection ¶ protected static

The route collection routes would be added to.

Type
Cake\Routing\RouteCollection

$_defaultExtensions ¶ protected static

Default extensions defined with Router::extensions()

Type
array

$_defaultRouteClass ¶ protected static

Default route class.

Type
bool

$_fullBaseUrl ¶ protected static

Contains the base string that will be applied to all generated URLs For example https://example.com

Type
string

$_initialState ¶ protected static

Initial state is populated the first time reload() is called which is at the bottom of this file. This is a cheat as get_class_vars() returns the value of static vars even if they have changed.

Type
array

$_namedExpressions ¶ protected static

Named expressions

Type
array

$_requestContext ¶ protected static

A hash of request context data.

Type
array

$_requests ¶ protected static

Maintains the request object stack for the current request. This will contain more than one request object when requestAction is used.

Type
array

$_urlFilters ¶ protected static

The stack of URL filters to apply against routing URLs before passing the parameters to the route collection.

Type
array

$initialized ¶ public static

Have routes been loaded

Type
bool
OpenHub
Pingping
Linode
  • Business Solutions
  • Showcase
  • Documentation
  • Book
  • API
  • Videos
  • Reporting Security Issues
  • Privacy Policy
  • Logos & Trademarks
  • Community
  • Get Involved
  • Issues (Github)
  • Bakery
  • Featured Resources
  • Training
  • Meetups
  • My CakePHP
  • CakeFest
  • Newsletter
  • Linkedin
  • YouTube
  • Facebook
  • Twitter
  • Mastodon
  • Help & Support
  • Forum
  • Stack Overflow
  • IRC
  • Slack
  • Paid Support

Generated using CakePHP API Docs