#ifeq parser function that checks a template parameter. If the parameter is empty or false, the function returns nothing; otherwise, it renders the full HTML table. This approach keeps your templates clean and allows for conditional display without duplicating code blocks.
Understanding the Core Mechanism
The foundation of this technique relies on two specific MediaWiki features: the #ifeq parser function and the <includeonly> tag. The #ifeq function compares its first argument to its second argument. If they are equal, it outputs the third argument; if not, it outputs the fourth. By setting the "equal" condition to return the table HTML and the "not equal" (or empty) condition to return nothing, you achieve the hiding effect.
However, simply using #ifeq is not enough if you want to maintain valid wiki syntax during editing. You must wrap the entire table structure in <includeonly> tags. This ensures that when users view the source code of the page, they see the raw table markup for editing purposes, but when the page is rendered, the content is processed according to the logic defined inside those tags. Without <includeonly>, the table might appear broken or malformed in edit mode.
Step-by-Step Implementation
To implement this solution, follow these steps to create a reusable template that hides its table based on a parameter.
- Create a New Template: Navigate to
Template:ConditionalTable(or your preferred name). This will be the container for your logic. - Define the Parameter: Start with a check to see if the parameter exists. Use
{{#if:{{{1|}}}|...to handle cases where no parameter is passed at all. - Wrap the Table: Inside the true branch of the
#ifstatement, place your<includeonly>block containing the#ifeqlogic. - Construct the #ifeq Logic: The structure should look like this:
<includeonly>{{#ifeq|{{{param|}}}|show|<table>...</table>||}}</includeonly>.
Here is the concrete code structure you should use:
<includeonly>
{{#ifeq: {{{show_table|}}} | yes |
<table class="wikitable">
<tr>
<th>Header 1</th>
<th>Header 2</th>
</tr>
<tr>
<td>Data A</td>
<td>Data B</td>
</tr>
</table>
|
}}
</includeonly>In this example, the table only appears if the parameter show_table is explicitly set to yes. If you call the template with {{{ConditionalTable|show_table=yes}}}, the table renders. If you call it with {{{ConditionalTable}}} or {{{ConditionalTable|show_table=no}}}, nothing is displayed.
Best Practices for Maintenance
When building complex templates, readability is crucial. Always use the pipe character (|) to separate parameters cleanly. It is also highly recommended to provide default values for your parameters to avoid unexpected behavior. For instance, using {{{show_table|no}}} ensures that even if the parameter is omitted entirely, the default state is "hidden," which is often the safer default for optional data displays.
Consider how this interacts with other templates. If your table contains nested templates, ensure they are also wrapped appropriately or called within the conditional scope. Otherwise, nested templates might render even when the parent table is hidden, leading to orphaned content. For more advanced scenarios involving multiple conditions, you might explore related techniques for managing table visibility. See Displaying and Hiding MediaWiki Tables Based on Parameter for deeper insights into variable handling.
Common Pitfalls and Debugging
A frequent error is forgetting the <includeonly> tags. Without them, the table markup becomes part of the visible source text for editors, making the wiki page difficult to read and edit. Another common issue is whitespace. Ensure there are no stray spaces between the #ifeq function and the table start tag, as this can sometimes cause rendering issues in older MediaWiki versions.
If your table does not appear when you expect it to, check the parameter name spelling. MediaWiki parameters are case-sensitive. Also, verify that you are not accidentally passing an empty string instead of a null value. Using {{#if:{{{param|}}}|... is generally safer than relying solely on #ifeq because it handles the absence of the parameter more gracefully.
Frequently Asked Questions
Can I hide the table if the parameter is 'no'?
Yes, you can reverse the logic by swapping the arguments in the #ifeq function. Set the second argument to no and place the table in the third argument (the "true" output), while leaving the fourth argument empty.
Does this method work for images as well?
Absolutely. Any wiki markup that can be placed inside a template can be conditionally hidden. Simply replace the <table> tags with an <img> tag or any other visual element within the same #ifeq structure.
What happens if I don't use includeonly tags?
Without <includeonly>, the table HTML will be visible in the page source when users click "Edit." This makes the editing interface cluttered and confusing, although the final rendered page will still look correct.
Can I nest multiple tables inside one template?
Yes, you can include multiple tables within the single <includeonly> block. They will all appear or disappear together based on the same parameter condition. If you need independent control, you would need separate parameters for each table.
Is there a performance impact on large pages?
The performance impact is negligible. Parser functions like #ifeq are lightweight and processed server-side during page generation. Even with many conditional blocks, the load time difference is typically imperceptible to end-users.