Help:替换引用

注意：當您編輯本頁面時，即同意以CC0協議授權您的貢獻。您可以在公有領域帮助页面找到更多信息。 此頁面的部分舊修訂版本是在知识共享署名-相同方式共享（CC BY-SA）許可下导入的。 只有新的貢獻採用公有領域授權。

替换引用是在wikitext引用了某个或多个模板、变量或解析器函数的情況下，當页面保存时所进行的wikitext自动转换。

在替换模板时，模板的调用将替换为模板的内容，并替换其中的参数。 因此，模板被當作巨集般地使用，且該页面在保存时被巨集展開，而不是像常見的那样，是页面在浏览时才被巨集展開。

在变量的替换或解析器函数的替换這種情况，变量或解析器函数的參考(reference)将會被结果值替换。

替换的方法是将魔法字subst:、或safesubst:放在二個大括號之后、中间不留空格，如示例：{{subst:FULLPAGENAME}}和{{safesubst:FULLPAGENAME}}。 指令safesubst:在多级替换中很有用，请参阅下面。

可以在保存前（或不保存）按下“显示更改”键，會出現（与現存的维基文本的差异）结果。 然而，如果文本涉及一个以上的段落，由于页边有加号，这种差異页就不太适合复制结果（例如，在不保存每一步的情况下进行逐步替换）。

应用

模板的替换：

• 使得呈現的页面與模板无关：
  • 在模板被编辑之时，已呈現的页面不会被改变。
  • 可以复制页面到另一个MediaWiki的wiki，而无需連同模板一起复制。
• 使得页面的呈現更容易，从而服务器的速度也更快。
• 分析并演示模板的工作情形。 然而，在某些情况下，替換的工作方式是截然不同的。
• 使得维基文本和被呈現页面之间的对应关系更容易理解（這也許适用，也可能正好相反）。

时间依赖变量的替换：

• 使得呈現的页面與时间无关。

页面依赖变量的替换：

• 使得呈現的页面不受页面重命名和复制wikitext到其他页面的影响（如果在页面的非包含部份使用变量PAGENAME来包含页面本身，则情况相反）。

有些 MediaWiki 扩展有这样的限制：如果在带参数的模板中使用这些扩展，它们只能在模板被替换后才能運作。

概要

在討論替换的時候，「普通模板」是指，若不是以{{subst:pagename }}(針對模板命名空間中的頁面)，就是以{{subst:fullpagename }}(針對其他命名空間中的頁面)的模式來引用的頁面。 「預先定義的模板」是指，以類似方式替换的變數或解析器函數。

替換是一個獨立的過程，早於任何一個：非替換的模板、變數、解析器函數、或參數，的擴張之前執行。

某個替换调用可以嵌入其它的替换调用到它的裏面。 同樣地，某個替換的被替換模板也可以包含其他替換调用。 會先對這些表達式進行替換：在模板或解析器函數名稱中的表達式、在被替換的模板的參數定義或解析器函數的參數定義中的表達式、以及在被替換的模板的正文中的表達式。

由於擴張是稍後才進行的，因此任何在替換中使用的表達式，如果碰巧包含有成對的雙大括號，則大括號會被視為純文字。 因此，在替換過程中，替換呼叫中帶大括弧的參數名稱 (例如 {{subst:foo|a{{bc}}d=...}}) 可能與模板內的正文的同名參數 (例如 {{{a{{bc}}d}}}) 相吻合。

如果嘗試對不存在之類的模板執行替換，則不會有替換，前綴「subst:」會保留在 wikitext 中。

在替換過程之後，對模板的擴張之類、以及其他對結果wikitext的那些處理，都會照常運作。 由於替換已經結束，因此無法撤銷在替換過程中發生的參數名稱不匹配（請參閱下面的「部份替換」一節）。

只有在下列內容完全求得值之後，才有可能進行替換：

• 模板、变量、或解析器函数的名称
• 在模板的情況下：模板呼叫和模板本身中的參數名稱
• 在#if, #ifexpr, #ifexist和#iferror的情況下，冒號後的參數
• 在#ifeq的情況下，冒號後的參數和下一個參數
• 在#switch的情況下，冒號後的參數和等號左側的表達式

由於如前所述，替換是在其他擴張之前進行的，因此如果表達式涉及非替換的擴張，則上述所需的求值並未進行。

此外，在其他解析器函數的情況下，冒號之後的參數若未完全求值，會導致解析器函數套用於帶大括弧的 wikitext，而非擴張後的wikitext，進而影響了結果。

例如：

• {{subst:Help:L{{tc}}k}} using Template:tc, does not do substitution, because Help:L{{tc}}k is not an existing page, although Help:L{{tc}}k is rendered as Help:Link. Thus the resulting wikitext is the same as the original wikitext and rendered as {{subst:Help:Link}}.
• {{#if:{{void|abc}}|yes|no}} (using Template:void) is rendered as "no", and so {{subst:#if:{{subst:void|abc}}|yes|no}} similarly gives the wikitext "no". On the other hand, {{subst:#if:{{void|abc}}|yes|no}} gives the wikitext "yes", because Template:void is not resolved until after substitution.

In principle the wikitext resulting from full substitution is, immediately after that, rendered the same as the wikitext with ordinary inclusion.

Note however that on substitution of a parser function, an undefined parameter with default, used in a parameter value, is not replaced by the default (in English Wikipedia), and is for example not allowed in the numerical expression evaluated on substitution of #expr:

• {{#expr:2*{{{p|3}}}}} gives 6, while {{subst:#expr:2*{{{p|3}}}}} gives:

On substitution of a template that contains this, {{{p|3}}} is either replaced by the value of {{{p}}} or by 3, so then there is no complication.

{{ {{t6}} }} using Template:t6 containing "t2demo|a<noinclude>[[Category:Demo templates]]</noinclude>" is rendered as {{ t2demo|a }}. {{subst:{{subst:t6}} }} gives the wikitext {{subst:t2demo|a }} rendered the same as the wikitext, and on the next edit/save changed into start-a -middle{{2}}end. {{ {{subst:t6}} }} gives the wikitext {{ t2demo|a }}, rendered as start-a -middle{{2}}end. This is because, both without substitution and in the case of full substitution, the pipe characters in template calls, excluding those inside inner template calls, template parameters, links, and image tags, determine the separation of parameter definitions from each other and from the template name. This separation does not depend on possible extra pipe characters in the expanded form of the template name and parameter definitions. However, if after substitution of an inner template the pipe character is in the outer template call it is one like any other and plays its part in determining the separation. In other words, parsing is done first once for substitution, and then once for rendering, but in both cases not an extra time in between. In the case of substitution of the inner template only, two subsequent parsings are effective.

When substituting a template containing {{{p|q}}} (a parameter tag with default) this results in the value of p if it is defined, and otherwise in q. For example, using {{timc|t pd}} (in English Wikipedia), {{subst:t pd}} gives the wikitext 2. If a page substitutes itself (e.g. in the noinclude-part of a template page) it substitutes the old version.

注意事项

As mentioned, a change of an ordinary template after substitution does not affect the page in which it was substituted, and a substituted variable depending on time no longer depends on time, etc. However, a substitution of e.g. {{#expr:2*3}} does not affect rendering at all.

The relationship between wikitext of a page and its rendering can become easier to understand after substitution, because one has all wikitext together, and parameter substitutions have been performed.

It can also become more complex. Separately focusing on understanding a template call and understanding the template content can be easier. Wikitext after substitution is often more complex than when the required wikitext would have been written directly.

Unlike a template call (if one knows about templates), wikitext after substitution does not show how one can produce a similar result. The wikitext can be long and complicated, and therefore cumbersome to write directly, or it can be simple, e.g. a number resulting from a computation, but cumbersome to find directly. When studying the wikitext of a page one may think that this wikitext is what one is supposed to write and find directly to get the result, even in cases where that would be very impractical.

In such cases documentation of the template call is useful. Just like in computer programming we change the source code and/or the data to produce new results, and we do not directly change the object file, here we would change the template calls and/or the templates, instead of changing the wikitext resulting from substitution directly.

普通模板

In the case of substituting an ordinary template, the template tag is replaced by the wikitext of the template, with the parameter values substituted for the parameters.

Example: m:Template:t2, containing

start-{{{1}}}-middle-{{{2}}}-end

and called as {{subst:t2|[[a]]|{{tc}}}} (see {{Tc }}) gives the wikitext:

start-[[a]]-middle-{{tc}}-end, rendering as

start-a-middle-in-end.

Substitution removes the noinclude parts and the includeonly tags.

Parameters:

• A substitution with p=r replaces {{{p}}} and {{{p|q}}} by r. This includes the cases that r is of the form {{{s}}} or {{{s|t}}}.
• A substitution with undefined p preserves {{{p}}} and replaces {{{p|q}}} by the default q (in English Wikipedia).

With subst: the replacement of a template tag by wikitext does not work recursively. For full recursive substitution use Special:ExpandTemplates. See also substall, and multilevel substitution below.

Stepwise substitution of templates including other templates including more templates etc. can be useful for analyzing and documenting the behaviour of complex templates.

However, after a substitution a page may render differently, e.g. if templates produce braces, pipes, and/or equals signs which after substitution determine expansion of other templates, but without substitution are treated as plain text.

In the absence of parameters, template substitution can be compared with copying the wikitext, or the rendering of a previewed or saved {{ msgnw:pagename }} inclusion. However, template substitution excludes ‎<noinclude> parts, removes ‎<includeonly> tags, and replaces undefined parameters with defaults by those defaults.

预定义模板

In the case of substituting a predefined template, without parameters depending on other templates, the tag is replaced by the result.

subst: has to be added directly in front of the predefined template name without intervening spaces.

Applying subst to a variable works like applying it to a template. E.g. a timestamp:

{{subst:CURRENTYEAR}}-{{subst:CURRENTMONTH}}-{{subst:CURRENTDAY}} T {{subst:CURRENTTIME}} [[w:UTC|]]

may give the wikitext

2010-04-10 T 06:30 [[w:UTC|UTC]]

rendered as

2010-04-10 T 06:30 UTC

In the case of substituting a predefined template with a parameter depending on another template, that has to be substituted too, with a separate subst: modifier, otherwise the result is undefined.

• {{subst:UC:{{subst:tc}}}} - gives IN, the same wikitext as {{UC:{{tc}}}} is expanded to; UC: is applied to the output "in" of Tc.
• {{subst:ns:{{subst:#expr:2*3}}}} - gives File.
• {{ns:{{subst:#expr:2*3}}}} - gives wikitext {{ns:6}} rendered as File.
• {{subst:t1|{{subst:NAMESPACE}}}} - gives the wikitext startHelpend (see {{T1 }})
• {{subst:t1|{{subst:#expr:3*4}}}} - gives the wikitext start12end
• {{subst:t1|{{subst:uc:AbCdEf}}}} - gives the wikitext startABCDEFend
• {{subst:#expr:{{subst:3X|11*}}1}} - gives the wikitext 1331
• {{subst:UC:{{subst:3X|abc}}}} - gives the wikitext ABCABCABC
• {{subst:LC:{{subst:#expr:1/100000}}}} - gives the wikitext 1e-05
• {{subst:#expr:2*{{subst:CURRENTDAY}}}} - gives (at the time of writing) the wikitext 30
• {{subst:UC:{{subst:CURRENTDAYNAME}}}} - gives (at the time of writing) the wikitext THURSDAY

However:

1. {{subst:UC:{{tc}}}} - gives the wikitext {{TC}} rendered as Template:TC.
2. {{subst:ns:{{#expr:2*3}}}} - stays {{subst:ns:{{#expr:2*3}}}}, rendered as {{subst:ns:6}}.

As mentioned before, on substitution, all calls without substitution of templates, variables, and parser functions are treated as plain text.

As a result substitution of the outer x: in a nested {{ x:...{{ y:...}} }} often is only suitable if all inner y: are also substituted.

In the case of substitution of a predefined template, if the expression for one of its parameters contains {{{p|3}}} with undefined p, this code reduces to 3. However, on the page itself, {{{p|3}}} is treated as such, not as 3.

Examples:

• {{#expr:2*{{{p}}}}} →
• {{#expr:2*{{{p|3}}}}} → 6
• {{subst:#expr:2*{{{p|3}}}}} →
• substituting a template containing {{<includeonly>subst:</includeonly>#expr:2*{{{p|3}}}}} gives 6 if p is not assigned a value, and twice the number p if it is assigned a value.
• the same result can be obtained from a template containing {{{{{subst}}}#expr:2*{{{p|3}}}}}, if the substitution call has a parameter of "subst=subst:".

Compare:

• {{uc:2*{{{p}}}}} → 2*{{{P}}}
• {{uc:2*{{{p|q}}}}} → 2*Q
• {{subst:uc:2*{{{p|q}}}}} → the wikitext 2*{{{P|Q}}} rendered as 2*Q

and also (from above):

• {{subst:UC:{{subst:tc}}}} - gives IN, just like {{UC:{{tc}}}} does; UC is applied to the output "in" of Tc.
• {{subst:UC:{{tc}}}} - gives the wikitext {{TC}} rendered as Template:TC.

In the substitution of UC, the inclusion tag {{tc}} is treated as string just like {{{p|q}}}.

部份替換

Inside an ordinary template one can apply substitution to an ordinary template call containing a parameter, to replace it by the direct wikitext containing the parameter. It amounts to automatically merging the two templates (creating a "composite template" like a composite function). It is not possible if the inner and/or outer template is predefined. (However, manually merging e.g. a call of #expr inside another one is useful for increasing the accuracy of the result by avoiding intermediate rounding to 12 digits.)

This way one can dispense with the optional substitution technique described below, and apply substitution of the resulting outer template by simply using subst: (unless there are more nesting levels).

Example:

• {{subst:t}} - gives the wikitext start-{{{1|pqr}}}-end, just that of m:Template:t, without noinclude parts and includeonly tags
• {{subst:t|a{{{p|q}}}b}} - gives the wikitext start-a{{{p|q}}}b-end

Examples with double substitution:

• {{subst:3X|{{subst:t}}}} - gives the wikitext start-{{{1|pqr}}}-endstart-{{{1|pqr}}}-endstart-{{{1|pqr}}}-endstart-{{{1|q}}}-end
• {{subst:3X|{{subst:t|{{{1|q}}}}}}} - gives the wikitext start-{{{1|q}}}-endstart-{{{1|q}}}-endstart-{{{1|q}}}-end

多级替换

When substituting a template it may be desirable to carry out a substitution inside the template too. This can be done with safesubst: in the template. To prevent premature substitution (i.e., when the template is saved), it is possible to append the ‎<noinclude /> directive after the substitution directive – i.e. safesubst:<noinclude />. Another solution is to use the default value of an unused parameter. Often the empty string works, i.e. {{{|safesubst:}}}, however it is sometimes used by modules that call templates or for inserting comments.

The difference with subst:<noinclude /> is that safesubst:<noinclude />, evaluating to safesubst: not only allows multilevel substitution but also multilevel transclusion, because on transclusion it is ignored. To make the template such that it allows the choice between these two options as well as one-level substitution (and more choices if more templates, variables, and/or parser functions are involved) one or more parameters are needed, see below.

Multilevel substitution with independent control of each substitution separately

A parameter subst (or more, each with its own name) can be used with safesubst: and the empty string as possible values. Thus we can for example control whether an inner template is substituted too when the outer template is substituted. Either possibility can be made the default.

Inner templates with parameters may control further inner substitutions in the same way; these parameters may depend on the substitution parameter controlling the substitution of the inner template, since if that is not substituted, inner substitutions within that template are not possible.

Similarly, if there are multiple templates, variables, and/or parser functions in the inner template(s) we can control substitution of all, either independently by using different parameters, or with some or all using the same parameter.

For example, if template T uses parameter subst1:

• with the empty string as default, T calls inner templates and parser functions prefixing their names with {{{subst1|}}}; for calling T we can use:
  • {{t|..}} - no substitution
  • {{subst:t|..}} - one-level substitution
  • {{subst:t|subst1=subst:|..}} - two-level substitution
  • {{subst:t|subst1=safesubst:|..}} - ditto
• with default "safesubst:", T calls inner templates and parser functions prefixing their names with {{{subst1|safesubst:}}}; for calling T we can use:
  • {{t|..}} - no substitution
  • {{subst:t|subst1=|..}} - one-level substitution
  • {{subst:t|..}} - two-level substitution

To transfer the choice of substituting or not to templates and parser functions called inside the inner templates of T, we can add to the call of these inner templates something of the form subst2={{{subst1|}}} or subst2={{{subst1|safesubst:}}}, respectively (variables and parser functions don't get the additional parameter).

Partial substitution

Using a template prepared for optional subst=subst: only with ordinary substitution, without specifying parameter values, allows to insert its code into another template, like copy and paste, but all ‎<noinclude> parts and ‎<includeonly> keywords automatically stripped.

Executing inserted code instead of calling it may be more efficient for the server.

A typical example for this technique is expanding, within another template, a template used as test expression in a #switch: like m:Template:len:

1. Development code:
   {{#switch: {{len|parameter tag}}|0=case 0 etc.}}
2. Standard solution:
   {{{{{subst|}}}#switch: {{{{{subst|}}}len|parameter tag|subst={{{subst|}}}}}|0=case 0 etc.}}
3. Better solution: create template code by applying substitution using this wikitext:
   {{{{{subst|}}}#switch: {{subst:len|parameter tag}}|0=case 0 etc.}}

m:Template:len is prepared for optional substitution, therefore both solutions work, but the latter solution substituting its code is simpler and more efficient.

See m:Template:csn and m:Template:lz12 for cases where Template:len was substituted in this way.

If a template uses a parameter whose name is an expression containing a template or parser function, and the template is called with a corresponding parameter definition (in terms of the final name of the parameter) it expands properly only if at the time of expansion of the template the expression for the name of the parameter is or has been evaluated. Thus if the template is substituted without substituting the expression for the parameter name, the parameter definition is "lost", so the parameter becomes undefined. Therefore in such a case no substitution can give the same rendered result as full substitution, while partial substitution gives a different result. See e.g. m:Template:ts1.

Composite operations

By {{A|{{B|p}}}} a template A is called with, as parameter, a call of template B with a parameter p. We could integrate such template calls to a single call {{C|p}} of a "composite template" C with parameter p.

The wikitext for template C would be {{A|{{B|{{{1}}}}}}}, or with optional substitution the following construct :

{{ {{{subst|}}} A|{{ {{{subst|}}} B|{{{1}}} |subst={{{subst|}}} }} |subst={{{subst|}}} }}

The subst={{{subst|}}} is only necessary for recursive substitution as explained above.

Note that it is not useful to specify {{subst|subst:}} since in the substitution phase this tag does not reduce to the default subst:.

If A and/or B is predefined the construct is similar, but without subst={{{subst|}}} for that template.

includeonly

An alternative method to prevent premature substitution, known as "includeonly subst magic", is with a pair of includeonly tags. Substitution is prevented by having the template call inside these tags. Substitution is also prevented by having one or both tags anywhere in the template call except inside a parameter definition. Thus the tag(s) can be before, inside, or after safesubst: or subst:, or inside or after the template name. The positions of the two tags only influence the rendering of the template page itself.

The form {{<includeonly>safesubst:</includeonly>something}} suggests that substitution is prevented by discarding safesubst: on the page itself, but actually substitution is prevented because the safesubst-syntax is disturbed by the tags.

It doesn't substitute "something" at the time of the creation of the relevant template, but has the desired effect when the template is substituted.

For examples see "preload" in Extension:InputBox and "substitution" in Help:Magic words .

Creating a page which applies substitution on the next save

See Manual:Recursive conversion of wikitext .

Forced substitution

Some templates deliberately refuse to work without substitution, for an example see w:Template:en. This technique is essential for templates like w:Template:en producing some kind of timestamp, e.g. adding pages to dated categories.

The following code in any template T outputs a warning unless recursive substitution with subst=subst: is in effect:

{{{{{subst|}}}ifdef|{{{{{subst|subst:}}}ns:0}}|'''Warning'''}}.

1. Output for {{T}} or {{subst:T}} - Warning
2. Output for {{T|subst=subst:}} - Warning
3. Output for {{subst:T|subst=subst:}} - nothing (no remaining wikitext)

This is a rare case where replacing ifdef by #if: doesn't work directly.

Substitution of part of the parameters

Let template Feelings use parameters 1 and 2. Consider creating a template Emotions with one parameter 1, corresponding to Feelings, with a given value love of parameter 2. Compare {{Feelings|2=love}} and {{Feelings|1={{{1}}}|2=love}}. They look the same on the template page, see e.g. m:Template:t ps, but the first does not work because {{{1}}} is treated as text, not as parameter.

However, with substitution (using subst: or Special:Expandtemplates) the resulting wikitext is the same, without distinction between a text {{{1}}} and a parameter, it is a parameter anyway, so 1={{{1}}} is not needed.

If Feelings contains e.g. #expr with an expression containing both parameters the same applies, except that we can only substitute the highest level (Feelings), not the parser function, so we cannot use Special:Expandtemplates.

In general, substituting a parameter and applying a template or parser function sometimes gives the same result as substituting the template or parser function with the triple-braced parameter code and then substituting the parameter.

Without defaults (all rendered the same in one-step substitution as without substitution):

Examples with equality:

• Feelings template containing With {{{1}}} one can {{{2}}}
  • When substituted with 1=love, 2=help, it gives With love one can help.
  • When substituted with 2=help, it gives With {{{1}}} one can help. This itself, when substituted with 1=compassion, it gives With compassion one can help.
• Two-level substitution of a template containing {{#if:{{{4}}}|{{{3}}}p}}.
  • When substituted with 3=u, 4=v, it gives up.
  • When substituted with 4=v, it gives {{{3}}}p. This itself, when substituted with 3=u, it gives up.

Examples without equality:

• Two-level substitution of a template containing {{#if:{{{3}}}|{{{4}}}p}}
  • When substituted with 3=, 4=v, it gives the empty string.
  • When substituted with 4=v, it gives vp. This itself, when substituted with 3=u, it remains vp.
• Two-level substitution of a template containing {{#if:{{{2}}}|{{{1}}}p}}
  • When substituted with 1=u, 2=v, it gives up.
  • When substituted with 2=v, it gives {{{1}}}pp (the bug). This itself, when substituted with 3=u, it gives upp.
• Two-level substitution of a template containing {{#expr:{{{1}}}*{{{2}}}}}
  • When substituted with 1=7, 2=8, it gives 56.
  • When substituted with 2=8, it gives . This itself, when substituted with 1=7, it remains the same.

Thus without equality we may or may not get an error message.

One example shows that substitution of one parameter can be affected by the bug mentioned above. However, we can then replace e.g. {{{1}}} by {{{1{{{{{substvoid|}}}void}}}}} and do full substitution, except that substvoid is undefined, preventing the bug. The result works already correctly with transclusion. Subsequently it can be substituted with substvoid=subst: so that we get the plain {{{1}}}.

With defaults:

Rendered the same as without substitution:

• Two-level substitution of a template containing With {{{1|love}}} one can {{{2}}} with 2=help gives With {{{1|love}}} one can help.
• Two-level substitution of a template containing {{#if:{{{4}}}|{{{3|d}}}p}} with 4=v gives dp.

Not rendered the same as without substitution:

• Two-level substitution of a template containing {{#if:{{{3|}}}|{{{4}}}p}} with 4=v gives vp.
• Two-level substitution of a template containing {{#if:{{{2}}}|{{{1|d}}}p}} with 2=v gives dpp (the bug).
• Two-level substitution of a template containing {{#expr:{{{1|6}}}*{{{2}}}}} with 2=8 gives:

After substitution with the parameter definition:

• {{subst:#if:{{{3|}}}|vp}} → vp
• {{subst:#if:v|{{{1|d}}}p}} → dpp (the bug)
• {{subst:#expr:{{{1|6}}}*8}} →

Rewritten:

• {{subst:#if:{{subst:#ifeq:{{{3|+}}}|{{{3|-}}}|vp}}}} → the empty string
• {{subst:#if:v|{{subst:#ifeq:{{{1|+}}}|{{{1|-}}}|{{{1}}}|d}}p}} → dp
• {{subst:#expr:{{subst:#ifeq:{{{1|+}}}|{{{1|-}}}|{{{1}}}|6}}*8}} → 48

限制

引用替换在‎<ref>...‎</ref>和‎<gallery>...‎</gallery>等解析器标签中不可用。 如果你输入{{subst:foo}}，它将不会被替换也不会被嵌入，而是解析为普通文本。

文档替换

通过subst:使用模板不会自动显示在页面的历史记录中。 因此在编辑摘要中提供包含“subst:”的维基文本特别有用。

此外，有被替换的模板的页面不会显示在链入页面中，该模板也不会显示在编辑页面上的嵌入模板列表中。 The template could add pages to a category to track substitutions, but listing this category on a page may clutter the list of content-based categories the page is in. Also, comments outside noinclude tags are included in the wikitext. 因此注释可用于提示模板。 它甚至可以包含参数的值，因为参数的替换即使在注释中也有效。

参见

• Help:Substitution/tl;dr – tl;dr
• modifier
• w:Wikipedia:Template substitution – partly technical, partly policy
• Phabricator:T4003 – feature request to allow marking a template as being substituted without subst:
• Templates containing a call to itself with subst: and producing a similar call with updated info, either replacing or adding to the previous info:
  • m:Template:last edit
  • m:Template:page history
• The pipe trick, which behaves similarly to template substitution