MediaWiki syntax is the markup language used to format text and create content on MediaWiki-based websites, such as Wikipedia and countless wikis dedicated to various topics. Understanding this syntax is crucial for contributing effectively to these platforms. This guide aims to provide a comprehensive introduction for beginners, covering fundamental elements and progressively moving towards more complex features. We will explore how to format text, create links, insert images, build tables, and utilize templates. This guide will also briefly touch upon some more advanced concepts to set you on the path to becoming a proficient MediaWiki editor. This article will be lengthy, as the syntax is quite robust.
The foundation of MediaWiki syntax lies in simple markup rules. Unlike WYSIWYG editors, you directly write code that defines how the content *should* appear, rather than seeing the appearance as you type.
Bold Text:* Use three single quotes () around the text you want to bold. Example: ```This text is bold.``` renders as ***This text is bold.***
Italic Text:* Use two single quotes ( ) around the text you want to italicize. Example: ```This text is italicized.``` renders as *This text is italicized.*
~~Strikethrough Text:~~* Use two tildes (~~) around the text. Example: ```~~This text is struckthrough.~~``` renders as ~~This text is struckthrough.~~
`Monospace Text:`* Use backticks (`) around the text for a monospace font, often used for code snippets or variable names. Example: ````This text is monospace.```` renders as `This text is monospace.`
Underline Text:* MediaWiki doesn't have direct underline support. It can be achieved with HTML, but it is discouraged due to accessibility issues. Consider using *italic* text instead.
^Superscript^* Use a caret (^) before and after the text. Example: ```^Superscript^``` renders as ^Superscript^
~Subscript~* Use a tilde (~) before and after the text. Example: ```~Subscript~``` renders as ~Subscript~
Headings
Headings organize your content and improve readability. MediaWiki uses equal signs (=) to define heading levels.
`= Heading 1 =`* Creates the largest heading.
`== Heading 2 ==`* Creates a slightly smaller heading.
`=== Heading 3 ===`* And so on, up to six heading levels.
Paragraphs and Line Breaks
Separate paragraphs by leaving a blank line between them. MediaWiki automatically interprets this as a paragraph break. To force a line break *within* a paragraph, use ` `.
Example:
This is the first line of a paragraph.
This is the second line of the same paragraph.
Links
Links are essential for connecting information within a wiki and to external resources.
Internal Links:* Use double square brackets `[[ ]]` around the page title you want to link to. Example: `Main Page` links to the Main Page of the wiki. If the page doesn't exist, it will be marked as a red link. You can also specify a different link text: `Home` displays "Home" but links to the Main Page. See Help:Links for more details.
External Links:* Use single square brackets `[ ]` around the URL and optional link text. Example: `MediaWiki Official Website`.
Named Links:* You can create named links for reuse. Use `<ref name="link_name">link text</ref>` to define the link and `#link_name` to reference it.
Images
Images enhance your content and make it more engaging.
`File:Example.jpgCaption of the image`* This syntax displays an image named "Example.jpg". `thumb` creates a thumbnail. `200px` sets the width to 200 pixels. "Caption of the image" is the image's caption. Consider using images that are relevant to the topic, and always respect copyright. For detailed information, see Help:Images and other files.
Lists
Lists organize information effectively.
Unordered Lists:* Use asterisks (*) at the beginning of each list item.
```
Item 1
Item 2
Item 3
```
Renders as:
Item 1
Item 2
Item 3
Ordered Lists:* Use numbers (#) at the beginning of each list item.
```
Item A
Item B
Item C
```
Renders as:
1. Item A
2. Item B
3. Item C
Definition Lists:* Use a colon (:) at the beginning of the term and a semicolon (;) at the beginning of the definition.
```
Term 1
Definition of Term 1
Term 2
Definition of Term 2
```
Tables
Tables are useful for presenting data in a structured format.
```
Caption of the table
Header 1
Header 2
Header 3
Row 1, Cell 1
Row 1, Cell 2
Row 1, Cell 3
Row 2, Cell 1
Row 2, Cell 2
Row 2, Cell 3
```
This creates a basic table. The `{| class="wikitable"` tag defines the table with a standard wiki table style. `|+` adds a caption. `|-` indicates a new row. `!` indicates a header cell. `|` indicates a data cell. See Help:Tables for more advanced table formatting options, such as cell spanning and alignment.
Templates
Templates are reusable content blocks that can be inserted into multiple pages. They help maintain consistency and reduce redundancy. Creating and using templates is a more advanced topic. See Help:Templates for further guidance.
Special Characters
Certain characters have special meaning in MediaWiki syntax and need to be escaped to display them literally.
Apostrophe ('):* Use `'` or `'` (within a template) to display an apostrophe.
Equal Sign (=):* Use `&eq;` to display an equal sign.
Square Brackets ([ ]):* Use `[` and `]` to display square brackets.
Pipe (|):* Use `|` to display a pipe character.
Angle Brackets (< >):* Use `<` and `>` to display angle brackets.
Mathematical Formulas
MediaWiki supports mathematical formulas using LaTeX syntax. Wrap your LaTeX code with `$` for inline formulas or `$$` for displayed formulas.
Inline formula:* `$E=mc^2$` renders as $E=mc^2$
Displayed formula:* `$$E=mc^2$$` renders as:
$$E=mc^2$$
Code Blocks
For displaying code snippets, use the `<source>` tag or the backtick (`) notation (as shown in the Monospace Text section). The `<source>` tag allows for better formatting and syntax highlighting.
```
<source lang="python">
def hello_world():
print("Hello, world!")
</source>
```
Comments
Comments are used to add notes to the wiki source code that are not displayed on the page. Use `` to add a comment.
Advanced Features & Resources
This guide has covered the fundamentals of MediaWiki syntax. Here are some more advanced features to explore:
Categories:* Add pages to categories using ``.
Infoboxes:* Use templates to create standardized information boxes for specific topics.
Transclusion:* Include the content of one page into another using `
Template:Page Name
Template:Page Name is a fundamental and incredibly useful MediaWiki template that allows you to dynamically display the name of the current page within a wiki. While seemingly simple, it has a wide range of applications, from creating navigational aids to generating dynamic content based on the page title. This article will provide a comprehensive guide to understanding and utilizing the `Page Name` template, geared towards beginners. We'll cover its basic usage, variations, common use cases, troubleshooting, and advanced techniques. This will be particularly useful for those building complex templates or wiki structures.
What does Template:Page Name do?
At its core, `Template:Page Name` resolves to the title of the page on which it is placed. It's a parser function, meaning it's processed by the MediaWiki software during page rendering. The result is a string containing the page title, which can then be used in various ways within the wiki content. Crucially, it doesn't display the full namespace; by default, it shows only the page *name* within its namespace. This distinction is important and will be elaborated upon later. Understanding how this works is the first step towards mastering more complex template functionality, such as Template:Full Page Name.
Basic Usage
The most basic way to use the template is simply to transclude it:
If you place this code on the page "Help:Contents", it will display:
`Help:Contents`
Notice that it displays the entire page title, including the "Help:" namespace. This is the default behavior. However, as mentioned, you often want just the page name *without* the namespace.
Removing the Namespace
The `Page Name` template has a parameter that allows you to strip the namespace. You use the `|` (pipe) character to pass this parameter:
Using the same example on the "Help:Contents" page, this will now display:
`Contents`
This is often the desired behavior when you want to refer to the page's content without explicitly mentioning its namespace. This is crucial for building consistent and user-friendly interfaces. Consider using this when creating dynamic table of contents or navigation sections. It’s also essential when working with Template:Current Month or other templates needing just the core page identifier.
Variations and Parameters
While `no namespace` is the primary parameter, there are other techniques to achieve similar results or customize the output further. These often involve combining `Page Name` with other parser functions.
**Using `subst:`:** The `subst:` magic word can be used to *substitute* the template's output directly into the page content. This means the template code is replaced with its rendered value, making it static. This is useful if you want to permanently store the page name at a specific point in time. However, it will not update if the page title changes.
**Combining with `string-format`:** The `string-format` parser function allows you to manipulate the output of `Page Name`. For example, you can convert the page name to uppercase or lowercase.
This would display the page name in all uppercase letters. This is particularly useful for creating titles or headings with a consistent style. You can also use `string-format` to add prefixes or suffixes to the page name. Understanding Template:String Format is vital for advanced customization.
**Combining with `#if`:** You can use the `#if` parser function to conditionally display the page name based on certain criteria.
This will display "This is the page: [Page Name]" if the page name exists; otherwise, it will display "Page name is empty." This can be useful for handling special cases, such as empty pages or redirect pages.
Common Use Cases
`Template:Page Name` has numerous applications within a MediaWiki environment. Here are some common examples:
**Creating Dynamic Table of Contents:** You can use `Page Name` to generate a table of contents that automatically reflects the current page's structure. This is often used in conjunction with heading levels and other parser functions.
**Building Navigational Aids:** You can create links to related pages based on the current page name. For example, you could create a template that displays links to the current page's talk page, history page, or edit page. This enhances user experience and simplifies navigation.
**Generating Dynamic Titles:** You can use `Page Name` to create dynamic titles for sections or pages. This can be useful for creating templates that are used across multiple pages with different titles. Consider its use with Template:Title for more complex title generation.
**Creating Consistent Headers and Footers:** You can use `Page Name` to display the current page name in a header or footer, providing a consistent visual cue for users.
**Automated Categorization:** Although categories are often added manually, `Page Name` can be used in conjunction with other templates to automate the categorization process based on the page title.
**Error Handling and Reporting:** You can use `Page Name` to include the current page name in error messages or reports, making it easier to identify the source of the problem.
**Creating Dynamic Infoboxes:** Infoboxes can be made more dynamic by incorporating the page name into their content. This helps to ensure that the infobox is relevant to the current page.
**Log Files and Tracking:** `Page Name` can be used in templates that generate log files or track page views, providing valuable data for wiki administrators. This is often used with extensions like Extension:PageView.
**Template Documentation:** Using `Page Name` within template documentation examples helps illustrate how the template works in different contexts.
**Automated Indexing:** Creating automated indexes or lists of pages based on their names.
Troubleshooting
While `Page Name` is a relatively simple template, you may encounter issues when using it. Here are some common problems and their solutions:
**Incorrect Namespace:** If you're getting the full page title instead of just the page name, make sure you're using the `|no namespace` parameter correctly. Double-check the syntax and ensure there are no typos.
**Template Not Rendering:** If the template isn't rendering at all, check the following:
* Make sure the template page exists and is not protected.
* Check for syntax errors in the template code.
* Ensure that the template is being transcluded correctly (using `Template loop detected: Template:Page Name`).
* Check for conflicting templates or parser functions.
**Unexpected Output:** If you're getting unexpected output, carefully review your template code and the surrounding content. Make sure you're not accidentally passing incorrect parameters or using conflicting functions. Use the MediaWiki debugger to step through the code and identify the source of the problem. Template:Debugger can be helpful.
**Caching Issues:** Sometimes, changes to templates may not be reflected immediately due to caching. Try purging the page cache by editing the page and saving it, or by using the `?action=purge` parameter in the URL.
**Circular References:** Avoid creating templates that recursively call themselves, as this can lead to infinite loops and errors.
**Compatibility Issues:** Some extensions or custom code may interfere with the `Page Name` template. If you suspect this is the case, try disabling the extension or custom code to see if it resolves the issue.
Advanced Techniques
Once you're comfortable with the basics of `Page Name`, you can explore more advanced techniques:
**Using `#titleparts`:** The `#titleparts` parser function allows you to extract specific parts of the page title. This can be useful for creating more complex templates that need to manipulate the page name in a granular way.
**Combining with Regular Expressions:** You can use regular expressions to match and extract specific patterns from the page name. This can be useful for creating templates that need to process page names with a specific format.
**Creating Custom Templates:** You can create your own custom templates that encapsulate the `Page Name` functionality and add additional features. This can help to simplify your wiki code and improve maintainability.
**Utilizing Lua Modules:** For more complex logic and performance optimization, you can use Lua modules to implement the `Page Name` functionality. Lua provides a more powerful and flexible programming environment than the built-in parser functions. Extension:Lua is required for this.
**Conditional Logic with `#switch`:** The `#switch` parser function can be used to perform different actions based on the value of the page name. This allows you to create templates that behave differently depending on the page they are used on.
**Data Retrieval with API Integration:** You can combine `Page Name` with the MediaWiki API to retrieve data about the current page, such as its revision history or associated categories. This allows you to create dynamic templates that are linked to external data sources.
Best Practices
**Keep it Simple:** Avoid unnecessary complexity when using `Page Name`. The simpler the template, the easier it will be to understand and maintain.
**Document Your Code:** Clearly document your template code, explaining its purpose, parameters, and usage. This will help other wiki editors understand and modify your code in the future.
**Test Thoroughly:** Thoroughly test your template on different pages to ensure it works as expected. Pay attention to edge cases and potential errors.
**Use Comments:** Use comments to explain complex sections of your code. This will make it easier to understand and maintain.
**Follow Wiki Style Guidelines:** Follow the wiki's style guidelines when creating templates. This will help to ensure consistency and readability.
**Consider Performance:** Be mindful of the performance impact of your templates. Avoid using excessively complex code or making unnecessary API calls.
**Use Namespaces Wisely:** Understand the implications of using namespaces and how they affect the output of `Page Name`.
By following these guidelines, you can create robust and maintainable templates that enhance your MediaWiki wiki. Remember that consistent application of these principles will lead to a more organized and scalable wiki environment. You should also explore Template:Variables and Template:Parameters for further understanding of template construction.
The power of MediaWiki isn't limited to general knowledge. It can be exceptionally useful for documenting and sharing financial analysis. Here are some ways to leverage the syntax:
**Stock Analysis:** Create tables to display key financial ratios (P/E, Debt-to-Equity, ROE). Use links to relevant financial news articles ([2](https://www.investopedia.com/)). Embed charts using image links or, if your wiki supports extensions, interactive charting tools.
**Trading Strategies:** Document your trading strategies with clear headings, bulleted lists of rules, and examples. Use code blocks to display trading algorithms ([3](https://www.quantstart.com/)).
**Market Trends:** Analyze market trends using tables to present historical data. Use images to illustrate chart patterns ([8](https://www.tradingview.com/)).
