正文
在Web开发中，对于URL有一些共性的需求，如：
- 统一、简洁的URL创建方式
- URL的伪静态化（美化）处理
- 从URL中解析出相应的路由信息，引导应用执行后续处理
这些功能在 前面我们讲的 UrlRule 层面已经得到了一定程度的实现。 但从层次上来讲，UrlRule 更偏向于基础一些，直接使用 UrlRule 相对而言还不是很方便。
比如，针对各种类型的URL，我们需要提供相应的 UrlRule 实例来进行处理。 这些实例如何进行统一管理，相互关系怎么处理？都无法在 UrlRule 自身层面解决。
我们需要更贴近开发的接口。于是Yii把Web应用中对于URL的常用要求抽象到了urlManager中， 并作为Web应用的核心组件，更便于开发者使用。
urlManager概览
urlManager组件由 yii\web\UrlManager 类定义:
namespace yii\web;
use Yii;
use yii\base\Component;
use yii\base\InvalidConfigException;
use yii\caching\Cache;
class UrlManager extends Component
{
// 用于表明urlManager是否启用URL美化功能，在Yii1.1中称为path格式URL，Yii2.0中改称美化。
// 默认不启用。但实际使用中，特别是产品环境，一般都会启用。
public $enablePrettyUrl = false;
// 是否启用严格解析，如启用严格解析，要求当前请求应至少匹配1个路由规则，否则认为是无效路由。
// 这个选项仅在 enablePrettyUrl 启用后才有效。
public $enableStrictParsing = false;
// 保存所有路由规则的配置数组，并不在这里保存路由规则的实例
public $rules = [];
// 指定续接在URL后面的一个后缀，如 .html 之类的。仅在 enablePrettyUrl 启用时有效。
public $suffix;
// 指定是否在URL中保留入口脚本 index.php
public $showScriptName = true;
// 指定不启用 enablePrettyUrl 情况下，URL中用于表示路由的查询参数，默认为 r
public $routeParam = 'r';
// 指定应用的缓存组件ID，编译过的路由规则将通过这个缓存组件进行缓存。
// 由于应用的缓存组件默认为 cache ，所以这里也默认为 cache 。
// 如果不想使用缓存，需显式地置为 false
public $cache = 'cache';
// 路由规则的默认配置，注意上面的 rules[] 中的同名规则，优先于这个默认配置的规则。
public $ruleConfig = ['class' => 'yii\web\UrlRule'];
private $_baseUrl;
private $_scriptUrl;
private $_hostInfo;
// urlManager 初始化
public function init()
{
parent::init();
// 如果未启用 enablePrettyUrl 或者没有指定任何的路由规则，这个urlManager不需要进一步初始化。
if (!$this->enablePrettyUrl || empty($this->rules)) {
return;
}
// 初始化前， $this->cache 是缓存组件的ID，是个字符串，需要获取其实例。
if (is_string($this->cache)) {
// 如果获取不到实例，说明应用不提供缓存功能，那么置这个 $this->cache 为false
$this->cache = Yii::$app->get($this->cache, false);
}
// 如果顺利引用到了缓存组件，那么就将路由规则缓存起来
if ($this->cache instanceof Cache) {
// 以当前urlManager类的类名为缓存的键
$cacheKey = __CLASS__;
// urlManager所有路由规则转换为json格式编码后的HASH值，用于确保缓存中的路由规则没有变化。
// 即外部没有对已经缓存起来的路由规则有增加、修改、删除、调整前后位置等操作。
$hash = md5(json_encode($this->rules));
// cache中是一个数组, 0号元素用于缓存创建好的路由规则，
// 1号元素用于保存HASH值。这个判断用于确认是否有缓存、且缓存仍有效。
// 是的话，直接使用缓存中的内容作为当前的路由规则数组。
if (($data = $this->cache->get($cacheKey)) !== false && isset($data[1]) && $data[1] === $hash) {
$this->rules = $data[0];
// 如果尚未缓存或路由规则已经被修改导致缓存失效，那么重新创建路由规则并缓存。
} else {
$this->rules = $this->buildRules($this->rules);
$this->cache->set($cacheKey, [$this->rules, $hash]);
}
// 要么是应用不提供缓存功能，要么是开发者将 $this->cache 手动置为false，
// 总之，就是不使用缓存。那么就直接创建吧，也无需缓存了。
} else {
$this->rules = $this->buildRules($this->rules);
}
}
// 增加新的规则
public function addRules($rules, $append = true){ ... }
// 创建路由规则
protected function buildRules($rules){ ... }
// 用于解析请求
public function parseRequest($request){ ... }
// 这2个用于创建URL
public function createUrl($params){ ... }
public function createAbsoluteUrl($params, $scheme = null){ ... }
}
在urlManager的使用上，用得最多的配置项就是：
$enablePrettyUrl，是否开启URL美化功能。关于美化功能，我们在 路由(Route) 部分已经介绍过了。 注意如果$enablePrettyUrl不开启，表明使用原始的格式，那么所有路由规则都是无效的。$showScriptName，是否在URL中显示入口脚本。是对美化功能的进一步补充。- suffix 设置一个
.html之类的假后缀，是对美化功能的进一步补充。 - rules 保存路由规则们的声明，注意并非保存其实例。
$enableStrictParsing是否开启严格解析。该选项仅在开启美化功能后生效。 在开启严格解析模式时，所有请求必须匹配$rules[]所声明的至少一个路由规则。 如果未开启，请求的PATH_INFO部分将作为所请求的路由进行后续处理。
在 UrlManager::init() 初始化过程中，可以发现 urlManager 使用了应用所提供的缓存组件（如果有的话），
对所有路由规则的实例进行缓存。
从架构上来讲，将所有请求交由入口脚本统一接收，再分发到相应模块进行处理的这种方式， 就注定了入口脚本有产生性能瓶颈的可能。 但是带来的开发上的便利，却是实实在在的。 可以想像，在由Web Server进行请求分发的情景下，每个接收请求的脚本都要执行相同或类似的代码， 这会造成很冗余。而且会将权限控制、日志记录等逻辑上就应当作为所有请求第一关的的模块都分散到各处去。
因此，目前这种单一入口脚本的设计成为事实上的标准，几乎所有的Web开发框架都采用这种方式。 但这同时也对各框架的性能提出挑战。
在前面讲路由规则时，我们就体会到了初始化过程的繁琐，转换来转换去的。 如果采用简单粗暴的方式， Yii完全可以牺牲一定的开发便利性，在代码层面提高路由规则的性能。 比如，直接使用正则表达式。
但是，Yii没有这样做，而是很好地平稳了性能与开发便利性，通过将路由规则进行缓存来克服这个瓶颈。
源码
yii\web\UrlManager 类
yii\web\UrlManager 类：
<?php
/**
* @link http://www.yiiframework.com/
* @copyright Copyright (c) 2008 Yii Software LLC
* @license http://www.yiiframework.com/license/
*/
namespace yii\web;
use Yii;
use yii\base\Component;
use yii\base\InvalidConfigException;
use yii\caching\CacheInterface;
use yii\di\Instance;
use yii\helpers\Url;
/**
* UrlManager handles HTTP request parsing and creation of URLs based on a set of rules.
*
* UrlManager is configured as an application component in [[\yii\base\Application]] by default.
* You can access that instance via `Yii::$app->urlManager`.
*
* You can modify its configuration by adding an array to your application config under `components`
* as it is shown in the following example：
*
* 'urlManager' => [
* 'enablePrettyUrl' => true,
* 'rules' => [
* // your rules go here
* ],
* // ...
* ]
*
*
* Rules are classes implementing the [[UrlRuleInterface]], by default that is [[UrlRule]].
* For nesting rules, there is also a [[GroupUrlRule]] class.
*
* For more details and usage information on UrlManager, see the [guide article on routing](guide:runtime-routing).
*
* @property string $baseUrl The base URL that is used by [[createUrl()]] to prepend to created URLs.
* @property string $hostInfo The host info (e.g. `http://www.example.com`) that is used by
* [[createAbsoluteUrl()]] to prepend to created URLs.
* @property string $scriptUrl The entry script URL that is used by [[createUrl()]] to prepend to created
* URLs.
*
* @author Qiang Xue <qiang.xue@gmail.com>
* @since 2.0
*/
class UrlManager extends Component
{
/**
* @var bool whether to enable pretty URLs. Instead of putting all parameters in the query
* string part of a URL, pretty URLs allow using path info to represent some of the parameters
* and can thus produce more user-friendly URLs, such as "/news/Yii-is-released", instead of
* "/index.php?r=news%2Fview&id=100".
*/
public $enablePrettyUrl = false;
/**
* @var bool whether to enable strict parsing. If strict parsing is enabled, the incoming
* requested URL must match at least one of the [[rules]] in order to be treated as a valid request.
* Otherwise, the path info part of the request will be treated as the requested route.
* This property is used only when [[enablePrettyUrl]] is `true`.
*/
public $enableStrictParsing = false;
/**
* @var array the rules for creating and parsing URLs when [[enablePrettyUrl]] is `true`.
* This property is used only if [[enablePrettyUrl]] is `true`. Each element in the array
* is the configuration array for creating a single URL rule. The configuration will
* be merged with [[ruleConfig]] first before it is used for creating the rule object.
*
* A special shortcut format can be used if a rule only specifies [[UrlRule::pattern|pattern]]
* and [[UrlRule::route|route]]: `'pattern' => 'route'`. That is, instead of using a configuration
* array, one can use the key to represent the pattern and the value the corresponding route.
* For example, `'post/<id:\d+>' => 'post/view'`.
*
* For RESTful routing the mentioned shortcut format also allows you to specify the
* [[UrlRule::verb|HTTP verb]] that the rule should apply for.
* You can do that by prepending it to the pattern, separated by space.
* For example, `'PUT post/<id:\d+>' => 'post/update'`.
* You may specify multiple verbs by separating them with comma
* like this: `'POST,PUT post/index' => 'post/create'`.
* The supported verbs in the shortcut format are: GET, HEAD, POST, PUT, PATCH and DELETE.
* Note that [[UrlRule::mode|mode]] will be set to PARSING_ONLY when specifying verb in this way
* so you normally would not specify a verb for normal GET request.
*
* Here is an example configuration for RESTful CRUD controller:
*
* ```php
* [
* 'dashboard' => 'site/index',
*
* 'POST <controller:[\w-]+>' => '<controller>/create',
* '<controller:[\w-]+>s' => '<controller>/index',
*
* 'PUT <controller:[\w-]+>/<id:\d+>' => '<controller>/update',
* 'DELETE <controller:[\w-]+>/<id:\d+>' => '<controller>/delete',
* '<controller:[\w-]+>/<id:\d+>' => '<controller>/view',
* ];
* ```
*
* Note that if you modify this property after the UrlManager object is created, make sure
* you populate the array with rule objects instead of rule configurations.
*/
public $rules = [];
/**
* @var string the URL suffix used when [[enablePrettyUrl]] is `true`.
* For example, ".html" can be used so that the URL looks like pointing to a static HTML page.
* This property is used only if [[enablePrettyUrl]] is `true`.
*/
public $suffix;
/**
* @var bool whether to show entry script name in the constructed URL. Defaults to `true`.
* This property is used only if [[enablePrettyUrl]] is `true`.
*/
public $showScriptName = true;
/**
* @var string the GET parameter name for route. This property is used only if [[enablePrettyUrl]] is `false`.
*/
public $routeParam = 'r';
/**
* @var CacheInterface|array|string|bool the cache object or the application component ID of the cache object.
* This can also be an array that is used to create a [[CacheInterface]] instance in case you do not want to use
* an application component.
* Compiled URL rules will be cached through this cache object, if it is available.
*
* After the UrlManager object is created, if you want to change this property,
* you should only assign it with a cache object.
* Set this property to `false` or `null` if you do not want to cache the URL rules.
*
* Cache entries are stored for the time set by [[\yii\caching\Cache::$defaultDuration|$defaultDuration]] in
* the cache configuration, which is unlimited by default. You may want to tune this value if your [[rules]]
* change frequently.
*/
public $cache = 'cache';
/**
* @var array the default configuration of URL rules. Individual rule configurations
* specified via [[rules]] will take precedence when the same property of the rule is configured.
*/
public $ruleConfig = ['class' => 'yii\web\UrlRule'];
/**
* @var UrlNormalizer|array|string|false the configuration for [[UrlNormalizer]] used by this UrlManager.
* The default value is `false`, which means normalization will be skipped.
* If you wish to enable URL normalization, you should configure this property manually.
* For example:
*
* ```php
* [
* 'class' => 'yii\web\UrlNormalizer',
* 'collapseSlashes' => true,
* 'normalizeTrailingSlash' => true,
* ]
* ```
*
* @since 2.0.10
*/
public $normalizer = false;
/**
* @var string the cache key for cached rules
* @since 2.0.8
*/
protected $cacheKey = __CLASS__;
private $_baseUrl;
private $_scriptUrl;
private $_hostInfo;
private $_ruleCache;
/**
* Initializes UrlManager.
*/
public function init()
{
parent::init();
if ($this->normalizer !== false) {
$this->normalizer = Yii::createObject($this->normalizer);
if (!$this->normalizer instanceof UrlNormalizer) {
throw new InvalidConfigException('`' . get_class($this) . '::normalizer` should be an instance of `' . UrlNormalizer::className() . '` or its DI compatible configuration.');
}
}
if (!$this->enablePrettyUrl) {
return;
}
if (!empty($this->rules)) {
$this->rules = $this->buildRules($this->rules);
}
}
/**
* Adds additional URL rules.
*
* This method will call [[buildRules()]] to parse the given rule declarations and then append or insert
* them to the existing [[rules]].
*
* Note that if [[enablePrettyUrl]] is `false`, this method will do nothing.
*
* @param array $rules the new rules to be added. Each array element represents a single rule declaration.
* Please refer to [[rules]] for the acceptable rule format.
* @param bool $append whether to add the new rules by appending them to the end of the existing rules.
*/
public function addRules($rules, $append = true)
{
if (!$this->enablePrettyUrl) {
return;
}
$rules = $this->buildRules($rules);
if ($append) {
$this->rules = array_merge($this->rules, $rules);
} else {
$this->rules = array_merge($rules, $this->rules);
}
}
/**
* Builds URL rule objects from the given rule declarations.
*
* @param array $ruleDeclarations the rule declarations. Each array element represents a single rule declaration.
* Please refer to [[rules]] for the acceptable rule formats.
* @return UrlRuleInterface[] the rule objects built from the given rule declarations
* @throws InvalidConfigException if a rule declaration is invalid
*/
protected function buildRules($ruleDeclarations)
{
$builtRules = $this->getBuiltRulesFromCache($ruleDeclarations);
if ($builtRules !== false) {
return $builtRules;
}
$builtRules = [];
$verbs = 'GET|HEAD|POST|PUT|PATCH|DELETE|OPTIONS';
foreach ($ruleDeclarations as $key => $rule) {
if (is_string($rule)) {
$rule = ['route' => $rule];
if (preg_match("/^((?:($verbs),)*($verbs))\\s+(.*)$/", $key, $matches)) {
$rule['verb'] = explode(',', $matches[1]);
$key = $matches[4];
}
$rule['pattern'] = $key;
}
if (is_array($rule)) {
$rule = Yii::createObject(array_merge($this->ruleConfig, $rule));
}
if (!$rule instanceof UrlRuleInterface) {
throw new InvalidConfigException('URL rule class must implement UrlRuleInterface.');
}
$builtRules[] = $rule;
}
$this->setBuiltRulesCache($ruleDeclarations, $builtRules);
return $builtRules;
}
/**
* @return CacheInterface|null|bool
*/
private function ensureCache()
{
if (!$this->cache instanceof CacheInterface && $this->cache !== false && $this->cache !== null) {
try {
$this->cache = Instance::ensure($this->cache, 'yii\caching\CacheInterface');
} catch (InvalidConfigException $e) {
Yii::warning('Unable to use cache for URL manager: ' . $e->getMessage());
$this->cache = null;
}
}
return $this->cache;
}
/**
* Stores $builtRules to cache, using $rulesDeclaration as a part of cache key.
*
* @param array $ruleDeclarations the rule declarations. Each array element represents a single rule declaration.
* Please refer to [[rules]] for the acceptable rule formats.
* @param UrlRuleInterface[] $builtRules the rule objects built from the given rule declarations.
* @return bool whether the value is successfully stored into cache
* @since 2.0.14
*/
protected function setBuiltRulesCache($ruleDeclarations, $builtRules)
{
$cache = $this->ensureCache();
if (!$cache) {
return false;
}
return $cache->set([$this->cacheKey, $this->ruleConfig, $ruleDeclarations], $builtRules);
}
/**
* Provides the built URL rules that are associated with the $ruleDeclarations from cache.
*
* @param array $ruleDeclarations the rule declarations. Each array element represents a single rule declaration.
* Please refer to [[rules]] for the acceptable rule formats.
* @return UrlRuleInterface[]|false the rule objects built from the given rule declarations or boolean `false` when
* there are no cache items for this definition exists.
* @since 2.0.14
*/
protected function getBuiltRulesFromCache($ruleDeclarations)
{
$cache = $this->ensureCache();
if (!$cache) {
return false;
}
return $cache->get([$this->cacheKey, $this->ruleConfig, $ruleDeclarations]);
}
/**
* Parses the user request.
* @param Request $request the request component
* @return array|bool the route and the associated parameters. The latter is always empty
* if [[enablePrettyUrl]] is `false`. `false` is returned if the current request cannot be successfully parsed.
*/
public function parseRequest($request)
{
if ($this->enablePrettyUrl) {
/* @var $rule UrlRule */
foreach ($this->rules as $rule) {
$result = $rule->parseRequest($this, $request);
if (YII_DEBUG) {
Yii::debug([
'rule' => method_exists($rule, '__toString') ? $rule->__toString() : get_class($rule),
'match' => $result !== false,
'parent' => null,
], __METHOD__);
}
if ($result !== false) {
return $result;
}
}
if ($this->enableStrictParsing) {
return false;
}
Yii::debug('No matching URL rules. Using default URL parsing logic.', __METHOD__);
$suffix = (string) $this->suffix;
$pathInfo = $request->getPathInfo();
$normalized = false;
if ($this->normalizer !== false) {
$pathInfo = $this->normalizer->normalizePathInfo($pathInfo, $suffix, $normalized);
}
if ($suffix !== '' && $pathInfo !== '') {
$n = strlen($this->suffix);
if (substr_compare($pathInfo, $this->suffix, -$n, $n) === 0) {
$pathInfo = substr($pathInfo, 0, -$n);
if ($pathInfo === '') {
// suffix alone is not allowed
return false;
}
} else {
// suffix doesn't match
return false;
}
}
if ($normalized) {
// pathInfo was changed by normalizer - we need also normalize route
return $this->normalizer->normalizeRoute([$pathInfo, []]);
}
return [$pathInfo, []];
}
Yii::debug('Pretty URL not enabled. Using default URL parsing logic.', __METHOD__);
$route = $request->getQueryParam($this->routeParam, '');
if (is_array($route)) {
$route = '';
}
return [(string) $route, []];
}
/**
* Creates a URL using the given route and query parameters.
*
* You may specify the route as a string, e.g., `site/index`. You may also use an array
* if you want to specify additional query parameters for the URL being created. The
* array format must be:
*
* ```php
* // generates: /index.php?r=site%2Findex¶m1=value1¶m2=value2
* ['site/index', 'param1' => 'value1', 'param2' => 'value2']
* ```
*
* If you want to create a URL with an anchor, you can use the array format with a `#` parameter.
* For example,
*
* ```php
* // generates: /index.php?r=site%2Findex¶m1=value1#name
* ['site/index', 'param1' => 'value1', '#' => 'name']
* ```
*
* The URL created is a relative one. Use [[createAbsoluteUrl()]] to create an absolute URL.
*
* Note that unlike [[\yii\helpers\Url::toRoute()]], this method always treats the given route
* as an absolute route.
*
* @param string|array $params use a string to represent a route (e.g. `site/index`),
* or an array to represent a route with query parameters (e.g. `['site/index', 'param1' => 'value1']`).
* @return string the created URL
*/
public function createUrl($params)
{
$params = (array) $params;
$anchor = isset($params['#']) ? '#' . $params['#'] : '';
unset($params['#'], $params[$this->routeParam]);
$route = trim($params[0], '/');
unset($params[0]);
$baseUrl = $this->showScriptName || !$this->enablePrettyUrl ? $this->getScriptUrl() : $this->getBaseUrl();
if ($this->enablePrettyUrl) {
$cacheKey = $route . '?';
foreach ($params as $key => $value) {
if ($value !== null) {
$cacheKey .= $key . '&';
}
}
$url = $this->getUrlFromCache($cacheKey, $route, $params);
if ($url === false) {
/* @var $rule UrlRule */
foreach ($this->rules as $rule) {
if (in_array($rule, $this->_ruleCache[$cacheKey], true)) {
// avoid redundant calls of `UrlRule::createUrl()` for rules checked in `getUrlFromCache()`
// @see https://github.com/yiisoft/yii2/issues/14094
continue;
}
$url = $rule->createUrl($this, $route, $params);
if ($this->canBeCached($rule)) {
$this->setRuleToCache($cacheKey, $rule);
}
if ($url !== false) {
break;
}
}
}
if ($url !== false) {
if (strpos($url, '://') !== false) {
if ($baseUrl !== '' && ($pos = strpos($url, '/', 8)) !== false) {
return substr($url, 0, $pos) . $baseUrl . substr($url, $pos) . $anchor;
}
return $url . $baseUrl . $anchor;
} elseif (strncmp($url, '//', 2) === 0) {
if ($baseUrl !== '' && ($pos = strpos($url, '/', 2)) !== false) {
return substr($url, 0, $pos) . $baseUrl . substr($url, $pos) . $anchor;
}
return $url . $baseUrl . $anchor;
}
$url = ltrim($url, '/');
return "$baseUrl/{$url}{$anchor}";
}
if ($this->suffix !== null) {
$route .= $this->suffix;
}
if (!empty($params) && ($query = http_build_query($params)) !== '') {
$route .= '?' . $query;
}
$route = ltrim($route, '/');
return "$baseUrl/{$route}{$anchor}";
}
$url = "$baseUrl?{$this->routeParam}=" . urlencode($route);
if (!empty($params) && ($query = http_build_query($params)) !== '') {
$url .= '&' . $query;
}
return $url . $anchor;
}
/**
* Returns the value indicating whether result of [[createUrl()]] of rule should be cached in internal cache.
*
* @param UrlRuleInterface $rule
* @return bool `true` if result should be cached, `false` if not.
* @since 2.0.12
* @see getUrlFromCache()
* @see setRuleToCache()
* @see UrlRule::getCreateUrlStatus()
*/
protected function canBeCached(UrlRuleInterface $rule)
{
return
// if rule does not provide info about create status, we cache it every time to prevent bugs like #13350
// @see https://github.com/yiisoft/yii2/pull/13350#discussion_r114873476
!method_exists($rule, 'getCreateUrlStatus') || ($status = $rule->getCreateUrlStatus()) === null
|| $status === UrlRule::CREATE_STATUS_SUCCESS
|| $status & UrlRule::CREATE_STATUS_PARAMS_MISMATCH;
}
/**
* Get URL from internal cache if exists.
* @param string $cacheKey generated cache key to store data.
* @param string $route the route (e.g. `site/index`).
* @param array $params rule params.
* @return bool|string the created URL
* @see createUrl()
* @since 2.0.8
*/
protected function getUrlFromCache($cacheKey, $route, $params)
{
if (!empty($this->_ruleCache[$cacheKey])) {
foreach ($this->_ruleCache[$cacheKey] as $rule) {
/* @var $rule UrlRule */
if (($url = $rule->createUrl($this, $route, $params)) !== false) {
return $url;
}
}
} else {
$this->_ruleCache[$cacheKey] = [];
}
return false;
}
/**
* Store rule (e.g. [[UrlRule]]) to internal cache.
* @param $cacheKey
* @param UrlRuleInterface $rule
* @since 2.0.8
*/
protected function setRuleToCache($cacheKey, UrlRuleInterface $rule)
{
$this->_ruleCache[$cacheKey][] = $rule;
}
/**
* Creates an absolute URL using the given route and query parameters.
*
* This method prepends the URL created by [[createUrl()]] with the [[hostInfo]].
*
* Note that unlike [[\yii\helpers\Url::toRoute()]], this method always treats the given route
* as an absolute route.
*
* @param string|array $params use a string to represent a route (e.g. `site/index`),
* or an array to represent a route with query parameters (e.g. `['site/index', 'param1' => 'value1']`).
* @param string|null $scheme the scheme to use for the URL (either `http`, `https` or empty string
* for protocol-relative URL).
* If not specified the scheme of the current request will be used.
* @return string the created URL
* @see createUrl()
*/
public function createAbsoluteUrl($params, $scheme = null)
{
$params = (array) $params;
$url = $this->createUrl($params);
if (strpos($url, '://') === false) {
$hostInfo = $this->getHostInfo();
if (strncmp($url, '//', 2) === 0) {
$url = substr($hostInfo, 0, strpos($hostInfo, '://')) . ':' . $url;
} else {
$url = $hostInfo . $url;
}
}
return Url::ensureScheme($url, $scheme);
}
/**
* Returns the base URL that is used by [[createUrl()]] to prepend to created URLs.
* It defaults to [[Request::baseUrl]].
* This is mainly used when [[enablePrettyUrl]] is `true` and [[showScriptName]] is `false`.
* @return string the base URL that is used by [[createUrl()]] to prepend to created URLs.
* @throws InvalidConfigException if running in console application and [[baseUrl]] is not configured.
*/
public function getBaseUrl()
{
if ($this->_baseUrl === null) {
$request = Yii::$app->getRequest();
if ($request instanceof Request) {
$this->_baseUrl = $request->getBaseUrl();
} else {
throw new InvalidConfigException('Please configure UrlManager::baseUrl correctly as you are running a console application.');
}
}
return $this->_baseUrl;
}
/**
* Sets the base URL that is used by [[createUrl()]] to prepend to created URLs.
* This is mainly used when [[enablePrettyUrl]] is `true` and [[showScriptName]] is `false`.
* @param string $value the base URL that is used by [[createUrl()]] to prepend to created URLs.
*/
public function setBaseUrl($value)
{
$this->_baseUrl = $value === null ? null : rtrim(Yii::getAlias($value), '/');
}
/**
* Returns the entry script URL that is used by [[createUrl()]] to prepend to created URLs.
* It defaults to [[Request::scriptUrl]].
* This is mainly used when [[enablePrettyUrl]] is `false` or [[showScriptName]] is `true`.
* @return string the entry script URL that is used by [[createUrl()]] to prepend to created URLs.
* @throws InvalidConfigException if running in console application and [[scriptUrl]] is not configured.
*/
public function getScriptUrl()
{
if ($this->_scriptUrl === null) {
$request = Yii::$app->getRequest();
if ($request instanceof Request) {
$this->_scriptUrl = $request->getScriptUrl();
} else {
throw new InvalidConfigException('Please configure UrlManager::scriptUrl correctly as you are running a console application.');
}
}
return $this->_scriptUrl;
}
/**
* Sets the entry script URL that is used by [[createUrl()]] to prepend to created URLs.
* This is mainly used when [[enablePrettyUrl]] is `false` or [[showScriptName]] is `true`.
* @param string $value the entry script URL that is used by [[createUrl()]] to prepend to created URLs.
*/
public function setScriptUrl($value)
{
$this->_scriptUrl = $value;
}
/**
* Returns the host info that is used by [[createAbsoluteUrl()]] to prepend to created URLs.
* @return string the host info (e.g. `http://www.example.com`) that is used by [[createAbsoluteUrl()]] to prepend to created URLs.
* @throws InvalidConfigException if running in console application and [[hostInfo]] is not configured.
*/
public function getHostInfo()
{
if ($this->_hostInfo === null) {
$request = Yii::$app->getRequest();
if ($request instanceof \yii\web\Request) {
$this->_hostInfo = $request->getHostInfo();
} else {
throw new InvalidConfigException('Please configure UrlManager::hostInfo correctly as you are running a console application.');
}
}
return $this->_hostInfo;
}
/**
* Sets the host info that is used by [[createAbsoluteUrl()]] to prepend to created URLs.
* @param string $value the host info (e.g. "http://www.example.com") that is used by [[createAbsoluteUrl()]] to prepend to created URLs.
*/
public function setHostInfo($value)
{
$this->_hostInfo = $value === null ? null : rtrim($value, '/');
}
}
里面在buildRules()方法有一段正则匹配的内容：
if (preg_match("/^((?:($verbs),)*($verbs))\\s+(.*)$/", $key, $matches)) {
$rule['verb'] = explode(',', $matches[1]);
$key = $matches[4];
}
我们看个例子理解下：
$key = 'DELETE,POST <controller:\w+>/<id:\d+>';
$verbs = 'GET|HEAD|POST|PUT|PATCH|DELETE|OPTIONS';
preg_match("/^((?:($verbs),)*($verbs))\\s+(.*)$/", $key, $matches);
print_r($matches);
// 输出
Array
(
[0] => DELETE,POST <controller:\w+>/<id:\d+>
[1] => DELETE,POST
[2] => DELETE
[3] => POST
[4] => <controller:\w+>/<id:\d+>
)
$key = 'DELETE <controller:\w+>/<id:\d+>';
$verbs = 'GET|HEAD|POST|PUT|PATCH|DELETE|OPTIONS';
preg_match("/^((?:($verbs),)*($verbs))\\s+(.*)$/", $key, $matches);
print_r($matches);
// 输出
Array
(
[0] => DELETE <controller:\w+>/<id:\d+>
[1] => DELETE
[2] =>
[3] => DELETE
[4] => <controller:\w+>/<id:\d+>
)
$key = 'DELETE,POST,PUT,GET <controller:\w+>/<id:\d+>';
$verbs = 'GET|HEAD|POST|PUT|PATCH|DELETE|OPTIONS';
preg_match("/^((?:($verbs),)*($verbs))\\s+(.*)$/", $key, $matches);
print_r($matches);
// 输出
Array
(
[0] => DELETE,POST,PUT,GET <controller:\w+>/<id:\d+>
[1] => DELETE,POST,PUT,GET
[2] => PUT
[3] => GET
[4] => <controller:\w+>/<id:\d+>
)
yii\web\UrlRule 类
yii\web\UrlRule 类：
<?php
/**
* @link http://www.yiiframework.com/
* @copyright Copyright (c) 2008 Yii Software LLC
* @license http://www.yiiframework.com/license/
*/
namespace yii\web;
use Yii;
use yii\base\BaseObject;
use yii\base\InvalidConfigException;
/**
* UrlRule represents a rule used by [[UrlManager]] for parsing and generating URLs.
*
* To define your own URL parsing and creation logic you can extend from this class
* and add it to [[UrlManager::rules]] like this:
*
*
* 'rules' => [
* ['class' => 'MyUrlRule', 'pattern' => '...', 'route' => 'site/index', ...],
* // ...
* ]
*
*
* @property-read null|int $createUrlStatus Status of the URL creation after the last [[createUrl()]] call.
* `null` if rule does not provide info about create status.
*
* @author Qiang Xue <qiang.xue@gmail.com>
* @since 2.0
*/
class UrlRule extends BaseObject implements UrlRuleInterface
{
/**
* Set [[mode]] with this value to mark that this rule is for URL parsing only.
*/
const PARSING_ONLY = 1;
/**
* Set [[mode]] with this value to mark that this rule is for URL creation only.
*/
const CREATION_ONLY = 2;
/**
* Represents the successful URL generation by last [[createUrl()]] call.
* @see createStatus
* @since 2.0.12
*/
const CREATE_STATUS_SUCCESS = 0;
/**
* Represents the unsuccessful URL generation by last [[createUrl()]] call, because rule does not support
* creating URLs.
* @see createStatus
* @since 2.0.12
*/
const CREATE_STATUS_PARSING_ONLY = 1;
/**
* Represents the unsuccessful URL generation by last [[createUrl()]] call, because of mismatched route.
* @see createStatus
* @since 2.0.12
*/
const CREATE_STATUS_ROUTE_MISMATCH = 2;
/**
* Represents the unsuccessful URL generation by last [[createUrl()]] call, because of mismatched
* or missing parameters.
* @see createStatus
* @since 2.0.12
*/
const CREATE_STATUS_PARAMS_MISMATCH = 4;
/**
* @var string the name of this rule. If not set, it will use [[pattern]] as the name.
*/
public $name;
/**
* On the rule initialization, the [[pattern]] matching parameters names will be replaced with [[placeholders]].
* @var string the pattern used to parse and create the path info part of a URL.
* @see host
* @see placeholders
*/
public $pattern;
/**
* @var string|null the pattern used to parse and create the host info part of a URL (e.g. `http://example.com`).
* @see pattern
*/
public $host;
/**
* @var string the route to the controller action
*/
public $route;
/**
* @var array the default GET parameters (name => value) that this rule provides.
* When this rule is used to parse the incoming request, the values declared in this property
* will be injected into $_GET.
*/
public $defaults = [];
/**
* @var string the URL suffix used for this rule.
* For example, ".html" can be used so that the URL looks like pointing to a static HTML page.
* If not set, the value of [[UrlManager::suffix]] will be used.
*/
public $suffix;
/**
* @var string|array the HTTP verb (e.g. GET, POST, DELETE) that this rule should match.
* Use array to represent multiple verbs that this rule may match.
* If this property is not set, the rule can match any verb.
* Note that this property is only used when parsing a request. It is ignored for URL creation.
*/
public $verb;
/**
* @var int a value indicating if this rule should be used for both request parsing and URL creation,
* parsing only, or creation only.
* If not set or 0, it means the rule is both request parsing and URL creation.
* If it is [[PARSING_ONLY]], the rule is for request parsing only.
* If it is [[CREATION_ONLY]], the rule is for URL creation only.
*/
public $mode;
/**
* @var bool a value indicating if parameters should be url encoded.
*/
public $encodeParams = true;
/**
* @var UrlNormalizer|array|false|null the configuration for [[UrlNormalizer]] used by this rule.
* If `null`, [[UrlManager::normalizer]] will be used, if `false`, normalization will be skipped
* for this rule.
* @since 2.0.10
*/
public $normalizer;
/**
* @var int|null status of the URL creation after the last [[createUrl()]] call.
* @since 2.0.12
*/
protected $createStatus;
/**
* @var array list of placeholders for matching parameters names. Used in [[parseRequest()]], [[createUrl()]].
* On the rule initialization, the [[pattern]] parameters names will be replaced with placeholders.
* This array contains relations between the original parameters names and their placeholders.
* The array keys are the placeholders and the values are the original names.
*
* @see parseRequest()
* @see createUrl()
* @since 2.0.7
*/
protected $placeholders = [];
/**
* @var string the template for generating a new URL. This is derived from [[pattern]] and is used in generating URL.
*/
private $_template;
/**
* @var string the regex for matching the route part. This is used in generating URL.
*/
private $_routeRule;
/**
* @var array list of regex for matching parameters. This is used in generating URL.
*/
private $_paramRules = [];
/**
* @var array list of parameters used in the route.
*/
private $_routeParams = [];
/**
* @return string
* @since 2.0.11
*/
public function __toString()
{
$str = '';
if ($this->verb !== null) {
$str .= implode(',', $this->verb) . ' ';
}
if ($this->host !== null && strrpos($this->name, $this->host) === false) {
$str .= $this->host . '/';
}
$str .= $this->name;
if ($str === '') {
return '/';
}
return $str;
}
/**
* Initializes this rule.
*/
public function init()
{
if ($this->pattern === null) {
throw new InvalidConfigException('UrlRule::pattern must be set.');
}
if ($this->route === null) {
throw new InvalidConfigException('UrlRule::route must be set.');
}
if (is_array($this->normalizer)) {
$normalizerConfig = array_merge(['class' => UrlNormalizer::className()], $this->normalizer);
$this->normalizer = Yii::createObject($normalizerConfig);
}
if ($this->normalizer !== null && $this->normalizer !== false && !$this->normalizer instanceof UrlNormalizer) {
throw new InvalidConfigException('Invalid config for UrlRule::normalizer.');
}
if ($this->verb !== null) {
if (is_array($this->verb)) {
foreach ($this->verb as $i => $verb) {
$this->verb[$i] = strtoupper($verb);
}
} else {
$this->verb = [strtoupper($this->verb)];
}
}
if ($this->name === null) {
$this->name = $this->pattern;
}
$this->preparePattern();
}
/**
* Process [[$pattern]] on rule initialization.
*/
private function preparePattern()
{
$this->pattern = $this->trimSlashes($this->pattern);
$this->route = trim($this->route, '/');
if ($this->host !== null) {
$this->host = rtrim($this->host, '/');
$this->pattern = rtrim($this->host . '/' . $this->pattern, '/');
} elseif ($this->pattern === '') {
$this->_template = '';
$this->pattern = '#^$#u';
return;
} elseif (($pos = strpos($this->pattern, '://')) !== false) {
if (($pos2 = strpos($this->pattern, '/', $pos + 3)) !== false) {
$this->host = substr($this->pattern, 0, $pos2);
} else {
$this->host = $this->pattern;
}
} elseif (strncmp($this->pattern, '//', 2) === 0) {
if (($pos2 = strpos($this->pattern, '/', 2)) !== false) {
$this->host = substr($this->pattern, 0, $pos2);
} else {
$this->host = $this->pattern;
}
} else {
$this->pattern = '/' . $this->pattern . '/';
}
if (strpos($this->route, '<') !== false && preg_match_all('/<([\w._-]+)>/', $this->route, $matches)) {
foreach ($matches[1] as $name) {
$this->_routeParams[$name] = "<$name>";
}
}
$this->translatePattern(true);
}
/**
* Prepares [[$pattern]] on rule initialization - replace parameter names by placeholders.
*
* @param bool $allowAppendSlash Defines position of slash in the param pattern in [[$pattern]].
* If `false` slash will be placed at the beginning of param pattern. If `true` slash position will be detected
* depending on non-optional pattern part.
*/
private function translatePattern($allowAppendSlash)
{
$tr = [
'.' => '\\.',
'*' => '\\*',
'$' => '\\$',
'[' => '\\[',
']' => '\\]',
'(' => '\\(',
')' => '\\)',
];
$tr2 = [];
$requiredPatternPart = $this->pattern;
$oldOffset = 0;
if (preg_match_all('/<([\w._-]+):?([^>]+)?>/', $this->pattern, $matches, PREG_OFFSET_CAPTURE | PREG_SET_ORDER)) {
$appendSlash = false;
foreach ($matches as $match) {
$name = $match[1][0];
$pattern = isset($match[2][0]) ? $match[2][0] : '[^\/]+';
$placeholder = 'a' . hash('crc32b', $name); // placeholder must begin with a letter
$this->placeholders[$placeholder] = $name;
if (array_key_exists($name, $this->defaults)) {
$length = strlen($match[0][0]);
$offset = $match[0][1];
$requiredPatternPart = str_replace("/{$match[0][0]}/", '//', $requiredPatternPart);
if (
$allowAppendSlash
&& ($appendSlash || $offset === 1)
&& (($offset - $oldOffset) === 1)
&& isset($this->pattern[$offset + $length])
&& $this->pattern[$offset + $length] === '/'
&& isset($this->pattern[$offset + $length + 1])
) {
// if pattern starts from optional params, put slash at the end of param pattern
// @see https://github.com/yiisoft/yii2/issues/13086
$appendSlash = true;
$tr["<$name>/"] = "((?P<$placeholder>$pattern)/)?";
} elseif (
$offset > 1
&& $this->pattern[$offset - 1] === '/'
&& (!isset($this->pattern[$offset + $length]) || $this->pattern[$offset + $length] === '/')
) {
$appendSlash = false;
$tr["/<$name>"] = "(/(?P<$placeholder>$pattern))?";
}
$tr["<$name>"] = "(?P<$placeholder>$pattern)?";
$oldOffset = $offset + $length;
} else {
$appendSlash = false;
$tr["<$name>"] = "(?P<$placeholder>$pattern)";
}
if (isset($this->_routeParams[$name])) {
$tr2["<$name>"] = "(?P<$placeholder>$pattern)";
} else {
$this->_paramRules[$name] = $pattern === '[^\/]+' ? '' : "#^$pattern$#u";
}
}
}
// we have only optional params in route - ensure slash position on param patterns
if ($allowAppendSlash && trim($requiredPatternPart, '/') === '') {
$this->translatePattern(false);
return;
}
$this->_template = preg_replace('/<([\w._-]+):?([^>]+)?>/', '<$1>', $this->pattern);
$this->pattern = '#^' . trim(strtr($this->_template, $tr), '/') . '$#u';
// if host starts with relative scheme, then insert pattern to match any
if ($this->host !== null && strncmp($this->host, '//', 2) === 0) {
$this->pattern = substr_replace($this->pattern, '[\w]+://', 2, 0);
}
if (!empty($this->_routeParams)) {
$this->_routeRule = '#^' . strtr($this->route, $tr2) . '$#u';
}
}
/**
* @param UrlManager $manager the URL manager
* @return UrlNormalizer|null
* @since 2.0.10
*/
protected function getNormalizer($manager)
{
if ($this->normalizer === null) {
return $manager->normalizer;
}
return $this->normalizer;
}
/**
* @param UrlManager $manager the URL manager
* @return bool
* @since 2.0.10
*/
protected function hasNormalizer($manager)
{
return $this->getNormalizer($manager) instanceof UrlNormalizer;
}
/**
* Parses the given request and returns the corresponding route and parameters.
* @param UrlManager $manager the URL manager
* @param Request $request the request component
* @return array|bool the parsing result. The route and the parameters are returned as an array.
* If `false`, it means this rule cannot be used to parse this path info.
*/
public function parseRequest($manager, $request)
{
if ($this->mode === self::CREATION_ONLY) {
return false;
}
if (!empty($this->verb) && !in_array($request->getMethod(), $this->verb, true)) {
return false;
}
$suffix = (string) ($this->suffix === null ? $manager->suffix : $this->suffix);
$pathInfo = $request->getPathInfo();
$normalized = false;
if ($this->hasNormalizer($manager)) {
$pathInfo = $this->getNormalizer($manager)->normalizePathInfo($pathInfo, $suffix, $normalized);
}
if ($suffix !== '' && $pathInfo !== '') {
$n = strlen($suffix);
if (substr_compare($pathInfo, $suffix, -$n, $n) === 0) {
$pathInfo = substr($pathInfo, 0, -$n);
if ($pathInfo === '') {
// suffix alone is not allowed
return false;
}
} else {
return false;
}
}
if ($this->host !== null) {
$pathInfo = strtolower($request->getHostInfo()) . ($pathInfo === '' ? '' : '/' . $pathInfo);
}
if (!preg_match($this->pattern, $pathInfo, $matches)) {
return false;
}
$matches = $this->substitutePlaceholderNames($matches);
foreach ($this->defaults as $name => $value) {
if (!isset($matches[$name]) || $matches[$name] === '') {
$matches[$name] = $value;
}
}
$params = $this->defaults;
$tr = [];
foreach ($matches as $name => $value) {
if (isset($this->_routeParams[$name])) {
$tr[$this->_routeParams[$name]] = $value;
unset($params[$name]);
} elseif (isset($this->_paramRules[$name])) {
$params[$name] = $value;
}
}
if ($this->_routeRule !== null) {
$route = strtr($this->route, $tr);
} else {
$route = $this->route;
}
Yii::debug("Request parsed with URL rule: {$this->name}", __METHOD__);
if ($normalized) {
// pathInfo was changed by normalizer - we need also normalize route
return $this->getNormalizer($manager)->normalizeRoute([$route, $params]);
}
return [$route, $params];
}
/**
* Creates a URL according to the given route and parameters.
* @param UrlManager $manager the URL manager
* @param string $route the route. It should not have slashes at the beginning or the end.
* @param array $params the parameters
* @return string|bool the created URL, or `false` if this rule cannot be used for creating this URL.
*/
public function createUrl($manager, $route, $params)
{
if ($this->mode === self::PARSING_ONLY) {
$this->createStatus = self::CREATE_STATUS_PARSING_ONLY;
return false;
}
$tr = [];
// match the route part first
if ($route !== $this->route) {
if ($this->_routeRule !== null && preg_match($this->_routeRule, $route, $matches)) {
$matches = $this->substitutePlaceholderNames($matches);
foreach ($this->_routeParams as $name => $token) {
if (isset($this->defaults[$name]) && strcmp($this->defaults[$name], $matches[$name]) === 0) {
$tr[$token] = '';
} else {
$tr[$token] = $matches[$name];
}
}
} else {
$this->createStatus = self::CREATE_STATUS_ROUTE_MISMATCH;
return false;
}
}
// match default params
// if a default param is not in the route pattern, its value must also be matched
foreach ($this->defaults as $name => $value) {
if (isset($this->_routeParams[$name])) {
continue;
}
if (!isset($params[$name])) {
// allow omit empty optional params
// @see https://github.com/yiisoft/yii2/issues/10970
if (in_array($name, $this->placeholders) && strcmp($value, '') === 0) {
$params[$name] = '';
} else {
$this->createStatus = self::CREATE_STATUS_PARAMS_MISMATCH;
return false;
}
}
if (strcmp($params[$name], $value) === 0) { // strcmp will do string conversion automatically
unset($params[$name]);
if (isset($this->_paramRules[$name])) {
$tr["<$name>"] = '';
}
} elseif (!isset($this->_paramRules[$name])) {
$this->createStatus = self::CREATE_STATUS_PARAMS_MISMATCH;
return false;
}
}
// match params in the pattern
foreach ($this->_paramRules as $name => $rule) {
if (isset($params[$name]) && !is_array($params[$name]) && ($rule === '' || preg_match($rule, $params[$name]))) {
$tr["<$name>"] = $this->encodeParams ? urlencode($params[$name]) : $params[$name];
unset($params[$name]);
} elseif (!isset($this->defaults[$name]) || isset($params[$name])) {
$this->createStatus = self::CREATE_STATUS_PARAMS_MISMATCH;
return false;
}
}
$url = $this->trimSlashes(strtr($this->_template, $tr));
if ($this->host !== null) {
$pos = strpos($url, '/', 8);
if ($pos !== false) {
$url = substr($url, 0, $pos) . preg_replace('#/+#', '/', substr($url, $pos));
}
} elseif (strpos($url, '//') !== false) {
$url = preg_replace('#/+#', '/', trim($url, '/'));
}
if ($url !== '') {
$url .= ($this->suffix === null ? $manager->suffix : $this->suffix);
}
if (!empty($params) && ($query = http_build_query($params)) !== '') {
$url .= '?' . $query;
}
$this->createStatus = self::CREATE_STATUS_SUCCESS;
return $url;
}
/**
* Returns status of the URL creation after the last [[createUrl()]] call.
*
* @return null|int Status of the URL creation after the last [[createUrl()]] call. `null` if rule does not provide
* info about create status.
* @see createStatus
* @since 2.0.12
*/
public function getCreateUrlStatus()
{
return $this->createStatus;
}
/**
* Returns list of regex for matching parameter.
* @return array parameter keys and regexp rules.
*
* @since 2.0.6
*/
protected function getParamRules()
{
return $this->_paramRules;
}
/**
* Iterates over [[placeholders]] and checks whether each placeholder exists as a key in $matches array.
* When found - replaces this placeholder key with a appropriate name of matching parameter.
* Used in [[parseRequest()]], [[createUrl()]].
*
* @param array $matches result of `preg_match()` call
* @return array input array with replaced placeholder keys
* @see placeholders
* @since 2.0.7
*/
protected function substitutePlaceholderNames(array $matches)
{
foreach ($this->placeholders as $placeholder => $name) {
if (isset($matches[$placeholder])) {
$matches[$name] = $matches[$placeholder];
unset($matches[$placeholder]);
}
}
return $matches;
}
/**
* Trim slashes in passed string. If string begins with '//', two slashes are left as is
* in the beginning of a string.
*
* @param string $string
* @return string
*/
private function trimSlashes($string)
{
if (strncmp($string, '//', 2) === 0) {
return '//' . trim($string, '/');
}
return trim($string, '/');
}
}
在 init() 方法中有一段正则匹配的内容：
preg_match_all('/<(\w+)>/', $this->route, $matches)
我们看个例子理解下：
$route = "<controller>/<action>";
preg_match_all('/<(\w+)>/', $route, $matches);
print_r($matches);
// 输出
Array
(
[0] => Array
(
[0] => <controller>
[1] => <action>
)
[1] => Array
(
[0] => controller
[1] => action
)
)
$route = "<controller>/delete";
preg_match_all('/<(\w+)>/', $route, $matches);
print_r($matches);
// 输出
Array
(
[0] => Array
(
[0] => <controller>
)
[1] => Array
(
[0] => controller
)
)
$route = "user/profile";
preg_match_all('/<(\w+)>/', $route, $matches);
print_r($matches);
// 输出
Array
(
[0] => Array
(
)
[1] => Array
(
)
)
还有一段：
preg_match_all('/<(\w+):?([^>]+)?>/', $this->pattern, $matches, PREG_OFFSET_CAPTURE | PREG_SET_ORDER)
看个例子理解下：
$pattern = "/post/<action:\w+>/<id:\d+>/";
preg_match_all('/<(\w+):?([^>]+)?>/', $pattern, $matches, PREG_OFFSET_CAPTURE | PREG_SET_ORDER);
print_r($matches);
// 输出
Array
(
[0] => Array
(
[0] => Array
(
[0] => <action:\w+>
[1] => 6
)
[1] => Array
(
[0] => action
[1] => 7
)
[2] => Array
(
[0] => \w+
[1] => 14
)
)
[1] => Array
(
[0] => Array
(
[0] => <id:\d+>
[1] => 19
)
[1] => Array
(
[0] => id
[1] => 20
)
[2] => Array
(
[0] => \d+
[1] => 23
)
)
)
$pattern = "<controller>/delete";
preg_match_all('/<(\w+):?([^>]+)?>/', $pattern, $matches, PREG_OFFSET_CAPTURE | PREG_SET_ORDER);
print_r($matches);
// 输出
Array
(
[0] => Array
(
[0] => Array
(
[0] => <controller>
[1] => 0
)
[1] => Array
(
[0] => controller
[1] => 1
)
)
)
$pattern = "user/profile";
preg_match_all('/<(\w+):?([^>]+)?>/', $pattern, $matches, PREG_OFFSET_CAPTURE | PREG_SET_ORDER);
print_r($matches);
// 输出
Array
(
)
附图
参考资料
深入理解Yii2.0 » 请求与响应(TBD) » Url管理
http://www.digpage.com/urlmanager.html