repo_id
stringlengths 22
103
| file_path
stringlengths 41
147
| content
stringlengths 181
193k
| __index_level_0__
int64 0
0
|
|---|---|---|---|
data/mdn-content/files/en-us/mdn/writing_guidelines/howto | data/mdn-content/files/en-us/mdn/writing_guidelines/howto/creating_moving_deleting/index.md | ---
title: How to create, move, delete, and edit pages
slug: MDN/Writing_guidelines/Howto/Creating_moving_deleting
page-type: mdn-writing-guide
---
{{MDNSidebar}}
This article describes how to create, move, delete, or edit a page. In all these instances, it's a good idea to check our guidelines for [What we write](/en-US/docs/MDN/Writing_guidelines/What_we_write) to confirm if any of these actions should be taken and discuss it with the MDN Web Docs team on the [MDN Web Docs chat rooms](/en-US/docs/MDN/Community/Communication_channels#chat_rooms) before proceeding.
## Creating pages
All pages on MDN Web Docs are authored in Markdown format. The content is written in a file named `index.md`, which is stored in its own unique directory. The directory name represents the name of the page. For example, if `align-content` is a new CSS property for which you want to create a new reference page, you'd create a folder in `en-us/web/css` named `align-content` and create a file called `index.md` inside it.
> **Note:** The name of the directory differs slightly from the slug of the page. Most notably, the slug follows sentence casing.
There are a lot of different [page types](/en-US/docs/MDN/Writing_guidelines/Page_structures/Page_types) with certain structures and supporting page templates for them, which you can copy to get you started.
A document's `index.md` file must start with front matter that defines the `title`, `slug`, and `page-type`. All of this front matter information can be found in the aforementioned page templates. Alternatively, you might find it helpful to refer to the front matter within a similar document's `index.md`.
The general step-by-step process for creating a page would be:
1. Start a fresh, up-to-date branch to work in.
```bash
cd ~/repos/mdn/content
git checkout main
git pull mdn main
# Run "yarn" again to ensure you've
# installed the latest Yari dependency.
yarn
git checkout -b my-add
```
2. Create one or more new document folders, each with their own `index.md` files.
3. Add and commit your new files as well as push your new branch to your fork.
```bash
git add files/en-us/folder/you/created
git commit -m "appropriate message about your changes"
git push -u origin my-add
```
4. Create your pull request.
## Moving pages
Moving one or more documents or an entire tree of documents is easy
because we've created a special command that takes care of the details for you:
```bash
yarn content move <from-slug> <to-slug> [locale]
```
You just have to specify the slug of the existing document that you'd like
to move (e.g., `Learn/Accessibility`), as well as the slug of its new
location (e.g., `Learn/A11y`), optionally followed by the locale of the
existing document (defaults to `en-US`).
If the existing document that you'd like to move has child documents (i.e.,
it represents a document tree), the `yarn content move` command will move
the entire tree.
For example, let's say you want to move the entire
`/en-US/Learn/Accessibility` tree to `/en-US/Learn/A11y`, you'd perform the following steps:
1. You'll start a fresh branch to work in.
```bash
cd ~/repos/mdn/content
git checkout main
git pull mdn main
# Run "yarn" again just to ensure you've
# installed the latest Yari dependency.
yarn
git checkout -b my-move
```
2. Perform the move (which will delete and modify existing files as well as create new files).
```bash
yarn content move Learn/Accessibility Learn/A11y
```
3. Once files are moved we need to update references to those files in the other content files as well. Use following command to update all the references automatically in one go:
```bash
node scripts/update-moved-file-links.js
```
4. Add and commit all the deleted, created, and modified files as well as push your branch to your fork.
```bash
git add .
git commit -m "Move Learn/Accessibility to Learn/A11y"
git push -u origin my-move
```
5. Create your pull request.
> **Note:** `yarn content move` automatically adds the necessary redirect information to the `_redirects.txt` file so that the old location will redirect to the new one. Don't edit the `_redirects.txt` file manually! Mistakes can easily creep in if you do. If you need to add a redirect without moving a file, talk to the MDN Web Docs team on the [MDN Web Docs chat rooms](/en-US/docs/MDN/Community/Communication_channels#chat_rooms) about it.
## Deleting pages
Documents should only be removed from MDN Web Docs under special circumstances. If you are thinking about deleting pages, please discuss it with the MDN Web Docs team on the [MDN Web Docs chat rooms](/en-US/docs/MDN/Community/Communication_channels#chat_rooms) first.
Deleting one or more documents or an entire tree of documents is easy, just like moving pages, because we've created a special command that takes care of the
details for you:
```bash
yarn content delete <document-slug> [locale]
```
> **Note:** You need to use the `yarn content delete` command to delete pages from MDN Web Docs. Don't just delete their directories from the repo. The `yarn content delete` command also handles other necessary changes such as updating the `_wikihistory.json` file.
You just have to specify the slug of the existing document that you'd like
to delete (e.g., `Learn/Accessibility`), optionally followed by the locale
of the existing document (defaults to `en-US`).
If the existing document that you'd like to delete has child documents (i.e., it represents a
document tree), you must also specify the `-r, --recursive` option, otherwise
the command will fail.
For example, if you want to delete the
entire `/en-US/Learn/Accessibility` tree, you'd perform the following steps:
1. You'll start a fresh branch to work in.
```bash
cd ~/repos/mdn/content
git checkout main
git pull mdn main
# Run "yarn" again just to ensure you've
# installed the latest Yari dependency.
yarn
git checkout -b my-delete
```
2. Perform the delete.
```bash
yarn content delete Learn/Accessibility --recursive
```
3. Add a redirect. The target page can be an external URL or another page on MDN Web Docs.
```bash
yarn content add-redirect /en-US/path/of/deleted/page /en-US/path/of/target/page
```
4. Add and commit all the deleted files as well as push your branch to your fork.
```bash
git commit -a
git push -u origin my-delete
```
5. Create your pull request.
> **Note:** If the slug of the page you wish to delete contains special characters, include it in quotes, like so:
>
> ```bash
> yarn content delete "Mozilla/Add-ons/WebExtensions/Debugging_(before_Firefox_50)"
> ```
Removing content from MDN Web Docs will inevitably result in updating the existing content as well. As a lot of articles link to others, the removed content will likely be referenced elsewhere. Adding the redirect will mitigate the impact of removing content; however, it's best practice to edit content to reflect the change and include the content edits along with the removal pull request.
## Editing existing pages
To edit a page, you need to find the page source in our [content](https://github.com/mdn/content) repository. The easiest way to find it is to navigate to the page you want to edit, go to the bottom of the page, and click on the "View the source on GitHub" link.
### Preview changes
If you are editing the page locally, to see what your changes look like you can go to the content repo folder, execute the CLI command `yarn start`, go to `localhost:5042` in your browser, and navigate to the page and view it. Enter the title in the search box to find it easily. The previewed page will update in the browser as you edit the source.
### Attach files
To attach a file to your article, you just need to include it in the same directory as the article's `index.md` file. Include the file in your page, typically via an {{htmlelement("a")}} element.
| 0 |
data/mdn-content/files/en-us/mdn/writing_guidelines/howto | data/mdn-content/files/en-us/mdn/writing_guidelines/howto/write_a_new_entry_in_the_glossary/index.md | ---
title: How to write an entry in the glossary
slug: MDN/Writing_guidelines/Howto/Write_a_new_entry_in_the_glossary
page-type: mdn-writing-guide
---
{{MDNSidebar}}
This article explains how to add and link to entries in the [MDN Web Docs glossary](/en-US/docs/Glossary).
It also provides guidelines about glossary entry layout and content.
The glossary provides definitions for all the terms, jargon, abbreviations, and acronyms you'll come across when reading MDN content about the web and web development.
It's possible that the glossary will never be complete because the web is always changing.
By contributing new entries or fixing problems, you can help us update the glossary and fill-in gaps.
Contributing to the glossary is an easy way to help make the web more understandable for everyone.
You don't need high level technical skills.
Glossary entries are intended to be straightforward and brief.
## How to write an entry
First, choose what topic you'd like to write a glossary entry for.
If you're looking for topics that need a glossary entry, check the list of terms in the sidebar of the [Glossary landing page](/en-US/docs/Glossary).
If you have an idea for a new glossary entry, [create a new page](/en-US/docs/MDN/Writing_guidelines/Howto/Creating_moving_deleting#creating_pages) for it underneath the [glossary landing page](https://github.com/mdn/content/tree/main/files/en-us/glossary).
### Write a summary
The first paragraph of any glossary page is a simple and short description of the term.
Preferably, this should be no more than two sentences.
Make sure anyone reading the description can immediately understand the defined term.
> **Note:** Please don't copy-and-paste from other definitions or content on the internet.
> (And especially not Wikipedia, since its range of license versions is smaller and incompatible with MDN.) Your glossary entry should be original content.
#### Writing a good glossary entry
Add a few extra paragraphs if you must, but it's easy to find yourself writing an entire article.
Writing an article is fine, but please don't create it in/for the glossary.
If you aren't sure where to put your article, feel free to [reach out to discuss it](/en-US/docs/MDN/Community/Discussions).
There are a few simple guidelines to consider for writing a better glossary entry:
- When you use terms in the glossary's description of the term or when you use abbreviation, you should create appropriate links.
Often, this just involves creating links to other pages in the glossary.
- Use appropriate related terms (with links) in the glossary entry, if it can be done without making the article difficult to follow.
Having a good network of related and useful links makes a page—or set of pages—much easier to use.
- Think about the search terms you would choose if you wanted to find this page.
Try to use all the words you would use to search for the term, but without making the glossary entry nonsensical, long, or difficult to read.
### Expand with links
A glossary entry should always end with a _See also_ section.
This section should contain links to help the reader move forward: discovering more details; learning to use the relevant technology.
It is good practice to organize the links into three groups:
- General knowledge
- : These links provide higher-level information about the term or topic.
For example: a link to a relevant [Wikipedia](https://en.wikipedia.org/) page.
- Technical reference
- : These links offer in-depth technical information, on MDN Web Docs or other sites.
- Learn about it
- : These are links to tutorials, exercises, examples, or any other instructional content that helps the reader learn.
## Dealing with disambiguation
Some terms can have multiple meanings depending upon context.
To resolve ambiguity, follow these guidelines:
- The term's main page must be a disambiguation page containing the [`GlossaryDisambiguation`](https://github.com/mdn/yari/blob/main/kumascript/macros/GlossaryDisambiguation.ejs) macro.
- The term has subpages that define the term for different contexts.
Let's illustrate this with an example.
The term _signature_ can have different meanings in at least two different contexts: security and function.
1. The page [Glossary/Signature](/en-US/docs/Glossary/Signature) is the disambiguation page with the [`GlossaryDisambiguation`](https://github.com/mdn/yari/blob/main/kumascript/macros/GlossaryDisambiguation.ejs) macro.
2. The page [Glossary/Signature/Security](/en-US/docs/Glossary/Signature/Security) is the page defining a signature in a security context.
3. The page [Glossary/Signature/Function](/en-US/docs/Glossary/Signature/Function) is the page defining a function signature.
| 0 |
data/mdn-content/files/en-us/mdn/writing_guidelines/howto | data/mdn-content/files/en-us/mdn/writing_guidelines/howto/document_an_http_header/index.md | ---
title: How to document an HTTP header
slug: MDN/Writing_guidelines/Howto/Document_an_HTTP_header
page-type: mdn-writing-guide
---
{{MDNSidebar}}
The [HTTP headers reference](/en-US/docs/Web/HTTP/Headers) on MDN Web Docs documents HTTP header fields. These are components of the header section of request and response messages in the Hypertext Transfer Protocol ([HTTP](/en-US/docs/Web/HTTP)). They define the operating parameters of an HTTP transaction. This article explains how to create a new reference page for an HTTP header.
You will need to know or be able to dive into some [HTTP](/en-US/docs/Web/HTTP).
## Step 1 – Determine the HTTP header to document
- There are many HTTP headers defined in various IETF standards.
- IANA maintains a [registry of headers](https://www.iana.org/assignments/message-headers/message-headers.xhtml) and Wikipedia lists the [known header fields](https://en.wikipedia.org/wiki/List_of_HTTP_header_fields), but not all are relevant to web developers or are part of an official standard.
- If there are any **red links** on the current [HTTP headers reference overview page](/en-US/docs/Web/HTTP/Headers), these headers are a good choice to document.
- If in doubt, [ask the MDN Web Docs team](/en-US/docs/MDN/Community/Communication_channels) whether or not it makes sense to write about the header you have chosen.
## Step 2 – Check the existing HTTP header pages
- Existing HTTP headers are documented [here](/en-US/docs/Web/HTTP/Headers).
- There are different header categories: {{Glossary("Request header")}}, {{Glossary("Response header")}}, and {{Glossary("Representation header")}}.
- Find the category of the header you are about to document (note that some headers can be both request and response headers, depending on the context).
- Go to an existing header reference page that has the same category.
## Step 3 – Create the HTTP header page
- All header pages live under this tree: [/docs/Web/HTTP/Headers/](/en-US/docs/Web/HTTP/Headers)
- To create a new page, see the instructions in our [how to create a page](/en-US/docs/MDN/Writing_guidelines/Howto/Creating_moving_deleting) guide.
## Step 4 – Write the content
- Either start from our [template HTTP header page](/en-US/docs/MDN/Writing_guidelines/Page_structures/Page_types#http_header_reference_page) or use a copied structure from one of the existing HTTP header documents that you found in step 2. It's your choice.
- Write about the new HTTP header.
- Make sure you have these sections:
- Introductory text where the first sentence mentions the header name (bold) and summarizes its purpose.
- Information box containing at least the header type and if the header is a {{Glossary("Forbidden header name")}}.
- A syntax box containing all possible directives/parameters/values of the HTTP header.
- A section that explains these directives/values.
- An example section that contains a practical use case for this header or shows where and how it occurs usually.
- A specification section listing relevant RFC standard documents.
- A "See also" section listing relevant resources.
## Step 5 – Add browser compatibility information
- If you have looked at other HTTP header pages, you will see that there is a `\{{Compat}}` macro that will fill in a browser table for you.
- The compatibility table page is generated from structured data. If you'd like to contribute to the data, please check out the instructions at <https://github.com/mdn/browser-compat-data/blob/main/README.md> and send us a pull request.
## Step 6 – Update the HTTP headers list
Make sure your header is listed in an appropriate category on the [HTTP headers reference overview page](/en-US/docs/Web/HTTP/Headers).
## Step 7 – Get the content reviewed
After you've created the header page, submit it as a pull request. A member of our review team will be assigned automatically to review your page.
| 0 |
data/mdn-content/files/en-us/mdn/writing_guidelines/howto | data/mdn-content/files/en-us/mdn/writing_guidelines/howto/research_technology/index.md | ---
title: How to research a technology
slug: MDN/Writing_guidelines/Howto/Research_technology
page-type: mdn-writing-guide
---
{{MDNSidebar}}
This article gives you some handy information about approaching how to document technologies.
## Doing the prep work
Before starting to document or update something on MDN Web Docs, there are some things you should prepare and plan before starting to actually write.
It is assumed that before reading this guide, you have a reasonable knowledge of:
- Web technologies like HTML, CSS, and JavaScript.
- Reading web technology specifications. You'll be looking at these a lot as you document APIs.
Everything else can be learned along the way.
### Checking out resources
Useful resources for writing any documentation include:
1. The [How-to guides](/en-US/docs/MDN/Writing_guidelines/Howto) for MDN Web Docs: You're already here, but it's good to browse through all the articles and familiarize yourself with our writing style, the different types of pages and what sections are included in them, and the different ways we include different parts of the page (like specifications and browser compatibility).
2. The latest specification: Different standards bodies create specifications for technologies that are documented on MDN Web Docs. For example, [TC39](https://tc39.es/) for JavaScript, the [WHATWG](https://whatwg.org/) for HTML, and the [W3C](https://www.w3.org/) for CSS, XML, and some Web APIs. Specifications are linked to from reference pages on MDN Web Docs (check the "Specifications" section). Alternatively, you can usually do a web search. Always work from the latest, most up-to-date specification.
3. The latest modern web browsers: These should be experimental/alpha builds such as [Firefox Nightly](https://www.mozilla.org/en-US/firefox/channel/desktop/#nightly), [Chrome Canary](https://www.google.com/intl/en/chrome/canary/), or [Safari Technology Preview](https://webkit.org/downloads/) that are more likely to support the features you are documenting. This is especially pertinent if you are documenting a feature that is "upcoming".
4. Demos/blog posts/other info: Find as much info as you can. If you are updating a technology because it has changed, ensure that the resources you are using to learn are not out of date. This is why the first two points above are important.
It can also be wise to try and find someone to help answer questions. This can be the specification authors or the engineers who implement browser features.
### Reading specifications
This can feel a little alien to start, but the more you do it the more you get used to it. Here are some good links to help you get started:
- [How to read W3C specs](https://alistapart.com/article/readspec/) by J. David Eisenberg on A List Apart
- [Understanding the CSS specifications](https://www.w3.org/Style/CSS/read) from the w3c
- [How to read web specs part I – or: WebVR, how do you work?](https://surma.dev/things/reading-specs/) talks through reading the WebVR spec specifically, but is a great introduction to reading Web API specs.
- [How to read web specs part IIa – or: ECMAScript Symbols](https://surma.dev/things/reading-specs-2/) the second part to the link above contains information on understanding the ECMAScript specification which outlines the JavaScript language
In addition, we have the [Information contained in a WebIDL file](/en-US/docs/MDN/Writing_guidelines/Howto/Write_an_API_reference/Information_contained_in_a_WebIDL_file) guide, which can really help when reading Web API specs.
## Exploring the feature
You will return to writing code examples or building demos many times through the course of documenting a technology, but it is very useful to start by spending time familiarizing yourself with how the technology works. This is a really valuable exercise because it gives you a good understanding of what the use cases are (_why_ a developer would use this technology) and help with creating some code examples at the same time.
> **Note:** If the specification has been recently updated so that, say, a method is now defined differently, but the old method still works in browsers, you will often have to document both in the same place so that the old and new methods are covered.
> If you need help, refer to demos you have found, or ask an engineering contact.
## Creating the list of pages to write or update
The different pages that you need to write from scratch or update varies depending on the technology you are writing about. Check out the [page types](/en-US/docs/MDN/Writing_guidelines/Page_structures/Page_types) and the relevant section for the technology you're documenting. You'll most likely need to update existing documentation as well, so search MDN Web Docs for pages that are related to what you are writing about.
### Sidebars
It's possible that the sidebar of the pages you write will also need to be defined or updated. To find out if this is needed and how to do it, check out the [sidebar guide](/en-US/docs/MDN/Writing_guidelines/Howto/Write_an_API_reference/Sidebars).
### Code examples
Some of the code examples for MDN Web Docs are held in separate repositories. Most notably, these are the interactive examples that appear in the "Try it" section in the reference pages and the larger demo code needed for guides. If you do need to add to or amend one of these repositories, it's a good idea to make a note of it in your list.
The [Code examples](/en-US/docs/MDN/Writing_guidelines/Page_structures/Code_examples) article describes the different types of code examples we use on MDN Web Docs.
### Example
Let's say you're documenting a new Web API, your initial list of sections to be documented will look something like this:
1. Overview page
2. Interface pages
3. Constructor pages
4. Method pages
5. Property pages
6. Event pages
7. Concept/guide pages
8. Code examples
9. Sidebars
You can then expand on it with more details, adding each interface and it's members. For example, if you were documenting the Web Audio API, your list might look more like this:
- Web_Audio_API
- AudioContext
- AudioContext.currentTime
- AudioContext.destination
- AudioContext.listener
- ...
- AudioContext.createBuffer()
- AudioContext.createBufferSource()
- ...
- AudioNode
- AudioNode.context
- AudioNode.numberOfInputs
- AudioNode.numberOfOutputs
- ...
- AudioNode.connect(Param)
- ...
- AudioParam
- Events (update list)
- start
- end
- …
## Opening an issue
It's a good idea at this point to open a tracking [issue](https://github.com/mdn/content/issues) on the `mdn/content` repository with the pages listed as a to-do (checkbox) list. This enables not just you, but others working on documentation to publicly keep track of the status. You can also link your pull requests to this issue to give everyone more context.
## Creating the pages
Now create the pages you need. To create a new page, see the instructions in our [How to create, move, delete, and edit pages](/en-US/docs/MDN/Writing_guidelines/Howto/Creating_moving_deleting) guide. Check out our [Page types](/en-US/docs/MDN/Writing_guidelines/Page_structures/Page_types) guide for page templates that might be useful.
| 0 |
data/mdn-content/files/en-us/mdn/writing_guidelines/howto | data/mdn-content/files/en-us/mdn/writing_guidelines/howto/markdown_in_mdn/index.md | ---
title: How to write in Markdown
slug: MDN/Writing_guidelines/Howto/Markdown_in_MDN
page-type: mdn-writing-guide
---
{{MDNSidebar}}
This page describes how we use Markdown to write documentation on MDN Web Docs. We have chosen GitHub-Flavored Markdown (GFM) as a baseline, and added some extensions to support some of the things we need to do on MDN that aren't readily supported in GFM.
## Baseline: GitHub-Flavored Markdown
The baseline for MDN Markdown is GitHub-Flavored Markdown (GFM): <https://github.github.com/gfm/>. This means that you can refer to the GFM specification for anything not explicitly specified in this page. GFM in turn is a superset of CommonMark (<https://spec.commonmark.org/>).
## Links
The GFM specification defines two basic types of links:
- [inline links](https://github.github.com/gfm/#inline-link), in which the destination is given immediately after the link text.
- [reference links](https://github.github.com/gfm/#reference-link), in which the destination is defined elsewhere in the document.
On MDN we allow only inline links.
This is the correct way to write GFM links on MDN:
```md example-good
[Macarons](https://en.wikipedia.org/wiki/Macaron) are delicious but tricky to make.
```
This is an incorrect way to write links on MDN:
```md example-bad
[Macarons][macaron] are delicious but tricky to make.
[macaron]: https://en.wikipedia.org/wiki/Macaron
```
## Example code blocks
In GFM and CommonMark, authors can use "code fences" to demarcate `<pre>` blocks. The opening code fence may be followed by some text that is called the "info string". The specification states the following:
> The first word of the info string is typically used to specify the language of the code sample, and rendered in the class attribute of the code tag.
It's permissible for the info string to contain multiple words, like:
````md
```fee fi fo fum
// some example code
```
````
On MDN, writers will use code fences for example code blocks. They must specify the language of the code sample using the first word of the info string, and this will be used to provide syntax highlighting for the block. The following words are supported:
- Programming Languages
- JavaScript
- `js` - JavaScript
- `ts` - TypeScript
- `jsx` - React JSX
- `tsx` - React TSX
- C-like
- `c` - C
- `cpp` - C++
- `cs` - C#
- `java` - Java
- Other
- `python` - Python
- `php` - PHP
- `rust` - Rust
- `glsl` - GLSL (OpenGL Shaders)
- `sql` - SeQueL commands
- `wasm` - WebAssembly
- `webidl` - Web Interface Definition Language
- Styling
- `css` - CSS
- `scss` - Sass (SCSS)
- `less` - Less
- Markup
- `html` - HTML
- `svg` - SVG
- `xml` - XML
- `mathml` - MathML
- `md` - Markdown
- `latex` - LaTeX
- Command Prompts
- `bash` - Bash/Shell
- `batch` - Batch (Windows Shell)
- `powershell` - PowerShell
- Configuration/Data Files
- `json` - JSON
- `ini` - INI
- `yaml` - YAML
- `toml` - TOML
- `sql` - SQL Database
- `ignore` - Gitignore file
- `apacheconf` - Apache configuration
- `nginx` - NGINX configuration
- Templates
- `django` - Django templates
- `svelte` - Svelte templates
- `handlebars` - Handlebars templates
- `pug` - [Pug templates](https://pugjs.org/api/getting-started.html) (which may be used by [Express](/en-US/docs/Learn/Server-side/Express_Nodejs/Displaying_data/Template_primer))
- Other
- `plain` - Plain text
- `diff` - Diff file
- `http` - HTTP headers
- `regex` - Regex
- `uri` - URIs and URLs
For example:
````md
```js
const greeting = "I will get JavaScript syntax highlighting";
```
````
If the highlighting that you wish to use is not listed above, you should markup the code block as `plain`.
Additional languages may be requested in the process [discussed on GitHub](https://github.com/orgs/mdn/discussions/170#discussioncomment-3404366).
### Suppressing linting
Writers can add a `-nolint` suffix to any of the language identifiers:
````md-nolint
```html-nolint
<p>
I will not be linted.
</p>
```
````
Code blocks like this will get appropriate syntax highlighting and will be recognized by the live sample system, but will be ignored by linters or automatic formatters like Prettier. Authors should use this suffix for showing invalid code or alternative formatting that linters or formatters should not fix.
### Additional classes (info strings)
GFM supports [info strings](https://github.github.com/gfm/#info-string), which allow authors to supply additional information about a code block. On MDN, info strings are converted into class names.
Writers will be able to supply any one of the following info strings:
- `example-good`: style this example as a good example (one to follow)
- `example-bad`: style this example as a bad example (one to avoid)
- `hidden`: don't render this code block in the page. This is for use in live samples.
For example:
````md
```js example-good
const greeting = "I'm a good example";
```
```js example-bad
const greeting = "I'm a bad example";
```
```js hidden
const greeting = "I'm a secret greeting";
```
````
These will be rendered as:
```js example-good
const greeting = "I'm a good example";
```
```js example-bad
const greeting = "I'm a bad example";
```
### Discussion reference
This issue was resolved in:
- <https://github.com/mdn/content/issues/3512>
- <https://github.com/mdn/yari/pull/7017>
## Notes, warnings, and callouts
Sometimes writers want to call special attention to a piece of content. To do this, they will use a GFM blockquote with a special first paragraph. There are three types of these: notes, warnings, and callouts.
- To add a note, create a GFM blockquote whose first paragraph starts with `**Note:**`.
- To add a warning, create a GFM blockquote whose first paragraph starts with `**Warning:**`.
- To add a callout, create a GFM blockquote whose first paragraph starts with `**Callout:**`.
Notes and warnings will render the **Note:** or **Warning:** text in the output, while callouts will not. This makes callouts a good choice when an author wants to provide a custom title.
Processing of the markup works on the AST it produces, not on the exact characters provided. This means that providing `<strong>Note:</strong>` will also generate a note. However, the Markdown syntax is required as a matter of style.
Multiple lines are produced by an empty block quote line in the same way as normal paragraphs. Further, multiple lines without a space are also treated like normal Markdown lines, and concatenated.
The blockquote can contain code blocks or other block elements.
### Examples
#### Note
```md
> **Note:** This is how you write a note.
>
> It can have multiple lines.
```
This will produce the following HTML:
```html
<div class="notecard note">
<p><strong>Note:</strong> This is how you write a note.</p>
<p>It can have multiple lines.</p>
</div>
```
This HTML will be rendered as a highlighted box:
> **Note:** This is how you write a note.
>
> It can have multiple lines.
#### Warnings
```md
> **Warning:** This is how you write a warning.
>
> It can have multiple paragraphs.
```
This will produce the following HTML:
```html
<div class="notecard warning">
<p><strong>Warning:</strong> This is how you write a warning.</p>
<p>It can have multiple paragraphs.</p>
</div>
```
This HTML will be rendered as a highlighted box:
> **Warning:** This is how you write a warning.
>
> It can have multiple paragraphs.
#### Callouts
```md
> **Callout:** **This is how you write a callout.**
>
> It can have multiple paragraphs.
```
This will produce the following HTML:
```html
<div class="callout">
<p><strong>This is how you write a callout.</strong></p>
<p>It can have multiple paragraphs.</p>
</div>
```
This HTML will be rendered as a highlighted box:
> **Callout:**
>
> **This is how you write a callout.**
>
> It can have multiple paragraphs.
#### Translated warning
Because the text "Note:" or "Warning:" also appears in the rendered output, it has to be sensitive to translations. In practice this means that every locale supported by MDN must supply its own translation of these strings, and the platform must recognize them as indicating that the construct needs special treatment.
The localizations are stored in [Yari](https://github.com/mdn/yari/tree/main/markdown/localizations) as JSON files in [gettext](https://www.gnu.org/software/gettext/) format. Refer to these files to determine what string should be used in place of "Note:" or "Warning:" for that locale. If a locale file is not defined, English will be used as a fallback.
For example, if we want to use "Warnung" for "Warning" in German, then in German pages we would write:
```md
> **Warnung:** So schreibt man eine Warnung.
```
And this will produce:
```html
<div class="notecard warning">
<p><strong>Warnung:</strong> So schreibt man eine Warnung.</p>
</div>
```
#### Note containing a code block
This example contains a code block.
````md
> **Note:** This is how you write a note.
>
> It can contain code blocks.
>
> ```js
> const s = "I'm in a code block";
> ```
>
> Like that.
````
This will produce the following HTML:
```html
<div class="notecard note">
<p><strong>Note:</strong> This is how you write a note.</p>
<p>It can contain code blocks.</p>
<pre class="brush: js">const s = "I'm in a code block";</pre>
<p>Like that.</p>
</div>
```
This HTML will be rendered as with a code block:
> **Note:** This is how you write a note.
>
> It can contain code blocks.
>
> ```js
> const s = "I'm in a code block";
> ```
>
> Like that.
### Discussion reference
This issue was resolved in <https://github.com/mdn/content/issues/3483>.
## Definition lists
Definition lists are commonly used across MDN, but are not supported by GFM. MDN introduces a custom format for definition lists, which is a modified form of a GFM unordered list ({{HTMLElement("ul")}}). In this format:
- The GFM `<ul>` contains any number of top-level GFM `<li>` elements.
- Each of these top-level GFM `<li>` elements must contain, as its final element, one GFM `<ul>` element.
- This final nested `<ul>` must contain a single GFM `<li>` element, whose text content must start with ": " (a colon followed by a space). This element may contain block elements, including paragraphs, code blocks, embedded lists, and notes.
Each of these top-level GFM `<li>` elements will be transformed into a `<dt>`/`<dd>` pair, as follows:
- The top-level GFM `<li>` element will be parsed as a GFM `<li>` element and its internal contents will comprise the contents of the `<dt>`, except for the final nested `<ul>`, which will not be included in the `<dt>`.
- The `<li>` element in the final nested `<ul>` will be parsed as a GFM `<li>` element and its internal contents will comprise the contents of the `<dd>`, except for the leading ": ", which will be discarded.
For example, this is a `<dl>`:
````md
- term1
- : My description of term1
- `term2`
- : My description of term2
It can have multiple paragraphs, and code blocks too:
```js
const thing = 1;
```
````
In GFM/CommonMark, this would produce the following HTML:
```html
<ul>
<li>
<p>term1</p>
<ul>
<li>: My description of term1</li>
</ul>
</li>
<li>
<p><code>term2</code></p>
<ul>
<li>
<p>: My description of term2</p>
<p>It can have multiple paragraphs, and code blocks too:</p>
<pre>
<code class="brush: js">const thing = 1;</code>
</pre>
</li>
</ul>
</li>
</ul>
```
On MDN, this would produce the following HTML:
```html
<dl>
<dt>
<p>term1</p>
</dt>
<dd>My description of term1</dd>
<dt>
<p><code>term2</code></p>
</dt>
<dd>
<p>My description of term2</p>
<p>It can have multiple paragraphs, and code blocks too:</p>
<pre>
<code class="brush: js">const thing = 1;</code>
</pre>
</dd>
</dl>
```
Definition lists written using this syntax must consist of pairs of `<dt>`/`<dd>` elements. Using this syntax, it's not possible to write a list with more than one consecutive `<dt>` element or more than one consecutive `<dd>` element: the parser will treat this as an error. We expect almost all definition lists on MDN will work with this limitation, and for those that do not, authors can fall back to raw HTML.
This is not permitted:
```md example-bad
- `param1`, `param2`, `param3`
- : My description of `param1`
- : My description of `param2`
- : My description of `param3`
```
As a workaround for cases where an author needs to associate multiple `<dt>` items with a single `<dd>`, consider providing them as a single `<dt>` that holds multiple terms, separated by commas, like this:
```md example-good
- `param1`, `param2`, `param3`
- : My description of params 1, 2, and 3
```
The rationale for the syntax described here is that it works well enough with tools that expect CommonMark (for example, Prettier or GitHub previews) while being reasonably easy to write and to parse.
### Discussion reference
This issue was resolved in <https://github.com/mdn/content/issues/4367>.
## Tables
GFM provides a syntax for creating [tables](https://github.github.com/gfm/#tables-extension-), which we make use of in MDN. However, there are times when GFM tables do not suit our needs:
- The GFM syntax only supports a subset of the features available in HTML. If you need to use table features that are not supported in GFM, use HTML for the table.
- If the GFM representation of the table would be more than 150 characters wide, use HTML for the table.
- We support a special kind of table called a "properties table", which has its own CSS class and is therefore always HTML.
So the general principle is that authors should use the GFM Markdown syntax when they can, and fall back to raw HTML when they have to or when HTML is more readable. For more information, see [When to use HTML tables](#when_to_use_html_tables).
### GFM table syntax style
In GFM table syntax, authors can omit leading and trailing pipes for rows. However, for the sake of readability, MDN authors must include these pipes. Additionally, authors must provide trailing spaces in rows, so that all cells in a column are the same length in plain text.
That is, MDN authors must use this style:
```md example-good
| Heading 1 | Heading 2 | Heading 3 |
| --------- | --------- | --------- |
| cell 1 | cell 2 | cell 3 |
| cell 4 | cell 5 | cell 6 |
```
and not this style:
```md-nolint example-bad
| Heading 1 | Heading 2 | Heading 3 |
| --------- | --- |----------------------|
| cell 1 | cell 2 | cell 3 |
cell 4 | cell 5 | cell 6
```
Luckily, table formatting is auto-fixed by Prettier, so authors may rely on Prettier to format their tables properly.
### When to use HTML tables
There are three main circumstances in which authors should use HTML tables rather than GFM syntax:
1. The table uses features that are not supported in GFM (see below).
2. The GFM table would be too wide to be readable.
3. The writer wants a special type of table called a "properties table".
#### Table features that are not supported in GFM
The main limitations of GFM table syntax are:
- GFM tables must have a header row.
- GFM tables may not have a header column.
- GFM won't parse GFM block elements in table cells. For example, you can't have a list in a table cell.
- GFM tables cannot have classes assigned to them.
- GFM doesn't support any table elements beyond `<table>`, `<tr>`, `<th>`, and `<td>`.
- GFM doesn't support any table element attributes like `colspan`, `rowspan`, or `scope`.
If an author needs to use any of the unsupported features, they should write the table in HTML.
Note that we don't recommend the general use of `<caption>` elements on tables, since that would also rule out the GFM syntax.
#### GFM table maximum width
Even when a table could be written in GFM it is sometimes better to use HTML, because GFM uses an "{{Glossary("ASCII")}} art" approach to tables that is not readable when table rows get long. Consider the following table:
```html
<table>
<tr>
<th>A heading 1</th>
<th>A heading 2</th>
<th>A heading 3</th>
<th>A heading 4</th>
<th>A heading 5</th>
<th>A heading 6</th>
</tr>
<tr>
<td>Something shortish</td>
<td>
Something much longer that really goes into a lot of detail about
something, so much so that the table formatting starts to look bad in GFM
format.
</td>
<td>Something shortish</td>
<td>
Another cell with lots of text in it, that also really goes into a lot of
detail about something, so much so that the table formatting starts to
look bad in GFM format.
</td>
<td>Something shortish</td>
<td>Something shortish</td>
</tr>
</table>
```
In GFM this will look like:
```md
| A heading 1 | A heading 2 | A heading 3 | A heading 4 | A heading 5 | A heading 6 |
| ------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------------ | ------------------ |
| Something shortish | Something much longer that really goes into a lot of detail about something, so much so that the table formatting starts to look bad in GFM format. | Something shortish | Another cell with lots of text in it, that also really goes into a lot of detail about something, so much so that the table formatting starts to look bad in GFM format. | Something shortish | Something shortish |
```
In a case like this it would be better to use HTML.
This leads us to the following guideline: _if the Markdown representation of the table would be more than 150 characters wide, use HTML for the table_.
#### Properties tables
Properties tables are a specific type of table used for displaying structured property-value content across a set of pages of a particular type. These tables have two columns: the first column is the header column and lists the properties, and the second column lists their values for this particular item. For example, here's the properties table for the {{domxref("PannerNode")}} interface:
<table class="properties">
<tbody>
<tr>
<th scope="row">Number of inputs</th>
<td><code>1</code></td>
</tr>
<tr>
<th scope="row">Number of outputs</th>
<td><code>0</code></td>
</tr>
<tr>
<th scope="row">Channel count mode</th>
<td><code>"explicit"</code></td>
</tr>
<tr>
<th scope="row">Channel count</th>
<td><code>2</code></td>
</tr>
<tr>
<th scope="row">Channel interpretation</th>
<td><code>"speakers"</code></td>
</tr>
</tbody>
</table>
These pages can't be represented in GFM because they have a header column, so writers should use HTML in this case.
To get the special styling, writers should apply the `"properties"` class to the table:
```html
<table class="properties"></table>
```
### Discussion reference
This issue was resolved in <https://github.com/mdn/content/issues/4325>, <https://github.com/mdn/content/issues/7342>, and <https://github.com/mdn/content/issues/7898#issuecomment-913265900>.
## Superscript and subscript
Writers will be able to use the HTML {{HTMLElement("sup")}} and {{HTMLElement("sub")}} elements if necessary, but should use alternatives if possible. In particular:
- For exponentiation, use the caret: `2^53`.
- For ordinal expressions like 1<sup>st</sup>, prefer words like "first".
- For footnotes, don't mark up the footnote references, e.g., `<sup>[1]</sup>`.
### Discussion reference
This issue was resolved in <https://github.com/mdn/content/issues/4578>.
## Page summary
The _page summary_ is the first "content" paragraph in a page—the first text that appears after the page front matter and any [sidebar](/en-US/docs/MDN/Writing_guidelines/Page_structures/Macros/Commonly_used_macros#sidebar_generation) or [page banner](/en-US/docs/MDN/Writing_guidelines/Page_structures/Macros/Commonly_used_macros#page_or_section_header_indicators) macros.
This summary is used for search engine optimization (SEO) and also automatically included alongside page listings by some macros.
The first paragraph should therefore be both succinct and informative.
### Discussion reference
This issue was resolved in <https://github.com/mdn/content/issues/3923>.
## KumaScript
Writers will be able to include KumaScript macro calls in prose content:
```md
The **`margin`** [CSS](/en-US/docs/Web/CSS) property
sets the margin area on all four sides of an element. It is a shorthand for
\{{cssxref("margin-top")}}, \{{cssxref("margin-right")}}, \{{cssxref("margin-bottom")}},
and \{{cssxref("margin-left")}}.
\{{EmbedInteractiveExample("pages/css/margin.html")}}
The top and bottom margins have no effect on replaced inline elements, such as
\{{HTMLElement("span")}} or \{{HTMLElement("code")}}.
```
See [Using macros](/en-US/docs/MDN/Writing_guidelines/Page_structures/Macros) for more information on macros.
| 0 |
data/mdn-content/files/en-us/mdn/writing_guidelines/howto | data/mdn-content/files/en-us/mdn/writing_guidelines/howto/images_media/index.md | ---
title: How to add images and media
slug: MDN/Writing_guidelines/Howto/Images_media
page-type: mdn-writing-guide
---
{{MDNSidebar}}
## Adding images
To add an image to a document, add your image file to the document's folder, and then reference the image from within the document's `index.md` file using [Markdown image syntax](https://github.github.com/gfm/#images) or the equivalent HTML `<img>` element.
Let's walk through an example:
1. Start with a fresh working branch with the latest content from the `main` branch of the `mdn` remote.
```bash
cd ~/path/to/mdn/content
git checkout main
git pull mdn main
# Run "yarn" again just to ensure you've
# installed the latest Yari dependency.
yarn
git checkout -b my-images
```
2. Add your image to the document folder. For this example, let's assume
we're adding a new image to the `files/en-us/web/css` document.
```bash
cd ~/path/to/mdn/content
cp ../some/path/my-cool-image.png files/en-us/web/css/
```
3. Run `filecheck` on each image, which might complain if something's wrong.
For more details, see the [Compressing images](#compressing_images) section.
```bash
yarn filecheck files/en-us/web/css/my-cool-image.png
```
4. Reference your image in the document using the Markdown syntax for images, providing [descriptive text for the `alt` attribute](/en-US/docs/Learn/Accessibility/HTML#text_alternatives) between the brackets that describe the image, or include an {{htmlelement("img")}} element with `alt` attribute inside `files/en-us/web/css/index.md`:
```md
<img src="my-cool-image.png" alt="My cool image" />
```
5. Add and commit all of the deleted, created, and modified files, as well as
push your branch to your fork:
```bash
git add files/en-us/web/css/my-cool-image.png files/en-us/web/css/index.html
git commit
git push -u origin my-images
```
6. Now you're ready to create your
[pull request](https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/proposing-changes-to-your-work-with-pull-requests/creating-a-pull-request).
## Adding alternative text to images
Every image, `![]` and `<img>`, must include `alt` text.
Alt attributes should be short, providing all the relevant information the image conveys.
When writing the image description, think about the valuable information of the image and how you would relay that information to someone who can read the page's content but can't load images.
Make sure the alternative text for the image is based on its context.
If the photo of Fluffy the dog is an avatar next to a review for Yuckymeat dog food, `alt="Fluffy"` is appropriate.
If the same photo is part of Fluffy's animal rescue adoption page, the information conveyed in the image is relevant for prospective dog parents, such as `alt="Fluffy, a tri-color terrier with very short hair, with a tennis ball in her mouth."`.
The surrounding text likely has Fluffy's size and breed, so including it would be redundant.
Refrain from describing the image in too much detail: the prospective parent does not need to know if the dog is in- or outdoors or has a red collar and a blue leash.
With screenshots, write what you learn from the image, don't detail the screenshot's contents, and omit information readers don't need or already know.
For example, if you're on a page about changing settings on Bing, if you have a screenshot of a Bing search result, don't include the search term or number of results, etc., as those are not the point of the image.
Limit the alt to the topic at hand: how to change settings in Bing.
The alt might be `alt="The settings icon is in the navigation bar below the search field."`.
Don't include "screenshot" or "Bing" as the user doesn't need to know it's a screenshot and already knows it's Bing as they are on a page explaining changing Bing settings.
The syntax in markdown and HTML:
```md-nolint
<img alt="<alt-text>" src="<url-of-image>">
```
Examples:
```md
<img alt="OpenWebDocs Logo: Carle the book worm" src="carle.png" />
```
While purely decorative images should have an empty `alt`, images added to MDN documentation should have a purpose, and therefore require a non-empty-string description.
## Compressing images
When you add images to a page on MDN Web Docs, you should make sure that they are compressed as much as possible (without degrading quality) to save on the download size for our readers.
In fact, if you don't do this, our CI process will fail and the build results will warn you that some of your images are too big.
The best way to compress the images is by using the built-in compression tool.
You can compress an image appropriately by using the `filecheck` command with the `--save-compression` option.
This option compresses the image as much as possible and replaces the original with the compressed version.
For example:
```bash
yarn filecheck files/en-us/web/css/my-cool-image.png --save-compression
```
## Adding videos
MDN Web Docs is not a very video-heavy site, but there are certain places where video content makes sense to use as part of an article.
This article discusses when including videos in articles is appropriate and provides tips on how to create simple but effective videos on a budget.
There are several arguments against using video content for technical documentation, particularly for reference material and advanced level guides. Some of these are listed below:
- Video is linear.
People don't tend to read online documentation in a linear fashion, starting at the start and reading through to the end.
_They scan._
Video is really hard to scan — it forces the user to consume the content start-to-finish.
- Video is less information-dense than text.
It takes longer to consume a video explaining something than it does to read the equivalent instructions.
- Video is big in terms of file size, and therefore, more expensive and less performant than text.
- Video has accessibility problems: it's more expensive to produce generally than text, but especially to localize, or make usable by screen reader users.
- Following on from the last point, video is much harder to edit/update/maintain than text content.
> **Note:** It's worth keeping these problems in mind even when you are making videos, so you can try to alleviate some of them.
There are many popular video sites that provide a lot of video tutorials.
MDN Web Docs isn't a video-driven site, but video does have a place on MDN Web Docs in certain contexts.
We tend to most commonly use video when describing some kind of instruction sequence or multi-step workflow that would be hard to describe concisely in words: _"do this, then do that, then this will happen"_.
It is especially useful when trying to describe processes that cross over multiple applications or windows and that include GUI interactions that might not be simple to describe: _"now click on the button near the top-left that looks a bit like a duck"_.
In such cases, it is often more effective to just **show** what you mean.
<!-- We most commonly use videos when explaining features of the [Firefox DevTools](https://firefox-source-docs.mozilla.org/devtools-user/index.html).-->
## Guidelines for video content
Video content for MDN Web Docs should be:
- **Short**: Try to keep videos under 30 seconds, ideally under 20 seconds.
This is short enough not to make big demands on readers' attention spans.
- **Simple**: Try to make the workflow simple, 2-4 distinct pieces.
This makes them easier to follow.
- **Silent**: Audio makes videos much more engaging, but they are much more time-consuming to make.
Also, having to explain what you're doing makes the videos much longer and adds to the costs (both financial and in terms of time) of localization.
To explain something more complex, you can use a blend of short videos and screenshots, interspersed with text.
The text can help reinforce the points made in the video, and the user can rely on the text or the video as they choose.
See [Working with the Animation Inspector](https://firefox-source-docs.mozilla.org/devtools-user/page_inspector/how_to/work_with_animations/index.html#animation-inspector) for a good example.
In addition, you should consider the following tips:
- The video will end up being uploaded to YouTube before embedding.
We recommend a 16:9 aspect ratio for this use, so that it fills up the entire viewing frame and you don't end up with ugly black bars on the top and bottom (or left and right) of your video.
So for example, you might choose a resolution of 1024×576, 1152×648, or 1280×720.
- Record the video in HD, so that it looks better when uploaded.
- For DevTools videos, it is often a good idea to choose a contrasting theme to the page content. For example, choose the dark theme if the example webpage is light-themed. It is easier to see what is going on and where the DevTools start and the page ends.
- For DevTools videos, zoom in the DevTools as much as you can while still showing everything you want to show and making it look OK.
- Make sure the thing you are trying to demonstrate isn't covered up by the mouse cursor.
- Consider whether or not it would be useful to configure the screen recording tool to add a visual indicator of mouse clicks.
## Guidelines for video tools
You'll need a tool for recording the video.
These range from free to expensive and simple to complex.
If you are already experienced in creating video content, then great.
If not, then we'd recommend that you start with a simple tool and then work up to something more complex if you start to enjoy creating video content and want to create more interesting productions.
The following table provides some recommendations for good starter tools:
| Tool | OS | Cost | Post-production features available? |
| ------------------------- | --------------------- | ------ | ----------------------------------- |
| Open Broadcaster Software | macOS, Windows, Linux | Free | Yes |
| CamStudio | Windows | Free | Limited |
| Camtasia | Windows, macOS | High | Yes |
| QuickTime Player | macOS | Free | No, just allows simple recording |
| ScreenFlow | macOS | Medium | Yes |
| Kazam | Linux | Free | Minimal |
### QuickTime Player tips
If you are using macOS, you should have QuickTime Player available.
The recording steps using this tool are pretty simple:
1. Choose _File_ > _New Screen Recording_ from the main menu.
2. In the _Screen Recording_ box, hit the record button (the red round button).
3. Drag a rectangle round the area of the screen you want to record.
4. Press the _Start Recording_ button.
5. Perform whatever actions you want to record.
6. Press the _Stop_ button.
7. Choose _File_ > _Export As..._ > _1080p_ from the main menu to save as hi definition.
### Other resources
- [How to Add Custom Callouts to Screencast Videos in Screenflow](https://photography.tutsplus.com/tutorials/how-to-add-custom-callouts-to-screencast-videos-in-screenflow--cms-27122)
## Workflow for creating videos
The following subsections describe the general steps you'd want to follow to create a video and add it to an MDN Web Docs article.
### Preparing
First, plan the flow you want to capture: consider the best points to start and end.
Make sure the desktop background and your browser profile are clean.
Plan the size and positioning of browser windows, especially if you will be using multiple windows.
Plan carefully what you are actually going to record, and practice the steps a few times before recording them:
- Don't start a video in the middle of a process — consider whether the viewer will have enough context for your actions to make sense of them.
In a short DevTools video for example, it is a good idea to start by opening the DevTools to allow the viewer to get oriented.
- Consider what your actions are, slow down, and make them obvious.
Whenever you have to perform an action (say, click an icon), take it slow and make it obvious. So, for example:
- Move the mouse over the icon.
- Highlight or zoom (not always, depending on whether it feels needed).
- Pause for a beat.
- Click the icon.
- Plan zoom levels for the parts of the UI that you're going to show.
Not everyone will be able to view your video in high definition.
You will be able to zoom particular parts in post-production, but it's a good idea to zoom the app beforehand as well.
> **Note:** Don't zoom so far that the UIs you are showing start to look unfamiliar or ugly.
### Recording
When recording the workflow you want to show, go through the flow smoothly and steadily.
Pause for a second or two when you are at key moments — for example, when you're about to click a button.
Make sure the mouse pointer doesn't obscure any icons or text that are important to what you are trying to demonstrate.
Remember to pause for a second or two at the end to show the result of the flow.
> **Note:** If you are using a really simple tool like QuickTime Player and post production is not an option for some reason, you should get your windows set up in the right size to show the area you want to show. In the Firefox DevTools, you can use the [Rulers Tool](https://firefox-source-docs.mozilla.org/devtools-user/rulers/index.html) to make sure the viewport is at the right aspect ratio for the recording.
### Post-processing
You'll be able to highlight key moments in post-production.
A highlight can consist of a couple of things, which you'll often combine, like:
- Zoom in on parts of the screen.
- Fade the background.
Highlight key moments of the workflow, especially where the detail is hard to see: clicking on a particular icon or entering a particular URL, for example.
Aim for the highlight to last for 1-2 seconds.
It's a good idea to add a short transition (200-300 milliseconds) at the start and end of the highlights.
Use some restraint here: don't make the video a constant procession of zooming in and out, otherwise viewers will get seasick.
Crop the video to the desired aspect ratio, if required.
### Uploading
Videos currently have to be uploaded to YouTube to be displayed on MDN Web Docs, for example, to the [mozhacks](https://www.youtube.com/user/mozhacks/videos) channel.
Ask a member of MDN Web Docs team to upload the video if you don't have somewhere appropriate to put it.
> **Note:** Mark the video as "unlisted" if it doesn't make sense out of the context of the page (if it's a short video, then it probably doesn't).
### Embedding
Once uploaded, you can embed the video in the page using the [`EmbedYouTube`](https://github.com/mdn/yari/blob/main/kumascript/macros/EmbedYouTube.ejs) macro.
This is used by inserting the following in your page at the position you want the video to appear:
```plain
\{{EmbedYouTube("you-tube-url-slug")}}
```
The single property taken by the macro call is the string of characters at the end of the video URL, not the whole URL.
For example, if the video URL is `https://www.youtube.com/watch?v=ELS2OOUvxIw`, the required macro call will be:
```plain
\{{EmbedYouTube("ELS2OOUvxIw")}}
```
| 0 |
data/mdn-content/files/en-us/mdn/writing_guidelines/howto | data/mdn-content/files/en-us/mdn/writing_guidelines/howto/document_web_errors/index.md | ---
title: How to document web errors
slug: MDN/Writing_guidelines/Howto/Document_web_errors
page-type: mdn-writing-guide
---
{{MDNSidebar}}
The [JavaScript error reference](/en-US/docs/Web/JavaScript/Reference/Errors) on MDN Web Docs is a project to help web developers with errors occurring in the [Developer Console](https://firefox-source-docs.mozilla.org/devtools-user/web_console/index.html). For this project, we need to write more error documentation on MDN Web Docs so that we can add more links to the tools where the messages are thrown. This article explains how to document the web errors.
JavaScript errors contain a "Learn more" link that takes you to the JavaScript error reference containing additional advice for fixing issues. To be able to document the web errors, you will need to know or be able to dive into some [JavaScript](/en-US/docs/Web/JavaScript).
## Step 1 – Determine the error to document
- Firefox/Gecko's error messages: <https://github.com/mozilla/gecko-dev/blob/master/js/src/jsshell.msg>
- Edge/Chakra's error messages: <https://github.com/Microsoft/ChakraCore/blob/master/lib/Parser/rterrors.h>
- Chrome/v8's error messages: <https://chromium.googlesource.com/v8/v8.git/+/refs/heads/main/src/execution/messages.h>
## Step 2 – Check the existing error documentation
- Look at the existing [JavaScript error reference](/en-US/docs/Web/JavaScript/Reference/Errors) and see how errors are documented.
- Depending on which type of error you want to write about, you can take a closer look at these pages.
- You might want to copy the content of an existing page to kick off your new page.
## Step 3 – Create the new error page
- All error pages live under this tree: [/docs/Web/JavaScript/Reference/Errors](/en-US/docs/Web/JavaScript/Reference/Errors)
- To create a new page, see the instructions in our [how to create a page](/en-US/docs/MDN/Writing_guidelines/Howto/Creating_moving_deleting) guide.
## Step 4 – Document the error
- Either use a copied structure from one of the existing error documents or start from scratch. Your choice!
- You should have at least:
- A syntax box containing the message as thrown in different browsers.
- The error type.
- A text that explains why this error happened and what its consequences are. Go beyond the thrown message.
- Examples showcasing the error (there might be more than one!) and an example showing how to fix the code.
- Pointers to other reference material on MDN Web Docs.
## Step 5 – Get the content reviewed
After you've created the error page, submit it as a pull request. A member of our review team will be assigned automatically to review your page.
| 0 |
data/mdn-content/files/en-us/mdn/writing_guidelines/howto | data/mdn-content/files/en-us/mdn/writing_guidelines/howto/write_an_api_reference/index.md | ---
title: How to write an API reference
slug: MDN/Writing_guidelines/Howto/Write_an_api_reference
page-type: mdn-writing-guide
---
{{MDNSidebar}}
This guide takes you through all you need to know to write an API reference on MDN.
## Getting prepared
Before starting to document an API, there are some things you should prepare and plan in advance of starting to actually write.
### Prerequisite knowledge
It is assumed that before reading this guide you have a reasonable knowledge of:
- Web technologies like HTML, CSS and JavaScript. JavaScript is most important.
- Reading Web technology specs. You'll be looking at these a lot as you document APIs.
Everything else can be learned along the way.
### Prerequisite resources
Before starting to document an API, you should have available:
1. The latest spec:
Whether it is a W3C Recommendation or an early editor's draft, you should refer to the latest available draft of the spec that covers (or specs that cover) that API.
To find it, you can usually do a Web search. The latest version will often be linked to from all versions of the spec, listed under "latest draft" or similar.
2. The latest modern web browsers:
These should be experimental/alpha builds such as [Firefox Nightly](https://www.mozilla.org/en-US/firefox/channel/desktop/)/[Chrome Canary](https://www.google.com/intl/en/chrome/canary/) that are more likely to support the features you are documenting.
This is especially pertinent if you are documenting a nascent/experimental API.
3. Demos/blog posts/other info: Find as much info as you can.
4. Useful engineering contacts:
It is really useful to find yourself a friendly engineering contact to ask questions about the spec, someone who is involved in the standardization of the API, or its implementation in a browser.
Good places to find them are:
- Your internal company address book, if you work for a relevant company.
- A public mailing list that is involved in the discussion of that API, such as Mozilla's [dev-platform](https://groups.google.com/a/mozilla.org/g/dev-platform/) or a W3C list like [public-webapps](https://lists.w3.org/Archives/Public/public-webapps/).
- The spec itself. For example, the [Web Audio API spec](https://webaudio.github.io/web-audio-api/) lists the authors and their contact details at the top.
### Take some time to play with the API
You will return to build demos many times through the course of documenting an API, but it is useful to start by spending time familiarizing yourself with how the API works — learn what the main interfaces/properties/methods are, what the primary use cases are, and how to write simple functionality with it.
When an API has changed, you need to be careful that existing demos you refer to or learn from are not out of date. Check the main constructs that are used in the demo to see if they match up to the latest spec. They may also not work in up-to-date browsers, but this is not a very reliable test, as often the old features continue to be supported for backwards compatibility.
> **Note:** If the spec has been recently updated so that, say, a method is now defined differently, but the old method still works in browsers, you will often have to document both in the same place, so that the old and new methods are covered.
> If you need help, refer to demos you have found, or ask an engineering contact.
### Create the list of documents you need to write or update
An API reference will generally contain the following pages.
You can find more details of what each page contains, examples, and templates, in our [Page types](/en-US/docs/MDN/Writing_guidelines/Page_structures/Page_types) article.
Before you start you should write down a list of all the pages you should create.
1. Overview page
2. Interface pages
3. Constructor pages
4. Method pages
5. Property pages
6. Event pages
7. Concept/guide pages
8. Examples
> **Note:** We'll be referring to the [Web Audio API](/en-US/docs/Web/API/Web_Audio_API) for examples in this article.
#### Overview pages
A single API overview page is used to describe the role of the API, its top-level interfaces, related features contained in other interfaces, and other high level details.
Its name and slug should be the name of the API plus "API" on the end. It is placed at the top level of the API reference, as a child of [https://developer.mozilla.org/en-US/docs/Web/API](/en-US/docs/Web/API).
Example:
- Title: _Web Audio API_
- Slug: _Web_Audio_API_
- URL: [https://developer.mozilla.org/en-US/docs/Web/API/Web_Audio_API](/en-US/docs/Web/API/Web_Audio_API)
#### Interface pages
Each interface will have its own page too, describing the purpose of the interface, listing any members (constructors, methods, properties, etc. it contains), and showing what browsers it is compatible with.
A page's name and slug should be the name of the interface, exactly as written in the spec.
Each page is placed at the top level of the API reference, as a child of [https://developer.mozilla.org/en-US/docs/Web/API](/en-US/docs/Web/API).
Examples:
- Title: _AudioContext_
- Slug: _AudioContext_
- URL: [https://developer.mozilla.org/en-US/docs/Web/API/AudioContext](/en-US/docs/Web/API/AudioContext)
<!---->
- Title: _AudioNode_
- Slug: _AudioNode_
- URL: [https://developer.mozilla.org/en-US/docs/Web/API/AudioNode](/en-US/docs/Web/API/AudioNode)
> **Note:** We document every member appearing in the interface. You should bear the following rules in mind:
- We document methods defined on the prototype of an object implementing this interface (instance methods), and methods defined on the actual class itself (static methods).
On the rare occasions that they both exist on the same interface, you should list them in separate sections on the page (Static methods/Instance methods).
Usually only instance methods exist, in which case you can put these under the title "Methods".
- We do not document inherited properties and methods of the interface: they are listed on the respective parent interface. We do hint at their existence though.
- We do document properties and methods defined in mixins. Please see the [contribution guide for mixins](/en-US/docs/MDN/Writing_guidelines/Howto/Write_an_API_reference/Information_contained_in_a_WebIDL_file#mixins) for more details.
- Special methods like the stringifier (`toString()`) and the jsonizer (`toJSON()`) are also listed if they do exist.
- Named constructors (like `Image()` for {{domxref("HTMLImageElement")}}) are also listed, if relevant.
#### Constructor pages
Each interface has 0 or 1 constructors, documented on a subpage of the interface's page. It describes the purpose of the constructor and shows what its syntax looks like, usage examples, browser compatibility information, etc. Its slug is the name of the constructor, which is exactly the same as the interface name, and the title is interface name, dot, constructor name, then parentheses on the end.
Example:
- Title: _AudioContext.AudioContext()_
- Slug: _AudioContext_
- URL: [https://developer.mozilla.org/en-US/docs/Web/API/AudioContext/AudioContext](/en-US/docs/Web/API/AudioContext/AudioContext)
#### Property pages
Each interface has zero or more properties, documented on subpages of the interface's page. Each page describes the purpose of the property and shows what its syntax looks like, usage examples, browser compatibility information, etc. Its slug is the name of the property, and the title is interface name, dot, then property name.
Examples:
- Title: _AudioContext.state_
- Slug: _state_
- URL: [https://developer.mozilla.org/en-US/docs/Web/API/AudioContext/state](/en-US/docs/Web/API/BaseAudioContext/state)
<!---->
#### Method pages
Each interface has zero or more methods, documented on subpages of the interface's page. Each page describes the purpose of the method and shows what its syntax looks like, usage examples, browser compatibility information, etc. Its slug is the name of the method, and the title is interface name, dot, method name, then parentheses.
Examples:
- Title: _AudioContext.close()_
- Slug: _close_
- URL: [https://developer.mozilla.org/en-US/docs/Web/API/AudioContext/close](/en-US/docs/Web/API/AudioContext/close)
<!---->
- Title: _AudioContext.createGain()_
- Slug: _createGain_
- URL: [https://developer.mozilla.org/en-US/docs/Web/API/AudioContext/createGain](/en-US/docs/Web/API/BaseAudioContext/createGain)
#### Event pages
Document events as sub pages of their target interfaces and use the slug _eventname_\_event with the title set to `Interface: eventName event`.
Don't create pages for `on` event handler properties. Mention both ways to access the event on the `eventName_event` page.
Example:
- Title: XRSession: end event
- Slug: end_event
- URL: [https://developer.mozilla.org/en-US/docs/Web/XRSession/end_event](/en-US/docs/Web/API/XRSession/end_event)
#### Concept/guide pages
Most API references have at least one guide and sometimes also a concept page to accompany it. At minimum, an API reference should contain a guide called "Using the _name-of-api_", which will provide a basic guide to how to use the API. More complex APIs may require multiple usage guides to explain how to use different aspects of the API.
If required, you can also include a concepts article called "_name-of-api_ concepts", which will provide explanation of the theory behind any concepts related to the API that developers should understand to effectively use it.
These articles should all be created as subpages of the API overview page. For example, the Web Audio has four guides and a concept article:
- [https://developer.mozilla.org/en-US/docs/Web/API/Web_Audio_API/Using_Web_Audio_API](/en-US/docs/Web/API/Web_Audio_API/Using_Web_Audio_API)
- [https://developer.mozilla.org/en-US/docs/Web/API/Web_Audio_API/Visualizations_with_Web_Audio_API](/en-US/docs/Web/API/Web_Audio_API/Visualizations_with_Web_Audio_API)
- [https://developer.mozilla.org/en-US/docs/Web/API/Web_Audio_API/Web_audio_spatialization_basics](/en-US/docs/Web/API/Web_Audio_API/Web_audio_spatialization_basics)
- [https://developer.mozilla.org/en-US/docs/Web/API/Web_Audio_API/Basic_concepts_behind_Web_Audio_API](/en-US/docs/Web/API/Web_Audio_API/Basic_concepts_behind_Web_Audio_API)
#### Examples
You should create some examples that demonstrate at least the most common use cases of the API. You can put these anywhere that is appropriate, although the recommended place is the [MDN GitHub repo](https://github.com/mdn/).
#### Listing them all
Creating a list of all these subpages is a good way to track them. For example:
- Web_Audio_API
- AudioContext
- AudioContext.currentTime
- AudioContext.destination
- AudioContext.listener
- …
- AudioContext.createBuffer()
- AudioContext.createBufferSource()
- …
- AudioNode
- AudioNode.context
- AudioNode.numberOfInputs
- AudioNode.numberOfOutputs
- …
- AudioNode.connect(Param)
- …
- AudioParam
- Events (update list)
- start
- end
- …
Each interface in the list has a separate page created for it as a subpage of `https://developer.mozilla.org/en-US/docs/Web/API`; for example, the document for {{domxref("AudioContext")}} would be located at `https://developer.mozilla.org/en-US/docs/Web/API/AudioContext`. Each [interface page](#interface_pages) explains what that interface does and provides a list of the methods and properties that comprise the interface. Then each method and property is documented on its own page, which is created as a subpage of the interface it's a member of. For instance, {{domxref("BaseAudioContext/currentTime")}} is documented at `https://developer.mozilla.org/en-US/docs/Web/API/AudioContext/currentTime`.
## Create the pages
Now create the pages you need, according to the structures below. Our [MDN content README](https://github.com/mdn/content#adding-a-new-document) contains instructions on creating a new document, and our [Page types](/en-US/docs/MDN/Writing_guidelines/Page_structures/Page_types) guide contains further examples and page templates that might be useful.
### Structure of an overview page
API landing pages will differ greatly in length, depending on how big the API is, but they will all have basically the same features. See [https://developer.mozilla.org/en-US/docs/Web/API/Web_Audio_API](/en-US/docs/Web/API/Web_Audio_API) for an example of a big landing page.
The features of a landing page are outlined below:
1. **Description**: the first paragraph of the landing page should provide a short, concise description of the API's overarching purpose.
2. **Concepts and usage section**: The next section should be titled "\[name of API] concepts and usage", and provide an overview of all the main functionality that the API provides, what problems it solves, and how it works — all at a high level. This section should be fairly short, and not go into code or specific implementation details.
3. **List of interfaces**: This section should be titled "\[name of API] interfaces", and provide links to the reference page for each interface that makes up the API, along with a short description of what each one does. See the "Referencing other API features with the \\{{domxref}} macro" section for a quicker way to create new pages.
4. **Examples**: This section should show a simple use case or two for the API.
5. **Specifications table**: At this point you need to include a specifications table — see the "Creating a spec reference table" section for more details.
6. **Browser compatibility**: Now you need to include a browser compatibility table. See [Compatibility tables](/en-US/docs/MDN/Writing_guidelines/Page_structures/Compatibility_tables) for details.
7. **See also**: The "See also" section is a good place to include further links that may be useful when learning about this technology, including MDN (and external) tutorials, examples, libraries, etc.
### Structure of an interface page
Now you should be ready to start writing your interface pages. Each interface reference page should observe the following structure:
1. **\\{{APIRef}}**: Include the \\{{APIRef}} macro in the first line of each interface page, including the name of the API as an argument, so for example \\{{APIRef("Web Audio API")}}. This macro serves to construct a reference menu on the left-hand side of the interface page, including properties and methods, and other quick links as defined in the [GroupData](https://github.com/mdn/content/blob/main/files/jsondata/GroupData.json) macro (ask someone to add your API to an existing GroupData entry, or to create a new one, if it isn't already listed there). The menu will look something like the below screenshot.
2. **Standardization status**: The banner indicating the standardization status should be added next (these can be placed on the same line as the \\{{APIRef}} macro.):
- \\{{SeeCompatTable}} for an experimental feature (i.e. the spec is not at the CR level.)
- \\{{Deprecated_header}}
- \\{{Non-standard_header}}
3. **Description**: the first paragraph of the interface page should provide a short concise description of the interface's overarching purpose. You may also want to include a couple more paragraphs if any additional description is required. If the interface is actually a dictionary, you should use that term instead of "interface".
4. **Inheritance diagram:** Use the [`\{{InheritanceDiagram}}`](https://github.com/mdn/yari/blob/main/kumascript/macros/InheritanceDiagram.ejs) macro to embed an SVG inheritance diagram for the interface.
5. **List of properties, List of methods**: These sections should be titled "Properties" and "Methods", and provide links (using the \\{{domxref}} macro) to a reference page for each property/method of that interface, along with a description of what each one does. These should be marked up using [description/definition lists](/en-US/docs/MDN/Writing_guidelines/Howto/Markdown_in_MDN#definition_lists). Each description should be short and concise — one sentence if possible. See the "Referencing other API features with the \\{{domxref}} macro" section for a quicker way to create links to other pages.
At the beginning of both sections, before the beginning of the list of properties/methods, indicate inheritance using the appropriate sentence, in italics:
- _This interface doesn't implement any specific properties, but inherits properties from \\{{domxref("XYZ")}}, and \\{{domxref("XYZ2")}}._
- _This interface also inherits properties from \\{{domxref("XYZ")}}, and \\{{domxref("XYZ2")}}._
- _This interface doesn't implement any specific methods, but inherits methods from \\{{domxref("XYZ")}}, and \\{{domxref("XYZ2")}}._
- _This interface also inherits methods from \\{{domxref("XYZ")}}, and \\{{domxref("XYZ2")}}._
> **Note:** Properties that are read-only should have the \\{{ReadOnlyInline}} macro, which creates a nifty little "Read only" badge, included on the same line as their \\{{domxref}} links (after the use of the \\{{experimentalInline}}, \\{{non-standard_Inline}} and \\{{deprecatedInline}} macros, if some of these are needed.
6. **Examples**: Include a code listing to show typical usage of a major feature of the API. Rather than listing ALL the code, you should list an interesting subset of it. For a complete code listing, you could reference a [GitHub](https://github.com/) repo containing the full example, and you could also link to a live example created using the [GitHub gh-pages](https://docs.github.com/en/pages/getting-started-with-github-pages/creating-a-github-pages-site) feature (so long as it uses only client-side code of course.) If the example is visual, you could also use the MDN [Live Sample](/en-US/docs/MDN/Writing_guidelines/Page_structures/Live_samples) feature to make it live and playable in the page.
7. **Specifications table**: At this point you need to include a specifications table — see the "Creating a spec reference table" section for more details.
8. **Browser compatibility**: Now you need to include a browser compatibility table. See [Compatibility tables](/en-US/docs/MDN/Writing_guidelines/Page_structures/Compatibility_tables) for details.
9. **Polyfill**: If appropriate, include this section, providing code for a polyfill that enables the API to be used even on browsers that don't implement it. If no polyfill exists or is needed, leave this section out entirely.
10. **See also**: The "See also" section is a good place to include further links that may be useful when learning about this technology, including MDN (and external) tutorials, examples, libraries, etc. We have a liberal policy for linking to external sources, but pay attention:
- Do not include pages with the same information as another page in the MDN; link to that page instead.
- Do not put author names — we are a writer-neutral documentation site. Link to the document; the author name will be displayed there.
- Pay special attention to blog posts: they tend to become outdated (old syntax, wrong compat information). Link to them only if they have a clear added value that can't be found in a maintained document.
- Do not use action verb like "See … for more information" or "Click to…", you don't know if your reader is able to see, or to click on the link (like on a paper version of the document).
#### Interface page examples
The following are exemplary examples of Interface pages:
- {{domxref("Request")}} from the [Fetch API](/en-US/docs/Web/API/Fetch_API).
- {{domxref("SpeechSynthesis")}} from the [Web Speech API](/en-US/docs/Web/API/Web_Speech_API).
### Structure of a property page
Create your property pages as subpages of the interface they are implemented on. Copy the structure of another property page to act as the basis for your new page.
Edit the property page name to follow the `Interface.property_name` convention.
Property pages must have the following sections:
1. **Title**: the title of the page must be **InterfaceName.propertyName**. The interface name must start with a capital letter. Although an interface is implemented in JavaScript on the prototype of objects, we don't include `.prototype.` in the title, like we do in the [JavaScript reference](/en-US/docs/Web/JavaScript/Reference).
2. **\\{{APIRef}}**: Include the \\{{APIRef}} macro in the first line of each property page, including the name of the API as an argument, so for example \\{{APIRef("Web Audio API")}}. This macro serves to construct a reference menu on the left-hand side of the interface page, including properties and methods, and other quick links as defined in the [GroupData](https://github.com/mdn/content/blob/main/files/jsondata/GroupData.json) macro (ask someone to add your API to an existing GroupData entry, or to create a new one, if it isn't already listed there). The menu will look something like the below screenshot.
3. **Standardization status**: The banner indicating the standardization status should be added next to the interface name (these can be placed on the same line as the \\{{APIRef}} macro):
- \\{{SeeCompatTable}} for an experimental feature (i.e. the spec is not at the CR level.)
- \\{{Deprecated_header}}
- \\{{Non-standard_header}}
4. **Description**: the first paragraph of the property page should provide a short, concise description of the property's overarching purpose. You may also want to include a couple more paragraphs if any additional description is required. Obvious extra information to include is its default/initial value, and whether it's read only or not. The structure of the first sentence must be:
- For read-only properties
- : The **`InterfaceName.property`** read-only property returns a \\{{domxref("type")}} that…
- For other properties
- : The **`InterfaceName.property`** property is a \\{{domxref("type")}} that…
> **Note:** `InterfaceName.property` should be in `<code>`, and should additionally be in bold (`<strong>`) the first time it's used.
5. **Value**: The Value section will contain a description of the property's value. This should contain the data type of the property, and what it represents. For an example, see {{domxref("SpeechRecognition.grammars")}}
6. **Examples**: Include a code listing to show typical usage of the property in question. You should start with a simple example that shows how an object of the type is created and how to access the property. More complex examples can be added after such an example. In these additional examples, rather than listing ALL the code, you should list an interesting subset of it. For a complete code listing, you can reference a [GitHub](https://github.com/) repo containing the full example, and you could also link to a live example created using the [GitHub gh-pages feature](https://docs.github.com/en/pages/getting-started-with-github-pages/creating-a-github-pages-site) (so long as it uses only client-side code of course.) If the example is visual, you could also use the MDN [Live Sample](/en-US/docs/MDN/Writing_guidelines/Page_structures/Live_samples) feature to make it live and playable in the page.
7. **Specifications table**: At this point you need to include a specifications table — see the "Creating a spec reference table" section for more details.
8. **Browser compatibility**: Now you need to include a browser compatibility table. See [Compatibility tables](/en-US/docs/MDN/Writing_guidelines/Page_structures/Compatibility_tables) for details.
9. **See also**: The "See also" section is a good place to include further links that may be useful when using this technology: like methods and properties affected by a change of this property or events thrown in relation to it. More links useful when learning about this technology, including MDN (and external) tutorials, examples, libraries,… can be added, though it may be useful to consider adding them on the interface reference page instead.
#### Property page examples
The following are exemplary examples of property pages:
- {{domxref("Request.method")}} from the [Fetch API](/en-US/docs/Web/API/Fetch_API).
- {{domxref("SpeechSynthesis.speaking")}} from the [Web Speech API](/en-US/docs/Web/API/Web_Speech_API).
### Structure of a method page
Create your method pages as subpages of the interface they are implemented on. Copy the structure of another method page to act as the basis for your new page.
Method pages need the following sections:
1. **Title**: the title of the page must be **InterfaceName.method()** (with the two terminal parentheses), but the slug (the end of the page URL) must not include the parentheses. Also the interface name must start with a capital. Although an interface is implemented in JavaScript on the prototype of objects, we don't put `.prototype.` in the title, like we do in the [JavaScript reference](/en-US/docs/Web/JavaScript/Reference).
2. **\\{{APIRef}}**: Include the \\{{APIRef}} macro in the first line of each method page, including the name of the API as an argument, so for example \\{{APIRef("Web Audio API")}}. This macro serves to construct a reference menu on the left-hand side of the interface page, including properties and methods, and other quick links as defined in the [GroupData](https://github.com/mdn/content/blob/main/files/jsondata/GroupData.json) macro (ask someone to add your API to an existing GroupData entry, or to create a new one, if it isn't already listed there). The menu will look something like the below screenshot.
3. **Standardization status**: Next, the banner indicating the standardization status should be added (these can be placed on the same line as the \\{{APIRef}} macro):
- \\{{SeeCompatTable}} for an experimental feature (i.e. the spec is not at the CR level.)
- \\{{Deprecated_header}}
- \\{{Non-standard_header}}
4. **Description**: The first paragraph of the method page should provide a short concise description of the method's overarching purpose. You may also want to include a couple more paragraphs if any additional description is required. Obvious extra information to include is its default parameter values, any theory that the method relies on, and what the parameter values do.
- The beginning of the first sentence must follow the following structure:
- : The **`InterfaceName.method()`** method interface …
> **Note:** `InterfaceName.method()` should be in `<code>`, and should also be in bold (`<strong>`) the first time it's used.
5. **Syntax**: The syntax section should include a 2–3 line example — usually just construction of the interface, then calling of the interface method.
- The syntax should be of the form:
- : method(param1, param2, …)
The syntax section should include three subsections (see {{domxref("SubtleCrypto.sign()")}} for an example):
- "Parameters": This should contain a definition list (or unordered list) that names and describes the different parameters the method takes. You should include the {{optional_inline}} macro next to the parameter name, in the case of optional parameters. If there are no parameters, this section should be omitted.
- "Return value": This should say what return value the method has, be it a simple value like a double or boolean, or a more complex value like another interface object, in which case you can use \\{{domxref}} macro to link to the MDN API page covering that interface (if it exists.) A method might return nothing, in which case the return value should be written as "\\{{jsxref('undefined')}}" (which will look like this in the rendered page: {{jsxref("undefined")}}).
- "Exceptions": This should list the different exceptions that can be raised when invoking the method, and what circumstances cause them. If there are no exceptions, this section should be omitted.
6. **Examples**: Include a code listing to show typical usage of the method in question. Rather than listing ALL the code, you should list an interesting subset of it. For a complete code listing, you should reference a [GitHub](https://github.com/) repo containing the full example, and you could also link to a live example created using the [GitHub gh-pages feature](https://docs.github.com/en/pages/getting-started-with-github-pages/creating-a-github-pages-site) (so long as it uses only client-side code of course.) If the example is visual, you could also use the MDN [Live Sample](/en-US/docs/MDN/Writing_guidelines/Page_structures/Live_samples) feature to make it live and playable in the page.
7. **Specifications table**: At this point you need to include a specifications table — see the "Creating a spec reference table" section for more details.
8. **Browser compatibility**: Now you need to include a browser compatibility table. See [Compatibility tables](/en-US/docs/MDN/Writing_guidelines/Page_structures/Compatibility_tables) for details.
#### Method page examples
The following are exemplary examples of method pages:
- {{domxref("Document.getAnimations")}} from the [Web Animations API](/en-US/docs/Web/API/Web_Animations_API).
- {{domxref("fetch()")}} from the [Fetch API](/en-US/docs/Web/API/Fetch_API).
## Sidebars
Once you've created your API reference pages, you'll want to insert the correct sidebars on them to associate the pages together. Our [API reference sidebars](/en-US/docs/MDN/Writing_guidelines/Howto/Write_an_API_reference/Sidebars) guide explains how.
| 0 |
data/mdn-content/files/en-us/mdn/writing_guidelines/howto/write_an_api_reference | data/mdn-content/files/en-us/mdn/writing_guidelines/howto/write_an_api_reference/sidebars/index.md | ---
title: API reference sidebars
slug: MDN/Writing_guidelines/Howto/Write_an_API_reference/Sidebars
page-type: mdn-writing-guide
---
{{MDNSidebar}}
You are able to include a custom sidebar on API reference pages it so that it displays links to related Interfaces, tutorials, and other resources relevant just to that API.
This article explains how.
## Creating a sidebar
You need to take the following three steps to create your API sidebar:
1. Create your API reference pages.
2. Add an entry for your particular API into the [`GroupData.json`](https://github.com/mdn/content/blob/main/files/jsondata/GroupData.json) file.
3. Use the [`APIRef`](https://github.com/mdn/yari/blob/main/kumascript/macros/APIRef.ejs) macro to insert the sidebar into each page you want to display it on.
Let's run through each of these steps in turn.
The example we'll refer to in this article is the [Fetch API](/en-US/docs/Web/API/Fetch_API).
### Adding an entry to GroupData.json
The `GroupData.json` file holds all the data relating to what links should appear in API reference sidebars.
When invoked, the `APIRef` macro takes an API name given to it as a parameter, looks up that name in `GroupData.json`, builds an appropriate sidebar, and inserts it into the page.
To add an entry to `GroupData.json`, you need to:
1. Make sure you have a [GitHub](https://github.com/) account.
2. Fork the MDN content repo, create a new branch to contain your changes, and clone the repo locally.
3. Checkout your new branch before starting work, and make sure you push changes to it after finishing.
4. Create a pull request so that the MDN team can review your work, and ask for changes if necessary.
The `GroupData.json` file can be found inside the `files/jsondata/` directory.
Looking at it, you'll see a giant JSON structure, with each API having its own member.
The name is the API name, and the value is an object containing several sub-members defining the sidebar links to be created.
For example, look at the [Fetch API](/en-US/docs/Web/API/Fetch_API) page on MDN.
The corresponding entry in `GroupData.json` looks like this:
```json
"Fetch API": {
"overview": [ "Fetch API"],
"interfaces": [ "Headers",
"Request",
"Response",
"FetchController",
"FetchObserver",
"FetchSignal",
"ObserverCallback" ],
"methods": [ "fetch()" ],
"properties": [],
"events": []
},
```
As you can see, we've used "Fetch API" for the name, and inside the object value we include a number of sub-members.
#### Sub-members to include inside a GroupData entry
This section lists all the sub-members you could include in a `GroupData` entry.
Note that most of the values included inside the listed sub-members equate to both the link text, and slugs appended to the end of the main API index page — `https://developer.mozilla.org/<language-code>/docs/Web/API` — to create the final URL for the displayed link.
So for example, "Response" will result in a link being created like so:
```html
<li><a href="/en-US/docs/Web/API/Response">Response</a></li>
```
There are a few exceptions.
For example the "guides" sub-member contains the URLs that point to associated guides/tutorials.
In this case the URLs are appended to the end of the MDN docs root — `https://developer.mozilla.org/<language-code>` — allowing an article anywhere on MDN to be included.
Here are the available members.
These are all technically optional, but it is strongly encouraged that instead of omitting them, you include empty arrays.
1. `"overview"` — the value is an array, inside of which you include the slug of the API overview page, if there is one.
"Fetch API" results in a link being made to [https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API](/en-US/docs/Web/API/Fetch_API).
2. `"interfaces"` — the value is an array in which you should list all of the interfaces that form part of that API.
"Response" results in a link being made to [https://developer.mozilla.org/en-US/docs/Web/API/Response](/en-US/docs/Web/API/Response).
3. `"methods"` — the value is an array that should contain any methods the spec adds to interfaces associated with other APIs, such as instantiation methods created on {{domxref("Navigator")}} or {{domxref("Window")}}.
If there are a huge number of methods, you might want to consider only listing the most popular ones, or putting them first in the list.
"fetch()" results in a link being made to [https://developer.mozilla.org/en-US/docs/Web/API/fetch](/en-US/docs/Web/API/fetch).
Do _not_ list methods that are members of interfaces that are owned by the same API.
4. `"properties"` — the value is an array that should contain all of the properties associated with the API.
This can include properties that are members of interfaces defined in the API spec, and properties the API defines on other interfaces.
If there are a huge number of properties, you might want to consider only listing the most popular ones, or putting them first in the list.
"Headers.append" results in a link being made to [https://developer.mozilla.org/en-US/docs/Web/API/Headers/append](/en-US/docs/Web/API/Headers/append).
5. `"events"` — the value is an array that should contain the _title_ of events that are part of the API bit are defined in interfaces that are _not_ part of the API (events belonging to interfaces in the API (`interfaces`) are documented by default).
If there are a huge number of events, you might want to consider only listing the most popular ones, or putting them first in the list.
For example, `"Document: selectionchange"` is part of the [Selection API](/en-US/docs/Web/API/Selection_API) but `Document` is not, so we add the event to the array and it will be linked from the [Selection API](/en-US/docs/Web/API/Selection_API) topic.
6. `"guides"` — the value is an array of strings, each that addresses a guide topic that explain how to use the API.
The strings contain the part of the guide's URL address after the language path: i.e. the `/docs/...` part of the guide URL.
For example, to link to the topic "Using Fetch" at `https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API/Using_Fetch`, the guide array would contain "/docs/Web/API/Fetch_API/Using_Fetch".
7. `"dictionaries"` — an array of strings listing all of the dictionaries which are part of the API.
Generally, only dictionaries used by more than one property or method should be listed here, unless they are of special significance or are likely to require being referenced from multiple pages.
"CryptoKeyPair" results in a link to [https://developer.mozilla.org/en-US/docs/Web/API/CryptoKeyPair](/en-US/docs/Web/API/CryptoKeyPair).
> **Note:** MDN is moving away from separately documenting dictionaries.
> Where possible, these are now described as objects in the places where they are used.
8. `"types"` — an array of typedefs and enumerated types defined by the API.
You may choose to only list those that are of special importance or are referenced from multiple pages, in order to keep the list short.
> **Note:** MDN is moving away from separately documenting typedefs.
> Where possible, these are now described as values in the places where they are used.
9. `"callbacks"` — the value is an array containing a list of all the defined callback types for the API.
You may find it unnecessary to use this group at all, even on APIs that include callback types, as often they are not useful to document separately.
## Tags used by sidebars
Some sub-members are automatically discovered from child pages, based on page tags.
Pages under the top-level API are crawled each time the sidebar is rendered, and entries are automatically created for methods ("Method" tag), properties ("Property" tag), and constructors ("Constructor" tag).
Sub-members are automatically decorated with warning icons based on tags as well.
Decorations are added for experimental ("Experimental" tag), non-standard ("Non Standard" or "Non-standard" tag), or deprecated ("Deprecated" tag) sub-members.
Further information about tag-based processing is available [in the APIRef source](https://github.com/mdn/yari/blob/main/kumascript/macros/APIRef.ejs).
## Inserting the sidebar
Once you've added an entry for your API into `GroupData.json`, submitted it as a pull request and had the change accepted into the main repo, you can include it in your API reference pages using the [`APIRef`](https://github.com/mdn/yari/blob/main/kumascript/macros/APIRef.ejs) macro, which takes the name you used for your API in GroupData as a parameter.
As an example, the [WebVR API](/en-US/docs/Web/API/WebVR_API)'s sidebar is included in its pages with the following:
```plain
\{{APIRef("WebVR API")}}
```
| 0 |
data/mdn-content/files/en-us/mdn/writing_guidelines/howto/write_an_api_reference | data/mdn-content/files/en-us/mdn/writing_guidelines/howto/write_an_api_reference/information_contained_in_a_webidl_file/index.md | ---
title: Information contained in a WebIDL file
slug: MDN/Writing_guidelines/Howto/Write_an_API_reference/Information_contained_in_a_WebIDL_file
page-type: mdn-writing-guide
---
{{MDNSidebar}}
When writing documentation about an API, the sources of information are many: the specifications describe what should be implemented as well as the model, and the implementations describe what has actually been put in the browsers. WebIDL files are a very condensed way of giving a lot, but not all, of the information about the API. This document provides a reference to help understand WebIDL syntax.
IDL stands for **_Interface Definition Language_** and it is designed to describe APIs. In the wider world of computing there are several kinds of IDL. In the world of browsers, the IDL we use is called _WebIDL_. Two kinds of WebIDL are available: the one given in the WebIDL spec, and the one implemented in browsers. The spec is the canonical reference, and the browser WebIDL describes what is actually implemented in a particular browser, and contains additional things such as annotations, information about non-standard elements, and browser-specific extensions to the IDL specification.
## Where to find WebIDL files
WebIDL can be found in multiple locations:
- Each specification contains WebIDL inside the text: it is a very convenient way to convey precise definition. These describe the syntax of the API. Though the canonical reference, we have to keep in mind that they may differ from the actual implementation. On MDN we want to be practical and document what the Web platform really is, not what it ideally should be. So double check what is there with implementations (and don't hesitate to file bugs if you discover incoherence).
- Three browser engines use (modified) WebIDL as part as their toolchain: Gecko, Chromium/Blink, and WebCore/WebKit. Pre-Chromium versions of Edge used it internally, but these are unfortunately not public.
- For Gecko, all WebIDL files are grouped in a single directory: <https://dxr.mozilla.org/mozilla-central/source/dom/webidl/>. Their extension is `.webidl`. There are other `*.idl` files in the Gecko source tree but they are not WebIDL, so you can ignore them. Older versions of Gecko have some of their WebIDL scattered around somewhat, and may even use Mozilla's IDL instead of WebIDL to describe some Web interfaces, but this won't be a problem in any recent Gecko code.
- For Chromium, they are located in two locations, both subtrees of the source code's [`renderer/`](https://source.chromium.org/chromium/chromium/src/+/master:third_party/blink/renderer/) directory: [`core/`](https://source.chromium.org/chromium/chromium/src/+/master:third_party/blink/renderer/core/) and [`modules/`](https://source.chromium.org/chromium/chromium/src/+/master:third_party/blink/renderer/modules/). Chromium source code has IDL files in other locations, but these are part of the testing system and not relevant to API implementations.
- For WebCore, they are scattered around the source code, so you need to dig a bit more: E.g. <https://github.com/WebKit/webkit/blob/main/Source/WebCore/html/DOMTokenList.idl>
## Different dialects of WebIDL
WebIDL is defined in [its specification](https://webidl.spec.whatwg.org/). But it has been designed to be extended to convey more information, and browser vendors have done so:
- For Gecko, Mozilla created the [documentation](https://firefox-source-docs.mozilla.org/dom/webIdlBindings/index.html) of its dialectal WebIDL.
- For Chromium, Google also created a [document](https://www.chromium.org/blink/webidl/) to describe its extensions.
- For WebCore, Apple also made available a [page](https://trac.webkit.org/wiki/WebKitIDL) for its dialect.
> **Note:** We describe here only the subset of WebIDL which is most useful when writing documentation. There are many more annotations useful for implementers; refer to the four documents linked above to have a complete overview.
## Interfaces
This section explains the WebIDL syntax that describes overall API features.
### Name of the interface
The interface name is the string that appears after the keyword `interface` and before the next opening bracket (`'{'`) or colon (`':'`).
```webidl
interface URL {};
```
Each WebIDL interface, being a true interface or a mixin, has its own page in the documentation, listing every constructor, property and method defined for it.
### Inheritance chain
The parent, if any, of a given interface is defined after the interface name, following a colon (`':'`). There can be only one parent per interface.
```webidl
interface HTMLMediaElement : HTMLElement {…}
```
The inheritance chain is listed automatically in the sidebar (using the \\{{APIRef}} macro). It can also be added as an SVG image via the macro \\{{InheritanceDiagram}}.
### Mixins
Some properties or methods are available to several interfaces. To prevent redefinition they are defined in special WebIDL interfaces called _mixins_.
As of September 2019, mixin syntax was updated. In the new syntax, you use `interface mixin` to define a mixin interface, like so:
```webidl
interface MyInterface {};
interface mixin MyMixin {
void somethingMixedIn();
}
```
You then use the `includes` keyword to say that the properties defined inside a mixin are available on an interface:
```webidl
MyInterface includes MyMixin;
```
Mixins have no inheritance and cannot include other mixins. They do however support partials, so you will see things like this:
```webidl
interface MyInterface {};
interface mixin MyMixin {};
partial interface mixin MyMixin {
void somethingMixedIn();
};
MyInterface includes MyMixin;
```
For documentation purposes, MDN hides mixins. They are abstract and specification-only constructs.
You can't see them in the browser console and it is more useful to know on which real interfaces methods and properties are implemented on.
If you encounter a mixin in IDL, like [HTMLHyperlinkElementUtils](https://html.spec.whatwg.org/multipage/links.html#htmlhyperlinkelementutils),
search for the interfaces that implement the mixin, for example
[HTMLAnchorElement](https://html.spec.whatwg.org/multipage/text-level-semantics.html#htmlanchorelement), and document the mixin members directly on those interfaces.
In practice this means instead of documenting `HTMLHyperlinkElementUtils`,
docs are added to the concrete interfaces, like [`HTMLAnchorElement`](/en-US/docs/Web/API/HTMLAnchorElement)
and [`HTMLAreaElement`](/en-US/docs/Web/API/HTMLAreaElement).
See the following two pages that document `HTMLHyperlinkElementUtils.hash` accordingly:
- [`HTMLAnchorElement.hash`](/en-US/docs/Web/API/HTMLAnchorElement/hash)
- [`HTMLAreaElement.hash`](/en-US/docs/Web/API/HTMLAreaElement/hash)
For compat data, consult the [data guideline for mixins in BCD](https://github.com/mdn/browser-compat-data/blob/main/docs/data-guidelines/index.md).
### Old mixin syntax
In the old-style WebIDL mixin syntax, which you still might encounter in some places, mixins are prefixed using the `[NoInterfaceObject]` annotation:
```webidl
[NoInterfaceObject]
interface MyMixin {…}
```
In the old-style syntax, mixins implemented on an interface are defined using the `implements` keyword.
```webidl
MyInterface implements MyMixin;
```
### Availability in window and workers
Availability in Web workers (of any type) and on the Window scope is defined using an annotation: `[Exposed=(Window,Worker)]`. The annotation applies to the partial interface it is listed with.
```webidl
[Exposed=(Window,Worker)]
interface Performance {
[DependsOn=DeviceState, Affects=Nothing]
DOMHighResTimeStamp now();
};
[Exposed=Window]
partial interface Performance {
[Constant]
readonly attribute PerformanceTiming timing;
[Constant]
readonly attribute PerformanceNavigation navigation;
jsonifier;
};
```
In this case `Performance.now()` is available on the `Window` scope and to any worker, while `Performance.timing`, `Performance.navigation` and `Performance.toJSON()` are not available to Web workers.
The most common values for the `[Exposed]` are:
- `Window`
- : The partial interface is available to the {{domxref('Window')}} global scope.
- `Worker`
- : The partial interface is available to any kind of worker, that is if the global scope is a descendant of {{domxref('WorkerGlobalScope')}} — {{domxref('DedicatedWorkerGlobalScope')}}, {{domxref('SharedWorkerGlobalScope')}}, or {{domxref('ServiceWorkerGlobalScope')}} (It also is available to `ChromeWorker`, but we don't document this as they are not visible on the Web and are internal to Firefox.)
- `DedicatedWorker`
- : The partial interface is available to the {{domxref('DedicatedWorkerGlobalScope')}} only.
- `SharedWorker`
- : The partial interface is available to the {{domxref('SharedWorkerGlobalScope')}} only.
- `ServiceWorker`
- : The partial interface is available to the {{domxref('ServiceWorkerGlobalScope')}} only.
Another value is possible, like `System`, but this has a [special meaning](https://firefox-source-docs.mozilla.org/dom/webIdlBindings/index.html#custom-extended-attributes) and doesn't need to be documented.
Note that these possible values are themselves defined in WebIDL files. Interfaces may have a `[Global=xyz]` annotation. It means that when an object of this type is used as a global scope, any interface, property or method, with `xyz` as a value of `[Exposed]` is available.
```webidl
[Global=(Worker,DedicatedWorker), Exposed=DedicatedWorker]
interface DedicatedWorkerGlobalScope : WorkerGlobalScope {…}
```
Here, it is defined that when the global scope is of type `DedicatedWorkerGlobalScope`, that is if we are in a dedicated worker, any interface, property or method exposed – using the `[Exposed]` annotation – to `Worker` or `DedicatedWorker` is available.
### Preferences
> **Note:** this information is specific to Gecko and should only be used in the Browser compatibility section.
In Gecko, the availability of a partial interface, including its constructor, properties and methods may be controlled by a preference (usually called a "pref"). This is marked in the WebIDL too.
```webidl
[Pref="media.webspeech.synth.enabled"]
interface SpeechSynthesis {
readonly attribute boolean pending;
readonly attribute boolean speaking;
readonly attribute boolean paused;
};
```
Here `media.webspeech.synth.enabled` controls the `SpeechSynthesis` interface and its properties (the full listing has more than 3.)
> **Note:** the default value of the preference is not available directly in the WebIDL (it can be different from one product using Gecko to another.)
### Available only in system code
Some interface features might only be available in browser internal system code, or chrome code. To signify this, in Gecko we use \[ChromeOnly], for example the property propName in the following example is only callable via chrome code:
```webidl
interface MyInterface {
[ChromeOnly]
readonly attribute PropValue propName;
};
```
## Properties
You can recognize the definition of a property by the presence of the `attribute` keyword.
### Name of the property
```webidl
readonly attribute MediaError? error;
```
In the above example the name of the property is `error`; in the docs we will refer to it as `HTMLMediaElement.error` as it belongs to the `HTMLMediaElement` interface. Linking to the page is either done **with** the interface prefix using \\{{domxref('HTMLMediaElement.error')}} or **without** the prefix using \\{{domxref('HTMLMediaElement.error', 'error')}} when the context is obvious and unambiguous.
### Type of the property
```webidl
readonly attribute MediaError? error;
```
The property value is an object of type `MediaError`. The question mark (`'?'`) indicates that it can take a value of `null`, and the documentation must explain _when_ this may occur. If no question mark is present, the `error` property can't be `null`.
### Writing permissions on the property
```webidl
readonly attribute MediaError? error;
```
If the keyword `readonly` is present, the property can't be modified. It must be marked as read-only:
- In the interface, by adding the \\{{ReadOnlyInline}} macro next to its definition term.
- In the first sentence of its own page, by starting the description with: _The read-only **`HTMLMediaElement.error`** property…_
- By starting its description in the interface page with _Returns…_
> **Note:** Only read-only properties can be described as 'returning' a value. Non read-only properties can also be used to set a value.
### Throwing exceptions
```webidl
[SetterThrows]
attribute DOMString src;
```
In some cases, like when some values are illegal, setting a new value can lead to an exception being raised. This is marked using the `[SetterThrows]` annotation. When this happens, the Syntax section of the property page _must_ have an Exceptions subsection. The list of exceptions and the conditions to have them thrown are listed, as textual information, in the specification of that API.
Note that some exceptions are not explicitly marked but are defined by the JavaScript bindings. [Trying to set an illegal enumerated value](https://webidl.spec.whatwg.org/#es-enumeration) (mapped to a JavaScript {{jsxref('String')}}) raises a {{jsxref('TypeError')}} exception. This must be documented, but is only implicitly marked in the WebIDL document.
It is uncommon to have getters throwing exceptions, though it happens in a few cases. In this case the `[GetterThrows]` annotation is used. Here also, the Syntax section of the property page _must_ have an Exceptions subsection.
```webidl
partial interface Blob {
[GetterThrows]
readonly attribute unsigned long long size;
};
```
### Not throwing exceptions
When the semantics of Webidl is not followed, an exception is often thrown, even without `[SetterThrows]` or `[GetterThrows]` set. For example, in strict mode, if we try to set a read-only property to a new value, that is to call its implicit setter, a read-only property will throw in strict mode.
Mostly for compatibility purpose, this behavior is sometimes annoying. To prevent this by creating a no-op setter (that is by silently ignoring any attempt to set the property to a new value), the `[LenientSetter]` annotation can be used.
```webidl
partial interface Document {
[LenientSetter]
readonly attribute boolean fullscreen;
[LenientSetter]
readonly attribute boolean fullscreenEnabled;
};
```
In these cases, an extra sentence is added to the description of the property. E.g
_Although this property is read-only, it will not throw if it is modified (even in strict mode); the setter is a no-operation and it will be ignored._
### New objects or references
The return value of a property can be either a copy of an internal object, a newly created synthetic object, or a reference to an internal object.
Basic objects with types like {{jsxref("String")}} (being an IDL `DOMString`, or other), {{jsxref("Number")}} (being an IDL `byte`, `octet`, `unsigned int`, or other), and {{jsxref("Boolean")}} are always copied and nothing special has to be noted about them (it is natural behavior expected by a JavaScript developer.)
For interface objects, the default is to return a _reference_ to the internal object. This has to be mentioned both in the short description in the interface page, and in the description in the specific sub-pages.
> **Note:** The keyword `readonly` used with a property returning an object applies to the reference (the internal object cannot be changed.) The properties of the returned object can be changed, even if they are marked as read-only in the relevant interface.
Sometimes an API must return a _new_ object, or a _copy_ of an internal one. This case is indicated in the WebIDL using the `[NewObject]` annotation.
```webidl
[NewObject]
readonly attribute TimeRanges buffered;
```
In this case, each call to `buffered` returns a different object: changing it will not change the internal value, and a change in the internal value will not affect each object instance. In the documentation, we will mark it by using the adjective _new_ next to object:
_The **`HTMLMediaElement.buffered`** read-only property returns a new \\{{domxref("TimeRanges")}} object that…_
and
- _\\{{domxref("HTMLMediaElement.buffered")}}\\{{ReadOnlyInline}}_
- : _Returns a new \\{{domxref("TimeRanges")}} object that …_
In the case of a reference to a collection object (like `HTMLCollection`, `HTMLFormElementsCollection`, or `HTMLOptionsCollection`, always without `[NewObject]`), we make it explicit that changes to the underlying object will be available via the returned reference. To mark this, we qualify the collection as a **live** `HTMLCollection` (or `HTMLFormElementsCollections`, or `HTMLOptionsCollection`), both in the interface description and in the subpage.
E.g.
- \\{{domxref("HTMLFormElement.elements")}}\\{{ReadOnlyInline}}
- : Returns a live \\{{domxref("HTMLFormControlsCollection")}} containing…
### Availability in workers
Individual property availability in workers is also found in the WebIDL. For a property, the default is the same availability as the `interface` (that is available to {{domxref('Window')}} context only if nothing special is marked) or as the `partial interface` it is defined in.
For documentation, the subpage must contain a sentence indicating if it is available or not in Web workers, right before the "Syntax" section.
### Preferences
> **Note:** This information is specific to Gecko and should only be used in the Browser compatibility section.
In Gecko, the availability of some properties may be controlled by a preference. This is marked in the WebIDL too.
```webidl
[Pref="media.webvtt.enabled"]
readonly attribute TextTrackList? textTracks;
```
Here `media.webvtt.enabled` controls the `textTracks` property.
> **Note:** The default value of the preference is not available directly in the WebIDL (it can be different from one product using Gecko to another).
## Methods
You can recognize the definition of a method by the presence of parentheses after the name.
### Name of the method
```webidl
DOMString canPlayType(DOMString type);
```
The name of the method is `canPlayType`, and we will refer to it as `HTMLMediaElement.canPlayType()` (with the parentheses that indicate that it is a method) in the docs, as it belongs to the `HTMLMediaElement` interface. Linking to the page is either done **with** the interface prefix using \\{{domxref('HTMLMediaElement.canPlayType()')}}, or **without** the prefix using \\{{domxref('HTMLMediaElement.canPlayType', 'canPlayType()')}} when the context is obvious and unambiguous. The parentheses should always be included.
### Parameters
```js
TextTrack addTextTrack(TextTrackKind kind,
optional DOMString label = "",
optional DOMString language = "");
```
The parameters of a method are listed in the Syntax section of the method sub-page. They are listed in the WebIDL in order, between the parenthesis, as a comma-separated list. Each parameter has a name (indicated above) and a type (e.g. a `'?'` means that the `null` value is valid.) If marked `optional`, the parameter is optional to include in a method call and must have the \\{{OptionalInline}} flag included when it is listed in the Syntax section. The parameter's default value is listed after the equality sign (`'='`).
### Type of the return value
```webidl
DOMString canPlayType(DOMString type);
```
The return value type is indicated before the method name — in the above case the value is an object of type `DOMString`. If the return type is followed by a question mark (`'?'`), a value of `null` can be returned too, and the documentation must explain _when_ this may happen. If no question mark is present, like here, the return value can't be `null`.
If the return value is the `void` keyword, it means that there is no return value. It is not a return value type. If the WebIDL entry reads `void`, the _Return value_ section in the docs should simply state "None (\{{jsxref("undefined")}}).".
### Throwing exceptions
```webidl
[Throws]
void fastSeek(double time);
```
Some methods can throw exceptions. This is marked using the `[Throws]` annotation. When this happens, the Syntax section of the method page _must_ have an Exceptions subsection. The list of exceptions and the conditions to have them thrown are listed, as textual information, in the specification of that API.
Note that some exceptions are not explicitly marked but are defined by the JavaScript bindings. [Trying to set an illegal enumerated value](https://webidl.spec.whatwg.org/#es-enumeration) (mapped to a JavaScript {{jsxref('String')}}) as a parameter will raise a {{jsxref('TypeError')}} exception. This must be documented, but it is only implicitly marked in the WebIDL document.
Have a look at one of these [_Exceptions_ sections](/en-US/docs/Web/API/SubtleCrypto/importKey#exceptions).
### Availability in workers
Individual method availability in workers is also found in the WebIDL. For a method, the default is the same availability as the `interface` (that is available to {{domxref('Window')}} context only if nothing special is marked) or as the `partial interface` it is defined it.
For the documentation, the sub-page must contain a sentence indicating if it is available in Web workers, right before the Syntax section.
### Preferences
> **Note:** this information is specific to Gecko and should only be used in the Browser compatibility section.
In Gecko, the availability of some methods may be controlled by a preference. This is marked in the WebIDL too.
```webidl
[Pref="media.webvtt.enabled"]
TextTrack addTextTrack(TextTrackKind kind,
optional DOMString label = "",
optional DOMString language = "");
```
Here `media.webvtt.enabled` controls the `addTextTrack()` method.
> **Note:** The default value of the preference is not available directly in the WebIDL (it can be different from one product using Gecko to another.)
## Special methods
Some methods are not listed as regular methods in WebIDL but instead as special keywords, which translate to specific standard JavaScript methods.
### toString() and toJSON()
A stringifier specifies how an object based on an interface is resolved in contexts expecting a string. (See the [Stringifiers](#stringifiers) section.) Additionally, the keyword is mapped to `toString()` and defined as:
```webidl
stringifier;
```
The `toString()` method is listed just like any other method of the interface and has its own sub-page (E.g. {{domxref("Range.toString()")}})
A jsonifier is mapped to `toJSON()` and defined as:
```webidl
jsonifier; // Gecko version
serializer; // Standard version
```
The `toJSON()` method is listed just like any other method of the interface and has its own sub-page (E.g. {{domxref("Performance.toJSON()")}})
> **Note:** the WebIDL specification uses `serializer` instead of `jsonifier`. This is not used in Gecko — only the non-standard likely early proposal `jsonifier` is found in mozilla-central.
### Iterator-like methods
An interface may be defined as _iterable_, meaning that it will have the following methods: `entries()`, `keys()`, `values()` and `forEach()`. They also supports the use of {{jsxref("Statements/for...of", "for...of")}} on an object implementing this interface.
There are two kinds of iteration possible: the _value iterator_ and the _pair iterator._
#### Value iterator
```webidl
iterable<valueType>
```
The iterator will iterate over values of type _valueType_. The generated methods will be:
- `entries()`, which returns an [`iterator`](/en-US/docs/Web/JavaScript/Reference/Iteration_protocols) on the indexes (that are `unsigned long`).
- `values()`, which returns an [`iterator`](/en-US/docs/Web/JavaScript/Reference/Iteration_protocols) on the values.
- `keys()`, which returns an [`iterator`](/en-US/docs/Web/JavaScript/Reference/Iteration_protocols) on the keys, that are its indexes (that are `unsigned long`). In the case of value iterators, `keys()` and `entries()` are identical.
- `forEach()`, which executes a given callback function once for each entry in the list.
Such an iterator allows to use the syntax `for (const p in object)` as a shorthand of `for (const p in object.entries())`. We add a sentence about it in the interface description.
The values to iterate over can be defined in one of the following ways:
- In the WebIDL file, using the `iterable<valueType>` notation. For example, see {{domxref('DOMTokenList')}}.
- Implicitly in the WebIDL file, if the interface supports indexed properties. This is indicated when the interface includes `getter` methods with a parameter of type `unsigned long`.
- Outside the WebIDL file, in the accompanying prose. Such a prose is typically found in the specification and usually starts with: _"The [values to iterate over](https://webidl.spec.whatwg.org/#dfn-value-iterator)…"_.
#### Pair iterator
```webidl
iterable<keyType, valueType>
```
The iterator will iterate over values of type _valueType_ with keys of type _keyType_, that is the value pairs. The generated methods will be:
- `entries()`, which returns an [`iterator`](/en-US/docs/Web/JavaScript/Reference/Iteration_protocols) on the value pairs. For example, see {{domxref('FormData.entries()')}}.
- `values()`, which returns an [`iterator`](/en-US/docs/Web/JavaScript/Reference/Iteration_protocols) on the values. For example, see {{domxref('FormData.values()')}}.
- `keys()`, which returns an [`iterator`](/en-US/docs/Web/JavaScript/Reference/Iteration_protocols) on the keys. For example, see {{domxref('FormData.keys()')}}.
- `forEach()`, which executes a given callback function once for each entry in the list. For example, see {{domxref('Headers.forEach()')}}.
Such an iterator allows to use the syntax `for (const p in object)` as a shorthand of `for (const p in object.entries())`. We add a sentence about it in the interface description. E.g. {{domxref('FormData')}}.
The value pairs to iterate over can be defined in one of the following ways:
- In the WebIDL file, using the `iterable<keyType, valueType>` notation. For example, see {{domxref('FormData')}}.
- Outside the WebIDL file, in the accompanying prose. Such a prose is typically found in the specification and usually starts with: _"The [value pairs to iterate over](https://webidl.spec.whatwg.org/#dfn-value-pairs-to-iterate-over)…"_.
### Set-like methods
An interface may be defined as _set-like_, meaning that it represents an _ordered set of values_ will have the following methods: `entries()`, `keys()`, `values()`, `forEach(),` and `has()` (it also has the `size` property). They also supports the use of {{jsxref("Statements/for...of", "for...of")}} on an object implementing this interface. The set-like can be prefixed `readonly` or not. If not read-only, the methods to modify the set are also implemented: `add()`, `clear()`, and `delete()`.
```webidl
setlike<valueType>
```
The generated properties will be:
- `entries()`, which returns an [`iterator`](/en-US/docs/Web/JavaScript/Reference/Iteration_protocols) on the indexes. For example, see {{domxref('NodeList.entries()')}}.
- `values()`, which returns an [`iterator`](/en-US/docs/Web/JavaScript/Reference/Iteration_protocols) on the values. For example, see {{domxref('NodeList.values()')}}.
- `keys()`, which returns an [`iterator`](/en-US/docs/Web/JavaScript/Reference/Iteration_protocols) on the keys. For example, see {{domxref('NodeList.keys()')}}.
- `forEach()`, which executes a given callback function once for each entry in the list. For example, see {{domxref('NodeList.forEach()')}}.
In cases where the set-like declaration is not prefixed by read-only, the following methods are also generated:
- `add()` that adds an entry. E.g. the `.add()` method of {{domxref('FontFaceSet')}}.
- `clear()` that empties the set-like structure. E.g. the `.clear()` method of {{domxref('FontFaceSet')}}.
- `delete()` that removes an entry. E.g. the `.delete()` method of {{domxref('FontFaceSet')}}.
Such an set interface also allows to use the syntax `for (const p in object)` as a shorthand of `for (const p in object.entries())`.
## Special Behaviors
Some IDL members indicate special behaviors that should be noted on appropriate pages.
### Stringifiers
In addition to adding the `toString()` method to an interface as described in [toString() and toJSON()](#tostring_and_tojson), stringifiers also indicate that an object instance, when used as a string, returns a string other than the default. (The default is usually a JSON representation of the object). Exactly how depends on the way it is specified in the IDL. Regardless of the how, the non-default behavior should be described on the interface page.
When the `stringifier` keyword accompanies an attribute name, referencing the object name has the same result as referencing the attribute name. Consider the following IDL:
```webidl
interface InterfaceIdentifier {
stringifier attribute DOMString DOMString name;
};
```
For a class based on this interface, the following lines of code below are equivalent. The behavior should be noted on the property page in addition to the interface page.
```js
console.log(interfaceIdentifier);
console.log(interfaceIdentifier.name);
```
When the `stringifier` keyword is used by itself, an object of the interface may be used as above, but the behavior is defined in source code.
```webidl
interface InterfaceIdentifier {
stringifier;
};
```
To learn what an interface reference actually does, refer to the interface's spec or experiment with the interface to determine its output.
## Constructors
Constructors are a little bit hidden in WebIDL: they are listed as annotations of the main interface.
### Unnamed constructors
This is the most common case for constructors. The constructor of a given interface A, can be used as `a = new A(parameters);`
```webidl
[Constructor, Func="MessageChannel::Enabled",
Exposed=(Window,Worker)]
interface MessageChannel {…};
```
A constructor with the same interface is defined using the `Constructor` annotation on the interface. There can be parenthesis and a list of parameters or not (like in the above example.) We document all the unnamed constructors on a sub-page — for example the above is given the slug _Web/API/MessageChannel/MessageChannel_ and the title `MessageChannel()`.
Another example of an unnamed constructor, with parameters:
```webidl
[Constructor(DOMString type, optional MessageEventInit eventInitDict),
Exposed=(Window,Worker,System)]
interface MessageEvent : Event {…};
```
There can also be several unnamed constructors, differing by their parameter lists. All syntax is documented in one single sub-page.
```webidl
[Constructor(DOMString url, URL base),
Constructor(DOMString url, optional DOMString base),
Exposed=(Window,Worker)]
interface URL {};
```
### Named constructors
```webidl
[NamedConstructor=Image(optional unsigned long width, optional unsigned long height)]
interface HTMLImageElement : HTMLElement {…
```
A named constructor is a constructor that has a different name than that of its interface. For example `new Image(…)` creates a new `HTMLImageElement` object. They are defined in the WebIDL using the `NamedConstructor` annotation on the interface, followed by the name of the constructor after the equality sign (`'='`) and the parameter inside the parenthesis, in the same format as you'll see for methods.
There can be several named constructors for a specific interface, but this is extremely rare; in such a case we include one sub-page per name.
### New constructor syntax
As of September 2019, WebIDL constructor syntax was updated. Constructor syntax no longer involves an extended attribute on the interface:
```webidl
[Constructor(DOMString str)]
interface MyInterface {
...
};
```
New specs instead use a method-like syntax named `constructor` with no explicitly-defined return type, written like so:
```webidl
interface MyInterface {
constructor(DOMString str);
};
```
This means extended attributes can now be specified on the constructor, and it is no longer assumed that all constructors throw. If a constructor does throw, `[Throws]` will be used to indicate that:
```webidl
interface MyInterface {
[Throws] constructor();
};
```
It is unlikely that _all_ specs will be updated to use the new syntax, so you'll probably encounter both out in the wild. We will therefore continue to cover both types of syntax here.
### Availability in workers
Constructors have the same availability as the interface, or partial interface, they are defined on. The sub-page provides this information in the same way as for a method.
### Preferences
Constructors are controlled by the same preference as the interface, or partial interface, they are defined on. The sub-page provides this information in the same way as for a method.
| 0 |
data/mdn-content/files/en-us/mdn/writing_guidelines | data/mdn-content/files/en-us/mdn/writing_guidelines/page_structures/index.md | ---
title: Page structures
slug: MDN/Writing_guidelines/Page_structures
page-type: landing-page
---
{{MDNSidebar}}
Throughout MDN there are document structures that are used to provide consistent presentation of information in MDN articles.
This page lists articles describing these structures so that you can modify page content appropriately for the documents you write, edit, or translate.
{{LandingPageListSubPages}}
## See also
- [Page templates](/en-US/docs/MDN/Writing_guidelines/Page_structures/Page_types#page_templates)
- [Page components](/en-US/docs/MDN/Writing_guidelines/Writing_style_guide#page_components)
| 0 |
data/mdn-content/files/en-us/mdn/writing_guidelines/page_structures | data/mdn-content/files/en-us/mdn/writing_guidelines/page_structures/macros/index.md | ---
title: Using macros
slug: MDN/Writing_guidelines/Page_structures/Macros
page-type: mdn-writing-guide
---
{{MDNSidebar}}
The [Yari](https://github.com/mdn/yari) platform on which MDN runs provides a macro system, [KumaScript](https://github.com/mdn/yari/tree/main/docs/kumascript), which makes it possible to automate certain tasks. This article provides information on how to invoke MDN's macros within articles.
The [KumaScript guide](https://github.com/mdn/yari/blob/main/docs/kumascript/README.md) provides an in-depth look at how to use macros on MDN, so this section is more of a brief overview.
## How macros are implemented
Macros on MDN are implemented using server-executed [JavaScript](/en-US/docs/Web/JavaScript) code, interpreted using [Node.js](https://nodejs.org/en/). On top of that we have a number of libraries we've implemented that provide services and features to let macros interact with the platform and its contents.
## Using a macro in content
To use a macro, you enclose the call to the macro in a pair of double-braces along with its parameters, if any:
```plain
\{{macroname(parameter-list)}}
```
A few notes about macro calls:
- Macro names are case-sensitive, but some attempt is made to correct for common capitalization errors; you may use all lowercase even if the macro name uses caps within it, and you may capitalize a macro whose name normally starts with a lower-case letter.
- Parameters are separated by commas.
- If there are no parameters, you may leave out the parentheses entirely; `\{{macroname()}}` and `\{{macroname}}` are identical.
- Numeric parameters can be in quotes, or not. It's up to you (however, if you have a version number with multiple decimals in it, it needs to be in quotes).
- If you get errors, review your code carefully. If you still can't figure out what's going on, see [Troubleshooting KumaScript errors](https://github.com/mdn/yari/blob/main/docs/kumascript/troubleshooting-errors.md) for help.
Macros are heavily cached; for any set of input values (both parameters and environmental values such as the URL for which the macro was run), the results are stored and reused. This means that the macro is only actually run when the inputs change.
Macros can be as simple as just inserting a larger block of text or swapping in contents from another part of MDN, or as complex as building an entire index of content by searching through parts of the site, styling the output, and adding links.
You can read up on our most commonly-used macros on the [Commonly-used macros](/en-US/docs/MDN/Writing_guidelines/Page_structures/Macros/Commonly_used_macros) page; also, you can browse through the [complete sources for all macros](https://github.com/mdn/yari/tree/main/kumascript/macros). Most of the macro sources have documentation built into them, as comments at the top.
## See also
- [Sidebar macros](/en-US/docs/MDN/Writing_guidelines/Page_structures/Sidebars)
- [Link macros](/en-US/docs/MDN/Writing_guidelines/Page_structures/Links)
- [List of macros](https://github.com/mdn/yari/tree/main/kumascript/macros) on Github
| 0 |
data/mdn-content/files/en-us/mdn/writing_guidelines/page_structures/macros | data/mdn-content/files/en-us/mdn/writing_guidelines/page_structures/macros/other/index.md | ---
title: Other macros
slug: MDN/Writing_guidelines/Page_structures/Macros/Other
page-type: mdn-writing-guide
---
{{MDNSidebar}}
In contrast to the macros listed in [Commonly-used macros](/en-US/docs/MDN/Writing_guidelines/Page_structures/Macros/Commonly_used_macros), the macros documented in this article are used infrequently or only in specific contexts, or are deprecated.
## Special contexts
This macro is used only with particular contexts, such as a specific API reference.
- [`RFC`](https://github.com/mdn/yari/blob/main/kumascript/macros/RFC.ejs) creates a link to the specified RFC, given its number. The syntax is: `\{\{RFC(number)\}\}`. For example, `\{\{RFC(2616)\}\}` becomes {{ RFC(2616) }}.
### Landing page components
We have an assortment of macros that can be used to automatically generate the contents of landing pages. Here they are.
#### Lists of subpages
- [`ListSubpages`](https://github.com/mdn/yari/blob/main/kumascript/macros/ListSubpages.ejs) generates an unordered list of links to all the immediate children of the current page; useful for automatically generating tables of contents for sets of documentation.
- [`LandingPageListSubpages`](https://github.com/mdn/yari/blob/main/kumascript/macros/LandingPageListSubpages.ejs) outputs a two-column definition list of all immediate subpages of the current page, with their titles as the {{HTMLElement("dt")}} and their SEO summary as the {{HTMLElement("dd")}}. This makes it easy to automatically generate reasonably attractive landing pages.
- [`APIListAlpha`](https://github.com/mdn/yari/blob/main/kumascript/macros/APIListAlpha.ejs) builds a list of the current page's subpages, formatted as a list of API terms, divided up by first letter. There are three parameters. The first is 0 if you want to include all top-level subpages or 1 to leave out subpages with "." in their names. The second and third let you add text to display as part of the name in each link. This can be used to add "<" and ">" for element links, or to add "()" at the end of lists of method names.
- [`SubpagesWithSummaries`](https://github.com/mdn/yari/blob/main/kumascript/macros/SubpagesWithSummaries.ejs) constructs a definition list of all the immediate children of the current page. There is no other formatting done. You can get a two-column list ready for use as a multi-column landing page using [`LandingPageListSubpages`](https://github.com/mdn/yari/blob/main/kumascript/macros/LandingPageListSubpages.ejs).
### Lists of links
We have one macro specifically designed to create [lists of links](/en-US/docs/MDN/Writing_guidelines/Page_structures/Sidebars) within content:
- [`QuickLinksWithSubpages`](https://github.com/mdn/yari/blob/main/kumascript/macros/QuickLinksWithSubpages.ejs) creates a list of links comprised of the pages below the current page (or specified page, if one is given). Up to two total levels of depth are generated.
| 0 |
data/mdn-content/files/en-us/mdn/writing_guidelines/page_structures/macros | data/mdn-content/files/en-us/mdn/writing_guidelines/page_structures/macros/commonly_used_macros/index.md | ---
title: Commonly-used macros
slug: MDN/Writing_guidelines/Page_structures/Macros/Commonly_used_macros
page-type: mdn-writing-guide
---
{{MDNSidebar}}
This page lists many of the general-purpose macros created for use on MDN.
For additional how-to information on using these macros, see [Using macros](/en-US/docs/MDN/Writing_guidelines/Page_structures/Macros).
See [Other macros](/en-US/docs/MDN/Writing_guidelines/Page_structures/Macros/Other) for information on macros that are infrequently used, are used only in special contexts, or are deprecated.
## Linking
MDN provides a number of link macros for easing the creation of links to reference pages, glossary entries, and other topics.
Link macros are recommended over normal Markdown links because they are succinct and translation-friendly.
For example a glossary or reference link created using a macro does not need to be translated: in other locales it will automatically link to the correct version of the file.
### Glossary links
The [`Glossary`](https://github.com/mdn/yari/blob/main/kumascript/macros/Glossary.ejs) macro creates a link to a specified term's entry in the MDN [glossary](/en-US/docs/Glossary).
This macro accepts one required parameter and one optional parameter:
1. The term's name (such as "HTML"): `\{{Glossary("HTML")}}` yields {{Glossary("HTML")}}
2. Optional: The text to display in the article instead of the term name: `\{{Glossary("CSS", "Cascading Style Sheets")}}` yields {{Glossary("CSS", "Cascading Style Sheets")}}
### Linking to pages in references
There are macros for locale-independent linking to pages in specific reference areas of MDN: JavaScript, CSS, HTML elements, SVG etc.
The macros are easy to use.
Minimally all you need to do is specify the name of the item to link to in the first argument.
Most macros will also take a second argument allowing you to change the display text (documentation can be found at the links in the left-most column below).
<table class="standard-table">
<thead>
<tr>
<th>Macro</th>
<th>Links to page under</th>
<th>Example</th>
</tr>
</thead>
<tbody>
<tr>
<td>
<a href="https://github.com/mdn/yari/tree/main/kumascript/macros/cssxref.ejs">CSSxRef</a>
</td>
<td>
<a href="/en-US/docs/Web/CSS/Reference">CSS Reference</a> (/Web/CSS/Reference)
</td>
<td>
<code>\{{CSSxRef("cursor")}}</code> results in {{CSSxRef("cursor")}}.
</td>
</tr>
<tr>
<td>
<a href="https://github.com/mdn/yari/tree/main/kumascript/macros/DOMxRef.ejs">DOMxRef</a>
</td>
<td><a href="/en-US/docs/Web/API">DOM Reference</a> (/Web/API)</td>
<td>
<code>\{{DOMxRef("Document")}}</code> or <code>\{{DOMxRef("document")}}</code> results in {{DOMxRef("Document")}},<br />
<code>\{{DOMxRef("document.getElementsByName()")}}</code> result in {{DOMxRef("document.getElementsByName()")}}<br />
<code>\{{DOMxRef("Node")}}</code> result in {{DOMxRef("Node")}}.<br />
You can change the display text using a second parameter: <code>\{{DOMxRef("document.getElementsByName()","getElementsByName()")}}</code> results in {{DOMxRef("document.getElementsByName()","getElementsByName()")}}.
</td>
</tr>
<tr>
<td>
<a href="https://github.com/mdn/yari/tree/main/kumascript/macros/HTMLElement.ejs">HTMLElement</a>
</td>
<td>
<a href="/en-US/docs/Web/HTML/Element">HTML Elements reference</a> (/Web/HTML/Element)
</td>
<td>
<code>\{{HTMLElement("select")}}</code> results in {{HTMLElement("select")}}
</td>
</tr>
<tr>
<td>
<a href="https://github.com/mdn/yari/tree/main/kumascript/macros/jsxref.ejs">JSxRef</a>
</td>
<td>
<a href="/en-US/docs/Web/JavaScript/Reference">JavaScript reference</a> (/Web/JavaScript/Reference).
</td>
<td>
<code>\{{JSxRef("Promise")}}</code> results in {{JSxRef("Promise")}}
</td>
</tr>
<tr>
<td>
<a href="https://github.com/mdn/yari/tree/main/kumascript/macros/SVGAttr.ejs">SVGAttr</a>
</td>
<td>
<a href="/en-US/docs/Web/SVG/Attribute">SVG attribute reference</a> (/Web/SVG/Attribute).
</td>
<td>
<code>\{{SVGAttr("d")}}</code> results in {{SVGAttr("d")}}
</td>
</tr>
<tr>
<td>
<a
href="https://github.com/mdn/yari/tree/main/kumascript/macros/SVGElement.ejs">SVGElement</a>
</td>
<td>
<a href="/en-US/docs/Web/SVG/Attribute">SVG Element reference</a> (/Web/SVG/Element).
</td>
<td>
<code>\{{SVGElement("view")}}</code> results in {{SVGElement("view")}}
</td>
</tr>
<tr>
<td>
<code><a href="https://github.com/mdn/yari/blob/main/kumascript/macros/httpheader.ejs">HTTPHeader</a></code>
</td>
<td>
<a href="/en-US/docs/Web/HTTP/Headers">HTTP headers</a> (/Web/HTTP/Headers).
</td>
<td>
<code>\{{HTTPHeader("ACCEPT")}}</code> results in {{HTTPHeader("ACCEPT")}}
</td>
</tr>
<tr>
<td>
<a href="https://github.com/mdn/yari/tree/main/kumascript/macros/HTTPMethod.ejs">HTTPMethod</a>
</td>
<td>
<a href="/en-US/docs/Web/HTTP/Methods">HTTP request methods</a> (/Web/HTTP/Methods).
</td>
<td>
<code>\{{HTTPMethod("HEAD")}}</code> results in {{HTTPMethod("HEAD")}}
</td>
</tr>
<tr>
<td>
<a href="https://github.com/mdn/yari/tree/main/kumascript/macros/HTTPStatus.ejs">HTTPStatus</a>
</td>
<td>
<a href="/en-US/docs/Web/HTTP/Status">HTTP response status codes</a> (/Web/HTTP/Status)
</td>
<td>
<code>\{{HTTPStatus("404")}}</code> results in {{HTTPStatus("404")}}
</td>
</tr>
</tbody>
</table>
### Navigation aids for multi-page guides
[`Previous`](https://github.com/mdn/yari/blob/main/kumascript/macros/Previous.ejs), [`Next`](https://github.com/mdn/yari/blob/main/kumascript/macros/Next.ejs), and [`PreviousNext`](https://github.com/mdn/yari/blob/main/kumascript/macros/PreviousNext.ejs) provide navigation controls for articles which are part of sequences.
For the single-way templates, the only parameter needed is the wiki location of the previous or next article in the sequence.
For [`PreviousNext`](https://github.com/mdn/yari/blob/main/kumascript/macros/PreviousNext.ejs), the two parameters needed are the wiki locations of the appropriate articles.
The first parameter is for the previous article and the second is for the next article.
## Code samples
### Live samples
- [`EmbedLiveSample`](https://github.com/mdn/yari/blob/main/kumascript/macros/EmbedLiveSample.ejs) lets you embed the output of a code sample on a page, as described in [Live samples](/en-US/docs/MDN/Writing_guidelines/Page_structures/Live_samples).
- [`LiveSampleLink`](https://github.com/mdn/yari/blob/main/kumascript/macros/LiveSampleLink.ejs) creates a link to a page containing the output of a code sample on a page, as described in [Live samples](/en-US/docs/MDN/Writing_guidelines/Page_structures/Live_samples).
- [`EmbedGHLiveSample`](https://github.com/mdn/yari/blob/main/kumascript/macros/EmbedGHLiveSample.ejs) allows to embed live samples from GitHub pages.
You can get more information at [GitHub live samples](/en-US/docs/MDN/Writing_guidelines/Page_structures/Code_examples#github_live_samples).
## Sidebar generation
There are templates for almost every large collection of pages.
They typically link back to the main page of the reference/guide/tutorial (this is often needed because our breadcrumbs sometimes can't do this) and put the article in the appropriate category.
- [`CSSRef`](https://github.com/mdn/yari/blob/main/kumascript/macros/CSSRef.ejs) generates the sidebar for CSS reference pages.
- [`HTMLSidebar`](https://github.com/mdn/yari/blob/main/kumascript/macros/HTMLSidebar.ejs) generates the sidebar for HTML reference pages.
- [`APIRef`](https://github.com/mdn/yari/blob/main/kumascript/macros/APIRef.ejs) generates the sidebar for Web API reference pages.
## General-purpose formatting
### Inline indicators for API documentation
[`optional_inline`](https://github.com/mdn/yari/blob/main/kumascript/macros/optional_inline.ejs) and [`ReadOnlyInline`](https://github.com/mdn/yari/blob/main/kumascript/macros/ReadOnlyInline.ejs) are used in API documentation, usually when describing the list of properties of an object or parameters of a function.
Usage: `\{{Optional_Inline}}` or `\{{ReadOnlyInline}}`.
Example:
- `isCustomObject` {{ReadOnlyInline}}
- : Indicates, if `true`, that the object is a custom one.
- `parameterX` {{optional_inline}}
- : Blah blah blah…
## Status and compatibility indicators
### Inline indicators with no additional parameters
#### Non-standard
[`non-standard_inline`](https://github.com/mdn/yari/blob/main/kumascript/macros/Non-standard_Inline.ejs) inserts an in-line mark indicating the API has not been standardized and is not on a standards track.
##### Syntax
`\{{Non-standard_Inline}}`
##### Examples
- Icon: {{Non-standard_Inline}}
#### Experimental
[`experimental_inline`](https://github.com/mdn/yari/blob/main/kumascript/macros/experimental_inline.ejs) inserts an in-line mark indicating the API is not widely implemented and may change in the future.
For more information on the definition **experimental**, see the [Experimental, deprecated, and obsolete](/en-US/docs/MDN/Writing_guidelines/Experimental_deprecated_obsolete) documentation.
##### Syntax
`\{{Experimental_Inline}}`
##### Examples
- Icon: {{Experimental_Inline}}
### Inline indicators that support specifying the technology
#### Deprecated
[`deprecated_inline`](https://github.com/mdn/yari/blob/main/kumascript/macros/Deprecated_Inline.ejs) inserts an in-line deprecated mark ({{Deprecated_Inline}}) to discourage the use of an API that is officially deprecated (or has been removed).
For more information on the definition **deprecated**, see the [Experimental, deprecated, and obsolete](/en-US/docs/MDN/Writing_guidelines/Experimental_deprecated_obsolete) documentation.
##### Syntax
`\{{Deprecated_Inline}}`
##### Examples
- Icon: {{Deprecated_Inline}}
### Page or section header indicators
These templates have the same semantics as their inline counterparts described above.
The templates should be placed directly underneath the main page title (or breadcrumb navigation if available) in the reference page.
They can also be used to mark up a section on a page.
- [`non-standard_header`](https://github.com/mdn/yari/blob/main/kumascript/macros/Non-standard_Header.ejs): `\{{Non-standard_Header}}` {{Non-standard_Header}}
- [`SeeCompatTable`](https://github.com/mdn/yari/blob/main/kumascript/macros/SeeCompatTable.ejs) should be used on pages that document [experimental features](/en-US/docs/MDN/Writing_guidelines/Experimental_deprecated_obsolete#experimental).
Example: `\{{SeeCompatTable}}` {{SeeCompatTable}}
- [`deprecated_header`](https://github.com/mdn/yari/blob/main/kumascript/macros/Deprecated_Header.ejs): `\{{Deprecated_Header}}` {{Deprecated_Header}}
- [`secureContext_header`](https://github.com/mdn/yari/blob/main/kumascript/macros/secureContext_header.ejs).
Should be used on main pages like interface pages, API overview pages, and API entry points (e.g. `navigator.xyz`) but usually not on sub-pages like method and property pages.
Example: `\{{SecureContext_Header}}` {{SecureContext_Header}}
### Indicating that a feature is available in web workers
The [`AvailableInWorkers`](https://github.com/mdn/yari/blob/main/kumascript/macros/AvailableInWorkers.ejs) macro inserts a localized note box indicating that a feature is available in a [Web worker](/en-US/docs/Web/API/Web_Workers_API) context.
You can use the argument `notservice` to indicate that a feature works in web workers except for service workers.
#### Syntax
```plain
\{{AvailableInWorkers}}
\{{AvailableInWorkers("notservice")}}
```
#### Examples
{{AvailableInWorkers}}
{{AvailableInWorkers("notservice")}}
## Browser compatibility and specification macros
The following macros are included on all reference pages, but are also supported by all page types:
- `\{{Compat}}` / `\{{Compat(<feature>)}}` / `\{{Compat(<feature>, <depth>)}}`
- : Generates a [compatibility table](/en-US/docs/MDN/Writing_guidelines/Page_structures/Compatibility_tables) for the feature passed as the parameter. If no parameter is included, it defaults to the features defined by `browser-compat` in the frontmatter. An optional depth parameter sets how deep sub features should be added to the table. The depth, if omitted, defaults to 1, meaning only the first level of sub feature data from BCD will be included.
- `\{{Specifications}}` / `\{{Specifications(<feature>)}}`
- : Includes the specification for the feature specified in the parameter. If no parameter is passed, the specification listed is defined by the value for `spec_urls` in the frontmatter, if present, or from the specification listed in browser compatibility data defined by `browser-compat` in the frontmatter. The specification is rendered as an external link.
## See also
- [Sidebar macros](/en-US/docs/MDN/Writing_guidelines/Page_structures/Sidebars)
- [Page templates](/en-US/docs/MDN/Writing_guidelines/Page_structures/Page_types#page_templates)
- [Page components](/en-US/docs/MDN/Writing_guidelines/Writing_style_guide#page_components)
- [List of macros](https://github.com/mdn/yari/tree/main/kumascript/macros) on Github
| 0 |
data/mdn-content/files/en-us/mdn/writing_guidelines/page_structures | data/mdn-content/files/en-us/mdn/writing_guidelines/page_structures/sidebars/index.md | ---
title: Sidebars
slug: MDN/Writing_guidelines/Page_structures/Sidebars
page-type: mdn-writing-guide
---
{{MDNSidebar}}
All the pages MDN community members may edit include a sidebar. These sidebars are created using macros.
This article describes the different MDN sidebar macros, demonstrating how to include sidebars on MDN pages.
In this guide, you will learn how to create a sidebar of links by just including a macro and how to create sidebars with additional content.
## Creating sidebars
Every page has a sidebar. These sidebars appear because a sidebar macro has been included on the pages that create a potentially hierarchical list of links to other pages on this site.
When a sidebar macro is included, the server creates a section of content containing an unordered list of links. The links created, where they are displayed, and how they are displayed depend on the macro used and the parameters included in the markdown macro call. Some sidebars include links based on a directory's structure or page type. Others include a list of predefined pages that are hard-coded in Yari.
### Including single-macro sidebars
To include only the content generated by a sidebar macro, the macro is added immediately after the frontmatter and before the content on every page. Frontmatter is where we specify the metadata and options for each page. The frontmatter on MDN includes the page title, slug, and page type, along with other information based on the page type, such as specification URL, browser compatibility object, etc.
For example, the first lines of this document are written as:
```md
---
title: Sidebars
slug: MDN/Writing_guidelines/Page_structures/Sidebars
page-type: mdn-writing-guide
---
\{{MDNSidebar}}
```
The frontmatter is the content between the dashes. The sidebar macro is included immediately after the frontmatter. The `\{{MDNSidebar}}` is a sidebar macro that adds the MDN sidebar to the page. When the sidebar is a single macro call, the macro is placed immediately after the frontmatter.
Here are a few other sidebar macros, with what they do:
- `\{{CSSRef}}`
- : Present on every CSS page, it generates a CSS sidebar that includes links for modules, properties, selectors, combinators, pseudo-classes, pseudo-elements, at-rules, functions, and types, with all the link lists collapsed except for the link list for the current page type.
- `\{{DefaultAPISidebar("<API_Title>")}}`
- : The API sidebar displayed for overview pages; the single parameter is the name of the API group in GroupData.
- `\{{GlossarySidebar}}`
- : Present on every glossary page, it generates the glossary sidebar that includes the list of top-level glossary terms (not the disambiguated terms) preceded by a section filter.
- `\{{LearnSidebar}}`
- : Present on every page within the Learn section except for common questions and how-to pages (which use the `QuickLinksWithSubpages` macro), it generates a sidebar based on the [hard-coded links](https://github.com/mdn/yari/blob/main/kumascript/macros/LearnSidebar.ejs) present in the Yari macro file. This macro is not based on file structure.
- `\{{HTMLSidebar}}`
- : Generates the sidebar for HTML documentation, including tutorials, references, and guides. The macro includes calls to the `\{{ ListSubpagesForSidebar}}` macro for the element and attribute reference sections, while the tutorial and guide [links are hard-coded](https://github.com/mdn/yari/blob/main/kumascript/macros/HTMLSidebar.ejs).
- `\{{HTTPSidebar}}`
- : Generates the sidebar for [HTTP documentation](/en-US/docs/Web/HTTP), including guides and reference docs.
- `\{{PWASidebar}}`
- : Generates the sidebar for progressive web app (PWA) documentation. The macro lists all the pages (it is not based on file structure).
The appropriate macro to use depends on the [page type](/en-US/docs/MDN/Writing_guidelines/Page_structures/Page_types). The [template](/en-US/docs/MDN/Writing_guidelines/Page_structures/Page_types#page_templates) for each page type includes the appropriate macro for that page type.
### Creating new sidebars
You should use existing sidebar macros, without adding any content to them. If you are creating a whole new section of content, create a [macro for your sidebar](https://github.com/mdn/yari/blob/main/kumascript/macros/) in Yari.
In the unlikely event that you need to create a temporary sidebar, this section explains how that can be done. Do not submit your temporary sidebar for PR review as it will not be approved.
If you need to create a new sidebar macro, you can do so in your development environment by following these steps:
1. Remove the sidebar macro appearing immediately after the frontmatter and before the content, as each document can only have one sidebar.
2. At the end of the markdown file, add an HTML {{htmlelement("section")}} element setting the `id` of the element to `Quick_links`.
3. Add a `\{{ListSubpagesForSidebar()}}` macro with the slug of the directory for each section of content you want to include in the sidebar, along with additional markdown, between the opening and closing `<section>` tags.
For example, when developing the Accessibility sidebar, we could have temporarily included the following at the end of a markdown file (and removing any sidebar macro from below the frontmatter), will create a sidebar containing the links to all the ARIA role pages, preceded by a link to the ARIA roles overview page:
```md
<section id="Quick_links">
1. [**Accessibility**](/en-US/docs/Web/Accessibility)
\{{ListSubpagesForSidebar("/en-US/docs/Web/Accessibility")}}
2. [**ARIA roles**](/en-US/docs/Web/Accessibility/ARIA/Roles)
\{{ListSubpagesForSidebar("/en-US/docs/Web/Accessibility/ARIA/Roles", "true")}}
3. [**ARIA attributes**](/en-US/docs/Web/Accessibility/ARIA/Attributes)
\{{ListSubpagesForSidebar("/en-US/docs/Web/Accessibility/ARIA/Attributes", "true")}}
</section>
```
If listed as the last content in the page, Yari, the engine that renders MDN, recognizes the `Quick_links` ID in the opening tag and converts the content of the identified `<section>` into a sidebar.
The `\{{ListSubpagesForSidebar(<parameters>)}}` macro inserts the tree of subpages for the page whose slug is specified as the first parameter. The above creates a sidebar containing a link to all the Accessibility documents, followed by the ARIA roles and attributes.
Once you have determined the links to include in your sidebar, submit a pull request to [Yari with your proposed sidebar macro](https://github.com/mdn/yari/blob/main/kumascript/macros/).
> **Note:** This `<section>` must be appended to the end of the document, instead of between the frontmatter and the page content. Only one sidebar is created per page, so any macro listed after the frontmatter must be removed.
The [macro source code](https://github.com/mdn/yari/tree/main/kumascript/macros) is on Github. Each macro includes the documentation for itself, including parameters, if any.
## See also
- [Using macros](/en-US/docs/MDN/Writing_guidelines/Page_structures/Macros)
- [Content link macros](/en-US/docs/MDN/Writing_guidelines/Page_structures/Links)
- [Page section macros](/en-US/docs/MDN/Writing_guidelines/Page_structures/Macros/Commonly_used_macros)
- [Banners and notices macros](/en-US/docs/MDN/Writing_guidelines/Page_structures/Banners_and_notices)
- [All macros](https://github.com/mdn/yari/tree/main/kumascript/macros) on Github
| 0 |
data/mdn-content/files/en-us/mdn/writing_guidelines/page_structures | data/mdn-content/files/en-us/mdn/writing_guidelines/page_structures/page_types/index.md | ---
title: Page types
slug: MDN/Writing_guidelines/Page_structures/Page_types
page-type: mdn-writing-guide
---
{{MDNSidebar}}
There are a number of types of pages that are used repeatedly on MDN.
This article describes these page types, their purpose, and gives examples of each and templates to use when creating a new page.
There are three broad categories of page types on MDN, though some page types fall into more than one category.
- **Reference** pages describe the details of something, and are organized according to the structure of the thing described.
- **Guide** pages describe how to do something or use something, and are organized based on the goals of the reader.
- **Navigation** pages exist primarily to provide links to other pages, usually about related topics.
## Creating a new page
To create new pages on MDN, you need to use GitHub — have a look at our [content repo](https://github.com/mdn/content) section about [adding a new document](https://github.com/mdn/content/blob/main/CONTRIBUTING.md#adding-a-new-document) for more instructions.
## How to use the templates
When creating a new page you can ensure that you've used the right page structure/contents by referring to one of our page templates — see the sections below.
You can find the exact source code of each template (if you want to copy it) by following the "Source on **GitHub**" link at the bottom of each one.
These page templates don't make much sense as published pages, but if you view their source code you'll see that they contain a lot of helpful comments, placeholders, and hints detailing how to fill in the missing information and create your page.
At the top of each template you'll find a section entitled _Remove before publishing_ — this contains information on how to fill in the page title, slug, sidebar menu, and tags (e.g. information that doesn't actually appear in the body of the article).
You need to delete this section after you've followed the instructions in it, before the page can be considered finished.
## Old-style page layouts
Sometimes you will come across old-style reference pages that look markedly different from the templates presented here.
For example, old-style interface pages had all the interfaces' member details on a single page, and individual method/property/constructor/event listener pages didn't exist.
If you come across an old-style set of pages, we'd love for you to update them to the new style!
However, we do appreciate that this could be a large amount of work.
If the information to update is not too large, and you have some free time, by all means try updating it to the new style.
If the work is more significant, then you should consider a few factors when prioritizing the work:
- How out-of-date is the information?
- How low quality is the information?
- How popular is the feature? How sought after is the information?
If you want to get a team together to work on an update, or you just want to report or discuss some content needing an update, feel free to [file a content issue](https://github.com/mdn/content/issues) or [ask us for help](/en-US/docs/MDN/Community/Communication_channels).
## The page-type front matter key
We have defined a front matter key `page-type` to clearly identify the type of MDN pages. The templates linked below indicate which `page-type` values you should set for each page type.
For the complete list of page types see [The page-type front matter key](/en-US/docs/MDN/Writing_guidelines/Page_structures/Page_types/Page_type_key).
## Page templates
Below are examples of the various pages you'll find on MDN along with templates that can be used to create new content based on the type of content you will be presenting, including the following pages:
- [API landing pages](#api_landing_page)
- [API reference page](#api_reference_page)
- [API reference subpage](#api_reference_subpage)
- [Conceptual pages](#conceptual_page)
- [CSS feature reference](#css_feature_reference_page)
- [CSS module landing page](#css_module_landing_page)
- [Glossary entry](#glossary_page)
- [HTML element](#html_element_reference_page)
- [HTTP header](#http_header_reference_page)
- [Landing page](#landing_page)
- [SVG element](#svg_element_reference_page)
Each section includes links to live example pages for that page type.
### API landing page
An **{{Glossary("API")}} landing page** provides an overview of what a particular API does, as well as links to the documentation for each of the interfaces, globals, functions, etc. offered by the API.
It does not link directly to specific methods or properties within the API's classes, except in the context of the overview text.
It is primarily a _navigation_ page, but also functions as an at-a-glance _reference_ page for the API.
There are some instances where multiple APIs exist that are distinct, and are defined in their own specifications, but they closely related and therefore would make sense to cover with a single API landing page.
For example, the [Generic Sensor API](https://www.w3.org/TR/generic-sensor/) cover general sensor concerns, but more specific concerns are covered in other APIs such as [Ambient Light Sensor](https://www.w3.org/TR/ambient-light/), [Motion Sensor](https://www.w3.org/TR/motion-sensors/), etc.
In such cases, many of the high level concepts are the same, so it makes no sense to repeat those over multiple landing pages.
In such a case, it would make more sense in terms of repetition and findability to cover them all under a single "Web sensors" landing page.
#### Example
- [WebVR API](/en-US/docs/Web/API/WebVR_API)
#### Templates
- [API landing page template](/en-US/docs/MDN/Writing_guidelines/Page_structures/Page_types/API_landing_page_template)
### API reference page
> **Note:** Also known as an _Interface landing page_.
An **API reference page** lists all the methods, properties, events, and so forth that are members of a particular interface or class.
It provides an overview of what the class or interface does or is used for, and gives links to the documentation for each of these members.
It is more granular than an API landing page, which typically links to multiple API reference pages.
#### Example
- [Request interface](/en-US/docs/Web/API/Request) of the [Fetch API](/en-US/docs/Web/API/Fetch_API).
#### Templates
- [API reference page template](/en-US/docs/MDN/Writing_guidelines/Page_structures/Page_types/API_reference_page_template)
### API reference subpage
An **API reference subpage** is a child of an API reference page.
It documents a single interface member in detail.
#### Examples
- [`count()` method](/en-US/docs/Web/API/IDBIndex/count) of the [IDBIndex](/en-US/docs/Web/API/IDBIndex) interface (part of the [IndexedDB API](/en-US/docs/Web/API/IndexedDB_API))
- [capabilities property](/en-US/docs/Web/API/VRDisplay/capabilities) of the [VRDisplay](/en-US/docs/Web/API/VRDisplay) interface (part of the [WebVR API](/en-US/docs/Web/API/WebVR_API))
- [Request() constructor](/en-US/docs/Web/API/Request/Request) of the [Request](/en-US/docs/Web/API/Request) interface (part of the [Fetch API](/en-US/docs/Web/API/Fetch_API))
- [vrdisplaypresentchange event](/en-US/docs/Web/API/Window/vrdisplaypresentchange_event) (part of the [WebVR API](/en-US/docs/Web/API/WebVR_API), hangs off the [Window](/en-US/docs/Web/API/Window)) interface
#### Templates
- [API method subpage template](/en-US/docs/MDN/Writing_guidelines/Page_structures/Page_types/API_method_subpage_template)
- [API property subpage template](/en-US/docs/MDN/Writing_guidelines/Page_structures/Page_types/API_property_subpage_template)
- [API constructor subpage template](/en-US/docs/MDN/Writing_guidelines/Page_structures/Page_types/API_constructor_subpage_template)
- [API event subpage template](/en-US/docs/MDN/Writing_guidelines/Page_structures/Page_types/API_event_subpage_template)
### HTML element reference page
An **HTML reference page** lists all the attributes that are available on an HTML element, explains the element's purpose and usage, and provides examples, browser compatibility information, and other important data.
#### Example
- [`<video>` element](/en-US/docs/Web/HTML/Element/video)
#### Templates
- [HTML element page template](/en-US/docs/MDN/Writing_guidelines/Page_structures/Page_types/HTML_element_page_template)
### SVG element reference page
An **SVG reference page** lists all the attributes that are available on an SVG element, explains the element's purpose and usage, and provides examples, browser compatibility information, and other important data.
#### Example
- [\<g> element](/en-US/docs/Web/SVG/Element/g)
#### Templates
- [SVG element page template](/en-US/docs/MDN/Writing_guidelines/Page_structures/Page_types/SVG_element_page_template)
### CSS module landing page
Every **[CSS](/en-US/docs/Web/CSS) module** represents a CSS specification that provides support for certain features and implementations in CSS. For example, the [CSS box model](/en-US/docs/Web/CSS/CSS_box_model) module represents the [specification](/en-US/docs/Web/CSS/CSS_box_model#specifications) that describes the margin and padding properties that let you create spacing in and around a CSS box.
A **CSS module landing page** provides an overview of the features that the module provides and lists all the properties, data types, CSS functions, and so on offered by the module. When possible, the CSS module landing page provides a quick demonstration of what can be achieved using the properties of the module through an interactive example.
The module landing page serves primarily as a _navigation_ page, but also functions as an at-a-glance _reference_ page for the module.
Some related properties and features that belong in other modules, but that are closely related to the functionality offered by the module you are documenting, can also be covered in a _Related concepts_ section.
For example, the `<easing-function>` data type and the `prefers-reduced-motion` media query are not covered in the CSS animations module, but because they are closely related with CSS animations, it is a good idea to highlight them in the [Related concepts](/en-US/docs/Web/CSS/CSS_animations#related_concepts) section of the CSS animations module landing page.
#### Examples
- [CSS animations](/en-US/docs/Web/CSS/CSS_animations)
- [CSS basic user interface](/en-US/docs/Web/CSS/CSS_basic_user_interface)
- [CSS filter effects](/en-US/docs/Web/CSS/CSS_filter_effects)
- [CSS scroll snap](/en-US/docs/Web/CSS/CSS_scroll_snap)
#### Templates
- [CSS module landing page template](/en-US/docs/MDN/Writing_guidelines/Page_structures/Page_types/CSS_module_landing_page_template)
### CSS feature reference page
A **CSS reference page** lists all the available syntax for a CSS feature such as a selector or property, and explains the feature's purpose and usage. It also provides examples, browser compatibility information, and other important data.
#### Examples
- [background-color property](/en-US/docs/Web/CSS/background-color)
- [:hover pseudo-class](/en-US/docs/Web/CSS/:hover)
- [@media at-rule](/en-US/docs/Web/CSS/@media)
#### Templates
- [CSS property page template](/en-US/docs/MDN/Writing_guidelines/Page_structures/Page_types/CSS_property_page_template)
- [CSS selector page template](/en-US/docs/MDN/Writing_guidelines/Page_structures/Page_types/CSS_selector_page_template)
- [CSS function page template](/en-US/docs/MDN/Writing_guidelines/Page_structures/Page_types/CSS_function_page_template)
### HTTP header reference page
An **HTTP header reference page** lists all the available directives that an HTTP header can contain, and explains the header's purpose and usage.
It also provides examples, browser compatibility information, and other important explanations.
#### Example
- [Cache-Control header](/en-US/docs/Web/HTTP/Headers/Cache-Control)
#### Templates
- [HTTP header page template](/en-US/docs/MDN/Writing_guidelines/Page_structures/Page_types/HTTP_header_page_template)
### Conceptual page
A **conceptual page** is a _guide_ page that explains or teaches something.
Generally, if a page contains primarily prose, and doesn't fall into another page type, it's probably a conceptual page.
An extended discussion of a topic might be spread across multiple conceptual pages, and linked using [Next](https://github.com/mdn/yari/blob/main/kumascript/macros/Next.ejs) and [Previous](https://github.com/mdn/yari/blob/main/kumascript/macros/Previous.ejs) macros.
#### Examples
- [Using the WebVR API](/en-US/docs/Web/API/WebVR_API/Using_the_WebVR_API)
- [Visualizations with Web Audio API](/en-US/docs/Web/API/Web_Audio_API/Visualizations_with_Web_Audio_API)
- [Cascade and inheritance in CSS](/en-US/docs/Learn/CSS/Building_blocks/Cascade_and_inheritance)
### Glossary page
A **glossary page** contains a brief explanation of a term, topic, or concept.
The first paragraph should be a simple, self-contained description of the term, no more than a couple sentences.
This can be followed by links to further information in the **See also** section.
If the page grows to more than a screenful or so, it's too long and should be converted to a conceptual page. See [How to write and reference an entry in the glossary](/en-US/docs/MDN/Writing_guidelines/Howto/Write_a_new_entry_in_the_glossary) for more details.
#### Examples
- [DOM](/en-US/docs/Glossary/DOM)
- [Exception](/en-US/docs/Glossary/Exception)
- [Hyperlink](/en-US/docs/Glossary/Hyperlink)
#### Templates
- [Glossary page template](/en-US/docs/MDN/Writing_guidelines/Page_structures/Page_types/Glossary_page_template)
### Landing page
A **landing page** serves as a menu, of sorts, for its subpages, and is therefore primarily a _navigation_ page.
A landing page layout is typically used for the root page of a tree of pages about a particular topic.
It opens with a brief summary of the topic, then presents a structured list of links to its subpages, and optionally, additional material that be useful to the reader.
The list of subpages can be generated automatically using the templates [`SubpagesWithSummaries`](https://github.com/mdn/yari/blob/main/kumascript/macros/SubpagesWithSummaries.ejs), and [`LandingPageListSubpages`](https://github.com/mdn/yari/blob/main/kumascript/macros/LandingPageListSubpages.ejs). However, in more complex cases, the list may need to be created (and maintained!) by hand.
### Examples
- [HTML](/en-US/docs/Web/HTML)
- [CSS](/en-US/docs/Web/CSS)
- [Web APIs](/en-US/docs/Web/API)
- [JavaScript](/en-US/docs/Web/JavaScript)
- [Learning area](/en-US/docs/Learn)
- [Contributing to MDN](/en-US/docs/MDN/Community/Contributing)
## See also
- [Page components](/en-US/docs/MDN/Writing_guidelines/Writing_style_guide#page_components)
- [Creating code examples in markdown](/en-US/docs/MDN/Writing_guidelines/Writing_style_guide/Code_style_guide)
| 0 |
data/mdn-content/files/en-us/mdn/writing_guidelines/page_structures/page_types | data/mdn-content/files/en-us/mdn/writing_guidelines/page_structures/page_types/svg_element_page_template/index.md | ---
title: SVG element page template
slug: MDN/Writing_guidelines/Page_structures/Page_types/SVG_element_page_template
page-type: mdn-writing-guide
browser-compat: path.to.feature.NameOfTheElement
---
{{MDNSidebar}}
> **Note:** _Remove this whole explanatory note before publishing_
>
> ---
>
> **Page front matter:**
>
> The frontmatter at the top of the page is used to define "page metadata".
> The values should be updated appropriately for the particular element.
>
> ```md
> ---
> title: <NameOfTheElement>
> slug: Web/SVG/Element/NameOfTheElement
> page-type: svg-element
> status:
> - experimental
> - deprecated
> - non-standard
> browser-compat: svg.elements.NameOfTheElement
> ---
> ```
>
> - **title**
> - : Title heading displayed at top of page.
> Format as **<**_NameOfTheElement_**>**.
> For example, the "[g](/en-US/docs/Web/SVG/Element/g)" element has a _title_ of `<g>`.
> - **slug**
> - : The end of the URL path after `https://developer.mozilla.org/en-US/docs/`).
> This will be formatted like `Web/SVG/Element/NameOfTheElement`.
> - **page-type**
> - : Always `svg-element`.
> - **status**
> - : Include (appropriate) technology status keys: [**experimental**](/en-US/docs/MDN/Writing_guidelines/Experimental_deprecated_obsolete#experimental), [**deprecated**](/en-US/docs/MDN/Writing_guidelines/Experimental_deprecated_obsolete#deprecated), **non-standard** (if not on a standards track).
> - **browser-compat**
>
> - : Replace the placeholder value `svg.elements.NameOfTheElement` with the query string for the element in the [Browser compat data repo](https://github.com/mdn/browser-compat-data).
> The toolchain automatically uses the key to populate the compatibility and specification sections (replacing the `\{{Compat}}` and `\{{Specifications}}` macros).
>
> Note that you may first need to create/update an entry for the element in our [Browser compat data repo](https://github.com/mdn/browser-compat-data), and the entry will need to include specification information.
> See our [guide on how to do this](/en-US/docs/MDN/Writing_guidelines/Page_structures/Compatibility_tables).
>
> ---
>
> **Top-of-page macros**
>
> A number of macro calls appear at the top of the content section (immediately below the page frontmatter).
> You should update or delete them according to the advice below:
>
> - `\{{SeeCompatTable}}` — this generates a **This is an experimental technology** banner that indicates the technology is [experimental](/en-US/docs/MDN/Writing_guidelines/Experimental_deprecated_obsolete#experimental).
> If the technology you are documenting is not experimental, you should remove this.
> If it is experimental, and the technology is hidden behind a pref in Firefox, you should also fill in an entry for it in the [Experimental features in Firefox](/en-US/docs/Mozilla/Firefox/Experimental_features) page.
> - `\{{Deprecated_Header}}` — this generates a **Deprecated** banner that indicates that use of the technology is [discouraged](/en-US/docs/MDN/Writing_guidelines/Experimental_deprecated_obsolete#deprecated).
> If it isn't, then you can remove the macro call.
> - `\{{SecureContext_Header}}` — this generates a **Secure context** banner that indicates the technology is only available in a [secure context](/en-US/docs/Web/Security/Secure_Contexts).
> If it isn't, then you can remove the macro call.
> If it is, then you should also fill in an entry for it in the [Features restricted to secure contexts](/en-US/docs/Web/Security/Secure_Contexts/features_restricted_to_secure_contexts) page.
> - `\{{SVGRef}}` — this generates the left-hand-side reference sidebar for the element.
> The content of the sidebar depends on the tags in the page metadata.
> - Remember to remove the `\{{MDNSidebar}}` macro when you copy this page.
>
> Samples of the **Experimental** and **Deprecated** banners are shown right after this note block.
>
> _Remember to remove this whole explanatory note before publishing_
{{SeeCompatTable}}{{deprecated_header}}{{SVGRef}}
Begin the content on the page with an introductory paragraph — start by naming the element and saying what it does.
This should ideally be one or two short sentences.
## Usage context
`\{{svginfo}}`
For the correct information to appear here, fill an entry for the element in the `\{{svginfo}}` macro if it is not in there already.
_To use this macro, remove the backticks and backslash in the markdown file._
## Attributes
### Global attributes
- [Conditional processing attributes](/en-US/docs/Web/SVG/Attribute#conditional_processing_attributes)
- [Core attributes](/en-US/docs/Web/SVG/Attribute#core_attributes)
- [Graphical event attributes](/en-US/docs/Web/SVG/Attribute#graphical_event_attributes)
- [Presentation attributes](/en-US/docs/Web/SVG/Attribute#presentation_attributes)
- {{SVGAttr("class")}}
- {{SVGAttr("style")}}
- {{SVGAttr("transform")}}
### Specific attributes
- Include bulleted
- list of all the
- SVG attributes it can take
## DOM Interface
This element implements the `\{{domxref("NameOfSVGDOMElement")}}` interface.
## Examples
Note that we use the plural "Examples" even if the page only contains one example.
### A descriptive heading
Each example must have an H3 heading (`###`) naming the example. The heading should be descriptive of what the example is doing. For example, "A simple example" does not say anything about the example and therefore, not a good heading. The heading should be concise. For a longer description, use the paragraph after the heading.
See our guide on how to add [code examples](/en-US/docs/MDN/Writing_guidelines/Page_structures/Code_examples) for more information.
> **Note:** Sometimes you will want to link to examples given on another page.
>
> **Scenario 1:** If you have some examples on this page and some more examples on another page:
>
> Include an H3 heading (`###`) for each example on this page and then a final H3 heading (`###`) with the text "More examples", under which you can link to the examples on other pages. For example:
>
> ```md
> ## Examples
>
> ### Using the fetch API
>
> Example of Fetch
>
> ### More examples
>
> Links to more examples on other pages
> ```
>
> **Scenario 2:** If you _only_ have examples on another page and none on this page:
>
> Don't add any H3 headings; just add the links directly under the H2 heading "Examples". For example:
>
> ```md
> ## Examples
>
> For examples of this API, see [the page on fetch()](https://example.org).
> ```
## Specifications
`\{{Specifications}}`
_To use this macro, remove the backticks and backslash in the markdown file._
## Browser compatibility
`\{{Compat}}`
_To use this macro, remove the backticks and backslash in the markdown file._
## See also
Include links to reference pages and guides related to the current element. For more guidelines, see the [See also section](/en-US/docs/MDN/Writing_guidelines/Writing_style_guide#see_also_section) in the _Writing style guide_.
- link1
- link2
- external_link (year)
| 0 |
data/mdn-content/files/en-us/mdn/writing_guidelines/page_structures/page_types | data/mdn-content/files/en-us/mdn/writing_guidelines/page_structures/page_types/css_property_page_template/index.md | ---
title: CSS property page template
slug: MDN/Writing_guidelines/Page_structures/Page_types/CSS_property_page_template
page-type: mdn-writing-guide
browser-compat: css.properties.NameOfTheProperty
---
{{MDNSidebar}}
> **Note:** _Remove this note block before publishing._
>
> ---
>
> **Page front matter:**
>
> The front matter at the top of the page is used to define "page metadata".
> The values should be updated appropriately for the particular property.
>
> ```md
> ---
> title: NameOfTheProperty
> slug: Web/CSS/NameOfTheProperty
> page-type: css-property OR css-shorthand-property
> status:
> - experimental
> - deprecated
> - non-standard
> browser-compat: css.properties.NameOfTheProperty
> ---
> ```
>
> - **title**
> - : The `title` value is displayed at the top of the page. The title format is _NameOfTheProperty_.
> For example, the [`background-color`](/en-US/docs/Web/CSS/background-color) property has a title of _background-color_.
> - **slug**
> - : The `slug` value is the end of the URL path after `https://developer.mozilla.org/en-US/docs/`. This will be formatted as `Web/CSS/NameOfTheProperty`.
> For example, the slug for the [`background-color`](/en-US/docs/Web/CSS/background-color) property is `Web/CSS/background-color`. For a multi-word component such as `Getting_started` in a slug, the slug should use an underscore as in `/en-US/docs/Learn/HTML/Getting_started`.
> - **page-type**
> - : The `page-type` value for CSS properties is `css-property`. For a shorthand CSS property, the value is `css-shorthand-property`. For example, the `page-type` value for the [animation](/en-US/docs/Web/CSS/animation) property is `css-shorthand-property` because it is a shorthand property, whereas the `page-type` value for the [animation-delay](/en-US/docs/Web/CSS/animation-delay) property is `css-property`.
> - **status**
> - : If applicable, the value of the technology `status` key can be [**experimental**](/en-US/docs/MDN/Writing_guidelines/Experimental_deprecated_obsolete#experimental), [**deprecated**](/en-US/docs/MDN/Writing_guidelines/Experimental_deprecated_obsolete#deprecated), and/or **non-standard** (if not on a standards track).
> - **browser-compat**
> - : Replace the placeholder value <code>css.properties.NameOfTheProperty</code> with the query string for the property in the [Browser compat data repo](https://github.com/mdn/browser-compat-data/tree/main/css/properties). Check the _Other macros in the page_ section of this note block to see how this key-value is used to generate content for the _Specifications_ and _Browser compatibility_ sections.
>
> ---
>
> **Top-of-the-page macros**
>
> A number of macro calls appear at the top of the content section (immediately below the page front matter).
> You should update or delete them according to the advice below:
>
> - `\{{SeeCompatTable}}`: This macro generates an **Experimental** banner, which indicates that the technology is [experimental](/en-US/docs/MDN/Writing_guidelines/Experimental_deprecated_obsolete#experimental).
> If the technology you are documenting is not experimental, you can remove this macro.
> If the technology is experimental and is hidden behind a preference in Firefox, you should also fill in an entry for it in the [Experimental features in Firefox](/en-US/docs/Mozilla/Firefox/Experimental_features) page.
> - `\{{Deprecated_Header}}`: This macro generates a **Deprecated** banner, which indicates that the use of the technology is [discouraged](/en-US/docs/MDN/Writing_guidelines/Experimental_deprecated_obsolete#deprecated).
> If it isn't, then you can remove the macro call.
> - `\{{CSSRef}}`: This macro must be present on every CSS property page. It generates a suitable CSS sidebar, depending on the tags included on the page.
> Remember to remove the `\{{MDNSidebar}}` macro when you use this template.
>
> Samples of the **Experimental** and **Deprecated** banners are shown right after this note block.
>
> ---
>
> **Other macros in the page**
>
> - Formal syntax section: The content for the _Formal syntax_ section is generated using the `\{{CSSSyntax}}` macro. This macro fetches data from the specifications using the [@webref/css npm package](https://www.npmjs.com/package/@webref/css).
> - Formal definition section: The content for the _Formal definition_ section is generated using the `\{{CSSInfo}}` macro. For this section to have data, you must ensure an appropriate entry has been filled in for the corresponding property in the [properties.json](https://github.com/mdn/data/blob/main/css/properties.json) data file in the `mdn/data` repository. See the [Properties](https://github.com/mdn/data/blob/main/css/properties.md) page for more information.
> - Specifications and Browser compatibility sections: The build tool automatically uses the `browser-compat` key-value pair from the page front matter to insert data into the _Specifications_ and _Browser compatibility_ sections (replacing the `\{{Specifications}}` and `\{{Compat}}` macros in those sections, respectively).
>
> Note that you may first need to create/update an entry for the property and its specification in our <a href="https://github.com/mdn/browser-compat-data">Browser compat data repo</a>.
> See our [compatibility tables guide](/en-US/docs/MDN/Writing_guidelines/Page_structures/Compatibility_tables) for information on adding or editing entries.
>
> _Remember to remove this note block before publishing._
{{SeeCompatTable}}{{deprecated_header}}{{CSSRef}}
Begin the content on the page with an introductory paragraph, which names the property and says what it does.
This should ideally be one or two short sentences.
## Try it
_This title is auto-generated by the macro `\{{EmbedInteractiveExample}}`._
This section is for interactive examples added using the `\{{EmbedInteractiveExample}}` macro. You create these examples in the [mdn/interactive-examples repository](https://github.com/mdn/interactive-examples/blob/main/CONTRIBUTING.md). See the [Interactive examples](/en-US/docs/MDN/Writing_guidelines/Page_structures/Code_examples#interactive_examples) section in our _Writing guidelines_ for more information.
## Constituent properties
Add this section only for shorthand properties, such as [animation](/en-US/docs/Web/CSS/animation), to list all the related longhand properties.
## Syntax
Include the common use cases as a code block and describe the component subvalues that make up a complete value.
```css
/* Insert code block showing common use cases */
/* or categories of values */
```
### Values
Include one term and definition for each subvalue.
- `subvalue1`
- : Include a description of the subvalue, its data type, and what it represents.
- `subvalue2`
- : Include a description of the subvalue, its data type, and what it represents.
## Description
This is an optional section to include a description of the property and explain how it works. Use this section to explain related terms and add use cases for the property.
## Formal definition
`\{{CSSInfo}}`
_To use this macro, remove the backticks and backslash in the markdown file._
## Formal syntax
`\{CSSSyntax}}`
_To use this macro, remove the backticks and backslash in the markdown file._
## Examples
Note that we use the plural "Examples" even if the page only contains one example.
### Add a descriptive heading
Each example must have an H3 heading (`###`) naming the example. The heading should be descriptive of what the example is doing. For example, "A simple example" does not say anything about the example and therefore, not a good heading. The heading should be concise. For a longer description, use the paragraph after the heading.
See our guide on how to add [code examples](/en-US/docs/MDN/Writing_guidelines/Page_structures/Code_examples) for more information.
> **Note:** Sometimes you will want to link to examples given on another page.
>
> **Scenario 1:** If you have some examples on this page and some more examples on another page:
>
> Include an H3 heading (`###`) for each example on this page and then a final H3 heading (`###`) with the text "More examples", under which you can link to the examples on other pages. For example:
>
> ```md
> ## Examples
>
> ### Using the fetch API
>
> Example of Fetch
>
> ### More examples
>
> Links to more examples on other pages
> ```
>
> **Scenario 2:** If you _only_ have examples on another page and none on this page:
>
> Don't add any H3 headings; just add the links directly under the H2 heading "Examples". For example:
>
> ```md
> ## Examples
>
> For examples of this API, see [the page on fetch()](https://example.org).
> ```
## Accessibility concerns
This is an optional section. You can include any warnings here for accessibility concerns that developers should be aware of while using this property. You can also include workarounds for these accessibility concerns if there are any.
## Specifications
`\{{Specifications}}`
_To use this macro, remove the backticks and backslash in the markdown file._
## Browser compatibility
`\{{Compat}}`
_To use this macro, remove the backticks and backslash in the markdown file._
## See also
Include links to reference pages and guides related to the current property. For more guidelines, see the [See also section](/en-US/docs/MDN/Writing_guidelines/Writing_style_guide#see_also_section) in the _Writing style guide_.
- link1
- link2
- external_link (year)
| 0 |
data/mdn-content/files/en-us/mdn/writing_guidelines/page_structures/page_types | data/mdn-content/files/en-us/mdn/writing_guidelines/page_structures/page_types/css_function_page_template/index.md | ---
title: CSS function page template
slug: MDN/Writing_guidelines/Page_structures/Page_types/CSS_function_page_template
page-type: mdn-writing-guide
browser-compat: css.functions.NameOfTheFunction
---
{{MDNSidebar}}
> **Note:** _Remove this note block before publishing._
>
> ---
>
> **Page front matter:**
>
> The front matter at the top of the page is used to define "page metadata".
> The values should be updated appropriately for the particular function. Note the presence (or absence) of parenthesis.
>
> ```md
> ---
> title: NameOfTheFunction()
> slug: Web/CSS/NameOfTheFunction
> page-type: css-function
> status:
> - experimental
> - deprecated
> - non-standard
> browser-compat: css.types.NameOfTheFunction
> ---
> ```
>
> - **title**
> - : The `title` value is displayed at the top of the page. The title format is _NameOfTheFunction()_.
> For example, the [`pow()`](/en-US/docs/Web/CSS/pow) function has a title of _pow()_.
> - **slug**
> - : The `slug` value is the end of the URL path after `https://developer.mozilla.org/en-US/docs/`. This will be formatted as `Web/CSS/NameOfTheFunction`. Note the absence of parentheses in the slug.
> For example, the slug for the [`pow()`](/en-US/docs/Web/CSS/pow) function is `Web/CSS/pow`.
> - **page-type**
> - : The `page-type` value for CSS functions is `css-function`.
> - **status**
> - : If applicable, the value of the technology `status` key can be [**experimental**](/en-US/docs/MDN/Writing_guidelines/Experimental_deprecated_obsolete#experimental), [**deprecated**](/en-US/docs/MDN/Writing_guidelines/Experimental_deprecated_obsolete#deprecated), and/or **non-standard** (if not on a standards track).
> - **browser-compat**
> - : Replace the placeholder value <code>css.types.NameOfTheFunction</code> with the query string for the function in the [Browser compat data repo](https://github.com/mdn/browser-compat-data/tree/main/css/types). Check the _Other macros in the page_ section of this note block to see how this key-value is used to generate content for the _Specifications_ and _Browser compatibility_ sections.
>
> ---
>
> **Top-of-the-page macros**
>
> A number of macro calls appear at the top of the content section (immediately below the page front matter).
> You should update or delete them according to the advice below:
>
> - `\{{SeeCompatTable}}`: This macro generates an **Experimental** banner, which indicates that the technology is [experimental](/en-US/docs/MDN/Writing_guidelines/Experimental_deprecated_obsolete#experimental).
> If the technology you are documenting is not experimental, you can remove this macro.
> If the technology is experimental and is hidden behind a preference in Firefox, you should also fill in an entry for it in the [Experimental features in Firefox](/en-US/docs/Mozilla/Firefox/Experimental_features) page.
> - `\{{Deprecated_Header}}`: This macro generates a **Deprecated** banner, which indicates that the use of the technology is [discouraged](/en-US/docs/MDN/Writing_guidelines/Experimental_deprecated_obsolete#deprecated).
> If it isn't, then you can remove the macro call.
> - `\{{CSSRef}}`: This macro must be present on every CSS page. It generates a suitable CSS sidebar, depending on the tags included on the page.
> Remember to remove the `\{{MDNSidebar}}` macro when you use this template.
>
> Samples of the **Experimental** and **Deprecated** banners are shown right after this note block.
>
> ---
>
> **Other macros in the page**
>
> - Formal syntax section: The content for the _Formal syntax_ section is generated using the `\{{CSSSyntax}}` macro. This macro fetches data from the specifications using the [@webref/css npm package](https://www.npmjs.com/package/@webref/css).
> - Specifications and Browser compatibility sections: The build tool automatically uses the `browser-compat` key-value pair from the page front matter to insert data into the _Specifications_ and _Browser compatibility_ sections (replacing the `\{{Specifications}}` and `\{{Compat}}` macros in those sections, respectively).
>
> Note that you may first need to create/update an entry for the function and its specification in our <a href="https://github.com/mdn/browser-compat-data">Browser compat data repo</a>.
> See our [compatibility tables guide](/en-US/docs/MDN/Writing_guidelines/Page_structures/Compatibility_tables) for information on adding or editing entries.
>
> _Remember to remove this note block before publishing._
{{SeeCompatTable}}{{deprecated_header}}{{CSSRef}}
Begin the content on the page with an introductory paragraph, which names the function and says what it does.
This should ideally be one or two short sentences.
## Try it
_This title is auto-generated by the macro `\{{EmbedInteractiveExample}}`._
This section is for interactive examples added using the `\{{EmbedInteractiveExample}}` macro. You create these examples in the [mdn/interactive-examples repository](https://github.com/mdn/interactive-examples/blob/main/CONTRIBUTING.md). See the [Interactive examples](/en-US/docs/MDN/Writing_guidelines/Page_structures/Code_examples#interactive_examples) section in our _Writing guidelines_ for more information.
## Syntax
Include a CSS code block to show the main use cases of the syntax, including examples of parameters that the function can accept. Only include the function itself, not a complete declaration in which it occurs. For example, use `minmax(200px, 1fr)`, not `grid-template-columns: minmax(min-content, 300px)`.
Don't end the syntax lines with semicolons: this should emphasize that we are not showing complete valid CSS code here, just the syntax usage.
Show all the invocation patterns that the function can take. Preceding all such cases, add a comment to describe the use case and another comment to name the parameters and highlight syntax punctuation and the order of parameters. The parameter names in the comment should match the parameters listed in the "Parameters" section.
The comment showing each invocation pattern should be followed by exactly one empty line.
For example:
```css
/* Without a fallback */
/* var( <custom-property-name> ) */
var(--custom-prop)
/* With an empty fallback */
/* var( <custom-property-name> , ) */
var(--custom-prop,)
/* With a fallback value */
/* var( <custom-property-name> , <declaration-value> ) */
var(--custom-prop, initial)
var(--custom-prop, #FF0000)
var(--my-background, linear-gradient(transparent, aqua), pink)
var(--custom-prop, var(--default-value))
var(--custom-prop, var(--default-value, red))
```
### Parameters
List the parameters that the function can accept as a {{htmlelement("dl")}}. List them in the order that they appear in the _Formal syntax_ section. Indicate if a parameter is optional using the `optional_inline` badge.
Include one term and definition for each parameter.
- `<custom-property-name>`
- : Include a description of the parameter, its data type, and its default value if any.
- `<declaration-value>` {{optional_inline}}
- : Include a description of the parameter, its data type, and its default value if any.
### Return value
Describe the value returned by the function. Begin the description with the word "Returns"; for example, "Returns a `<number>` or `<dimension>`."
## Description
This section is optional but recommended. It contains a description of the function and explains how it works. Use this section to explain related terms and add use cases for the function.
## Formal syntax
Not all functions have formal syntax: if a function doesn't, omit this whole section.
`\{{CSSSyntax}}`
_To use this macro, remove the backticks and backslash in the markdown file._
## Examples
Note that we use the plural "Examples" even if the page only contains one example.
### Add a descriptive heading
Each example must have an H3 heading (`###`) naming the example. The heading should be descriptive of what the example is doing. For example, "A simple example" does not say anything about the example and therefore, not a good heading. The heading should be concise. For a longer description, use the paragraph after the heading.
See our guide on how to add [code examples](/en-US/docs/MDN/Writing_guidelines/Page_structures/Code_examples) for more information.
> **Note:** Sometimes you will want to link to examples given on another page.
>
> **Scenario 1:** If you have some examples on this page and some more examples on another page:
>
> Include an H3 heading (`###`) for each example on this page and then a final H3 heading (`###`) with the text "More examples", under which you can link to the examples on other pages. For example:
>
> ```md
> ## Examples
>
> ### Using the polygon() function
>
> Example of polygon()
>
> ### More examples
>
> Links to more examples on other pages
> ```
>
> **Scenario 2:** If you _only_ have examples on another page and none on this page:
>
> Don't add any H3 headings; just add the links directly under the H2 heading "Examples". For example:
>
> ```md
> ## Examples
>
> For examples of this function, see [the page on basic-shape](https://example.org).
> ```
## Accessibility concerns
This is an optional section. You can include any warnings here for accessibility concerns that developers should be aware of while using this function. You can also include workarounds for these accessibility concerns if there are any.
## Specifications
`\{{Specifications}}`
_To use this macro, remove the backticks and backslash in the markdown file._
## Browser compatibility
`\{{Compat}}`
_To use this macro, remove the backticks and backslash in the markdown file._
## See also
Include links to reference pages and guides related to the current function. For more guidelines, see the [See also section](/en-US/docs/MDN/Writing_guidelines/Writing_style_guide#see_also_section) in the _Writing style guide_.
- link1
- link2
- external_link (year)
| 0 |
data/mdn-content/files/en-us/mdn/writing_guidelines/page_structures/page_types | data/mdn-content/files/en-us/mdn/writing_guidelines/page_structures/page_types/css_module_landing_page_template/index.md | ---
title: CSS module landing page template
slug: MDN/Writing_guidelines/Page_structures/Page_types/CSS_module_landing_page_template
page-type: mdn-writing-guide
---
{{MDNSidebar}}
> **Note:** _Remember to remove this note block before publishing._
>
> ---
>
> **Page front matter:**
>
> The front matter at the top of the page is used to define "page metadata".
> The values should be updated appropriately for the particular module.
>
> ```md
> ---
> title: CSS NameOfTheModule
> slug: Web/CSS/CSS_NameOfTheModule
> page-type: css-module
> spec-urls:
> - url1
> - url2
> ---
> ```
>
> - **title**
> - : The `title` value is displayed at the top of the page.
> This is the text "CSS" followed by the name of the module.
> For example, the title for the [grid layout](/en-US/docs/Web/CSS/CSS_grid_layout) module landing page is _CSS grid layout_.
> - **slug**
> - : The `slug` value is the end of the URL path after `https://developer.mozilla.org/en-US/docs/`.
> This will be formatted as `Web/CSS/CSS_NameOfTheModule`.
> For example, the slug for the [grid layout](/en-US/docs/Web/CSS/CSS_grid_layout) module landing page is `Web/CSS/CSS_grid_layout`.
> - **page-type**
> - : The `page-type` value for CSS module landing pages is `css-module`.
> - **spec-urls**
>
> - : The `spec-urls` value is a URL of the specification. In case there is more than one version of the specification that is relevant, present them in a bulleted list. For example, the value for `spec-urls` key for the [filter effects](/en-US/docs/Web/CSS/CSS_filter_effects) module landing page is:
>
> ```plain
> - `https://drafts.fxtf.org/filter-effects-2/`
> - `https://drafts.fxtf.org/filter-effects-1/`
> ```
>
> ---
>
> **Top-of-page macros**
>
> The `\{{CSSRef}}` macro call appears at the top of the content section (immediately below the page front matter).
> This macro must be present on every CSS module landing page. It generates a suitable CSS sidebar, depending on the tags included on the page.
> Remove the `\{{MDNSidebar}}` macro when you use this template.
>
> ---
>
> _Remember to remove this note block before publishing._
Begin the content on the page with an introductory paragraph, which names the module and says what it does.
This should ideally be one or two short sentences.
## NameOfTheModule in action
In this section, include an interactive example of the module that helps to demonstrate the usefulness or the power of various properties provided by this module. The purpose of this section is to demonstrate a few use cases and to create interest and curiosity in the mind of the readers learning about this module.
Provide a short description of how readers can interact with the example. Don't go into a lot of detail to explain the example, and don't include code snippets. Add a link to the source code for the example in the [`css-examples`](https://github.com/mdn/css-examples/tree/main/modules) repository. For example, for the filter effects module interactive example, you would say:
"To see the code for this example, [view the source on GitHub](https://github.com/mdn/css-examples/blob/main/modules/filters.html)."
## Reference
Create the relevant subsections to list the related properties, functions, data types, and so on.
### Properties
List of all shorthand and longhand properties provided by the module.
### At-rules
List of CSS at-rules provided by the module. Omit this section if there are no relevant CSS at-rules for this module.
### Functions
List of CSS functions provided by the module. Omit this section if there are no relevant CSS functions for this module.
### Data types
List of CSS data types provided by the module. Omit this section if there are no relevant CSS data types for this module.
### Events
List of API events provided by the module. Omit this section if there are no relevant events for this module.
### Interfaces
List the related API and interfaces provided by the module. Omit this section if there are no relevant API interfaces for this module.
## Guides
- LinkToGuide1
- : Description of the guide in one or two sentences.
- LinkToGuide2
- : Description of the guide in one or two sentences.
## Related concepts
List all other properties, data types, or glossary terms that may be relevant or related to this module.
## Specifications
`\{{Specifications}}`
_To use this macro, remove the backticks and backslash in the markdown file._
## See also
Include links to reference pages and guides related to the current property. Check the [See also](/en-US/docs/MDN/Writing_guidelines/Writing_style_guide#see_also_section) section in our _Writing style guide_ for more hints and directions.
- link1
- link2
- external_link (year)
| 0 |
data/mdn-content/files/en-us/mdn/writing_guidelines/page_structures/page_types | data/mdn-content/files/en-us/mdn/writing_guidelines/page_structures/page_types/http_header_page_template/index.md | ---
title: HTTP header page template
slug: MDN/Writing_guidelines/Page_structures/Page_types/HTTP_header_page_template
page-type: mdn-writing-guide
browser-compat: path.to.feature.NameOfTheHeader
---
{{MDNSidebar}}
> **Note:** _Remove this whole explanatory note before publishing_
>
> ---
>
> **Page front matter:**
>
> The frontmatter at the top of the page is used to define "page metadata".
> The values should be updated appropriately for the particular header.
>
> ```md
> ---
> title: NameOfTheHeader
> slug: Web/HTTP/Headers/NameOfTheHeader
> page-type: http-header
> status:
> - experimental
> - deprecated
> - non-standard
> browser-compat: path.to.feature.NameOfTheHeader
> ---
> ```
>
> - **title**
> - : Title heading displayed at top of page. Format as _NameOfTheHeader_. For example, the [Cache-Control](/en-US/docs/Web/HTTP/Headers/Cache-Control) header has a _title_ of `Cache-Control`.
> - **slug**
> - : The end of the URL path after `https://developer.mozilla.org/en-US/docs/`. This will be formatted like `Web/HTTP/Headers/NameOfTheHeader`. For example, the [Cache-Control](/en-US/docs/Web/HTTP/Headers/Cache-Control) slug is `Web/HTTP/Headers/Cache-Control`.
> - **page-type**
> - : For HTTP headers, must be `http-header`. For other HTTP `page-type` values, see the [HTTP section](/en-US/docs/MDN/Writing_guidelines/Page_structures/Page_types/Page_type_key#http_page_types) of the documentation for the `page-type` front matter key.
> - **status**
> - : Include (appropriate) technology status keys: [**experimental**](/en-US/docs/MDN/Writing_guidelines/Experimental_deprecated_obsolete#experimental), [**deprecated**](/en-US/docs/MDN/Writing_guidelines/Experimental_deprecated_obsolete#deprecated), **non-standard** (if not on a standards track).
> - **browser-compat**
>
> - : Replace the placeholder value <code>path.to.feature.NameOfTheHeader</code> with the query string for the header in the [Browser compat data repo](https://github.com/mdn/browser-compat-data).
> The toolchain automatically uses the key to populate the compatibility section (replacing the `\{{Compat}}` macro).
>
> Note that you may first need to create/update an entry for the HTTP header in our <a href="https://github.com/mdn/browser-compat-data">Browser compat data repo</a>, and the entry for the header will need to include specification information.
> See our [guide on how to do this](/en-US/docs/MDN/Writing_guidelines/Page_structures/Compatibility_tables).
>
> ---
>
> **Top-of-page macros**
>
> A number of macro calls appear at the top of the content section (immediately below the page frontmatter).
> You should update or delete them according to the advice below:
>
> - `\{{SeeCompatTable}}` — this generates a **This is an experimental technology** banner that indicates the header is [experimental](/en-US/docs/MDN/Writing_guidelines/Experimental_deprecated_obsolete#experimental).
> If the header you are documenting is not experimental, you can remove this.
> If it is experimental, and the technology is hidden behind a pref in Firefox, you should also fill in an entry for it in the [Experimental features in Firefox](/en-US/docs/Mozilla/Firefox/Experimental_features) page.
> - `\{{deprecated_header}}` — this generates a **Deprecated** banner that indicates that use of the header is [discouraged](/en-US/docs/MDN/Writing_guidelines/Experimental_deprecated_obsolete#deprecated).
> If it isn't, then you can remove the macro call.
> - `\{{httpsidebar}}` — this generates the HTTP sidebar that must appear on every HTTP reference page.
> Remember to remove the `\{{MDNSidebar}}` macro when you copy this page.
>
> _Remember to remove this whole explanatory note before publishing_
{{SeeCompatTable}}{{deprecated_header}}{{httpsidebar}}
The summary paragraph — start by naming the http header and saying what it does.
This should ideally be 1 or 2 short sentences.
<table class="properties">
<tbody>
<tr>
<th scope="row">Header type</th>
<td>
Include header category (or categories), e.g.
{{Glossary("Request header")}},
{{Glossary("Response header")}},
<a href="/en-US/docs/Web/HTTP/Client_hints">Client hint</a>
</td>
</tr>
<tr>
<th scope="row">{{Glossary("Forbidden header name")}}</th>
<td>yes or no</td>
</tr>
<tr>
<th scope="row">
{{Glossary("CORS-safelisted response header")}}
</th>
<td>yes or no</td>
</tr>
</tbody>
</table>
## Syntax
Fill in a syntax box, like the one below, according to the guidance in our [syntax sections](/en-US/docs/MDN/Writing_guidelines/Page_structures/Syntax_sections) article.
If the header has a lot of available directives, feel free to include multiple syntax boxes, subsections and explanations as appropriate.
```http
NameOfTheHeader: <directive1>
NameOfTheHeader: <directive1>, <directive2>, …
```
The directives are case-insensitive and have an optional argument, that can use both token and quoted-string syntax.
Multiple directives are comma-separated (delete information as appropriate).
## Directives
- `directive1`
- : Include a brief description of the directive and what it does here.
Include one term and definition for each directive.
- `directive2`
- : etc.
If the header has a lot of available directives, feel free to include multiple definition lists, subsections and explanations as appropriate.
## Examples
Note that we use the plural "Examples" even if the page only contains one example.
### A descriptive heading
Each example must have an H3 heading (`###`) naming the example. The heading should be descriptive of what the example is doing. For example, "A simple example" does not say anything about the example and therefore, not a good heading. The heading should be concise. For a longer description, use the paragraph after the heading.
See our guide on how to add [code examples](/en-US/docs/MDN/Writing_guidelines/Page_structures/Code_examples) for more information.
> **Note:** Sometimes you will want to link to examples given on another page.
>
> **Scenario 1:** If you have some examples on this page and some more examples on another page:
>
> Include an H3 heading (`###`) for each example on this page and then a final H3 heading (`###`) with the text "More examples", under which you can link to the examples on other pages. For example:
>
> ```md
> ## Examples
>
> ### Using the fetch API
>
> Example of Fetch
>
> ### More examples
>
> Links to more examples on other pages
> ```
>
> **Scenario 2:** If you _only_ have examples on another page and none on this page:
>
> Don't add any H3 headings; just add the links directly under the H2 heading "Examples". For example:
>
> ```md
> ## Examples
>
> For examples of this API, see [the page on fetch()](https://example.org).
> ```
## Specifications
`\{{Specifications}}`
_To use this macro, remove the backticks and backslash in the markdown file._
## Browser compatibility
`\{{Compat}}`
_To use this macro, remove the backticks and backslash in the markdown file._
## See also
Include links to reference pages and guides related to the current HTTP header. For more guidelines, see the [See also section](/en-US/docs/MDN/Writing_guidelines/Writing_style_guide#see_also_section) in the _Writing style guide_.
- link1
- link2
- external_link (year)
| 0 |
data/mdn-content/files/en-us/mdn/writing_guidelines/page_structures/page_types | data/mdn-content/files/en-us/mdn/writing_guidelines/page_structures/page_types/html_element_page_template/index.md | ---
title: HTML element page template
slug: MDN/Writing_guidelines/Page_structures/Page_types/HTML_element_page_template
page-type: mdn-writing-guide
browser-compat: path.to.feature.NameOfTheElement
---
{{MDNSidebar}}
> **Note:** _Remove this whole explanatory note before publishing_
>
> ---
>
> **Page front matter:**
>
> The frontmatter at the top of the page is used to define "page metadata".
> The values should be updated appropriately for the particular element.
>
> ```md
> ---
> title: "<NameOfTheElement>: The NameOfTheElement element"
> slug: Web/HTML/Element/NameOfTheElement
> page-type: html-element
> status:
> - experimental
> - deprecated
> - non-standard
> browser-compat: html.elements.NameOfTheElement
> ---
> ```
>
> - **title**
> - : Title heading displayed at top of page.
> Format as `'<NameOfTheElement>: Description of element's purpose'`.
> For example, the [`<video>`](/en-US/docs/Web/HTML/Element/video) element has a _title_ of: **'\<video>: The Video Embed element'**.
> - **slug**
> - : The end of the URL path after `https://developer.mozilla.org/en-US/docs/`).
> This will be formatted like `Web/HTML/Element/NameOfTheElement`, where the element name is in _lower case_.
> For example, the [`<video>`](/en-US/docs/Web/HTML/Element/video) element has a _slug_ of `Web/HTML/Element/video`.
> - **page-type**
> - : Always `html-element`.
> - **status**
> - : Include (appropriate) technology status keys: [**experimental**](/en-US/docs/MDN/Writing_guidelines/Experimental_deprecated_obsolete#experimental), [**deprecated**](/en-US/docs/MDN/Writing_guidelines/Experimental_deprecated_obsolete#deprecated), **non-standard** (if not on a standards track).
> - **browser-compat**
>
> - : Replace the placeholder value `html.elements.NameOfTheElement` with the query string for the element in the [Browser compat data repo](https://github.com/mdn/browser-compat-data).
> The toolchain automatically uses the key to populate the compatibility and specification sections (replacing the `\{{Compat}}` and `\{{Specifications}}` macros).
>
> Note that you may first need to create/update an entry for the element in our [Browser compat data repo](https://github.com/mdn/browser-compat-data), and the entry will need to include specification information.
> See our [guide on how to do this](/en-US/docs/MDN/Writing_guidelines/Page_structures/Compatibility_tables).
>
> ---
>
> **Top-of-page macros**
>
> A number of macro calls appear at the top of the content section (immediately below the page frontmatter).
> You should update or delete them according to the advice below:
>
> - `\{{SeeCompatTable}}` — this generates a **This is an experimental technology** banner that indicates the technology is [experimental](/en-US/docs/MDN/Writing_guidelines/Experimental_deprecated_obsolete#experimental).
> If the technology you are documenting is not experimental, you should remove this.
> If it is experimental, and the technology is hidden behind a pref in Firefox, you should also fill in an entry for it in the [Experimental features in Firefox](/en-US/docs/Mozilla/Firefox/Experimental_features) page.
> - `\{{Deprecated_Header}}` — this generates a **Deprecated** banner that indicates that use of the technology is [discouraged](/en-US/docs/MDN/Writing_guidelines/Experimental_deprecated_obsolete#deprecated).
> If it isn't, then you can remove the macro call.
> - `\{{SecureContext_Header}}` — this generates a **Secure context** banner that indicates the technology is only available in a [secure context](/en-US/docs/Web/Security/Secure_Contexts).
> If it isn't, then you can remove the macro call.
> If it is, then you should also fill in an entry for it in the [Features restricted to secure contexts](/en-US/docs/Web/Security/Secure_Contexts/features_restricted_to_secure_contexts) page.
> - `\{{HTMLSidebar}}` — this generates the left-hand-side reference sidebar for the element.
> The content of the sidebar depends on the tags in the page metadata.
> - Remember to remove the `\{{MDNSidebar}}` macro when you copy this page.
>
> Samples of the **Experimental** and **Deprecated** banners are shown right after this note block.
>
> _Remember to remove this whole explanatory note before publishing_
{{SeeCompatTable}}{{Deprecated_Header}}{{HTMLSidebar}}
The **`<insert_the_element_name>`** [HTML](/en-US/docs/Web/HTML) element does _(insert a summary paragraph naming the element and saying what it does, ideally 1 or 2 short sentences)_.
\\{{EmbedInteractiveExample("pages/tabbed/nameOfElement.html", "tabbed-standard")}}
Further information — at this point, include a few more paragraphs explaining the most important things you need to know about using the element and its main features. It is good to explain briefly what is going on in the interactive example if it is not immediately obvious. You could also explain key points about how this element interacts with important related JavaScript or CSS features. Not too much detail — you don't want to repeat the documentation across pages — but a key point plus a link to that feature's page would be useful. Again, see the `<video>` page for an example.
## Attributes
This element includes the [global attributes](/en-US/docs/Web/HTML/Global_attributes).
- `attribute1` {{Deprecated_inline}} {{experimental_inline}}
- : Include description here of what the attribute does. Include one term and definition for each attribute. If the attribute is not experimental/deprecated, remove the relevant macro calls.
- `attribute2`
- : etc.
## Events
Include a table of the events fired on this type of element, if any.
| Event name | Fired when |
| ---------- | -------------------------------- |
| event 1 | Explain briefly when it is fired |
| event 2 | Explain briefly when it is fired |
| etc. | |
## Examples
Note that we use the plural "Examples" even if the page only contains one example.
### A descriptive heading
Each example must have an H3 heading (`###`) naming the example. The heading should be descriptive of what the example is doing. For example, "A simple example" does not say anything about the example and therefore, not a good heading. The heading should be concise. For a longer description, use the paragraph after the heading.
See our guide on how to add [code examples](/en-US/docs/MDN/Writing_guidelines/Page_structures/Code_examples) for more information.
> **Note:** Sometimes you will want to link to examples given on another page.
>
> **Scenario 1:** If you have some examples on this page and some more examples on another page:
>
> Include an H3 heading (`###`) for each example on this page and then a final H3 heading (`###`) with the text "More examples", under which you can link to the examples on other pages. For example:
>
> ```md
> ## Examples
>
> ### Using the fetch API
>
> Example of Fetch
>
> ### More examples
>
> Links to more examples on other pages
> ```
>
> **Scenario 2:** If you _only_ have examples on another page and none on this page:
>
> Don't add any H3 headings; just add the links directly under the H2 heading "Examples". For example:
>
> ```md
> ## Examples
>
> For examples of this API, see [the page on fetch()](https://example.org).
> ```
## Accessibility concerns
Optionally, warn of any potential accessibility concerns that exist with using this element, and how to work around them. Remove this section if there are none to list.
## Technical summary
<table class="properties">
<tbody>
<tr>
<th scope="row">
<a href="/en-US/docs/Web/HTML/Content_categories"
>Content categories</a
>
</th>
<td>
Fill in a list of the content categories the HTML element belongs to.
</td>
</tr>
<tr>
<th scope="row">Permitted content</th>
<td>What content is the element allowed to contain?</td>
</tr>
<tr>
<th scope="row">Tag omission</th>
<td>
Can the end tag be omitted, or must it be present? Must it be omitted?
</td>
</tr>
<tr>
<th scope="row">Permitted parents</th>
<td>
What parent elements can the element be a child of? For example "Any
element that accepts
<a href="/en-US/docs/Web/HTML/Content_categories#flow_content"
>flow content</a
>."
</td>
</tr>
<tr>
<th scope="row">Permitted ARIA roles</th>
<td>
Fill in a list of ARIA roles that can be set on the element; for example
<a href="/en-US/docs/Web/Accessibility/ARIA/Roles/directory_role"><code>directory</code></a>.
</td>
</tr>
<tr>
<th scope="row">DOM interface</th>
<td>
What DOM interface represents the element in JavaScript? For example
{{domxref("HTMLOListElement")}} in the case of ol.
</td>
</tr>
</tbody>
</table>
## Specifications
`\{{Specifications}}`
_To use this macro, remove the backticks and backslash in the markdown file._
## Browser compatibility
`\{{Compat}}`
_To use this macro, remove the backticks and backslash in the markdown file._
## See also
Include links to reference pages and guides related to the current element. For more guidelines, see the [See also section](/en-US/docs/MDN/Writing_guidelines/Writing_style_guide#see_also_section) in the _Writing style guide_.
- link1
- link2
- external_link (year)
| 0 |
data/mdn-content/files/en-us/mdn/writing_guidelines/page_structures/page_types | data/mdn-content/files/en-us/mdn/writing_guidelines/page_structures/page_types/api_method_subpage_template/index.md | ---
title: API method subpage template
slug: MDN/Writing_guidelines/Page_structures/Page_types/API_method_subpage_template
page-type: mdn-writing-guide
browser-compat: path.to.feature.NameOfTheMethod
---
{{MDNSidebar}}
> **Note:** _Remove this whole explanatory note before publishing._
>
> ---
>
> **Page front matter:**
>
> The front matter at the top of the page is used to define "page metadata".
> The values should be updated appropriately for the particular method.
>
> ```md
> ---
> title: NameOfTheParentInterface.NameOfTheMethod()
> slug: Web/API/NameOfTheParentInterface/NameOfTheMethod
> page-type: web-api-instance-method OR web-api-static-method
> status:
> - experimental
> - deprecated
> - non-standard
> browser-compat: path.to.feature.NameOfTheMethod
> ---
> ```
>
> - **title**
> - : Title heading displayed at top of page.
> Format as _NameOfTheParentInterface_**.**_NameOfTheMethod_**()**.
> For example, the [count()](/en-US/docs/Web/API/IDBIndex/count) method of the [IDBIndex](/en-US/docs/Web/API/IDBIndex) interface has a _title_ of `IDBIndex.count()`.
> - **slug**
>
> - : The end of the URL path after `https://developer.mozilla.org/en-US/docs/`.
> This will be formatted like `Web/API/NameOfTheParentInterface/NameOfTheMethod`.
>
> If the method is static, then the slug must have a `_static` suffix, like: `Web/API/NameOfTheParentInterface/NameOfTheMethod_static`. This enables us to support instance and static methods which have the same name.
>
> Note that the name of the method in the slug omits the parenthesis (it ends in `NameOfTheMethod` not `NameOfTheMethod()`).
>
> - **page-type**
> - : The `page-type` key for Web/API methods is either `web-api-instance-method` (for instance methods) or `web-api-static-method` (for static methods).
> - **status**
> - : Include (appropriate) technology status keys: [**experimental**](/en-US/docs/MDN/Writing_guidelines/Experimental_deprecated_obsolete#experimental), [**deprecated**](/en-US/docs/MDN/Writing_guidelines/Experimental_deprecated_obsolete#deprecated), **non-standard** (if not on a standards track).
> - **browser-compat**
>
> - : Replace the placeholder value `path.to.feature.NameOfTheMethod` with the query string for the method in the [Browser compat data repo](https://github.com/mdn/browser-compat-data).
> The toolchain automatically uses the key to populate the compatibility and specification sections (replacing the `\{{Compat}}` and `\{{Specifications}}` macros).
>
> Note that you may first need to create/update an entry for the API method in our [Browser compat data repo](https://github.com/mdn/browser-compat-data), and the entry for the API will need to include specification information.
> See our [guide on how to do this](/en-US/docs/MDN/Writing_guidelines/Page_structures/Compatibility_tables).
>
> ---
>
> **Top-of-page macros**
>
> A number of macro calls appear at the top of the content section (immediately below the page front matter).
> You should update or delete them according to the advice below:
>
> - `\{{SeeCompatTable}}` — this generates a **This is an experimental technology** banner that indicates the technology is [experimental](/en-US/docs/MDN/Writing_guidelines/Experimental_deprecated_obsolete#experimental).
> If the technology you are documenting is not experimental, you should remove this.
> If it is experimental, and the technology is hidden behind a pref in Firefox, you should also fill in an entry for it in the [Experimental features in Firefox](/en-US/docs/Mozilla/Firefox/Experimental_features) page.
> - `\{{Deprecated_Header}}` — this generates a **Deprecated** banner that indicates that use of the technology is [discouraged](/en-US/docs/MDN/Writing_guidelines/Experimental_deprecated_obsolete#deprecated).
> If it isn't, then you can remove the macro call.
> - `\{{SecureContext_Header}}` — this generates a **Secure context** banner that indicates the technology is only available in a [secure context](/en-US/docs/Web/Security/Secure_Contexts).
> If it isn't, then you can remove the macro call.
> If it is, then you should also fill in an entry for it in the [Features restricted to secure contexts](/en-US/docs/Web/Security/Secure_Contexts/features_restricted_to_secure_contexts) page.
> - `\{{APIRef("GroupDataName")}}` — this generates the left-hand reference sidebar showing quick reference links related to the current page.
> For example, every page in the [WebVR API](/en-US/docs/Web/API/WebVR_API) has the same sidebar, which points to the other pages in the API.
> To generate the correct sidebar for your API, you need to add a `GroupData` entry to our GitHub repo, and include the entry's name inside the macro call in place of _GroupDataName_.
> See our [API reference sidebars](/en-US/docs/MDN/Writing_guidelines/Howto/Write_an_API_reference/Sidebars) guide for information on how to do this. Remember to remove the `\{{MDNSidebar}}` macro when you copy this page.
>
> Samples of the **Experimental**, **Secure context**, and **Deprecated** banners are shown right after this note block.
>
> _Remember to remove this whole explanatory note before publishing._
{{SeeCompatTable}}{{SecureContext_header}}{{Deprecated_Header}}
Begin the content on the page with an introductory paragraph — start by naming the method, saying what interface it is part of, and saying what it does.
This should ideally be one or two short sentences. You could copy most of this from the method's summary on the corresponding API reference page.
## Syntax
Fill in a syntax box, according to the guidance in our [syntax sections](/en-US/docs/MDN/Writing_guidelines/Page_structures/Syntax_sections) article.
### Parameters
- `parameter1` {{Optional_Inline}}
- : Include a brief description of the parameter and what it does here. Include one term and definition for each parameter. If the parameter is not optional, remove the \\{{optional_inline}} macro call.
- `parameter2`
- : etc.
> **Note:** This section is mandatory. If there aren't any parameter, put "None." instead of the definition list.
### Return value
Include a description of the method's return value, including data type and what it represents.
If the method doesn't return anything, just put "None ({{jsxref('undefined')}}).".
### Exceptions
Include a list of all the exceptions that the constructor can raise. Include one term and definition for each exception.
- `Exception1`
- : Include descriptions of how the exception is raised.
- `Exception2`
- : Include descriptions of how the exception is raised.
Note that we have two kinds of exceptions: {{domxref("DOMException")}} objects and regular JavaScript exceptions, like {{jsxref("TypeError")}} and {{jsxref("RangeError")}}. A web developer needs to know:
- which object is thrown
- for exceptions that are `DOMException` objects, the `name` of the exception.
Here is an example where a method can raise a `DOMException` with a name of `IndexSizeError`, a second `DOMException` with a name of `InvalidNodeTypeError` and a JavaScript exception of type `TypeError`:
- `IndexSizeError` {{domxref("DOMException")}}
- : Thrown …
- `InvalidNodeTypeError` {{domxref("DOMException")}}
- : Thrown …
- {{jsxref("TypeError")}}
- : Thrown …
## Examples
Note that we use the plural "Examples" even if the page only contains one example.
### A descriptive heading
Each example must have an H3 heading naming the example. The heading should be descriptive of what the example is doing. For example, "A simple example" does not say anything about the example and therefore, not a good heading. The heading should be concise. For a longer description, use the paragraph after the heading.
See our guide on how to add [code examples](/en-US/docs/MDN/Writing_guidelines/Page_structures/Code_examples) for more information.
> **Note:** Sometimes you will want to link to examples given on another page.
>
> **Scenario 1:** If you have some examples on this page and some more examples on another page:
>
> Include an H3 heading (`###`) for each example on this page and then a final H3 heading (`###`) with the text "More examples", under which you can link to the examples on other pages. For example:
>
> ```md
> ## Examples
>
> ### Using the fetch API
>
> Example of Fetch
>
> ### More examples
>
> Links to more examples on other pages
> ```
>
> **Scenario 2:** If you _only_ have examples on another page and none on this page:
>
> Don't add any H3 headings; just add the links directly under the H2 heading "Examples". For example:
>
> ```md
> ## Examples
>
> For examples of this API, see [the page on fetch()](https://example.org).
> ```
## Specifications
`\{{Specifications}}`
_To use this macro, remove the backticks and backslash in the markdown file._
## Browser compatibility
`\{{Compat}}`
_To use this macro, remove the backticks and backslash in the markdown file._
## See also
Include links to reference pages and guides related to the current API. For more guidelines, see the [See also section](/en-US/docs/MDN/Writing_guidelines/Writing_style_guide#see_also_section) in the _Writing style guide_.
- link1
- link2
- external_link (year)
| 0 |
data/mdn-content/files/en-us/mdn/writing_guidelines/page_structures/page_types | data/mdn-content/files/en-us/mdn/writing_guidelines/page_structures/page_types/api_event_subpage_template/index.md | ---
title: API event subpage template
slug: MDN/Writing_guidelines/Page_structures/Page_types/API_event_subpage_template
page-type: mdn-writing-guide
browser-compat: path.to.feature.NameOfTheEvent_event
---
{{MDNSidebar}}
> **Note:** _Remove this whole explanatory note before publishing._
>
> ---
>
> **Page front matter:**
>
> The front matter at the top of the page is used to define "page metadata".
> The values should be updated appropriately for the particular event.
>
> ```md
> ---
> title: "NameOfTheParentInterface: NameOfTheEvent event"
> slug: Web/API/NameOfTheParentInterface/NameOfTheEventHandler_event
> page-type: web-api-event
> status:
> - experimental
> - deprecated
> - non-standard
> browser-compat: path.to.feature.NameOfTheEvent_event
> ---
> ```
>
> - **title**
> - : Title heading displayed at top of page.
> Format as "_NameOfTheParentInterface_**:** _NameOfTheEvent_ **event**".
> For example, the [animationcancel](/en-US/docs/Web/API/Element/animationcancel_event) event of the [Window](/en-US/docs/Web/API/Window) interface has a _title_ of `Window: animationcancel event`.
> - **slug**
> - : The end of the URL path after `https://developer.mozilla.org/en-US/docs/`).
> This will be formatted like `Web/API/NameOfTheParentInterface/NameOfTheEventHandler_event`.
> - **page-type**
> - : The `page-type` key for Web/API events is always `web-api-event`.
> - **status**
> - : Include (appropriate) technology status keys: [**experimental**](/en-US/docs/MDN/Writing_guidelines/Experimental_deprecated_obsolete#experimental), [**deprecated**](/en-US/docs/MDN/Writing_guidelines/Experimental_deprecated_obsolete#deprecated), **non-standard** (if not on a standards track).
> - **browser-compat**
>
> - : Replace the placeholder value `path.to.feature.NameOfTheEvent_event` with the query string for the event in the [Browser compat data repo](https://github.com/mdn/browser-compat-data).
> The toolchain automatically uses the key to populate the compatibility and specification sections (replacing the `\{{Compat}}` and `\{{Specifications}}` macros).
>
> Note that you may first need to create/update an entry for the event in our [Browser compat data repo](https://github.com/mdn/browser-compat-data), and this entry will need to include specification information.
> See our [guide on how to do this](/en-US/docs/MDN/Writing_guidelines/Page_structures/Compatibility_tables).
>
> ---
>
> **Top-of-page macros**
>
> A number of macro calls appear at the top of the content section (immediately below the page frontmatter).
> You should update or delete them according to the advice below:
>
> - `\{{SeeCompatTable}}` — this generates a **This is an experimental technology** banner that indicates the technology is [experimental](/en-US/docs/MDN/Writing_guidelines/Experimental_deprecated_obsolete#experimental).
> If the technology you are documenting is not experimental, you should remove this.
> If it is experimental, and the technology is hidden behind a pref in Firefox, you should also fill in an entry for it in the [Experimental features in Firefox](/en-US/docs/Mozilla/Firefox/Experimental_features) page.
> - `\{{Deprecated_Header}}` — this generates a **Deprecated** banner that indicates that use of the technology is [discouraged](/en-US/docs/MDN/Writing_guidelines/Experimental_deprecated_obsolete#deprecated).
> If it isn't, then you can remove the macro call.
> - `\{{SecureContext_Header}}` — this generates a **Secure context** banner that indicates the technology is only available in a [secure context](/en-US/docs/Web/Security/Secure_Contexts).
> If it isn't, then you can remove the macro call.
> If it is, then you should also fill in an entry for it in the [Features restricted to secure contexts](/en-US/docs/Web/Security/Secure_Contexts/features_restricted_to_secure_contexts) page.
> - `\{{APIRef("GroupDataName")}}` — this generates the left-hand reference sidebar showing quick reference links related to the current page.
> For example, every page in the [WebVR API](/en-US/docs/Web/API/WebVR_API) has the same sidebar, which points to the other pages in the API.
> To generate the correct sidebar for your API, you need to add a `GroupData` entry to our GitHub repo, and include the entry's name inside the macro call in place of _GroupDataName_.
> See our [API reference sidebars](/en-US/docs/MDN/Writing_guidelines/Howto/Write_an_API_reference/Sidebars) guide for information on how to do this. Remember to remove the `\{{MDNSidebar}}` macro when you copy this page.
>
> Samples of the **Experimental**, **Secure context**, and **Deprecated** banners are shown right after this note block.
>
> ---
>
> **Parent object link**
>
> Add a link to this new page from its parent object's _Events_ section.
> For example [Element: wheel event](/en-US/docs/Web/API/Element/wheel_event) is linked from [`Element` Events](/en-US/docs/Web/API/Element#events).
>
> If the parent object does not have an _Events_ section, then add one.
> If this is a new "class" of event, then you should add link to this section of the parent from the [Event reference](/en-US/docs/Web/Events).
>
> _Remember to remove this whole explanatory note before publishing._
{{SeeCompatTable}}{{SecureContext_Header}}{{Deprecated_Header}}
Begin the content on the page with an introductory paragraph — start by naming the event, saying what interface it is part of, and saying what it does.
This should ideally be one or two short sentences.
You could copy most of this from the property's summary on the corresponding API reference page.
## Syntax
Use the event name in methods like {{domxref("EventTarget.addEventListener", "addEventListener()")}}, or set an event handler property.
```js
addEventListener("NameOfTheEvent", (event) => {});
onNameOfTheEvent = (event) => {};
```
## Event type
If the event has a special type, mention it along with its inheritance. If not, indicate that it is a generic event:
_A generic {{domxref("Event")}}._
Or, for example:
_An {{domxref("XRSessionEvent")}}. Inherits from {{domxref("Event")}}._
{{InheritanceDiagram("XRSessionEvent")}}
## Event properties
If the event is not just a generic {{domxref("Event")}}, list the additional properties the event has.
_In addition to the properties listed below, properties from the parent interface, {{domxref("Event")}}, are available._
- {{domxref("XRSessionEvent.session", "session")}} {{ReadOnlyInline}}
- : The {{domxref("XRSession")}} to which the event refers.
## Description
If you want to provide additional text (too long for the summary), add a Description section.
It may contain the headings
### Trigger
and
### Use cases
which can provide more information.
## Examples
Note that we use the plural "Examples" even if the page only contains one example.
### A descriptive heading
Each example must have an H3 heading (`###`) naming the example. The heading should be descriptive of what the example is doing. For example, "A simple example" does not say anything about the example and therefore, not a good heading. The heading should be concise. For a longer description, use the paragraph after the heading.
See our guide on how to add [code examples](/en-US/docs/MDN/Writing_guidelines/Page_structures/Code_examples) for more information.
> **Note:** Sometimes you will want to link to examples given on another page.
>
> **Scenario 1:** If you have some examples on this page and some more examples on another page:
>
> Include an H3 heading (`###`) for each example on this page and then a final H3 heading (`###`) with the text "More examples", under which you can link to the examples on other pages. For example:
>
> ```md
> ## Examples
>
> ### Using the fetch API
>
> Example of Fetch
>
> ### More examples
>
> Links to more examples on other pages
> ```
>
> **Scenario 2:** If you _only_ have examples on another page and none on this page:
>
> Don't add any H3 headings; just add the links directly under the H2 heading "Examples". For example:
>
> ```md
> ## Examples
>
> For examples of this API, see [the page on fetch()](https://example.org).
> ```
## Specifications
`\{{Specifications}}`
_To use this macro, remove the backticks and backslash in the markdown file._
## Browser compatibility
`\{{Compat}}`
_To use this macro, remove the backticks and backslash in the markdown file._
## See also
Include links to reference pages and guides related to the current API. For more guidelines, see the [See also section](/en-US/docs/MDN/Writing_guidelines/Writing_style_guide#see_also_section) in the _Writing style guide_.
- link1
- link2
- external_link (year)
| 0 |
data/mdn-content/files/en-us/mdn/writing_guidelines/page_structures/page_types | data/mdn-content/files/en-us/mdn/writing_guidelines/page_structures/page_types/api_reference_page_template/index.md | ---
title: API reference page template
slug: MDN/Writing_guidelines/Page_structures/Page_types/API_reference_page_template
page-type: mdn-writing-guide
browser-compat: path.to.feature.NameOfTheInterface
---
{{MDNSidebar}}
> **Note:** _Remove this whole explanatory note before publishing._
>
> ---
>
> **Page front matter:**
>
> The front matter at the top of the page is used to define "page metadata".
> The values should be updated appropriately for the particular property.
>
> ```md
> ---
> title: NameOfTheInterface
> slug: Web/API/NameOfTheInterface
> page-type: web-api-interface
> status:
> - experimental
> - deprecated
> - non-standard
> browser-compat: path.to.feature.NameOfTheInterface
> ---
> ```
>
> - **title**
> - : Title heading displayed at top of page. This is just the name of the interface. For example, the [Request](/en-US/docs/Web/API/Request) interface page has a _title_ of _Request_.
> - **slug**
> - : The end of the URL path after `https://developer.mozilla.org/en-US/docs/`). This will be formatted like `Web/API/NameOfTheParentInterface`. For example, [Request](/en-US/docs/Web/API/Request) slug is "Web/API/Request".
> - **page-type**
> - : The `page-type` key for Web/API interfaces is always `web-api-interface`.
> - **status**
> - : Include (appropriate) technology status keys: [**experimental**](/en-US/docs/MDN/Writing_guidelines/Experimental_deprecated_obsolete#experimental), [**deprecated**](/en-US/docs/MDN/Writing_guidelines/Experimental_deprecated_obsolete#deprecated), **non-standard** (if not on a standards track).
> - **browser-compat**
>
> - : Replace the placeholder value `path.to.feature.NameOfTheMethod` with the query string for the method in the [Browser compat data repo](https://github.com/mdn/browser-compat-data). The toolchain automatically uses the key to populate the compatibility and specification sections (replacing the `\{{Compat}}` and `\{{Specifications}}` macros).
>
> Note that you may first need to create/update an entry for the API method in our [Browser compat data repo](https://github.com/mdn/browser-compat-data), and the entry for the API will need to include specification information.
>
> See our [guide on how to do this](/en-US/docs/MDN/Writing_guidelines/Page_structures/Compatibility_tables).
>
> ---
>
> **Top-of-page macros**
>
> By default, there are five macro calls at the top of a template. You should update or delete them according to the advice below.
>
> - `\{{APIRef("<em>GroupDataName</em>")}}` — this generates the left-hand reference sidebar showing quick reference links related to the current page. For example, every page in the [WebVR API](/en-US/docs/Web/API/WebVR_API) has the same sidebar, which points to the other pages in the API. To generate the correct sidebar for your API, you need to add a GroupData entry to our KumaScript GitHub repo, and include the entry's name inside the macro call in place of _GroupDataName_. See our [API reference sidebars](/en-US/docs/MDN/Writing_guidelines/Howto/Write_an_API_reference/Sidebars) guide for information on how to do this.
> - `\{{SeeCompatTable}}` — this generates a **This is an experimental technology** banner that indicates the technology is [experimental](/en-US/docs/MDN/Writing_guidelines/Experimental_deprecated_obsolete#experimental). If the technology you are documenting is not experimental, you can remove this. If it is experimental, and the technology is hidden behind a pref in Firefox, you should also fill in an entry for it in the [Experimental features in Firefox](/en-US/docs/Mozilla/Firefox/Experimental_features) page.
> - `\{{SecureContext_Header}}` — this generates a **Secure context** banner that indicates the technology is only available in a [secure context](/en-US/docs/Web/Security/Secure_Contexts). If it isn't, then you can remove the macro call. If it is, then you should also fill in an entry for it in the [Features restricted to secure contexts](/en-US/docs/Web/Security/Secure_Contexts/features_restricted_to_secure_contexts) page.
> - `\{{Deprecated_Header}}` — this generates a **Deprecated** banner that indicates the technology is [deprecated](/en-US/docs/MDN/Writing_guidelines/Experimental_deprecated_obsolete#deprecated). If it isn't, then you can remove the macro call.
> - `\{{Interface_Overview("<em>GroupDataName</em>")}} {{Experimental_Inline}}` — this generates the main body of the page (Constructor, Properties, Methods and Events).
>
> Samples of the **Experimental**, **Secure context**, and **Deprecated** banners are shown right after this note block.
>
> _Remember to remove this whole explanatory note before publishing._
{{SeeCompatTable}}{{SecureContext_Header}}{{Deprecated_Header}}
The summary paragraph — start by naming the interface, saying what API it is part of, and saying what it does. This should ideally be 1 or 2 short sentences. You could copy most of this from the Interface's summary on the corresponding API landing page.
{{InheritanceDiagram}}
_To use the [domxref macro](/en-US/docs/MDN/Writing_guidelines/Page_structures/Macros/Commonly_used_macros#linking_to_pages_in_references) in the sections below, remove the backticks and backslash in the markdown file._
## Constructor
- `\{{DOMxRef("NameOfTheInterface.NameOfTheInterface", "NameOfTheInterface()")}}`
- : Creates a new instance of the `NameOfTheInterface` object.
## Static properties
_Also inherits properties from its parent interface, `\{{DOMxRef("NameOfParentInterface")}}`._ (Note: If the interface doesn't inherit from another interface, remove this whole line.)
Include one term and definition for each property.
- `\{{DOMxRef("NameOfTheInterface.staticProperty1")}}` {{ReadOnlyInline}} {{Deprecated_Inline}}
- : Include a brief description of the property and what it does here. If the property is not readonly/experimental/deprecated, remove the related macro calls.
- `\{{DOMxRef("NameOfTheInterface.staticProperty2")}}`
- : Include a brief description of the property and what it does here. If the property is not readonly/experimental/deprecated, remove the related macro calls.
## Instance properties
_Also inherits properties from its parent interface, `\{{DOMxRef("NameOfParentInterface")}}`._ (Note: If the interface doesn't inherit from another interface, remove this whole line.)
Include one term and definition for each property.
- `\{{DOMxRef("NameOfTheInterface.property1")}}` {{ReadOnlyInline}} {{Deprecated_Inline}}
- : Include a brief description of the property and what it does here. If the property is not readonly/experimental/deprecated, remove the related macro calls.
- `\{{DOMxRef("NameOfTheInterface.property2")}}`
- : Include a brief description of the property and what it does here. If the property is not readonly/experimental/deprecated, remove the related macro calls.
## Static methods
_Also inherits methods from its parent interface, `\{{DOMxRef("NameOfParentInterface")}}`._ (Note: If the interface doesn't inherit from another interface, remove this whole line.)
Include one term and definition for each method.
- `\{{DOMxRef("NameOfTheInterface.staticMethod1()")}}` {{Experimental_Inline}} {{Deprecated_Inline}}
- : Include a brief description of the method and what it does here. If the method is not experimental/deprecated, remove the related macro calls.
- `\{{DOMxRef("NameOfTheInterface.staticMethod2()")}}`
- : Include a brief description of the method and what it does here. If the method is not experimental/deprecated, remove the related macro calls.
## Instance methods
_Also inherits methods from its parent interface, `\{{DOMxRef("NameOfParentInterface")}}`._ (Note: If the interface doesn't inherit from another interface, remove this whole line.)
Include one term and definition for each method.
- `\{{DOMxRef("NameOfTheInterface.method1()")}}` {{Experimental_Inline}} {{Deprecated_Inline}}
- : Include a brief description of the method and what it does here. If the method is not experimental/deprecated, remove the related macro calls.
- `\{{DOMxRef("NameOfTheInterface.method2()")}}`
- : Include a brief description of the method and what it does here. If the method is not experimental/deprecated, remove the related macro calls.
## Events
_Also inherits events from its parent interface, `\{{DOMxRef("NameOfParentInterface")}}`._ (Note: If the interface doesn't inherit from another interface, remove this whole line.)
Listen to these events using {{DOMxRef("EventTarget.addEventListener", "addEventListener()")}} or by assigning an event listener to the `oneventname` property of this interface.
- [`eventname1`](#)
- : Fired when (include the description of when the event fires).
Also available via the `oneventname1` property.
- [`eventname2`](#)
- : Fired when _(include a description of when the event fires)_.
Also available via the `oneventname2` property.
## Examples
Note that we use the plural "Examples" even if the page only contains one example.
### A descriptive heading
Each example must have an H3 heading (`###`) naming the example. The heading should be descriptive of what the example is doing. For example, "A simple example" does not say anything about the example and therefore, not a good heading. The heading should be concise. For a longer description, use the paragraph after the heading.
See our guide on how to add [code examples](/en-US/docs/MDN/Writing_guidelines/Page_structures/Code_examples) for more information.
> **Note:** Sometimes you will want to link to examples given on another page.
>
> **Scenario 1:** If you have some examples on this page and some more examples on another page:
>
> Include an H3 heading (`###`) for each example on this page and then a final H3 heading (`###`) with the text "More examples", under which you can link to the examples on other pages. For example:
>
> ```md
> ## Examples
>
> ### Using the fetch API
>
> Example of Fetch
>
> ### More examples
>
> Links to more examples on other pages
> ```
>
> **Scenario 2:** If you _only_ have examples on another page and none on this page:
>
> Don't add any H3 headings; just add the links directly under the H2 heading "Examples". For example:
>
> ```md
> ## Examples
>
> For examples of this API, see [the page on fetch()](https://example.org).
> ```
## Specifications
`\{{Specifications}}`
_To use this macro, remove the backticks and backslash in the markdown file._
## Browser compatibility
`\{{Compat}}`
_To use this macro, remove the backticks and backslash in the markdown file._
## See also
Include links to reference pages and guides related to the current API. For more guidelines, see the [See also section](/en-US/docs/MDN/Writing_guidelines/Writing_style_guide#see_also_section) in the _Writing style guide_.
- link1
- link2
- external_link (year)
| 0 |
data/mdn-content/files/en-us/mdn/writing_guidelines/page_structures/page_types | data/mdn-content/files/en-us/mdn/writing_guidelines/page_structures/page_types/page_type_key/index.md | ---
title: The page-type front matter key
slug: MDN/Writing_guidelines/Page_structures/Page_types/Page_type_key
page-type: mdn-writing-guide
---
{{MDNSidebar}}
The `page-type` front matter key describes the type of an MDN page.
This allows MDN content tools to better automate content checking and sidebar organization.
Like any other front matter key, the `page-type` key is specified in the YAML at the start of "index.md":
```md
---
title: Geolocation.getCurrentPosition()
slug: Web/API/Geolocation/getCurrentPosition
page-type: web-api-instance-method
browser-compat: api.Geolocation.getCurrentPosition
---
```
Each main area of the site — JavaScript, CSS, and so on — has a set of domain-specific `page-type` values, and there is also a set of generic values that can appear in any area of the site.
## Generic page types
These page types are not specific to a particular MDN technology area:
- `guide`: a generic guide page with no specific structure. See [Conceptual page](#conceptual_page).
- `landing-page`: a page that acts primarily as a navigation aid, listing links to other pages. See [Landing page](#landing_page).
- `how-to`: a page that acts primarily as a goal-oriented how-to article.
- `tutorial`: a page that is the overview page of a learning-oriented article.
- `tutorial-chapter`: a page that is a part of a multipart tutorial.
## Domain-specific page types
This section lists page types that are specific to a single area of MDN.
### Learning Area page types
This section lists `page-type` values for pages under [Learn](/en-US/docs/Learn). Every page in that part of the tree must have a `page-type`, and its value must be one of those listed below or one of the generic page type values.
- `learn-topic`: an overview of a topic, that is, a collection of modules like [_CSS_](/en-US/docs/Learn/CSS).
- `learn-module` an overview of a module, that is, an ordered collection of guides, like [_Introduction to HTML_](/en-US/docs/Learn/HTML/Introduction_to_HTML).
- `learn-module-chapter` a guide that is part of a module, like [_Mobile accessibility_](/en-US/docs/Learn/Accessibility/Mobile).
- `learn-module-assessment` a special guide with an activity allowing to assess the comprehension of a module or a part of it, like [_Test your skills: basic controls_](/en-US/docs/Learn/Forms/Test_your_skills:_Basic_controls).
- `learn-faq`: the answer to a specific question about web development, like [_What is a domain name?_](/en-US/docs/Learn/Common_questions/Web_mechanics/What_is_a_domain_name).
### Accessibility page types
This section lists `page-type` values for pages under [Web/Accessibility](/en-US/docs/Web/Accessibility). Every page in that part of the tree must have a `page-type`, and its value must be one of those listed below or one of the [generic page type](#generic_page_types) values.
- `aria-role`: an ARIA [role](/en-US/docs/Web/Accessibility/ARIA/Roles), like [`section`](/en-US/docs/Web/Accessibility/ARIA/Roles/section_role).
- `aria-attribute`: an ARIA [attribute](eb/Accessibility/ARIA/Attributes), like [`aria-sort`](/en-US/docs/Web/Accessibility/ARIA/Attributes/aria-sort).
### CSS page types
This section lists `page-type` values for pages under [Web/CSS](/en-US/docs/Web/CSS). Every page in that part of the tree must have a `page-type`, and its value must be one of those listed below or one of the [generic page type](#generic_page_types) values.
- `css-at-rule`: an [at-rule](/en-US/docs/Web/CSS/At-rule), like {{cssxref("@charset")}}.
- `css-at-rule-descriptor`: an at-rule descriptor, like [`@counter-style/prefix`](/en-US/docs/Web/CSS/@counter-style/prefix).
- `css-combinator`: a combinator, like the [descendant combinator](/en-US/docs/Web/CSS/Descendant_combinator).
- `css-function`: a [function](/en-US/docs/Web/CSS/CSS_Functions), like {{cssxref("max")}}.
- `css-keyword`: a keyword, like {{cssxref("inherit")}}.
- `css-media-feature`: a [media feature](/en-US/docs/Web/CSS/@media#media_features), like [`hover`](/en-US/docs/Web/CSS/@media/hover).
- `css-module`: a module, like [CSS Animations](/en-US/docs/Web/CSS/CSS_animations).
- `css-property`: a property, like {{cssxref("background-color")}}.
- `css-pseudo-class`: a [pseudo-class](/en-US/docs/Web/CSS/Pseudo-classes), like {{cssxref(":enabled")}}.
- `css-pseudo-element`: a [pseudo-element](/en-US/docs/Web/CSS/Pseudo-elements), like {{cssxref("::before")}}.
- `css-selector`: a [basic selector](/en-US/docs/Web/CSS/CSS_selectors/Selectors_and_combinators#basic_selectors), like the [class selector](/en-US/docs/Web/CSS/Class_selectors).
- `css-shorthand-property`: a [shorthand property](/en-US/docs/Web/CSS/Shorthand_properties), like {{cssxref("background")}}.
- `css-type`: a [data type](/en-US/docs/Web/CSS/CSS_Types), like [`<color>`](/en-US/docs/Web/CSS/color_value).
### Glossary page types
This section lists `page-type` values for pages under [Glossary](/en-US/docs/Glossary). Every page in that part of the tree must have a `page-type`, and its value must be one of those listed below.
- `glossary-definition`: a page defining a term, like [Bézier curve](/en-US/docs/Glossary/Bezier_curve).
- `glossary-disambiguation`: a page providing links to two or more definition pages for an ambiguous term, like [Node](/en-US/docs/Glossary/Node).
### HTML page types
This section lists `page-type` values for pages under [Web/HTML](/en-US/docs/Web/HTML). Every page in that part of the tree must have a `page-type`, and its value must be one of those listed below or one of the [generic page type](#generic_page_types) values.
- `html-attribute`: an HTML attribute, like [`autocomplete`](/en-US/docs/Web/HTML/Attributes/autocomplete).
- `html-attribute-value`: a single value for an HTML attribute, like [`dns-prefetch`](/en-US/docs/Web/HTML/Attributes/rel/dns-prefetch).
- `html-element`: an HTML element, like [`<button>`](/en-US/docs/Web/HTML/Element/button).
### HTTP page types
This section lists `page-type` values for pages under [Web/HTTP](/en-US/docs/Web/HTTP). Every page in that part of the tree must have a `page-type`, and its value must be one of those listed below or one of the [generic page type](#generic_page_types) values.
- `http-csp-directive`: a [CSP](/en-US/docs/Web/HTTP/Headers/Content-Security-Policy) directive, like [`script-src`](/en-US/docs/Web/HTTP/Headers/Content-Security-Policy/script-src).
- `http-cors-error`: a [CORS](/en-US/docs/Web/HTTP/CORS) error, like [`CORSDidNotSucceed`](/en-US/docs/Web/HTTP/CORS/Errors/CORSDidNotSucceed).
- `http-permissions-policy-directive`: a [`Permissions-Policy`](/en-US/docs/Web/HTTP/Headers/Permissions-Policy) directive, like [`accelerometer`](/en-US/docs/Web/HTTP/Headers/Permissions-Policy/accelerometer).
- `http-header`: an [HTTP header](/en-US/docs/Web/HTTP/Headers), like [`Referer`](/en-US/docs/Web/HTTP/Headers/Referer).
- `http-method`: an [HTTP request method](/en-US/docs/Web/HTTP/Methods) like [`GET`](/en-US/docs/Web/HTTP/Methods/GET).
- `http-status-code`: an [HTTP response status code](/en-US/docs/Web/HTTP/Status), like [`404`](/en-US/docs/Web/HTTP/Status/404).
### JavaScript page types
This section lists `page-type` values for pages under [Web/JavaScript](/en-US/docs/Web/JavaScript). Every page in that part of the tree must have a `page-type`, and its value must be one of those listed below or one of the [generic page type](#generic_page_types) values.
- `javascript-class`: a definition of a built-in object, like [`Array`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array).
- `javascript-constructor`: an object constructor, like [`Array()`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/Array).
- `javascript-error`: an error, like [RangeError: invalid array length](/en-US/docs/Web/JavaScript/Reference/Errors/Invalid_array_length).
- `javascript-function`: a built-in function that isn't an object method, like [`encodeURI()`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/encodeURI).
- `javascript-global-property`: a global property like [`NaN`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/NaN).
- `javascript-instance-accessor-property`: an accessor property on an object instance, like [`Map.prototype.size`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/size).
- `javascript-instance-data-property`: a data property on an object instance, like the [`length`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/length) property of `Array`.
- `javascript-instance-method`: a method on an object instance, like [`Array.prototype.at()`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/at).
- `javascript-language-feature`: a part of JavaScript syntax not fitting into another category, like [rest parameters](/en-US/docs/Web/JavaScript/Reference/Functions/rest_parameters).
- `javascript-namespace`: an object that is not instantiable and has only static members, like [`Math`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math).
- `javascript-operator`: an operator, like [Addition (+)](/en-US/docs/Web/JavaScript/Reference/Operators/Addition).
- `javascript-statement`: a statement, like [`switch`](/en-US/docs/Web/JavaScript/Reference/Statements/switch).
- `javascript-static-accessor-property`: a static accessor property, like [`RegExp.lastMatch`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/lastMatch).
- `javascript-static-data-property`: a static data property, like [`Math.E`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/E).
- `javascript-static-method`: a static method, like [`Array.from()`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/from).
### MathML page types
This section lists `page-type` values for pages under [Web/MathML](/en-US/docs/Web/MathML). Every page in that part of the tree must have a `page-type`, and its value must be one of those listed below or one of the [generic page type](#generic_page_types) values.
- `mathml-attribute`: an MathML attribute, like [`mathcolor`](/en-US/docs/Web/MathML/Global_attributes/mathcolor).
- `mathml-element`: an HTML element, like [`<msqrt>`](/en-US/docs/Web/MathML/Element/msqrt).
### SVG page types
This section lists `page-type` values for pages under [Web/SVG](/en-US/docs/Web/SVG). Every page in that part of the tree must have a `page-type`, and its value must be one of those listed below or one of the [generic page type](#generic_page_types) values.
- `svg-attribute`: an SVG attribute, like [`crossorigin`](/en-US/docs/Web/SVG/Attribute/crossorigin).
- `svg-element`: an SVG element, like [`<circle>`](/en-US/docs/Web/SVG/Element/circle).
### Web API page types
This section lists `page-type` values for pages under [Web/API](/en-US/docs/Web/API). Every page in that part of the tree must have a `page-type`, and its value must be one of those listed below or one of the [generic page type](#generic_page_types) values.
- `web-api-overview`: gives an overview of a Web API, like the [Fetch API](/en-US/docs/Web/API/Fetch_API).
- `web-api-global-function`: a global function, like [`fetch()`](/en-US/docs/Web/API/fetch).
- `web-api-global-property`: a global property, like [`origin`](/en-US/docs/Web/API/origin).
- `web-api-interface`: a Web API interface, like [`Request`](/en-US/docs/Web/API/Request).
- `web-api-constructor`: a constructor, like [`Request()`](/en-US/docs/Web/API/Request/Request).
- `web-api-instance-method`: an instance method, like [`cache.add()`](/en-US/docs/Web/API/Cache/add).
- `web-api-instance-property`: an instance property, like [`request.headers`](/en-US/docs/Web/API/Request/headers).
- `web-api-static-method`: a static method, like [`Response.error()`](/en-US/docs/Web/API/Response/error_static).
- `web-api-static-property`: a static property, like [`Notification.permission`](/en-US/docs/Web/API/Notification/permission_static).
- `web-api-event`: an event, like [`Notification.click`](/en-US/docs/Web/API/Notification/click_event). See [API reference subpage](#api_reference_subpage).
- `webgl-extension`: a WebGL extension, like [`WEBGL_draw_buffers`](/en-US/docs/Web/API/WEBGL_draw_buffers).
- `webgl-extension-method`: a WebGL extension method, like [`OES_vertex_array_object.bindVertexArrayOES()`](/en-US/docs/Web/API/OES_vertex_array_object/bindVertexArrayOES).
### WebAssembly page types
This section lists `page-type` values for pages under [WebAssembly/](/en-US/docs/WebAssembly). Every page in that part of the tree must have a `page-type`, and its value must be one of those listed below or one of the generic page type values.
- `webassembly-function`: a global function, that is a method directly under the `WebAssembly` object that acts as a namespace, like [`WebAssembly.instantiate()`](WebAssembly/JavaScript_interface/instantiate).
- `webassembly-constructor`: a constructor, like [`WebAssembly.Exception()`](WebAssembly/JavaScript_interface/Exception/Exception).
- `webassembly-interface`: a WebAssembly interface, like [`WebAssembly.LinkError`](WebAssembly/JavaScript_interface/LinkError).
- `webassembly-instance-property`: an instance property, like [`WebAssembly.Instance.exports`](WebAssembly/JavaScript_interface/Instance/exports).
- `webassembly-instance-method`: an instance method, like [`WebAssembly.Exception.getArg()`](WebAssembly/JavaScript_interface/Exception/getArg).
- `webassembly-static-method`: a static method, like [`WebAssembly.Module.exports()`](WebAssembly/JavaScript_interface/Module/exports_static).
- `webassembly-instruction`: an instruction, or a set of instructions, like [`Wrap`](WebAssembly/Reference/Numeric/Wrap).
### WebDriver page types
This section lists `page-type` values for pages under [Web/WebDriver](/en-US/docs/Web/WebDriver). Every page in that part of the tree must have a `page-type`, and its value must be one of those listed below or one of the [generic page type](#generic_page_types) values.
- `webdriver-command`: a webdriver command, like [`CloseWindow`](/en-US/docs/Web/WebDriver/Commands/CloseWindow).
- `webdriver-capability`: a webdriver capability, like [`acceptInsecureCerts`](/en-US/docs/Web/WebDriver/Capabilities/acceptInsecureCerts).
- `webdriver-error`: a webdriver error, like [Insecure certificate](/en-US/docs/Web/WebDriver/Errors/InsecureCertificate).
### WebExtensions page types
This section lists `page-type` values for pages under [Mozilla/Add-ons/WebExtensions](/en-US/docs/Mozilla/Add-ons/WebExtensions). Every page in that part of the tree must have a `page-type`, and its value must be one of those listed below or one of the [generic page type](#generic_page_types) values.
- `webextension-api`: a WebExtension API, like [`alarms`](/en-US/docs/Mozilla/Add-ons/WebExtensions/API/alarms).
- `webextension-api-event`: a WebExtension API event, like [`action.onClicked`](/en-US/docs/Mozilla/Add-ons/WebExtensions/API/action/onClicked).
- `webextension-api-function`: a WebExtension function, like [`action.setBadgeText()`](/en-US/docs/Mozilla/Add-ons/WebExtensions/API/action/setBadgeText).
- `webextension-api-property`: a WebExtension property, like [`browserSettings.openBookmarksInNewTabs`](/en-US/docs/Mozilla/Add-ons/WebExtensions/API/browserSettings/openBookmarksInNewTabs).
- `webextension-api-type`: a WebExtension type, like [`contextualIdentities.ContextualIdentity`](/en-US/docs/Mozilla/Add-ons/WebExtensions/API/contextualIdentities/ContextualIdentity).
- `webextension-manifest-key`: a WebExtension manifest key, like [`user_scripts`](/en-US/docs/Mozilla/Add-ons/WebExtensions/manifest.json/user_scripts).
### Web Manifest page types
This section lists `page-type` values for pages under [Web/Manifest](/en-US/docs/Web/Manifest). Every page in that part of the tree must have a `page-type`, and its value must be one of those listed below or one of the [generic page type](#generic_page_types) values.
- `web-manifest-member`: a member of a manifest, like [`description`](/en-US/docs/Web/Manifest/description).
### XPath page types
This section lists `page-type` values for pages under [Web/XPath](/en-US/docs/Web/XPath). Every page in that part of the tree must have a `page-type`, and its value must be one of those listed below or one of the [generic page type](#generic_page_types) values.
- `xpath-function`: a function, like [`ceiling()`](/en-US/docs/Web/XPath/Functions/ceiling)
### XSLT page types
This section lists `page-type` values for pages under [Web/XSLT](/en-US/docs/Web/XSLT). Every page in that part of the tree must have a `page-type`, and its value must be one of those listed below or one of the [generic page type](#generic_page_types) values.
- `xslt-element`: an element of XSLT, like [`<xsl:message>`](/en-US/docs/Web/XSLT/Element/message).
- `xslt-axis`: an axis of XSLT, like [`ancestor`](/en-US/docs/Web/XSLT/Transforming_XML_with_XSLT/The_Netscape_XSLT_XPath_Reference/Axes/ancestor).
### EXSLT page types
This section lists `page-type` values for pages under [Web/EXSLT](/en-US/docs/Web/EXSLT). Every page in that part of the tree must have a `page-type`, and its value must be one of those listed below or one of the [generic page type](#generic_page_types) values.
- `xslt-function`: a function of EXSLT, like [`exsl:node-set()`](/en-US/docs/Web/EXSLT/exsl/node-set).
### Firefox page types
This section lists `page-type` values for pages under [Mozilla/Firefox](/en-US/docs/Mozilla/Firefox). Every page in that part of the tree must have a `page-type`, and its value must be one of those listed below or one of the [generic page type](#generic_page_types) values.
- `firefox-release-notes`: the release notes for a particular Firefox version, such as [_Firefox 115 for developers_](/en-US/docs/Mozilla/Firefox/Releases/115).
| 0 |
data/mdn-content/files/en-us/mdn/writing_guidelines/page_structures/page_types | data/mdn-content/files/en-us/mdn/writing_guidelines/page_structures/page_types/api_constructor_subpage_template/index.md | ---
title: API constructor subpage template
slug: MDN/Writing_guidelines/Page_structures/Page_types/API_constructor_subpage_template
page-type: mdn-writing-guide
browser-compat: path.to.feature.NameOfTheConstructor
---
{{MDNSidebar}}
> **Note:** _Remove this whole explanatory note before publishing_
>
> ---
>
> **Page front matter:**
>
> The front matter at the top of the page is used to define "page metadata".
> The values should be updated appropriately for the constructor.
>
> ```md
> ---
> title: NameOfTheConstructor()
> slug: Web/API/NameOfTheParentInterface/NameOfTheParentInterface
> page-type: web-api-constructor
> status:
> - experimental
> - deprecated
> - non-standard
> browser-compat: path.to.feature.NameOfTheConstructor
> ---
> ```
>
> - **title**
> - : Title heading displayed at top of page.
> Format as _NameOfTheParentInterface_**()**.
> For example, the [Request()](/en-US/docs/Web/API/Request/Request) constructor has a _title_ of `Request()`.
> - **slug**
> - : The end of the URL path after `https://developer.mozilla.org/en-US/docs/`.
> This will be formatted like `Web/API/NameOfTheParentInterface/NameOfTheParentInterface`.
> Note that the name of the constructor function in the slug omits the parenthesis (it ends in `NameOfTheParentInterface` not `NameOfTheParentInterface()`).
> - **page-type**
> - : The `page-type` key for Web/API constructors is always `web-api-constructor`.
> - **status**
> - : Include (appropriate) technology status keys: [**experimental**](/en-US/docs/MDN/Writing_guidelines/Experimental_deprecated_obsolete#experimental), [**deprecated**](/en-US/docs/MDN/Writing_guidelines/Experimental_deprecated_obsolete#deprecated), **non-standard** (if not on a standards track).
> - **browser-compat**
>
> - : Replace the placeholder value `path.to.feature.NameOfTheConstructor` with the query string for the constructor in the [Browser compat data repo](https://github.com/mdn/browser-compat-data).
> The toolchain automatically uses the key to populate the compatibility and specification sections (replacing the `\{{Compat}}` and `\{{Specifications}}` macros).
>
> Note that you may first need to create/update an entry for the API constructor in our [Browser compat data repo](https://github.com/mdn/browser-compat-data), and the entry for the API will need to include specification information.
> See our [guide on how to do this](/en-US/docs/MDN/Writing_guidelines/Page_structures/Compatibility_tables).
>
> ---
>
> **Top-of-page macros**
>
> A number of macro calls appear at the top of the content section (immediately below the page front matter).
> You should update or delete them according to the advice below:
>
> - `\{{SeeCompatTable}}` — this generates a **This is an experimental technology** banner that indicates the technology is [experimental](/en-US/docs/MDN/Writing_guidelines/Experimental_deprecated_obsolete#experimental).
> If the technology you are documenting is not experimental, you should remove this.
> If it is experimental, and the technology is hidden behind a pref in Firefox, you should also fill in an entry for it in the [Experimental features in Firefox](/en-US/docs/Mozilla/Firefox/Experimental_features) page.
> - `\{{Deprecated_Header}}` — this generates a **Deprecated** banner that indicates that use of the technology is [discouraged](/en-US/docs/MDN/Writing_guidelines/Experimental_deprecated_obsolete#deprecated).
> If it isn't, then you can remove the macro call.
> - `\{{SecureContext_Header}}` — this generates a **Secure context** banner that indicates the technology is only available in a [secure context](/en-US/docs/Web/Security/Secure_Contexts).
> If it isn't, then you can remove the macro call.
> If it is, then you should also fill in an entry for it in the [Features restricted to secure contexts](/en-US/docs/Web/Security/Secure_Contexts/features_restricted_to_secure_contexts) page.
> - `\{{APIRef("GroupDataName")}}` — this generates the left-hand reference sidebar showing quick reference links related to the current page.
> For example, every page in the [WebVR API](/en-US/docs/Web/API/WebVR_API) has the same sidebar, which points to the other pages in the API.
> To generate the correct sidebar for your API, you need to add a `GroupData` entry to our GitHub repo, and include the entry's name inside the macro call in place of _GroupDataName_.
> See our [API reference sidebars](/en-US/docs/MDN/Writing_guidelines/Howto/Write_an_API_reference/Sidebars) guide for information on how to do this. Remember to remove the `\{{MDNSidebar}}` macro when you copy this page.
>
> Samples of the **Experimental**, **Secure context**, and **Deprecated** banners are shown right after this note block.
>
> _Remember to remove this whole explanatory note before publishing._
{{SeeCompatTable}}{{SecureContext_Header}}{{Deprecated_Header}}
Begin the content on the page with an introductory paragraph — start by naming the constructor and saying what it does.
This should ideally be one or two short sentences.
You could copy most of this from the constructor's summary on the corresponding API reference page.
## Syntax
Fill in a syntax box, according to the guidance in our [syntax sections](/en-US/docs/MDN/Writing_guidelines/Page_structures/Syntax_sections) article.
### Parameters
- `parameter1` {{optional_inline}}
- : Include a brief description of the parameter and what it does here. Include one term and definition for each parameter.
If the parameter is not optional, remove the \\{{optional_inline}} macro call.
- `parameter2`
- : etc.
### Return value
Include a description of the constructor's return value, including data type and what it represents.
This is normally just "An instance of the `\{{domxref("NameOfTheParentInterface")}}` object."
_To use this macro, remove the backticks and backslash in the markdown file._
### Exceptions
Include a list of all the exceptions that the constructor can raise. Include one term and definition for each exception.
- `Exception1`
- : Include descriptions of how the exception is raised.
- `Exception2`
- : Include descriptions of how the exception is raised.
## Examples
### A descriptive heading
Each example must have an H3 heading naming the example. The heading should be descriptive of what the example is doing. For example, "A simple example" does not say anything about the example and therefore, not a good heading. The heading should be concise. For a longer description, use the paragraph after the heading.
See our guide on how to add [code examples](/en-US/docs/MDN/Writing_guidelines/Page_structures/Code_examples) for more information.
> **Note:** Sometimes you will want to link to examples given on another page.
>
> **Scenario 1:** If you have some examples on this page and some more examples on another page:
>
> Include an H3 heading (`###`) for each example on this page and then a final H3 heading (`###`) with the text "More examples", under which you can link to the examples on other pages. For example:
>
> ```md
> ## Examples
>
> ### Using the fetch API
>
> Example of Fetch
>
> ### More examples
>
> Links to more examples on other pages
> ```
>
> **Scenario 2:** If you _only_ have examples on another page and none on this page:
>
> Don't add any H3 headings; just add the links directly under the H2 heading "Examples". For example:
>
> ```md
> ## Examples
>
> For examples of this API, see [the page on fetch()](https://example.org).
> ```
## Specifications
`\{{Specifications}}`
_To use this macro, remove the backticks and backslash in the markdown file._
## Browser compatibility
`\{{Compat}}`
_To use this macro, remove the backticks and backslash in the markdown file._
## See also
Include links to reference pages and guides related to the current API. For more guidelines, see the [See also section](/en-US/docs/MDN/Writing_guidelines/Writing_style_guide#see_also_section) in the _Writing style guide_.
- link1
- link2
- external_link (year)
| 0 |
data/mdn-content/files/en-us/mdn/writing_guidelines/page_structures/page_types | data/mdn-content/files/en-us/mdn/writing_guidelines/page_structures/page_types/css_selector_page_template/index.md | ---
title: CSS selector page template
slug: MDN/Writing_guidelines/Page_structures/Page_types/CSS_selector_page_template
page-type: mdn-writing-guide
browser-compat: css.selectors.NameOfTheSelector
---
{{MDNSidebar}}
> **Note:** _Remove this whole explanatory note before publishing_
>
> ---
>
> **Page front matter:**
>
> The frontmatter at the top of the page is used to define "page metadata".
> The values should be updated appropriately for the particular selector.
>
> ```md
> ---
> title: :NameOfTheSelector
> slug: Web/CSS/:NameOfTheSelector
> page-type: css-selector OR css-pseudo-class OR css-pseudo-element OR css-combinator
> status:
> - experimental
> - deprecated
> - non-standard
> browser-compat: css.selectors.NameOfTheSelector
> ---
> ```
>
> - **title**
> - : Title heading displayed at top of page. Format as _:NameOfTheSelector_.
> For example, the [`:hover`](/en-US/docs/Web/CSS/:hover) selector has a title of _:hover_.
> - **slug**
> - : The end of the URL path after `https://developer.mozilla.org/en-US/docs/`). This will be formatted like `Web/CSS/:NameOfTheSelector`.
> For example, the [`:hover`](/en-US/docs/Web/CSS/:hover) selector slug is `Web/CSS/:hover`.
> - **page-type**
> - : The `page-type` key for CSS properties is one of `css-selector`, `css-pseudo-class`, or `css-pseudo-element`, depending on whether the selector is a [pseudo-class](/en-US/docs/Web/CSS/Pseudo-classes), a [pseudo-element](/en-US/docs/Web/CSS/Pseudo-elements), a [combinator](/en-US/docs/Web/CSS/CSS_selectors/Selectors_and_combinators#combinators), or a [basic selector](/en-US/docs/Web/CSS/CSS_selectors/Selector_structure#basic_selectors).
> - **status**
> - : Include (appropriate) technology status keys: [**experimental**](/en-US/docs/MDN/Writing_guidelines/Experimental_deprecated_obsolete#experimental), [**deprecated**](/en-US/docs/MDN/Writing_guidelines/Experimental_deprecated_obsolete#deprecated), **non-standard** (if not on a standards track).
> - **browser-compat**
>
> - : Replace the placeholder value <code>css.selectors.NameOfTheSelector</code> with the query string for the selector in the [Browser compat data repo](https://github.com/mdn/browser-compat-data).
> The toolchain automatically uses the key to populate the compatibility and specifications sections (replacing the `\{{Compat}}` and `\{{Specifications}}` macros in those sections, respectively).
>
> Note that you may first need to create/update an entry for the selector and its specification in our <a href="https://github.com/mdn/browser-compat-data">Browser compat data repo</a>.
> See our [guide on how to do this](/en-US/docs/MDN/Writing_guidelines/Page_structures/Compatibility_tables).
>
> ---
>
> **Top-of-page macros**
>
> A number of macro calls appear at the top of the content section (immediately below the page frontmatter).
> You should update or delete them according to the advice below:
>
> - `\{{SeeCompatTable}}` — this generates a **This is an experimental technology** banner that indicates the technology is [experimental](/en-US/docs/MDN/Writing_guidelines/Experimental_deprecated_obsolete#experimental).
> If the technology you are documenting is not experimental, you can remove this.
> If it is experimental, and the technology is hidden behind a pref in Firefox, you should also fill in an entry for it in the [Experimental features in Firefox](/en-US/docs/Mozilla/Firefox/Experimental_features) page.
> - `\{{Deprecated_Header}}` — this generates a **Deprecated** banner that indicates that use of the technology is [discouraged](/en-US/docs/MDN/Writing_guidelines/Experimental_deprecated_obsolete#deprecated).
> If it isn't, then you can remove the macro call.
> - `\{{CSSRef}}` — this must be present on every CSS selector page. It generates a suitable CSS sidebar, depending on what tags are included on the page.
> Remember to remove the `\{{MDNSidebar}}` macro when you copy this page.
>
> ---
>
> **Syntax section (`\{{CSSSyntax}}`)**
>
> The content of the Syntax section is generated using the `\{{CSSSyntax}}` macro.
> For these to populate you must ensure an appropriate entry has been filled in for the selector in our [selectors.json](https://github.com/mdn/data/blob/main/css/selectors.json) data file.
> See [selectors.md](https://github.com/mdn/data/blob/main/css/selectors.md) for more information.
>
> _Remember to remove this whole explanatory note before publishing_
{{CSSRef}}{{SeeCompatTable}}{{Deprecated_Header}}
The summary paragraph — start by naming the selector and saying what it does. This should ideally be 1 or 2 short sentences.
```css
/* Insert code block showing common use cases */
```
## Syntax
`\{CSSSyntax}}`
_To use this macro, remove the backticks and backslash in the markdown file._
## Examples
Note that we use the plural "Examples" even if the page only contains one example.
### A descriptive heading
Each example must have an H3 heading (`###`) naming the example. The heading should be descriptive of what the example is doing. For example, "A simple example" does not say anything about the example and therefore, not a good heading. The heading should be concise. For a longer description, use the paragraph after the heading.
See our guide on how to add [code examples](/en-US/docs/MDN/Writing_guidelines/Page_structures/Code_examples) for more information.
> **Note:** Sometimes, you will want to link to examples given on another page.
>
> **Scenario 1:** If you have some examples on this page and some more examples on another page:
>
> Include an H3 heading (`###`) for each example on this page and then a final H3 heading (`###`) with the text "More examples", under which you can link to the examples on other pages. For example:
>
> ```md
> ## Examples
>
> ### Using the fetch API
>
> Example of Fetch
>
> ### More examples
>
> Links to more examples on other pages
> ```
>
> **Scenario 2:** If you _only_ have examples on another page and none on this page:
>
> Don't add any H3 headings; just add the links directly under the H2 heading "Examples". For example:
>
> ```md
> ## Examples
>
> For examples of this API, see [the page on fetch()](https://example.org).
> ```
## Accessibility concerns
Optionally, warn of any potential accessibility concerns with using this selector and how to work around them.
Remove this section if there is no list.
## Specifications
`\{{Specifications}}`
_To use this macro, remove the backticks and backslash in the markdown file._
## Browser compatibility
`\{{Compat}}`
_To use this macro, remove the backticks and backslash in the markdown file._
## See also
Include links to reference pages and guides related to the current selector. For more guidelines, see the [See also section](/en-US/docs/MDN/Writing_guidelines/Writing_style_guide#see_also_section) in the _Writing style guide_.
- link1
- link2
| 0 |
data/mdn-content/files/en-us/mdn/writing_guidelines/page_structures/page_types | data/mdn-content/files/en-us/mdn/writing_guidelines/page_structures/page_types/api_landing_page_template/index.md | ---
title: API landing page template
slug: MDN/Writing_guidelines/Page_structures/Page_types/API_landing_page_template
page-type: mdn-writing-guide
---
{{MDNSidebar}}
> **Note:** _Remove this whole explanatory note before publishing_
>
> ---
>
> **Page front matter:**
>
> The front matter at the top of the page is used to define "page metadata".
> The values should be updated appropriately for the particular interface.
>
> ```md
> ---
> title: NameOfTheAPI API
> slug: Web/API/NameOfTheAPI_API
> page-type: web-api-overview
> status:
> - experimental
> - deprecated
> - non-standard
> ---
> ```
>
> - **title**
> - : Title heading displayed at top of page.
> This is the name of the API followed by the text "API": _NameOfTheAPI_ **API**.
> For example, [WebXR Device](/en-US/docs/Web/API/WebXR_Device_API) has a title of _WebXR Device API_, [Fetch](/en-US/docs/Web/API/Fetch_API) has a title of _Fetch API_.
> - **slug**
> - : The end of the URL path after `https://developer.mozilla.org/en-US/docs/`).
> This will be formatted like `Web/API/NameOfTheAPI_API`.
> For example, the [WebXR Device API](/en-US/docs/Web/API/WebVR_API)'s slug is `Web/API/WebXR_Device_API`.
> - **page-type**
> - : The `page-type` key for Web/API landing pages is always `web-api-overview`.
> - **status**
> - : Include (appropriate) technology status keys: [**experimental**](/en-US/docs/MDN/Writing_guidelines/Experimental_deprecated_obsolete#experimental), [**deprecated**](/en-US/docs/MDN/Writing_guidelines/Experimental_deprecated_obsolete#deprecated), **non-standard** (if not on a standards track).
>
> ---
>
> **Top-of-page macros**
>
> A number of macro calls appear at the top of the content section (immediately below the page front matter).
> You should update or delete them according to the advice below:
>
> - `\{{SeeCompatTable}}` — this generates a **This is an experimental technology** banner that indicates the technology is [experimental](/en-US/docs/MDN/Writing_guidelines/Experimental_deprecated_obsolete#experimental).
> If the technology you are documenting is not experimental, you should remove this.
> If it is experimental, and the technology is hidden behind a pref in Firefox, you should also fill in an entry for it in the [Experimental features in Firefox](/en-US/docs/Mozilla/Firefox/Experimental_features) page.
> - `\{{Deprecated_Header}}` — this generates a **Deprecated** banner that indicates that use of the technology is [discouraged](/en-US/docs/MDN/Writing_guidelines/Experimental_deprecated_obsolete#deprecated).
> If it isn't, then you can remove the macro call.
> - `\{{SecureContext_Header}}` — this generates a **Secure context** banner that indicates the technology is only available in a [secure context](/en-US/docs/Web/Security/Secure_Contexts).
> If it isn't, then you can remove the macro call.
> If it is, then you should also fill in an entry for it in the [Features restricted to secure contexts](/en-US/docs/Web/Security/Secure_Contexts/features_restricted_to_secure_contexts) page.
> - `\{{APIRef("GroupDataName")}}` — this generates the left-hand reference sidebar showing quick reference links related to the current page.
> For example, every page in the [WebVR API](/en-US/docs/Web/API/WebVR_API) has the same sidebar, which points to the other pages in the API.
> To generate the correct sidebar for your API, you need to add a `GroupData` entry to our GitHub repo, and include the entry's name inside the macro call in place of _GroupDataName_.
> See our [API reference sidebars](/en-US/docs/MDN/Writing_guidelines/Howto/Write_an_API_reference/Sidebars) guide for information on how to do this.
> - Remember to remove the `\{{MDNSidebar}}` macro when you copy this page.
>
> ---
>
> **Browser compatibility**
>
> API landing pages optionally have a browser compatibility section that shows compatibility tables for one or more of the most important interfaces in the API. If the compatibility is similar for most interfaces in the API then often just one compatibility table is needed. If compatibility across the API is complicated/impossible to capture in a few tables, this sections should be omitted.
>
> To fill in the browser compatibility section, you may first need to create/update entries for the API interfaces in our [Browser compat data repo](https://github.com/mdn/browser-compat-data) — see our [guide on how to do this](/en-US/docs/MDN/Writing_guidelines/Page_structures/Compatibility_tables).
>
> Add the `\{{Compat("path.to.feature.Interface")}}` macro for each interface for which compatibility information is required, replacing the "path.to.feature.Interface" argument with the path to the desired interface in the browser compatibility data.
>
> ---
>
> **Specifications**
>
> API landing pages optionally have a specifications section that lists the relevant specification(s) for each interface. Often there is just one specification covering all interfaces in the API.
>
> To fill in the specifications section, you may first need to create/update entries for interfaces in the [Browser compat data repo](https://github.com/mdn/browser-compat-data) to include specification data — see our [guide on how to do this](/en-US/docs/MDN/Writing_guidelines/Page_structures/Compatibility_tables).
>
> Use the `\{{specifications("path.to.feature.Interface")}}` macro to add tables for the main specifications.
>
> ---
>
> _Remember to remove this whole explanatory note before publishing_
{{securecontext_header}}
Begin the content on the page with an introductory paragraph — start by naming the API and saying what it does. This should ideally be one or two short sentences.
## Concepts and usage
In this section, describe the API's purpose and usage cases in a bit more detail — why was a need recognized for it?
What problems does it solve? What concepts does it involve? How do you use it, from a high level perspective?
Don't go into a lot of detail in this section, and don't include code examples.
If there are a lot of concepts to explain around this API, you should explain them in a separate "Fundamentals" or "Concepts" article (e.g. [Fundamentals of WebXR](/en-US/docs/Web/API/WebXR_Device_API/Fundamentals)).
For a practical usage guide with code examples, you should include a "Usage…" article in your API docs (e.g. [Using the WebVR API](/en-US/docs/Web/API/WebVR_API/Using_the_WebVR_API)).
To help improve content discoverability and {{Glossary("SEO")}}, keep the following tips in mind:
## Interfaces
_To use the [domxref macro](/en-US/docs/MDN/Writing_guidelines/Page_structures/Macros/Commonly_used_macros#linking_to_pages_in_references), remove the backticks and backslash in the markdown file._
- `\{{domxref("NameOfTheInterface")}}`
- : Include a brief description of the interface and what it does here.
Include one term and definition for each interface or dictionary.
### Extensions to other interfaces
The _name of interface_ extends the following APIs, adding the listed features.
#### Interface 1
- `\{{domxref("addition1")}}`
- : Description of the feature of Interface#1 that is added to that API by the API you are currently documenting.
One \*term and definition for each feature. If this API doesn't extend any other interfaces, you can delete these sections.
#### Interface 2
- `\{{domxref("addition1")}}`
- : Description of the feature of Interface#2 that is added to that API by the API you are currently documenting, etc.
## Examples
Note that we use the plural "Examples" even if the page only contains one example.
### A descriptive heading
Each example must have an H3 heading naming the example. The heading should be descriptive of what the example is doing. For example, "A simple example" does not say anything about the example and therefore, not a good heading. The heading should be concise. For a longer description, use the paragraph after the heading.
See our guide on how to add [code examples](/en-US/docs/MDN/Writing_guidelines/Page_structures/Code_examples) for more information.
> **Note:** Sometimes you will want to link to examples given on another page.
>
> **Scenario 1:** If you have some examples on this page and some more examples on another page:
>
> Include an H3 heading (`###`) for each example on this page and then a final H3 heading (`###`) with the text "More examples", under which you can link to the examples on other pages. For example:
>
> ```md
> ## Examples
>
> ### Using the fetch API
>
> Example of Fetch
>
> ### More examples
>
> Links to more examples on other pages
> ```
>
> **Scenario 2:** If you _only_ have examples on another page and none on this page:
>
> Don't add any H3 headings; just add the links directly under the H2 heading "Examples". For example:
>
> ```md
> ## Examples
>
> For examples of this API, see [the page on fetch()](https://example.org).
> ```
## Specifications
`\{{Specifications("path.to.feature.Interface_1")}}`
`\{{Specifications("path.to.feature.Interface_2")}}`
_To use this macro, remove the backticks and backslash in the markdown file._
## Browser compatibility
`\{{Compat("path.to.feature.Interface_1")}}`
`\{{Compat("path.to.feature.Interface_2")}}`
_To use this macro, remove the backticks and backslash in the markdown file._
## See also
Include links to reference pages and guides related to the current API. For more guidelines, see the [See also section](/en-US/docs/MDN/Writing_guidelines/Writing_style_guide#see_also_section) in the _Writing style guide_.
- link1
- link2
- external_link (year)
| 0 |
data/mdn-content/files/en-us/mdn/writing_guidelines/page_structures/page_types | data/mdn-content/files/en-us/mdn/writing_guidelines/page_structures/page_types/glossary_page_template/index.md | ---
title: Glossary page template
slug: MDN/Writing_guidelines/Page_structures/Page_types/Glossary_page_template
page-type: mdn-writing-guide
---
{{MDNSidebar}}
> **Note:** _Remove this whole explanatory note before publishing_
>
> ---
>
> **Page front matter:**
>
> The frontmatter at the top of the page is used to define "page metadata".
> The values should be updated appropriately for the particular method.
>
> ```md
> ---
> title: Term being defined
> slug: Glossary/Term_being_defined
> page-type: glossary-definition OR glossary-disambiguation
> ---
> ```
>
> - **title**
> - : Title heading displayed at top of page.
> Format as: `Term being defined`.
> - **slug**
> - : The end of the URL path after `https://developer.mozilla.org/en-US/docs/`).
> This will be formatted as snake case of the title: `Glossary/Term_being_defined`.
> - **page-type**
> - : `glossary-definition` for a definition page or `glossary-disambiguation` for a disambiguation page.
>
> ---
>
> _Remember to remove this whole explanatory note before publishing_
The **TermBeingDefined** is _(include a concise definition of the term)_.
Include further supporting information as required, but not much — no more than 2 more small paragraphs. Any further detailed information, code examples, tutorials, etc. should go in separate articles.
## See also
Include a list of links pointing to more detailed general and technical information. For example, you can add links to Wikipedia articles, other encyclopedia entries, technical tutorials, and specifications. For guidelines on adding this list of links, see the [See also section](/en-US/docs/MDN/Writing_guidelines/Writing_style_guide#see_also_section) in the _Writing style guide_.
- link1
- link2
| 0 |
data/mdn-content/files/en-us/mdn/writing_guidelines/page_structures/page_types | data/mdn-content/files/en-us/mdn/writing_guidelines/page_structures/page_types/aria_page_template/index.md | ---
title: ARIA page template
slug: MDN/Writing_guidelines/Page_structures/Page_types/ARIA_Page_Template
page-type: mdn-writing-guide
---
{{MDNSidebar}}
## Page front matter
### Title and slug
An ARIA role page should have a `title` and `slug` of `ARIA: Name Of The Role`. For example, the [button role](/en-US/docs/Web/Accessibility/ARIA/Roles/button_role) has a `title` and `slug` of `ARIA/NameOfTheRole_role` and the [aria-labelledby](/en-US/docs/Web/Accessibility/ARIA/Attributes/aria-labelledby) attribute has a `title` of `aria-labelledby`.
### Top macros
A number of macro calls appear at the top of the content section. You should update or delete them according to the advice below:
- \\{{deprecated_header}}—generates a **Deprecated** banner that indicates the technology is [deprecated](/en-US/docs/MDN/Writing_guidelines/Experimental_deprecated_obsolete#deprecated). If it isn't, then you can remove the macro call.
- \\{{ariaref}}—generates a suitable ARIA sidebar, depending on what tags are included on the page.
### Tags
In ARIA role or attribute subpages, you need to include the following tags (see the _Tags_ section at the bottom of the editor UI): **ARIA**, **Reference**, **ARIA Role** or **ARIA Attribute**, _the name of the Role or Attribute_ (e.g. **ARIA button** or **aria-labelledby**), **ARIA widget,** **Experimental** (if the role or attribute is [experimental](/en-US/docs/MDN/Writing_guidelines/Experimental_deprecated_obsolete#experimental)), and **Deprecated** (if it is [deprecated](/en-US/docs/MDN/Writing_guidelines/Experimental_deprecated_obsolete#deprecated)).
### Specifications
In the value of the `spec_urls` front matter metadata key, update the URLs to point to the fragment IDs for the correct sections from the following specifications:
- [ARIA](https://w3c.github.io/aria/)
- [ARIA Authoring Practices](https://www.w3.org/WAI/ARIA/apg/)
Additional resources:
- [Accessibility Object Model](https://wicg.github.io/aom/spec/)
- [ARIA in HTML](https://w3c.github.io/html-aria/)
## Page template
The summary paragraph—start by naming the role or attribute and saying what it does. This should ideally be 1 or 2 short sentences. This content appears as a tool tip on links to this page, so craft it well.
```html
<!-- Insert code block showing common use cases -->
```
(Optional) Include a short description of the preceding example.
## Description
Include a complete description of the attribute or role.
### Associated ARIA roles, states, and properties
- Name of associated roles
- : Explanation of requirement, link to features pages.
- Name of associated attribute(s)
- : Explanation of requirement, link to attribute's pages, along with link to JS required to change the value, if appropriate.
### Keyboard interactions
### Required JavaScript features
- Required event handlers
- : Explanation of each
- Changing attribute values
- : explanation of each
> **Note:** Include a note about semantic alternatives to using this role or attribute. The first rule of ARIA use is that you can use a native feature with the semantics and behavior you require already built in, instead of re-purposing an element and **adding** an ARIA role, state, or property to make it accessible, then do so. Then post full details in best practices section below.
## Examples
Note that we use the plural "Examples" even if the page only contains one example.
### A descriptive heading
Each example must have an H3 heading (`###`) naming the example. The heading should be descriptive of what the example is doing. For example, "A simple example" does not say anything about the example and therefore, not a good heading. The heading should be concise. For a longer description, use the paragraph after the heading.
See our guide on how to add [code examples](/en-US/docs/MDN/Writing_guidelines/Page_structures/Code_examples) for more information.
> **Note:** Sometimes you will want to link to examples given on another page.
>
> **Scenario 1:** If you have some examples on this page and some more examples on another page:
>
> Include an H3 heading (`###`) for each example on this page and then a final H3 heading (`###`) with the text "More examples", under which you can link to the examples on other pages. For example:
>
> ```md
> ## Examples
>
> ### Using the fetch API
>
> Example of Fetch
>
> ### More examples
>
> Links to more examples on other pages
> ```
>
> **Scenario 2:** If you _only_ have examples on another page and none on this page:
>
> Don't add any H3 headings; just add the links directly under the H2 heading "Examples". For example:
>
> ```md
> ## Examples
>
> For examples of this API, see [the page on fetch()](https://example.org).
> ```
## Accessibility concerns
Optionally, warn of any potential accessibility concerns that exist with using this property, and how to work around them. Remove this section if there are none to list.
## Best practices
Optionally, list any best practices that exist for this role. Remove the section if none exist.
### Added benefits
- Associated role
- : If that role is a required parent, child or sibling, and what it does.
Any additional benefits this feature has for non-typical screen reader users, like Google or mobile speech recognition.
## Specifications
`\{{Specifications}}`
_Remember to remove the backticks and backslash to use this macro._
## Precedence order
What are the related properties, and in what order will this attribute or property be read (which property will take precedence over this one, and which property will be overwritten.)
## Screen reader support
## See also
Include links to reference pages and guides related to the current role or attribute. For more guidelines, see the [See also section](/en-US/docs/MDN/Writing_guidelines/Writing_style_guide#see_also_section) in the _Writing style guide_.
- link1
- link2
| 0 |
data/mdn-content/files/en-us/mdn/writing_guidelines/page_structures/page_types | data/mdn-content/files/en-us/mdn/writing_guidelines/page_structures/page_types/api_property_subpage_template/index.md | ---
title: API property subpage template
slug: MDN/Writing_guidelines/Page_structures/Page_types/API_property_subpage_template
page-type: mdn-writing-guide
browser-compat: path.to.feature.NameOfTheProperty
---
{{MDNSidebar}}
> **Note:** _Remove this whole explanatory note before publishing._
>
> ---
>
> **Page front matter:**
>
> The front matter at the top of the page is used to define "page metadata".
> The values should be updated appropriately for the particular property.
>
> ```md
> ---
> title: NameOfTheParentInterface.NameOfTheProperty
> slug: Web/API/NameOfTheParentInterface/NameOfTheProperty
> page-type: web-api-instance-property OR web-api-static-property
> status:
> - experimental
> - deprecated
> - non-standard
> browser-compat: path.to.feature.NameOfTheProperty
> ---
> ```
>
> - **title**
> - : Title heading displayed at top of page.
> Format as _NameOfTheParentInterface_**.**_NameOfTheProperty_.
> For example, the [`capabilities`](/en-US/docs/Web/API/VRDisplay/capabilities) property of the [`VRDisplay`](/en-US/docs/Web/API/VRDisplay) interface has a `title` of `VRDisplay.capabilities`.
> - **slug**
>
> - : The end of the URL path after `https://developer.mozilla.org/en-US/docs/`.
> This will be formatted like `Web/API/NameOfTheParentInterface/NameOfTheProperty`.
>
> If the property is static, then the slug must have a `_static` suffix, like: `Web/API/NameOfTheParentInterface/NameOfTheProperty_static`. This enables us to support instance and static properties which have the same name.
>
> - **page-type**
> - : The `page-type` key for Web/API properties is either `web-api-instance-property` (for instance properties) or `web-api-static-property` (for static properties).
> - **status**
> - : Include (appropriate) technology status keys: [**experimental**](/en-US/docs/MDN/Writing_guidelines/Experimental_deprecated_obsolete#experimental), [**deprecated**](/en-US/docs/MDN/Writing_guidelines/Experimental_deprecated_obsolete#deprecated), **non-standard** (if not on a standards track).
> - **browser-compat**
>
> - : Replace the placeholder value `path.to.feature.NameOfTheProperty` with the query string for the property in the [Browser compat data repo](https://github.com/mdn/browser-compat-data).
> The toolchain automatically uses the key to populate the compatibility and specification sections (replacing the `\{{Compat}}` and `\{{Specifications}}` macros).
>
> Note that you may first need to create/update an entry for the API property in our [Browser compat data repo](https://github.com/mdn/browser-compat-data), and the entry for the API will need to include specification information.
> See our [guide on how to do this](/en-US/docs/MDN/Writing_guidelines/Page_structures/Compatibility_tables).
>
> ---
>
> **Top-of-page macros**
>
> A number of macro calls appear at the top of the content section (immediately below the page front matter).
> You should update or delete them according to the advice below:
>
> - `\{{SeeCompatTable}}` — this generates a **This is an experimental technology** banner that indicates the technology is [experimental](/en-US/docs/MDN/Writing_guidelines/Experimental_deprecated_obsolete#experimental).
> If the technology you are documenting is not experimental, you should remove this.
> If it is experimental, and the technology is hidden behind a pref in Firefox, you should also fill in an entry for it in the [Experimental features in Firefox](/en-US/docs/Mozilla/Firefox/Experimental_features) page.
> - `\{{Deprecated_Header}}` — this generates a **Deprecated** banner that indicates that use of the technology is [discouraged](/en-US/docs/MDN/Writing_guidelines/Experimental_deprecated_obsolete#deprecated).
> If it isn't, then you can remove the macro call.
> - `\{{SecureContext_Header}}` — this generates a **Secure context** banner that indicates the technology is only available in a [secure context](/en-US/docs/Web/Security/Secure_Contexts).
> If it isn't, then you can remove the macro call.
> If it is, then you should also fill in an entry for it in the [Features restricted to secure contexts](/en-US/docs/Web/Security/Secure_Contexts/features_restricted_to_secure_contexts) page.
> - `\{{APIRef("GroupDataName")}}` — this generates the left-hand reference sidebar showing quick reference links related to the current page.
> For example, every page in the [WebVR API](/en-US/docs/Web/API/WebVR_API) has the same sidebar, which points to the other pages in the API.
> To generate the correct sidebar for your API, you need to add a `GroupData` entry to our GitHub repo, and include the entry's name inside the macro call in place of _GroupDataName_.
> See our [API reference sidebars](/en-US/docs/MDN/Writing_guidelines/Howto/Write_an_API_reference/Sidebars) guide for information on how to do this. Remember to remove the `\{{MDNSidebar}}` macro when you copy this page.
>
> Samples of the **Experimental**, **Secure context**, and **Deprecated** banners are shown right after this note block.
>
> _Remember to remove this whole explanatory note before publishing._
{{SeeCompatTable}}{{SecureContext_Header}}{{Deprecated_Header}}
Begin the content on the page with an introductory paragraph — start by naming the property, saying what interface it is part of, and saying what it does.
This should ideally be one or two short sentences.
You could copy most of this from the property's summary on the corresponding API reference page. Include whether it is read-only or not.
## Value
Include a description of the property's value, including data type and what it represents.
## Examples
Note that we use the plural "Examples" even if the page only contains one example.
### A descriptive heading
Each example must have an H3 heading (`###`) naming the example. The heading should be descriptive of what the example is doing. For example, "A simple example" does not say anything about the example and therefore, not a good heading. The heading should be concise. For a longer description, use the paragraph after the heading.
See our guide on how to add [code examples](/en-US/docs/MDN/Writing_guidelines/Page_structures/Code_examples) for more information.
> **Note:** Sometimes you will want to link to examples given on another page.
>
> **Scenario 1:** If you have some examples on this page and some more examples on another page:
>
> Include an H3 heading (`###`) for each example on this page and then a final H3 heading (`###`) with the text "More examples", under which you can link to the examples on other pages. For example:
>
> ```md
> ## Examples
>
> ### Using the fetch API
>
> Example of Fetch
>
> ### More examples
>
> Links to more examples on other pages
> ```
>
> **Scenario 2:** If you _only_ have examples on another page and none on this page:
>
> Don't add any H3 headings; just add the links directly under the H2 heading "Examples". For example:
>
> ```md
> ## Examples
>
> For examples of this API, see [the page on fetch()](https://example.org).
> ```
## Specifications
`\{{Specifications}}`
_To use this macro, remove the backticks and backslash in the markdown file._
## Browser compatibility
`\{{Compat}}`
_To use this macro, remove the backticks and backslash in the markdown file._
## See also
Include links to reference pages and guides related to the current API. For more guidelines, see the [See also section](/en-US/docs/MDN/Writing_guidelines/Writing_style_guide#see_also_section) in the _Writing style guide_.
- link1
- link2
- external_link (year)
| 0 |
data/mdn-content/files/en-us/mdn/writing_guidelines/page_structures | data/mdn-content/files/en-us/mdn/writing_guidelines/page_structures/links/index.md | ---
title: Link macros
slug: MDN/Writing_guidelines/Page_structures/Links
page-type: mdn-writing-guide
---
{{MDNSidebar}}
MDN provides numerous macros to create always up-to-date links to MDN content. In this guide, you will learn about MDN cross-reference macros that you can use to include a single link to another page or a list of links to all of a document's subpages.
## Lists of links
MDN provides macros that create a list of links:
- [`\{{LandingPageListSubPages}}`](https://github.com/mdn/yari/blob/main/kumascript/macros/LandingPageListSubpages.ejs)
- : Inserts a definition list ({{HTMLelement("dl")}}) of the subpages of the current page, with each page's title as the {{HTMLelement("dt")}} term and its first paragraph as the {{HTMLelement("dd")}} term.
- [`\{{ListSubpagesForSidebar()}}`](https://github.com/mdn/yari/blob/main/kumascript/macros/ListSubpagesForSidebar.ejs)
- : When included without parameters, inserts an ordered list of links to the current page's subpages. This macro is most often used within [sidebars](/en-US/docs/MDN/Writing_guidelines/Page_structures/Sidebars#sidebars_adding_additional_content) (hence the macro name), where the bullets are not rendered. The first parameter is a slug of the link tree's parent page. The link text is displayed as code. Setting a second parameter to `true` or `1` converts the links to plain text. Setting a third parameter to `true` or `1` adds a link to the slug (parent) page at the top of the list with "Overview" as the link text.
- [`\{{QuickLinksWithSubpages()}}`](https://github.com/mdn/yari/blob/main/kumascript/macros/QuickLinksWithSubpages.ejs)
- : Creates a set of quicklinks using the current page's (or the specified page's) children as the destinations. This creates hierarchical lists up to two levels deep. The pages' titles are used as the link text and their summaries as tooltips.
### Example link list
To include an ordered list of links which includes this page and its siblings. write the following:
```md
\{{ListSubpagesForSidebar("/en-US/docs/MDN/Writing_guidelines/Page_structures/Macros", 1)}}
```
This produces:
{{ListSubpagesForSidebar("/en-US/docs/MDN/Writing_guidelines/Page_structures/Macros", 1)}}
## Cross-reference links
Some macros create a single link to cross-reference a CSS, JavaScript, SVG, or HTML feature, including attributes, elements, properties, data types, and APIs. The macros that create single links require at least one parameter: the feature being referenced.
These macros are:
- [`\{{CSSxRef("")}}`](https://github.com/mdn/yari/blob/main/kumascript/macros/cssxref.ejs)
- [`\{{DOMxRef("")}}`](https://github.com/mdn/yari/blob/main/kumascript/macros/DOMxRef.ejs)
- [`\{{HTMLElement("")}}`](https://github.com/mdn/yari/blob/main/kumascript/macros/HTMLElement.ejs)
- [`\{{glossary("")}}`](https://github.com/mdn/yari/blob/main/kumascript/macros/Glossary.ejs)
- [`\{{JSxRef("")}}`](https://github.com/mdn/yari/blob/main/kumascript/macros/jsxref.ejs)
- [`\{{SVGAttr("")}}`](https://github.com/mdn/yari/blob/main/kumascript/macros/SVGAttr.ejs)
- [`\{{SVGElement("")}}`](https://github.com/mdn/yari/blob/main/kumascript/macros/SVGElement.ejs)
- [`\{{HTTPMethod("")}}`](https://github.com/mdn/yari/blob/main/kumascript/macros/HTTPMethod.ejs)
- [`\{{HTTPStatus("")}}`](https://github.com/mdn/yari/blob/main/kumascript/macros/HTTPStatus.ejs)
The first parameter of each of these macros is the last section of the slug of the document being referenced. For example, for HTML Elements, include `\{{HTMLElement("")}}` with the part of the slug that comes after `Web/HTML/Element/` in the slug being the first parameter. With `\{{CSSxRef("")}}`, add the part of the slug that comes after `Web/CSS/` in the slug. The link will go to this page.
By default, the text displayed is the linked resource as written in the first parameter, in angle brackets for the case of `\{{HTMLElement()}}`. This may not be what you want. For example, the slug for the range input type is `Web/HTML/Element/input/range`. Including `\{{HTMLElement("input/range")}}` produces "{{HTMLElement("input/range")}}". That is not what you want. All the macros accept additional parameters, so you can provide the text you want to display.
The second parameter, if present, provides the link text. In the input range case, we would write `\{{HTMLElement("input/range", "<code><input type="range"></code>")}}` which produces "{{HTMLElement("input/range", "<code><input type="range"></code>")}}". This particular macro removes the {{htmlelement("code")}} and angle brackets when the second parameter includes a space, so we added the brackets and code tags.
Each macro is different!
To prevent HTML code semantics and CSS code styling, some cross-reference macros include a parameter with the `"nocode"` to disable this styling.
For example, `\{{CSSxRef("background-color")}}` creates the code link "{{CSSxRef("background-color")}}" and `{{domxref("CSS.supports_static", "check support", "nocode")}}` creates the plain text link "{{domxref("CSS.supports_static", "check support", "nocode")}}".
Make sure to look at the source code to understand how the macro you are using works and to understand the various parameters; while the parameters are generally well documented, exceptions like "don't render as code if the second parameter includes a space" that we saw in the `\{{HTMLElement("")}}` macro is in the code but not otherwise documented.
To learn which parameters each macro supports and the order of parameters for each macro, the macro's source file, linked above, includes documentation. There is a [list of commonly used macros](/en-US/docs/MDN/Writing_guidelines/Page_structures/Macros/Commonly_used_macros), each of which outputs links in the main content area of the page.
## See also
- [Using macros](/en-US/docs/MDN/Writing_guidelines/Page_structures/Macros)
- [Macros](https://github.com/mdn/yari/tree/main/kumascript/macros) on Github
- [Commonly used macros](/en-US/docs/MDN/Writing_guidelines/Page_structures/Macros/Commonly_used_macros), including BCD macros ( `\{{Compat}}`, `\{{Compat(<feature>)}}`, and `\{{Compat(<feature>, <depth>)}}`) and specification macros (`\{{Specifications}}` / `\{{Specifications(<feature>)}}`)
- [Banners and notices guide](/en-US/docs/MDN/Writing_guidelines/Page_structures/Banners_and_notices)including the `\{{SeeCompatTable}}`, `\{{Deprecated_Header}}`, and `\{{SecureContext_Header}}` macros.
| 0 |
data/mdn-content/files/en-us/mdn/writing_guidelines/page_structures | data/mdn-content/files/en-us/mdn/writing_guidelines/page_structures/syntax_sections/index.md | ---
title: Syntax sections
slug: MDN/Writing_guidelines/Page_structures/Syntax_sections
page-type: mdn-writing-guide
---
{{MDNSidebar}}
The syntax section of an MDN reference page contains a syntax box defining the exact syntax that a feature has (e.g. what parameters can it accept, which ones are optional?) This article explains how to write syntax boxes for reference articles.
## API reference syntax
Syntax sections for API reference pages are written manually, and may differ slightly based on the feature being documented.
The section starts with a heading (typically level two heading `##`) named "Syntax", and must be included at the top of the reference page (just below the introductory material).
Below the heading is a code block showing the feature's exact syntax, demarcated using code fence ` ```[markup-language] ` class.
The example below shows the Markdown code for a typical Syntax section (for a JavaScript function):
````md
## Syntax
```js-nolint
slice()
slice(start)
slice(start, end)
```
````
> **Note:** The markup-language used in this case is `js-nolint`, where `js` indicates that JavaScript syntax highlighting should be used.
> For JavaScript syntax sections `-nolint` is also required because the syntax section is deliberatively not "quite" JavaScript and we don't want the linter to "fix" it (return values and end-of-line semicolons are omitted).
### General style rules
A few rules to follow in terms of markup within the syntax block:
- Do **not** terminate a line with semicolon `;`. Syntax sections are not meant to show runnable code. So, it makes no sense to show semicolons.
- Do **not** use \<code> within the syntax block (or within any code sample block on MDN, either). Not only is it generally useless, but our markup does not want it, and will not render the way you want it to look if you include it.
- Only specify the function and arguments. Example showing "corrected" examples below
```js-nolint
querySelector(selector)
// responseStr = element.querySelector(selector)
new IntersectionObserver(callback, options)
// const observer = new IntersectionObserver(callback, options)
```
### Constructors and methods
#### Syntax block
Start with a syntax block, like this (from the {{DOMxRef("IntersectionObserver.IntersectionObserver", "IntersectionObserver constructor")}} page):
```js-nolint
new IntersectionObserver(callback, options)
```
or this (from {{DOMxRef("Document.hasStorageAccess()")}}):
```js-nolint
hasStorageAccess()
```
When the method is static, for example {{DOMxRef("URL/createObjectURL_static", "URL.createObjectURL()")}}, then provide its interface as well:
```js-nolint
URL.createObjectURL(object)
```
##### Multiple lines/Optional parameters
Methods that can be used in many different ways should be expanded out into multiple lines, showing all possible variations.
Each option should be on its own line, omitting both per-option comments and assignment. For example, {{jsxref("Array.prototype.slice()")}} has two optional parameters, and would be documented as shown below:
```js-nolint
slice()
slice(begin)
slice(begin, end)
```
Similarly, for {{DOMxRef("CanvasRenderingContext2D.drawImage")}}:
```js-nolint
drawImage(image, dx, dy)
drawImage(image, dx, dy, dWidth, dHeight)
drawImage(image, sx, sy, sWidth, sHeight, dx, dy, dWidth, dHeight)
```
Similarly for the {{jsxref("Date")}} constructor:
```js-nolint
new Date()
new Date(value)
new Date(dateString)
new Date(year, monthIndex)
new Date(year, monthIndex, day)
new Date(year, monthIndex, day, hours)
new Date(year, monthIndex, day, hours, minutes)
new Date(year, monthIndex, day, hours, minutes, seconds, milliseconds)
```
##### Formal syntax
Formal syntax notation (using [BNF](https://en.wikipedia.org/wiki/Backus%E2%80%93Naur_form)) should not be used in the Syntax section — instead use the expanded multiple-line format [described above](#multiple_linesoptional_parameters).
While the formal notation provides a concise mechanism for describing complex syntax, it is not familiar to many developers, and can _conflict_ with valid syntax for particular programming languages. For example, "`[ ]`" indicates both an "optional parameter" and a JavaScript {{jsxref("Array")}}. You can see this in the formal syntax for {{jsxref("Array.prototype.slice()")}} below:
```js-nolint
arr.slice([begin[, end]])
```
For specific cases where it is seen as beneficial, a separate **Formal syntax** section may be declared using the formal notification.
##### Concise syntax blocks
The aim is to make the syntax block as pure and unambiguous a definition of the feature's syntax as possible — don't include any irrelevant syntax. For example, you may see this syntax form used to describe promises in many places on the site:
```js-nolint
caches.match(request, options).then(function (response) {
// Do something with the response
})
```
But this version is much more concise, and doesn't include the superfluous {{JSxRef("Promise.prototype.then()")}} method call:
```js-nolint
match(request, options)
```
##### Callback syntax blocks
For methods accepting a callback function, show the callback as a parameter, not as an arrow function or `function` expression.
```js-nolint
filter(callbackFn)
filter(callbackFn, thisArg)
```
Then, in the "Parameters" section, list the callback function's parameters and what it's expected to return.
```md
- `callbackFn`
- : A function to execute for each element in the array. It should return a [truthy](/en-US/docs/Glossary/Truthy) value to keep the element in the resulting array, and a [falsy](/en-US/docs/Glossary/Falsy) value otherwise. The function is called with the following arguments:
- `element`
- : The current element being processed in the array.
- `index`
- : The index of the current element being processed in the array.
- `array`
- : The array `filter()` was called upon.
```
##### Syntax for arbitrary number of parameters
For methods that accept an arbitrary number of parameters, the syntax block is written like this:
```js-nolint
unshift()
unshift(element1)
unshift(element1, element2)
unshift(element1, element2, /* …, */ elementN)
```
Prefer starting numbering from 1, which allows writing description like "`unshift` adds N elements to the beginning of the array", as well as "the first element" (instead of "the zeroth element").
Note that the case of passing zero rest parameters is always included, even when it doesn't make much sense. Then, in the "Parameters" section, write this:
```md
- `element1`, …, `elementN`
- : The elements to add to the front of the array.
```
Add `\{{optional_inline}}` here when passing zero rest parameters makes sense.
Another example with some positional parameters before the rest parameter:
```js-nolint
splice(start)
splice(start, deleteCount)
splice(start, deleteCount, item1)
splice(start, deleteCount, item1, item2)
splice(start, deleteCount, item1, item2, /* …, */ itemN)
```
#### Parameters section
Next, include a "Parameters" subsection, which explains what each parameter should be, in a description list. Parameters that are objects containing multiple members can include a nested description list, which itself includes an explanation of what each member should be. Optional parameters should be marked with an \\{{optional_inline}} macro call next to their name in the description term.
The name of each parameter in the list should be contained in markdown code fence notation `` ` ` ``.
> **Note:** Even if the feature does not take any parameters, you need to include a "Parameters" section, with content of "None".
#### Return value section
Next, include a "Return value" subsection, which explains what the return value of the constructor or method is. See the above links as examples.
If there is no return value, use the following text:
None (\\{{jsxref("undefined")}}).
#### Exceptions section
Finally, include an "Exceptions" subsection, which explains what exceptions can be thrown if a problem is encountered when invoking the constructor/method. This could be because a parameter name has been misspelled or it has been given a value of the wrong datatype, because there is a problem with the environment it is being invoked in (e.g. trying to run a secure context-only feature in a non-secure context), or some other reason.
Determining what exceptions are thrown by a method can require a good perusal of the specification. Looking through the spec's step-by-step explanation of how a feature operates will generally provide a solid list of the exceptions and the situations that cause them to be thrown.
The exception names and explanations should be included in a description list.
> **Note:** If no exceptions can be raised on the feature, you don't need to include an "Exceptions" section, but you can if you wish include it with content of "None".
### Properties
#### Value section
Properties contain no syntax section. Instead, add a "Value" section containing an explanation of the property's value. Describe its data type and what its purpose is.
#### Exceptions section
If accessing the property can throw an exception, include an "Exceptions" subsection explaining each exception; this should be set up just like the one described for methods and constructors above.
## JavaScript reference syntax
JavaScript built-in object reference pages follow the same basic rules as API reference pages; e.g. for methods and properties. There are a few differences that you might observe:
- For built-in objects with a single constructor, the constructor syntax is often included on the object landing page. See {{JSxRef("Date")}} for example. You'll notice that static methods (those that exist on the `Date` object itself) are listed under "Methods", whereas instance methods are listed under "Date.prototype methods".
- You'll also notice that methods that have no parameters/exceptions are more likely to have those subsections not included at all on JavaScript reference pages. See {{JSxRef("Date.getDate()")}} and {{JSxRef("Date.now()")}} for examples.
## CSS reference syntax
### Properties
CSS property reference pages include a "Syntax" section, which used to be found at the top of the page but is increasingly commonly found below a section containing a block of code showing typical usage of the feature, plus a live example to illustrate what the feature does (see {{CSSxRef("animation")}} for example).
> **Note:** We do this because CSS formal syntax is complex, not used by many of the MDN readership, and off-putting for beginners. Real syntax and examples are more useful to the majority of people.
Inside the syntax section you'll find the following contents.
#### Optional explanation text
Some CSS properties are self-explanatory and don't really need extra explanation (for example {{CSSxRef("color")}}). Some on the other hand are more complex and need explanation on syntax order, including multiple values, etc. (see {{CSSxRef("animation")}}). In such cases you can include extra explanation before any of the subsections.
#### Values section
Next, you should include a "Values" section — this contains a description list explaining the CSS value types that make up the value of the property. Each value type should be wrapped in angle brackets and linked to the MDN reference page covering that value type if a page exists for it. For example, see the {{CSSxRef("border")}} property reference — this reference three value types, only one of which is linked ({{CSSxRef("<color>")}}).
#### Formal syntax
The last section, "Formal syntax", is automatically generated from the data included in the [MDN data repo](https://github.com/mdn/data)'s CSS directory. You just need to include a `CSSSyntax` macro call below the title, and it will take care of the rest.
The only complication arises from making sure the data you need is present. The [properties.json](https://github.com/mdn/data/blob/main/css/properties.json) file needs to contain an entry for the property you are documenting, and the [types.json](https://github.com/mdn/data/blob/main/css/types.json) file needs to contain an entry for all of the value types used in the property's value.
You need to do this by forking the [MDN data repo](https://github.com/mdn/data), cloning your fork locally, making the changes in a new branch, then submitting a pull request against the upstream repo. You can [find more details about using Git here](/en-US/docs/MDN/Writing_guidelines/Page_structures/Compatibility_tables).
### Selectors
The "Syntax" section of selector reference pages is much simpler than that of property pages. It contains one block styled using the "Syntax Box" style, which shows the basic syntax of the selector, whether it is just a simple keyword (e.g. {{CSSxRef(":hover")}}), or a more complex function value that takes a parameter (e.g. {{CSSxRef(":not", ":not()")}}). Sometimes the parameter is explained in a further entry inside the syntax block (see {{CSSxRef(":nth-last-of-type", ":nth-last-of-type()")}} for an example).
This block is automatically generated from the data included in the [MDN data repo](https://github.com/mdn/data)'s CSS directory. You just need to include a `CSSSyntax` macro call below the title, and it will take care of the rest.
The only complication arises from making sure the data you need is present. The [selectors.json](https://github.com/mdn/data/blob/main/css/selectors.json) file needs to contain an entry for the selector you are documenting.
You need to do this by forking the [MDN data repo](https://github.com/mdn/data), cloning your fork locally, making the changes in a new branch, then submitting a pull request against the upstream repo. You can [find more details about using Git here](/en-US/docs/MDN/Writing_guidelines/Page_structures/Compatibility_tables).
## HTML reference syntax
HTML reference pages don't have "Syntax" sections — the syntax is always just the element name surrounded by angle brackets, so it isn't needed. The main thing you need to know about HTML elements is what attributes they take and what their values can be, and this is covered in a separate "Attributes" section. See {{htmlelement("ol")}} and {{htmlelement("video")}} for examples.
## HTTP reference syntax
HTTP reference syntax is all manually created, and differs depending on what type of HTTP feature you are documenting.
### HTTP headers/Content-Security-Policy
HTTP header syntax (and Content-Security-Policy) is documented in two separate sections on the page — "Syntax" and "Directives".
#### Syntax section
The "Syntax" section shows what a header's syntax will look like, using a syntax block styled using the "Syntax Box" style, including formal syntax to show exactly what directives can be included in the value, in what order, etc. For example, the {{HTTPHeader("If-None-Match")}} header's syntax block looks like this:
```http
If-None-Match: <etag_value>
If-None-Match: <etag_value>, <etag_value>, …
If-None-Match: *
```
Some headers will have separate request directive, response directive, and extension syntax. If available, these must be included in separate syntax blocks, each under its own subsection. See {{HTTPHeader("Cache-Control")}} for an example.
#### Directive section
The "Directive" section contains a description list containing the names and descriptions of all the directives that can appear inside the syntax.
### HTTP request methods
Request method syntax is really simple, just containing a syntax block styled using the "Syntax Box" style that shows how the method syntax is structured. The syntax for the [GET method](/en-US/docs/Web/HTTP/Methods/GET) looks like this:
```http
GET /index.html
```
### HTTP response status codes
Again, the syntax for HTTP response status codes is really simple — a syntax block including the code and name. For example:
```http
404 Not Found
```
## SVG reference syntax
### SVG elements
SVG element syntax sections are non-existent — just like HTML element syntax sections. Each SVG element reference page just includes a list of the attributes that can apply to that element. See {{SVGElement("feTile")}} for example.
### SVG attributes
SVG attribute reference pages also do not include syntax sections.
## See also
- [Markdown in MDN](/en-US/docs/MDN/Writing_guidelines/Howto/Markdown_in_MDN#example_code_blocks)
| 0 |
data/mdn-content/files/en-us/mdn/writing_guidelines/page_structures | data/mdn-content/files/en-us/mdn/writing_guidelines/page_structures/code_examples/index.md | ---
title: Code examples
slug: MDN/Writing_guidelines/Page_structures/Code_examples
page-type: mdn-writing-guide
---
{{MDNSidebar}}
On MDN, you'll see numerous code examples inserted throughout the pages to demonstrate usage of web platform features. This article discusses the different mechanisms available for adding code examples to pages, along with which ones you should use and when.
> **Note:** If you want advice on the styling and linting of code as it appears on an MDN article, rather than the different ways of including code, see our [Code style guide](/en-US/docs/MDN/Writing_guidelines/Writing_style_guide/Code_style_guide).
## What types of code example are available?
There are four types of code examples available on MDN:
- Static examples — plain code blocks, possibly with a screenshot to statically show the result of such code if it were to be run.
- Interactive examples — Our system for creating [live interactive examples](https://github.com/mdn/interactive-examples) that show the code running live but also allow you to change code on the fly to see what the effect is and easily copy the results.
- Traditional MDN "live samples" — A macro that takes plain code blocks, dynamically puts them into a document inside an {{htmlelement("iframe")}} element, and embeds it into the page to show the code running live.
- GitHub "live samples" — A macro that takes a document in a GitHub repo inside the [MDN organization](https://github.com/mdn/), puts it inside an {{htmlelement("iframe")}} element, and embeds it into the page to show the code running live.
We'll discuss each one in later sections.
## When should you use each one?
Each type of code example has its own use cases. When should you use each one?
- Static examples are useful if you just need to show some code, and it isn't super important to show what the live result is. Some people just want something to copy and paste. Maybe you are just showing an intermediate step, or the source code is enough. (For example, the article is for an advanced audience, and they just need to see the code.) Also, you might be demonstrating an API feature that doesn't work well as an embedded example, which might need its own separate page to link to.
- The interactive examples are great as readers can modify values on the fly — this is very valuable for learning. However, they are more complex to set up than the other forms, with more limitations, and are intended for specific purposes.
- Traditional live samples are useful if you want to show source code on a page, then show it running, and you're not that bothered about it being accessible as a standalone example. This approach also has the advantage that if you are showing source code and live examples side by side, you only need to update the code once to update both. They can however be awkward to edit and get working.
- GitHub live samples are useful when you've got an existing example you want to embed, don't want to show the source code for, and/or you want to make sure the example is available in standalone form. They have a better contribution workflow, but it does require you to know GitHub. Also because on-page code and source code are in two different places, it is easier for them to get out of sync.
## General guidelines
Aside from the specific system for presenting the live samples, there are style and content considerations to keep in mind when adding or updating samples on MDN.
- When placing samples on a page, try to ensure that all of the features or options of the API or concept you're writing about are covered. At a minimum, at least the most-common options or properties should be included in examples.
- Precede each example with an explanation of what the example does and why it's interesting or useful.
- Follow each piece of code with an explanation of what it does.
- When possible, break large examples into smaller pieces. For instance, the "live sample" system will automatically concatenate all your code together into one piece before running the example, so you can actually break your JavaScript, HTML, and/or CSS into smaller pieces with descriptive text after each piece if you choose to do so. This is a great way to help explain long or complicated stretches of code more clearly.
- Go beyond just demonstrating how each piece of the API or technology works. Consider possible real-world use cases you might try to demonstrate.
## Static examples
By static examples, we are talking about static code blocks that show how a feature might be used in code. These are put on a page using Markdown "code fences", as described in [Example code blocks](/en-US/docs/MDN/Writing_guidelines/Howto/Markdown_in_MDN#example_code_blocks). An example result might look like this:
```js
// This is a JS example
const test = "Hello";
console.log(test);
```
Optionally, you might want to show a static image of the code's resulting output. For example:
## Interactive examples
Interactive examples are intended to be used at the top of MDN reference pages — we are aiming to provide these to improve their value to beginners and other readers who want to just grab and play with an example quickly before seeing all the details of whatever they are looking up. There are a few important limitations to note about the interactive examples:
- They are specialized for a particular technology — the UI for JavaScript is different from the UI for CSS, and they only illustrate one technology in isolation. They are not appropriate if you want to show, for example, how to combine a particular HTML/CSS/JS structure.
- The interactive live examples are currently only set up to show CSS and JavaScript. For other technologies, you'll just have to wait.
- The UI is more performance-intensive than other code examples; you shouldn't put more than one on each MDN article you apply them to.
- They are not intended for large code examples — the UI supports a range of fixed sizes, which only really work for short (say, 10–15 line) examples.
If you want to submit an example, you can find out how at the [interactive examples repo Contribution guide](https://github.com/mdn/interactive-examples/blob/main/CONTRIBUTING.md).
If you find a page that doesn't have an associated interactive example, you are welcome to contribute one!
### Interactive example demo
The [`EmbedInteractiveExample`](https://github.com/mdn/yari/blob/main/kumascript/macros/EmbedInteractiveExample.ejs) macro is used to embed finished examples into MDN pages. For example, the macro call \\{{EmbedInteractiveExample("pages/js/array-push.html")}} displays the following code example:
{{EmbedInteractiveExample("pages/js/array-push.html")}}Try adjusting the code to see what happens, and playing with the controls.
## Traditional live samples
Traditional live samples are inserted into the page using the [`EmbedLiveSample`](https://github.com/mdn/yari/blob/main/kumascript/macros/EmbedLiveSample.ejs) macro. An \\{{EmbedLiveSample}} call dynamically grabs the code blocks in the same document section as itself and puts them into a document, which it then inserts into the page inside an {{htmlelement("iframe")}}. See our [Live samples guide](/en-US/docs/MDN/Writing_guidelines/Page_structures/Live_samples) for more information.
## GitHub live samples
GitHub live samples are inserted into the page using the [`EmbedGHLiveSample`](https://github.com/mdn/yari/blob/main/kumascript/macros/EmbedGHLiveSample.ejs) macro. An \\{{EmbedGHLiveSample}} call dynamically grabs the document at a specified URL (which has to be inside the **mdn** GitHub organization), and inserts into the page inside an {{htmlelement("iframe")}}.
These work in a very similar way to Traditional live samples, but they are a lot simpler:
You don't have to worry about placement of code blocks on the page — it grabs an HTML document in a GitHub repo, and puts it in the `<iframe>`.
The macro only has three parameters:
1. The URL of the document to embed — this is relative to the MDN organization, the top level directory of which is at `https://mdn.github.io/`. So this parameter needs to contain the part of the URL after that, e.g. `my-subdirectory/example.html`. You can omit the filename if it is called `index.html`.
2. The width of the `<iframe>`, which can be expressed as a percentage or in pixels.
3. The height of the `<iframe>`, which can be expressed as a percentage or in pixels.
Let's look at an example. Say we wanted to embed the code at <https://mdn.github.io/learning-area/css/styling-boxes/backgrounds/>. We could use the following call:
\\{{EmbedGHLiveSample("learning-area/css/styling-boxes/backgrounds/", '100%', 100)}}
This looks like so when rendered:
{{EmbedGHLiveSample("learning-area/css/styling-boxes/backgrounds/", '100%', 100)}}
### Tips for using GitHub live samples
- You obviously need to get a suitable code sample onto the [MDN GitHub organization](https://github.com/mdn/) first. This needs to be done using Git. If you are not familiar with Git, check out our [How do I use GitHub Pages?](/en-US/docs/Learn/Common_questions/Tools_and_setup/Using_GitHub_pages) article, and [Preparing to add the data](/en-US/docs/MDN/Writing_guidelines/Page_structures/Compatibility_tables) for more advanced uses.
- Your code sample needs to be suitable to show what you are trying to demonstrate — it should contain one simple example that does one thing well, should have no offensive content in it, and should follow the MDN [Code sample guidelines](/en-US/docs/MDN/Writing_guidelines/Writing_style_guide/Code_style_guide).
| 0 |
data/mdn-content/files/en-us/mdn/writing_guidelines/page_structures | data/mdn-content/files/en-us/mdn/writing_guidelines/page_structures/banners_and_notices/index.md | ---
title: Banners and notices
slug: MDN/Writing_guidelines/Page_structures/Banners_and_notices
page-type: mdn-writing-guide
---
{{MDNSidebar}}
Banners are added to some pages, in particular API reference, in order to highlight important factors that will affect how the described content is used.
For example, banners are used to highlight when a particular interface, method or property is deprecated, and should not be used in production code.
This article describes the more important banners, and how they are added.
## How to add a banner
Banners are added using macros.
Banners macros should be inserted below the page metadata, alongside the page sidebar macro.
For example, the `\{{SeeCompatTable}}` macro is added below to indicate that the [Ink API](/en-US/docs/Web/API/Ink_API) is [Experimental](/en-US/docs/MDN/Writing_guidelines/Experimental_deprecated_obsolete#experimental).
```md
---
title: Ink API
slug: Web/API/Ink_API
page-type: web-api-overview
status:
- experimental
browser-compat: api.Ink
---
\{{DefaultAPISidebar("Ink API")}}\{{SeeCompatTable}}
```
A page that has a banner will usually also have "complementary" page metadata.
For example, a page that has `\{{SeeCompatTable}}` should usually have the `experimental` status added too (as shown above) to ensure that it has appropriate icons in the sidebar.
> **Note:** Banner macros do not _depend_ on the metadata, but some other macro-inserted content does.
> For example, the `\{{Compat}}` macro depends on the `browser-compat` metadata value.
## What banners can/should be added
The [Page type templates](/en-US/docs/MDN/Writing_guidelines/Page_structures/Page_types#templates) include the most important macros.
In summary:
- `\{{SeeCompatTable}}` — generates a **This is an experimental technology** banner that indicates the technology is [experimental](/en-US/docs/MDN/Writing_guidelines/Experimental_deprecated_obsolete#experimental).
Also add `status` of `experimental` to the page front-matter.
- `\{{Deprecated_Header}}` — generates a **Deprecated** banner that indicates that use of the technology is [discouraged](/en-US/docs/MDN/Writing_guidelines/Experimental_deprecated_obsolete#deprecated).
Also add `status` of `deprecated` to the page front-matter.
- `\{{Non-standard_Header}}` — generates a **Non-Standard** banner that indicates that use of the technology is not part of a formal specification, even if it is implemented in multiple browsers.
Also add `status` of `non-standard` to the page front-matter.
- `\{{SecureContext_Header}}` — this generates a **Secure context** banner that indicates the technology is only available in a [secure context](/en-US/docs/Web/Security/Secure_Contexts).
### Experimental: "Standards positions" banner
Occasionally, browser vendors disagree on how a feature is developing, and some may oppose it in its current form. In exceptional cases, MDN documents technologies in this state to encourage the web community to experiment with them, provide feedback, and help browser vendors reach a consensus.
It is important to clarify the current standardization status of such features to readers. While a longer-term solution for representing this information is not final, we are doing the following for specific high-profile technologies to avoid confusion:
- Adding this banner to the landing page for that feature (not for every subpage for the feature):
```text
> **Warning:** This feature is currently opposed by <number> browser vendor(s). See the [Standards positions](#standards_positions) section below for details of opposition.
```
- Replace `<number>` with the number of browser vendors opposing the feature.
- Use `vendor` or `vendors` as appropriate.
- Adding a "Standards positions" section to the same page as the above banner, as a sub-section of the standard "Specifications" section.
> **Note:** See [Related Website Sets](/en-US/docs/Web/API/Storage_Access_API/Related_website_sets) for an example of the "Standards positions" section and what it should contain, as well as the landing page banner.
| 0 |
data/mdn-content/files/en-us/mdn/writing_guidelines/page_structures | data/mdn-content/files/en-us/mdn/writing_guidelines/page_structures/specification_tables/index.md | ---
title: Specification tables
slug: MDN/Writing_guidelines/Page_structures/Specification_tables
page-type: mdn-writing-guide
browser-compat: css.properties.text-align
---
{{MDNSidebar}}
Every reference page on MDN should provide information about the specification or specifications in which that API or technology was defined. This article demonstrates what these tables look like and explains how to add them.
The specifications section definition is similar to the [compatibility table](/en-US/docs/MDN/Writing_guidelines/Page_structures/Compatibility_tables) definition, is commonly generated from the same data source, and typically appears immediately before it in a page.
## Standard specification tables
The standard specification section should look like this:
```md
## Specifications
\{{Specifications}}
```
The `\{{Specifications}}` macro generates the specification table based on the value(s) in the page front-matter.
By default the value(s) in the `browser-compat` key are used.
Each value references a particular feature and its associated compatibility and specification information in the [browser-compat-data](https://github.com/mdn/browser-compat-data) repository.
For example, the {{cssxref("text-align")}} page has the following key, which it uses to fetch the associated specification information.
```yaml
browser-compat: css.property.text-align
```
Some features are not maintained in the above repository.
In these cases, specification information can be added to the page front matter using the `spec-urls` key.
For example, the [`aria-atomic`](/en-US/docs/Web/Accessibility/ARIA/Attributes/aria-atomic) attribute has the front matter key:
```yaml
spec-urls: https://w3c.github.io/aria/#aria-atomic
```
The specifications table for the `css.property.text-align` key above is rendered in a table as shown:
### Specifications
{{Specifications}}
## Non-standard features
When documenting a non-standard feature, in particular one that has been removed from a standardization track, don't call the `\{{Specifications}}` macro.
Instead, try to provide information about the standardization status and possible alternatives. Examples:
- This method is no longer on a standardization track. It is kept for compatibility purposes. Use the _this other method_ instead.
- This method was originally a part of [DOM Level 2 Traversal and Range](https://www.w3.org/TR/DOM-Level-2-Traversal-Range/), but is absent in the current DOM specification. This feature is no longer on track to become a standard.
- This event handler was part of the old [WebVR API](https://immersive-web.github.io/webvr/spec/1.1/) that has been superseded by the [WebXR Device API](https://immersive-web.github.io/webxr/). It is no longer on track to becoming a standard.
| 0 |
data/mdn-content/files/en-us/mdn/writing_guidelines/page_structures | data/mdn-content/files/en-us/mdn/writing_guidelines/page_structures/compatibility_tables/index.md | ---
title: Compatibility tables and the browser compatibility data repository (BCD)
slug: MDN/Writing_guidelines/Page_structures/Compatibility_tables
page-type: mdn-writing-guide
browser-compat: api.AbortController
---
{{MDNSidebar}}
MDN has a standard format for tables that illustrate compatibility of shared technologies across all browsers, such as DOM, HTML, CSS, JavaScript, SVG, etc.
To make this data available in multiple projects programmatically, a Node.js package is built from the [`browser-compat-data` repository](https://github.com/mdn/browser-compat-data) and published to npm.
To modify the data within these tables, comprehensive documentation along with the most recent details of conventions and JSON schemas used to represent the data can be found in the repository's [contributing guide](https://github.com/mdn/browser-compat-data/blob/main/docs/contributing.md) as well as the [data guidelines guide](https://github.com/mdn/browser-compat-data/blob/main/docs/data-guidelines/index.md).
If you have questions or discover problems, you are welcome to [ask for help](/en-US/docs/MDN/Community/Communication_channels).
## Using BCD data in MDN pages
Once data has been included in the [`browser-compat-data`](https://github.com/mdn/browser-compat-data) repo, you can start dynamically including browser compatibility and specification tables based on that data within MDN pages.
To get started with BCD data in MDN pages, use the query string specified in the BCD source file for the relevant data you wish to include.
For example:
- {{domxref("AbortController")}} compatibility data is defined in [api/AbortController.json](https://github.com/mdn/browser-compat-data/blob/main/api/AbortController.json) and can be queried using `api.AbortController`.
- {{HTTPHeader("Content-Type")}} HTTP header compatibility data is defined in [http/headers/content-type.json](https://github.com/mdn/browser-compat-data/blob/main/http/headers/Content-Type.json) and the query is `http.headers.Content-Type`.
- {{domxref("VRDisplay.capabilities")}} property compatibility data is defined in [api/VRDisplay.json](https://github.com/mdn/browser-compat-data/blob/main/api/VRDisplay.json) and its query is `api.VRDisplay.capabilities`.
The compatibility data query should be specified in the page front-matter in the `browser-compat` key.
For example, {{domxref("AbortController")}} would be added as shown below:
```md
---
title: AbortController
slug: Web/API/AbortController
page-type: web-api-interface
browser-compat: api.AbortController
---
```
The compatibility and specification tables corresponding to the key are then automatically rendered in place of the `\{{Compat}}` and `\{{Specifications}}` macros in the source.
If multiple compatibility/specification tables are required on the same page, you can specify the value of `browser-compat` as an array. For example, for the [Channel Messaging API](/en-US/docs/Web/API/Channel_Messaging_API) this would be added as shown below:
```md
---
title: Channel Messaging API
slug: Web/API/Channel_Messaging_API
page-type: web-api-overview
browser-compat:
- api.MessageChannel
- api.MessagePort
---
```
The macro calls generate the following tables (and corresponding set of notes):
### Compatibility table example
{{Compat}}
### Specifications table examples
{{Specifications}}
| 0 |
data/mdn-content/files/en-us/mdn/writing_guidelines/page_structures | data/mdn-content/files/en-us/mdn/writing_guidelines/page_structures/live_samples/index.md | ---
title: Live examples
slug: MDN/Writing_guidelines/Page_structures/Live_samples
page-type: mdn-writing-guide
---
{{MDNSidebar}}
MDN supports displaying code blocks within the articles as _live samples_, enabling readers to see both the code and its output as it would look on a web page. This feature allows readers to understand exactly what the executed code would produce, making the documentation dynamic and instructive.
It also allows authors to be absolutely sure that the code blocks in documentation have the expected output, and work appropriately when used with different browsers.
The live sample system can process code blocks written in HTML, CSS, and JavaScript, regardless of the order in which they are written in the page. This ensures that the output corresponds to the combined source code because the system runs the code directly within the page.
Unlike [Interactive examples](/en-US/docs/MDN/Writing_guidelines/Page_structures/Code_examples#what_types_of_code_example_are_available), live samples don't provide inbuilt support for capturing console logging or resetting examples that are changed by user input.
The [Examples](#examples) section shows how you can implement these, and other, useful features.
## How does the live sample system work?
The live sample system groups code blocks, merges them into HTML and renders the HTML in an {{HTMLElement("iframe")}}.
A live sample consists of two parts:
- One or more code blocks grouped together
- A macro call that shows the result of the combined code blocks in an {{HTMLElement("iframe")}}
Each [code block](/en-US/docs/MDN/Writing_guidelines/Howto/Markdown_in_MDN#example_code_blocks) containing code for the output has a language identifier — `html`, `css`, or `js` — that specifies whether it's HTML, CSS, or JavaScript code. The language identifiers must be on the corresponding blocks of code, and a macro call (`EmbedLiveSample`) must be present in the page to display the output:
````md
## Examples
```html
<!-- HTML code -->
```
```css
/* CSS code */
```
\{{EmbedLiveSample("Examples")}}
````
The live sample system allows grouping of code blocks in different ways to effectively display the output. The next section describes these methods.
### Grouping code blocks
Code blocks can be grouped in two ways:
1. Using the ID of a heading or a block element that contains the code blocks as the identifier
2. Specifying a string identifier along with code blocks
Code blocks that do not explicitly specify an identifier are, by default, grouped together using the ID of the heading or block element that contains the code blocks. The identifier in this case is the ID of a heading or a block element (such as a {{HTMLElement("div")}}). This is shown in the example below, where `html` and `css` codes within the block "Styling a paragraph" are used to generate the output for the `EmbedLiveSample` macro call.
````md
## Examples
### Styling a paragraph
In this example, we're using CSS to style paragraphs that have the `fancy` class set.
#### HTML
```html
<p>I'm not fancy.</p>
<p class="fancy">But I am!</p>
```
#### CSS
```css
p.fancy {
color: red;
}
```
#### Result
\{{EmbedLiveSample("Styling a paragraph")}}
Only the `<p>` element with `class="fancy"` will get styled `red`.
````
- If the ID belongs to a block element, the group includes all the code blocks within the enclosing block element whose ID is used.
- If the ID belongs to a heading, the group includes all the code blocks that are after that heading and before the next heading of the same heading level. Note that code blocks under subheadings of the specified heading are all used; if this is not the effect you want, use an ID on a block element or use a string identifier instead.
To group code blocks using an identifier, add a string in the format `live-sample___{IDENTIFIER}` to the code block's info string. The identifier must be unique to the code blocks you want to group. For example, `live-sample___color-picker` uses `color-picker` as the identifier for the live sample system, and all code blocks with `live-sample___color-picker` in their info string are combined in the live sample.
The following example groups a CSS and a JavaScript code block together using the identifier `color-picker`:
````md
## Examples
### Styling a paragraph
In this example, we're using CSS to style paragraphs that have the `fancy` class set.
```html live-sample___paragraph-styling
<p>I'm not fancy.</p>
<p class="fancy">But I am!</p>
```
```css live-sample___paragraph-styling
p.fancy {
color: red;
}
```
Only the `<p>` element with `class="fancy"` will get styled `red`:
\{{EmbedLiveSample("paragraph-styling")}}
````
The macro uses a special URL to fetch the output for a given group of code blocks, for example `https://yari-demos.prod.mdn.mozit.cloud/en-US/docs/Web/CSS/animation/_sample_.Cylon_Eye.html`. The general structure followed is `https://url-of-page/_sample_.group-id.html`, where `group-id` is the ID of the heading or block where the code blocks are located.
The resulting frame (or page) is sandboxed, secure, and technically may do anything that works on the web. Of course, as a practical matter, the code should be relevant to the page's content; any unrelated material is subject to removal by MDN's editor community.
The live sample system has lots of options available, and we'll try to break things down to look at them one bit at a time.
### Live sample macros
There are two macros that you can use to display live samples:
- [`EmbedLiveSample`](https://github.com/mdn/yari/blob/main/kumascript/macros/EmbedLiveSample.ejs) embeds a live sample into a page
- [`LiveSampleLink`](https://github.com/mdn/yari/blob/main/kumascript/macros/LiveSampleLink.ejs) creates a link that opens the live sample in a new page
In many cases, you may be able to add the `EmbedLiveSample` or `LiveSampleLink` macro to pages with little or no additional work! As long as the sample can be identified by a heading's ID or is in a block with an ID you can use, adding the macro should do the job.
#### EmbedLiveSample macro
```plain
\{{EmbedLiveSample(sample_id, width, height, screenshot_URL, page_slug)}}
```
- sample_id
- : Required: This can be the string identifier of the sample or the ID of the heading or enclosing block to draw the code from.
To verify if you have the correct heading ID, look at the URL of the section in the page's table of contents; you can also check it by viewing the source of the page.
- width
- : The width of the {{HTMLElement("iframe")}} to create, specified in `px`. This is optional; a reasonable default width will be used if you omit this. Note that if you want to use a specific width, you _must_ also specify the height parameter.
- height
- : The height of the {{HTMLElement("iframe")}} to create, specified in `px`. This is optional; a reasonable default height will be used if you omit this. Note that if you want to use a specific height, you _must_ also specify the width parameter. If you use only one of them, the default frame size is used.
- screenshot_URL
- : The URL of a screenshot that shows what the live sample should look like. This is optional, but can be useful for new technologies that may not work in the user's browser, so they can see what the sample would look like if it were supported by their browser. If you include this parameter, the screenshot is shown next to the live sample, with appropriate headings.
- page_slug
- : The slug of the page containing the sample; this is optional, and if it's not provided, the sample is pulled from the same page on which the macro is used.
> **Warning:** This parameter is deprecated. Don't use it in new examples, and remove it from existing examples if you see it. We're actively removing usages of it, and when it is no longer used we will remove support for it.
#### LiveSampleLink macro
```plain
\{{LiveSampleLink(block_ID, link_text)}}
```
- block_ID
- : The ID of the heading or enclosing block to draw the code from. The best way to be sure you have the ID right is to look at the URL of the section in the page's table of contents; you can also check it by viewing the source of the page.
- link_text
- : A string to use as the link text.
## Using the live sample system
The sections below describe a few common use cases for the live sample system.
### Formatting live samples
If you write a live sample in the "Examples" section, provide a descriptive H3 heading (`###`) for this live sample example. Ideally, write a short description of the example explaining the scenario and what you are hoping to demonstrate. Then add subsections with following H4 headings (`####`), in the order listed:
- HTML
- CSS
- JavaScript
- Result
Write the code blocks in the respective subsections listed above.
In the **Result** subsection, add the call to the `EmbedLiveSample` macro. Preferably, include some more prose in this subsection to describe the result.
If you're not using a particular language type (for example, if you are not using JavaScript) or if you are hiding the code block, then you should omit the corresponding heading.
### Hiding code
Sometimes you just want to display the static code block pertinent to the example rendered within a page. However, you still need the HTML, CSS, and JavaScript code blocks to render such an example.
To achieve this, you can hide any code blocks that are not relevant by adding the `hidden` info string to the language identifier. If you do this, omit the `### HTML/CSS/JavaScript` headings for the hidden code blocks.
Using the example above but hiding the HTML code would look like this:
````md
## Examples
### Styling a paragraph
In this example, we're using CSS to style paragraphs that have the `fancy` class set.
```html hidden
<p>I'm not fancy.</p>
<p class="fancy">But I am!</p>
```
#### CSS
```css
p.fancy {
color: red;
}
```
#### Result
Only the `<p>` element with `class="fancy"` will get styled `red`.
\{{EmbedLiveSample("Styling a paragraph")}}
````
### Turning snippets into live samples
One common use case is to take existing code snippets already shown on MDN and turning them into live samples.
The first step is to either add code snippets or ensure that existing ones are ready to be used as live samples, in terms of the content and in terms of their markup. The code snippets, taken together, must comprise a complete, runnable example. For example, if the existing snippet shows only CSS, you might need to add a snippet of HTML for the CSS to operate on.
Each piece of code must be in a code block, with a separate block for each language, properly marked as to which language it is. Most of the time, this has already been done, but it's always worth double-checking to be sure each piece of code is configured with the correct syntax. This is done with a language identifier on the code block of `language-type`, where _language-type_ is the type of language the block contains, e.g. `html`, `css`, or `js`.
> **Note:** You may have more than one block for each language; they are all concatenated together. This lets you have a chunk of code, followed by an explanation of how it works, then another chunk, and so forth. This makes it even easier to produce tutorials and the like that utilize live samples interspersed with explanatory text.
So make sure the code blocks for your HTML, CSS, and/or JavaScript code are each configured correctly for that language's syntax highlighting, and you're good to go.
## Examples
This section contains examples showing how the live sample system may be used, including the different ways of grouping the code blocks that comprise an example, and how to display logging output in your samples.
Note that the headings for code blocks ("HTML", "CSS", or "JavaScript") are used by convention in most MDN examples, but are not actually required by the live sample macro.
### Grouping code blocks by heading
#### HTML
This HTML creates a paragraph and some blocks to help us position and style a message.
```html
<p>A simple example of the live sample system in action.</p>
<div class="box">
<div id="item">Hello world! Welcome to MDN</div>
</div>
```
#### CSS
The CSS code styles the box as well as the text inside it.
```css
.box {
width: 200px;
border-radius: 6px;
padding: 20px;
background-color: #ffaabb;
}
#item {
font-weight: bold;
text-align: center;
font-family: sans-serif;
font-size: 1.5em;
}
```
#### JavaScript
This code is very simple. All it does is attach an event handler to the "Hello world!" text that makes an alert appear when it is clicked.
```js
const el = document.getElementById("item");
el.onclick = function () {
alert("Owww, stop poking me!");
};
```
#### Result
Here is the result of running the code blocks above via `\{{EmbedLiveSample('grouping_code_blocks_by_heading')}}`:
{{EmbedLiveSample('grouping_code_blocks_by_heading')}}
Here is a link that results from calling these code blocks via `\{{LiveSampleLink('grouping_code_blocks_by_heading', 'Live sample demo link')}}`:
{{LiveSampleLink('grouping_code_blocks_by_heading', 'Live sample demo link')}}
### Grouping code blocks by identifier
This HTML creates a paragraph and some blocks to help us position and style a message. The `live-sample___hello-world` string has been added to the `html` language identifier for this code block.
```html live-sample___hello-world
<p>A simple example of the live sample system in action.</p>
<div class="box">
<div id="item">Hello world! Welcome to MDN</div>
</div>
```
The CSS code styles the box as well as the text inside it. The `live-sample___hello-world` string has been added to the `css` language identifier for this code block.
```css live-sample___hello-world
.box {
width: 200px;
border-radius: 6px;
padding: 20px;
background-color: #ffaabb;
}
#item {
font-weight: bold;
text-align: center;
font-family: sans-serif;
font-size: 1.5em;
}
```
This JavaScript code attaches an event handler to the "Hello world!" text that makes an alert appear when it is clicked. The `live-sample___hello-world` string has been added to the `js` language identifier for this code block as well.
```js live-sample___hello-world
const el = document.getElementById("item");
el.onclick = function () {
alert("Owww, stop poking me!");
};
```
We get this output by running the code blocks above using the string identifier `hello-world` in the `\{{EmbedLiveSample('hello-world')}}` macro call:
{{EmbedLiveSample("hello-world")}}
### Displaying a single entry log
This example shows how to implement a simple single-entry log in your live sample, where the previous value is replaced whenever a new log entry is added.
For clarity this example separates the logging code and the code that uses it, and displays the logging code first.
Generally when implementing your own samples you should place logging elements below other UI elements.
> **Note:** Displaying log output as part of the sample provides a much better user experience than using `console.log()`.
#### HTML
Create a {{HTMLElement("pre")}} element with an `id` of `"log"` for displaying the log output.
```html
<pre id="log"></pre>
```
#### JavaScript
Next define the logging function `log()`.
This takes the text to be logged as an argument, and uses it to replace the existing log.
```js
const logElement = document.querySelector("#log");
function log(text) {
logElement.innerText = text;
}
```
Note that the content of the log element is set using the `innerText` property, which is safer than using `innerHTML` because the logged text is not parsed to HTML (which might potentially inject malicious code).
#### CSS
The CSS sets the height of the logging element.
```css
#log {
height: 20px;
}
```
#### Logging test code
This example is designed to show "how to log", so "what is logged" isn't all that important.
This is therefore trivially implemented as a button that the user can press to increment a value.
```html
<button id="increment" type="button">Press me many times</button>
```
```js
const incrementButton = document.querySelector("#increment");
let incrementValue = 0;
incrementButton.addEventListener("click", () => {
incrementValue++;
log(`The button has been pressed ${incrementValue} time(s)`);
});
```
#### Result
Press the button to add new log content.
{{EmbedLiveSample("Displaying a single entry log", "100%", "80px")}}
### Displaying a log that appends items
This example shows how to implement a simple "logging console" in your live sample.
The console appends a new line to the end of the output each time a log is added, scrolling the new item into view.
For clarity this example separates the logging code and the code that uses it, and displays the logging code first.
Generally when implementing your own samples you should place logging elements below other UI elements.
> **Note:** Displaying log output as part of the sample is a much better user experience than using `console.log()`.
> **Note:** See [`DataTransfer.effectAllowed`](/en-US/docs/Web/API/DataTransfer/effectAllowed#setting_effectallowed) for a more complete example.
#### HTML
Create a {{HTMLElement("pre")}} element with an `id` of `"log"` for displaying the log output.
```html
<pre id="log"></pre>
```
#### JavaScript
Next define the logging function `log()`.
This takes the text to be logged as an argument, and appends it to the content in the log element as a new line.
The function also sets the element `scrollTop` to the `scrollHeight` of the element, which forces the new line of log text to scroll into view.
```js
const logElement = document.querySelector("#log");
function log(text) {
logElement.innerText = `${logElement.innerText}${text}\n`;
logElement.scrollTop = logElement.scrollHeight;
}
```
As with the previous example we set the content using the `innerText` property as this is less susceptible to malicious code than using `innerHTML`.
#### CSS
The CSS adds scrollbars if the element content overflows, sets the height of the logging element, and adds a border.
Note that the JavaScript above ensures that if it does overflow, addition of new log text will scroll the text into view.
```css
#log {
height: 100px;
overflow: scroll;
padding: 0.5rem;
border: 1px solid black;
}
```
#### Logging test code
This example is designed to show "how to log", so "what is logged" isn't all that important.
This is therefore trivially implemented as a button that the user can press to increment a value.
```html
<button id="increment" type="button">Press me many times</button>
```
```js
const incrementButton = document.querySelector("#increment");
let incrementValue = 0;
incrementButton.addEventListener("click", () => {
incrementValue++;
log(`The button has been pressed ${incrementValue} time(s)`);
});
```
#### Result
Press the button to add new log content.
{{EmbedLiveSample("Displaying a log that appends items", "100%", "180px")}}
### Displaying a reset button
A reset button can be helpful for examples that cannot be restored to their initial state without resetting the page.
For example, [the `Highlight.priority` "setting priority" example](/en-US/docs/Web/API/Highlight/priority#result_2) needs a reset button, because once you've set either priority the initial state is unavailable.
This example shows how to add a reset button to the [Displaying a log that appends items](#displaying_a_log_that_appends_items) example above.
Note that the JavaScript and CSS for the logging code are the same as in the previous example, so that code is hidden.
#### HTML
The HTML for the example now includes a reset button.
```html
<button id="increment" type="button">Press me many times</button>
<button id="reset" type="button">Reset</button>
<pre id="log"></pre>
```
#### JavaScript
The code for the button adds a `click` event handler function that simply reloads the frame containing the current example.
```js
const reload = document.querySelector("#reset");
reload.addEventListener("click", () => {
window.location.reload(true);
});
```
```css hidden
#log {
height: 100px;
overflow: scroll;
padding: 0.5rem;
border: 1px solid black;
}
```
```js hidden
const logElement = document.querySelector("#log");
function log(text) {
logElement.innerText = `${logElement.innerText}${text}\n`;
logElement.scrollTop = logElement.scrollHeight;
}
const incrementButton = document.querySelector("#increment");
let incrementValue = 0;
incrementButton.addEventListener("click", () => {
incrementValue++;
log(`The button has been pressed ${incrementValue} time(s)`);
});
```
#### Result
Click the "Press me many times" button a number of times.
Reset the example by pressing the "Reset" button.
{{EmbedLiveSample("Displaying a reset button", "100%", "180px")}}
## Conventions regarding live samples
- Orders of code blocks
- : When adding a live sample, the code blocks should be sorted so that the first one corresponds to the main language for this sample (if there is one). For example, when adding a live sample for the HTML Reference, the first block should be HTML, when adding a live sample for the CSS Reference, it should be CSS and so on.
- Naming of headings
- : When there is no ambiguity (e.g. the sample is under a "Examples" section), headings should be straightforward with the sole name of the corresponding language: HTML, CSS, JavaScript, SVG, etc. (see above). Headings like "HTML Content" or "JavaScript Content" should not be used. However if such a short heading makes content unclear, one can use a more thoughtful title.
- Using a "Result" block
- : After the different code blocks, please use a last "Result" block before using the `EmbedLiveSample` macro (see above). This way, the semantic of the example is made clearer for both the reader and any tools that would parse the page (e.g. screen reader, web crawler).
| 0 |
data/mdn-content/files/en-us/mdn/writing_guidelines | data/mdn-content/files/en-us/mdn/writing_guidelines/attrib_copyright_license/index.md | ---
title: Attribution and copyright licensing
slug: MDN/Writing_guidelines/Attrib_copyright_license
page-type: mdn-writing-guide
---
{{MDNSidebar}}
MDN Web Doc's content is available free of charge and is available under various open-source licenses.
## Using MDN Web Docs content
This section covers the types of content we provide and the copyrights and licenses that are in effect for each type if you choose to reuse any of it.
### Documentation
> **Note:** The content on MDN Web Docs has been prepared with the contributions of authors from both inside and outside Mozilla. Unless otherwise indicated, the content is available under the terms of the [Creative Commons Attribution-ShareAlike license](https://creativecommons.org/licenses/by-sa/2.5/) (CC-BY-SA), v2.5 or any later version.
Your reuse of the content here is published under the same license as the original content—CC-BY-SA v2.5 or any later version. When reusing the content on MDN Web Docs, you need to ensure that attribution is given to the original content as well as to "Mozilla Contributors". Include a hyperlink (online) or URL (in print) to the specific page of the content being sourced. For example, to provide attribution for _this_ article, you can write:
> [Attributions and copyright licensing](/en-US/docs/MDN/Writing_guidelines/Attrib_copyright_license) by [Mozilla Contributors](/en-US/docs/MDN/Community/Roles_teams#contributor) is licensed under [CC-BY-SA 2.5](https://creativecommons.org/licenses/by-sa/2.5/). <!--need to revisit the contributors.txt link-->
In the above example, "Mozilla Contributors" links to the history of the cited page. See [Recommended practices for attribution](https://wiki.creativecommons.org/wiki/Recommended_practices_for_attribution) for further explanation.
### Code samples
Code samples added on or after August 20, 2010 are in the [public domain CC0](https://creativecommons.org/publicdomain/zero/1.0/). No licensing notice is necessary but if you need one, you can use: `Any copyright is dedicated to the Public Domain: https://creativecommons.org/publicdomain/zero/1.0/`
Code samples added before August 20, 2010 are available under the [MIT license](https://opensource.org/license/mit/); you should insert the following attribution information into the MIT template: "© \<date of last wiki page revision> \<name of person who put it in the wiki>".
Since the launch of the new Yari MDN platform on December 14 2020, there is currently no way to determine which one you need. We are working on this and will update this content soon. <!--do we still need this here?-->
### Your contributions
If you wish to contribute to MDN Web Docs, you agree that your documentation is available under the Attribution-ShareAlike license (or occasionally an alternative license already specified by the page you are editing) and that your code samples are available under [Creative Commons CC-0](https://creativecommons.org/publicdomain/zero/1.0/) (a Public Domain dedication).
> **Warning:** No new pages may be created using alternate licenses.
**Copyright for contributed materials remains with the author unless the author assigns it to someone else.**
If you have any questions or concerns about anything discussed here, please contact the [MDN Web Docs team](/en-US/docs/MDN/Community/Communication_channels).
### Logos, trademarks, service marks, and wordmarks
The rights in the logos, trademarks, and service marks of the Mozilla Foundation, as well as the look and feel of this website, are not licensed under the Creative Commons license, and to the extent they are works of authorship (like logos and graphic design), they are not included in the work that is licensed under those terms. If you use the text of documents and wish to also use any of these rights, or if you have any other questions about complying with our licensing terms for this collection, you should contact the Mozilla Foundation here: [[email protected]](mailto:[email protected]).
## Using content from elsewhere on MDN Web Docs
In general, we do not approve of copying content from other sources and putting it on MDN.
MDN should be made up of original content wherever possible.
If we receive a pull request and discover that it contains plagiarized content, we will close it and request that the submitter resubmit the change with the content rewritten into their own words.
### If you want to reuse or republish content
> **Note:** Unless there is a good reason to republish the content, we will probably say "no".
> The MDN writing team's decision is final.
If someone wants to donate an article to MDN that they previously published on their blog or it makes sense to copy a complex reference sheet to MDN, there may be justification for republishing it. For these cases, discuss your plan with the MDN team beforehand:
- [Create a GitHub issue](https://github.com/mdn/mdn/issues/new/choose) that explains your intention.
- Describe what you would like to copy or republish.
- Provide a URL to the resource.
- Explain why you think it's appropriate.
**If the content is published under a closed license:**
- If you hold the rights to the content, state this and your express agreement to republish it on MDN.
- If you do not hold the rights to the content, include the author/publisher on the issue if possible, or include details of how they could be contacted so we can ask them for permission to republish the content.
**If the content is published under an open license:**
- Say what it is, and link to the license so we can check whether it is compatible with [MDN's license](https://github.com/mdn/content/blob/main/LICENSE.md).
## Linking to MDN Web Docs articles
We regularly get users asking us questions about how to link to MDN Web Docs and whether or not it is even allowed. The short answer is: **yes, you can link to MDN Web Docs!** Not only is the hypertext link the essence of the web, it is both a way to point your users to valuable resources as well as a show of trust toward the work our community does.
| 0 |
data/mdn-content/files/en-us/mdn | data/mdn-content/files/en-us/mdn/community/index.md | ---
title: Community guidelines
slug: MDN/Community
page-type: mdn-community-guide
---
{{MDNSidebar}}
👋 Welcome to MDN Web Docs, an open-source, collaborative project that documents web platform technologies, including [HTML](/en-US/docs/Web/HTML), [CSS](/en-US/docs/Web/CSS), [JavaScript](/en-US/docs/Web/JavaScript), and [Web APIs](/en-US/docs/Web/API).
We also provide extensive [learning resources](/en-US/docs/Learn) for early-stage developers and students.
## Ways to contribute
Here's a list of ways you can contribute to MDN Web Docs:
- [Fixing known high impact issues](https://github.com/orgs/mdn/projects/25/views/1)
- [Reviewing pull requests](/en-US/docs/MDN/Community/Pull_requests)
- [Help beginners to learn on MDN Web Docs](/en-US/docs/MDN/Community/Learn_forum)
- [Contribute to MDN Web Docs interactive examples](https://github.com/mdn/interactive-examples/blob/main/CONTRIBUTING.md)
- [Help translate MDN Web Docs](/en-US/docs/MDN/Community/Contributing/Translated_content)
- [Help fix known platform issues](https://github.com/mdn/yari/issues)
- [Help us keep browser compatibility data up to date](https://github.com/mdn/browser-compat-data)
## Community resources
- [Communication channels](/en-US/docs/MDN/Community/Communication_channels)
- : This page lists communication channels used by the MDN team and our community, with hints on which might be best for you.
- [Contributing](/en-US/docs/MDN/Community/Contributing)
- : This section explains how you can start contributing and the type of contributions we accept.
It covers [Getting started](/en-US/docs/MDN/Community/Contributing/Getting_started), [Our repositories](/en-US/docs/MDN/Community/Contributing/Our_repositories), [Translated content](/en-US/docs/MDN/Community/Contributing/Translated_content), and [Security vulnerability response steps](/en-US/docs/MDN/Community/Contributing/Security_vulnerability_response).
- [Open source etiquette](/en-US/docs/MDN/Community/Open_source_etiquette)
- : This article gives guidance on how to behave when contributing to our open source project including rules for contributing, etiquette, and how to handle conflicts.
- [Issues](/en-US/docs/MDN/Community/Issues)
- : Issues are used to track all bugs and work that has a clear actionable outcome.
This article contains guidelines on opening and working on issues and also covers [Issue triage](/en-US/docs/MDN/Community/Issues) and [Content and feature suggestions](/en-US/docs/MDN/Community/Issues/Content_suggestions_feature_proposals).
- [Pull requests](/en-US/docs/MDN/Community/Pull_requests)
- : This section covers our guidelines for submitting pull requests and what you should expect from the review process.
- [Roles and teams](/en-US/docs/MDN/Community/Roles_teams)
- : This section provides an overview of the users and teams that are part of the MDN Web Docs project and details what it means to be part of a team.
## Code of conduct
By participating in and contributing to our projects and discussions, you acknowledge that you have read and agree to the [Mozilla community participation guidelines](https://github.com/mdn/mdn-community/blob/main/CODE_OF_CONDUCT.md).
## Get in touch
You can communicate with the MDN Web Docs team and community using the [communication channels](/en-US/docs/MDN/Community/Communication_channels).
### General support
We are a small team working hard to keep up with the documentation demands of a continuously changing web ecosystem.
Unfortunately, we can't help with general support questions.
If you're learning to code, you can refer to the following resources:
- [Learn web development](/en-US/docs/Learn)
- [MDN Web Docs learn forum](https://discourse.mozilla.org/c/mdn/learn/250)
- [Stack Overflow](https://stackoverflow.com/questions/)
Any issues, discussions, or pull requests opened on repositories asking for general support will be directed here and may be closed and locked.
| 0 |
data/mdn-content/files/en-us/mdn/community | data/mdn-content/files/en-us/mdn/community/roles_teams/index.md | ---
title: MDN Web Docs roles and teams
slug: MDN/Community/Roles_teams
page-type: mdn-community-guide
---
{{MDNSidebar}}
The success and growth of the MDN Web Docs project is, in large part, due to our community of contributors. Some contributors have committed a portion of their time to assist with the daily tasks of running MDN Web Docs. Changes to the site, including maintenance tasks, are performed by employees, contractors, and a network of partners who are all dedicated to the health, growth, and maintenance of MDN Web Docs. The project relies heavily on [roles](#roles) and [teams](#teams) in the [MDN organization on GitHub](https://github.com/mdn) to manage and incorporate changes from these different groups. A list of the organization's members can be [found here](https://github.com/orgs/mdn/people).
Community contributions help this open source project immensely.
Contributors can use their work on MDN Web Docs to show their writing, technical, and collaboration skills, and the ability to work with people from diverse backgrounds. This section describes the roles you can take on while volunteering on the MDN Web Docs project.
## Roles
In the MDN Web Docs project, you can take on the role of a [contributor](#contributor), an [organization member](#organization_member), a [maintainer](#maintainer), or an [owner](#owner). The progression from one role to the next is a step-by-step journey.
With the advancement in your responsibilities, you could serve more than one role at the same time.
Roles such as [invited expert](#invited_expert) can be directly obtained if you've demonstrated expertise in a particular area.
Irrespective of the role you take on in this project, you are always a [contributor](#contributor).
A **contributor** is the base role and all other roles are built on top of it.
So while working on this project in any capacity, you must satisfy the requirements of the contributor role.
### Contributor
Contributors, or _community participants_, add to the project with their time, skills, opinions, and ideas.
Contributors work on the project directly and add value to it.
Apart from writing and testing code, contributions include creating and updating documentation, researching, fixing bugs, and helping other community members.
Depending on the frequency of your contributions, you can be someone who contributes occasionally or an active contributor.
If you demonstrate a large impact on the project, you may be nominated as a [spotlight contributor](#spotlight_contributor) or be promoted to an [organization member](#organization_member).
If you're new here and you would like to become a contributor, take a look at our [contribution guide](https://github.com/mdn/content/blob/main/CONTRIBUTING.md) and the [repositories in the MDN GitHub organization](https://github.com/orgs/mdn/repositories).
As a contributor, you can get involved with the project by engaging in the following activities:
- Participating in community discussions on the [communication channels](/en-US/docs/MDN/Community/Communication_channels).
- Helping other contributors with their pull requests and issues or mentoring new contributors.
- Submitting bug reports. Check out the [kind of issues you can open](https://github.com/mdn/content/issues/new/choose) on MDN's [`content`](https://github.com/mdn/content) repository.
If you notice a platform bug, you can [open an issue](https://github.com/mdn/yari/issues/new/choose) on MDN's `yari` repository.
- Commenting on issues to move conversations towards a fruitful resolution.
- Addressing open issues (for example, in the [`content`](https://github.com/mdn/content/issues) repository) by submitting [pull requests](/en-US/docs/MDN/Community/Pull_requests).
- Attending community events.
- Helping to promote the MDN project.
**Requirements:**
To be a contributor, you must follow:
- [Mozilla's code of conduct](https://github.com/mdn/mdn-community/blob/main/CODE_OF_CONDUCT.md)
- Contribution guidelines (check the `CONTRIBUTING.md` file in each repository; for example, these are the [contribution guidelines](https://github.com/mdn/content/blob/main/CONTRIBUTING.md) for the `mdn/content` repository).
**Privileges:**
Contributors enjoy the following privileges:
- Invitations to contributor events.
- Eligibility to become an [organization member](#organization_member).
### Organization member
[Organization members](https://github.com/orgs/mdn/people) are established [contributors](#contributor) who participate in and contribute to the MDN Web Docs project regularly.
They are expected to act in the interest of the project.
**Requirements:**
To be an organization member, you must meet one or more of the following requirements:
- Opened two or more pull requests that have been merged that resolve two or more issues.
- Contributed to MDN Web Docs projects for at least two months.
- Contributed actively to at least one project area.
The following two requirements are mandatory:
- Enabled [two-factor authentication](https://docs.github.com/en/authentication/securing-your-account-with-two-factor-authentication-2fa/configuring-two-factor-authentication) for your GitHub account.
- Enabled [signed commits](https://docs.github.com/en/authentication/managing-commit-signature-verification/signing-commits).
**Privileges:**
Organization members have privileges at the [organization level](https://github.com/mdn) on GitHub.
### Maintainer
Maintainers are established [contributors](#contributor) who are responsible for one or more projects on MDN.
They are expected to participate in making decisions about the policies and priorities of the project. See the [process](#nominating_a_maintainer) for nominating someone as a maintainer.
As a maintainer, you engage in the following activities:
- Determining priorities for the project you are responsible for.
- Participating in community meetings.
- Mentoring new and existing contributors across all other roles.
- Based on the skill set, proposing, approving, or implementing in your project area:
- Code and infrastructure improvements
- Content improvements
- Process improvements
<!--
TODO: Compare with https://developer.mozilla.org/en-US/docs/MDN/Community/Roles_teams#volunteer_and_partner_maintainers.
What info needs to be retained? Should we use the term 'partner maintainer' or is 'maintainer' good enough?
-->
**Requirements:**
To be eligible to be a maintainer, you must meet one or more of the following requirements:
- Gained experience as an [invited expert](#invited_expert) for at least six months.
- Demonstrated a broad knowledge of the project across multiple areas.
- Demonstrated the ability to exercise judgment for the good of the project, independent of the influence of other members.
- Exhibited the quality of mentoring other contributors.
- Consented to commit spending at least 16 hours per month working on the project.
- Attended the community meeting that takes place once every two months.
> **Note:** If there is someone you think is eligible for this role, you may [nominate a maintainer](#nominating_a_maintainer).
**Privileges:**
Maintainers have the permissions to approve and merge pull requests.
### Owner
Owners have wide permissions to manage users and [GitHub teams](https://github.com/orgs/mdn/teams), maintain access across repositories in the [MDN organization](https://github.com/mdn), maintain repository settings, and deploy to production.
Owners are bound by all the requirements of other contributor roles.
> **Note:** The role of an owner is currently limited to Mozilla staff.
**Requirements:**
In addition to the responsibilities of other contributor roles, owners have the following responsibilities:
- Following and enforcing MDN team norms, including the [Community Participation Guidelines](https://www.mozilla.org/en-US/about/governance/policies/participation/) and [Mozilla Policies](https://www.mozilla.org/en-US/about/governance/policies/).
- Following the MDN organization policies and leading by example.
- Suggesting, documenting, and implementing new policies through the [pull request process](/en-US/docs/MDN/Community/Pull_requests).
- Following and contributing to issues and discussions across the MDN organization.
- Ensuring that an issue or pull request gets feedback from one or more members within one week.
- [Archiving](https://help.github.com/articles/about-archiving-repositories/) or deleting unmaintained repositories.
- Discussing GitHub features, selecting the ones to use, and documenting decisions.
**Privileges:**
Owners can:
- Add and remove organization owners and members as needed.
- Add and remove collaborators to specific repositories as needed.
- Add repositories (as fresh projects or transfers) as needed.
### Summary of the roles
| Role | Requirements | Privileges |
| :---------------------------------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------- |
| [**Contributor**](#contributor) | Follow the code of conduct and contribution guidelines | - Invitations to contributor events<br>- Eligibility to become an organization member |
| [**Organization member**](#organization_member) | - Enable 2FA for GitHub account<br>- Enable signed commits<br><br>One or more of:<br>- Resolve two or more issues<br>- Contribute for at least two months<br>- Active contribution in a project area | Access rights at the organization level |
| [**Maintainer**](#maintainer) | One or more of:<br>- Invited expert for at least six months<br>- Knowledge across multiple project areas<br>- Act towards overall health of the project<br>- Mentor other contributors<br>- Spend at least 16 hours per month on the project<br>- Attend community meetings | Approve and merge pull requests |
| [**Owner**](#owner) | Limited to Mozilla staff | - Manage access of different roles to various repositories<br>- Add or archive repositories and projects |
## Special roles
Some contributor roles have more nuanced responsibilities and have special eligibility conditions. These include [spotlight contributor](#spotlight_contributor), [invited expert](#invited_expert), and [community manager](#community_manager).
### Spotlight contributor
Spotlight contributors are people who have gone above and beyond with their contributions to MDN Web Docs.
Their contributions are in the form of pull requests to improve the project, helping community members on various [communication channels](/en-US/docs/MDN/Community/Communication_channels) or learn forums, or providing feedback on GitHub issues and pull requests.
We feature a spotlight contributor on the [MDN website](/en-US/) once every month.
See the [process](#nominating_a_spotlight_contributor) to nominate someone as a spotlight contributor.
### Invited expert
Invited experts have a track record on MDN for their contributions, participation in discussions and reviews, or have proven knowledge in a certain area of expertise.
Invited experts are responsible for a specific topic area or a component of the MDN project.
They are responsible for reviewing and approving pull requests in their topic or project area, answering technical questions, and maintaining the general health of their particular project. See the [process](#nominating_an_invited_expert) to nominate someone as an invited expert.
In addition to the responsibilities of an [organization member](#organization_member), invited experts are responsible for:
- Following the [reviewing guide](https://github.com/mdn/content/blob/main/REVIEWING.md).
- Reviewing pull requests in their topic area.
- Helping other contributors become reviewers.
Invited experts are automatically assigned for review when pull requests are opened in their topic area.
If there is more than one expert in a topic area, they are assigned to pull requests using a [load-balancing strategy](https://docs.github.com/en/organizations/organizing-members-into-teams/managing-code-review-settings-for-your-team#about-auto-assignment).
**Requirements:**
To be eligible to be an invited expert, you must meet one or more of the following requirements:
- Demonstrated an in-depth knowledge of a particular topic area.
- Committed to being responsible for their assigned topic area.
- Supported new and occasional contributors and helped to get pull requests ready to merge.
- Attended the community meeting which takes place once every two months.
**Privileges:**
Invited experts get added to the [invited experts team](https://github.com/orgs/mdn/teams/invited-experts-and-co-maintainers) and to the appropriate topic or project team. Invited experts can:
- Access the required repository for commits and pull request approvals and merges.
- Recommend and vote for other members to become invited experts.
- Attend weekly MDN Web Docs editorial call.
### Community manager
Community managers have a distinct role in many respects.
Community managers share many of the same responsibilities as a [maintainer](#maintainer).
In addition, community managers have the following responsibilities:
- Addressing reports of violation of [Mozilla's code of conduct](https://github.com/mdn/mdn-community/blob/main/CODE_OF_CONDUCT.md) and deciding on the appropriate action.
- Organizing and running community events.
- Organizing community-related project meetings.
- Determining media strategies to promote the MDN project.
- Defining and implementing the contributor onboarding experience.
- Onboarding new contributors and users.
- Ensuring the health and well-being of the MDN project and all participants.
- Identifying and assisting with the implementation of automation to improve project sustainability.
- Meeting and ensuring a healthy relationship with contributors and partners.
- Assisting with issue triage and pull request review where appropriate.
- Monitoring all the [communication channels](/en-US/docs/MDN/Community/Communication_channels).
- Highlighting contributors that have done exceptional work and/or have shown dedication to the MDN project.
## Processes
### Nominating a maintainer
See who can be a [maintainer](#maintainer).
To nominate someone as a maintainer, open an issue on GitHub:
1. On the `Issues` tab in the `mdn/mdn` repository, click the [**New issue**](https://github.com/mdn/mdn/issues/new/choose) button on the right.
2. Under 'Nominate a maintainer', click the **Get started** button.
3. Fill in the form with details of the contributions of the person you are nominating and submit the form.
<!--
TODO: Update links in these steps
TODO: Edit the section after updating the links
- The nominator will open a pull request using the appropriate [template](https://github.com/mdn/mdn-community/roles/) against the [MDN Web Docs community repository](https://github.com/mdn/mdn-community/).
- The nominee will add a comment to the pull request agreeing to all responsibilities of becoming a Maintainer.
- At least three current Maintainers must approve the pull request.
- Once the pull request is approved, the new Maintainer is added to the [Maintainers team](https://github.com/orgs/mdn/teams/maintainers) and any other relevant topic or project teams.
-->
### Nominating a spotlight contributor
See who can be a [spotlight contributor](#spotlight_contributor).
To nominate someone as a spotlight contributor, open an issue on GitHub:
1. On the `Issues` tab in the `mdn/mdn` repository, click the [**New issue**](https://github.com/mdn/mdn/issues/new/choose) button on the right.
2. Under 'Nominate a spotlight contributor', click the **Get started** button.
3. Fill in the form with details of the contributions of the person you are nominating and submit the form.
The MDN team will get in touch with the nominated person to get their information to be published on the [website](/en-US/) under "Contributor Spotlight".
### Nominating an invited expert
See who can be an [invited expert](#invited_expert).
To nominate someone as an invited expert, open an issue on GitHub:
1. On the `Issues` tab in the `mdn/mdn` repository, click the [**New issue**](https://github.com/mdn/mdn/issues/new/choose) button on the right.
2. Under 'Nominate an invited expert', click the **Get started** button.
3. Fill in the form with details of the contributions of the person you are nominating and submit the form.
<!--
TODO: Revisit this PR process
- The nominator will open a pull request using the appropriate [template](https://github.com/mdn/mdn-community/roles/) against the [MDN Web Docs community repository](https://github.com/mdn/mdn-community/).
- The nominee will add a comment to the pull request agreeing to all responsibilities of becoming an Invited Expert.
- To be accepted, the pull request needs three approvals. This can be any combination of Invited Experts, or Maintainers.
- Once the pull request is approved, the new Invited Expert is added to the [invited-experts team](https://github.com/orgs/mdn/teams/invited-experts) and the appropriate topic team.
-->
### Stepping down or applying for emeritus status
Life happens and your commitment levels as a contributor could change over time. Depending on your situation, you might want to:
- Take a break from the project temporarily.
- Downgrade to a less-demanding role.
- Step away from the project completely (apply for an emeritus status).
In all these situations, feel free to discuss your situation and current commitment levels with the [MDN team](#contact_the_mdn_team).
### Demoting or removing inactive contributors
A contributor can be demoted or removed as a contributor when responsibilities and requirements aren't being met, including repeated patterns of inactivity or a violation of the [code of conduct](https://github.com/mdn/mdn-community/blob/main/CODE_OF_CONDUCT.md).
Demotion or removal of a contributor is proposed by a participant during a maintainers meeting.
The participant provides supporting information for the demotion or removal request.
After discussion, maintainers and community managers vote on the matter to make a decision.
Removing inactive contributors protects the project and its deliverables and also opens up opportunities for new contributors to step in.
We define inactivity as:
- No contributions to the project for at least six months.
- No response to communication for at least three months.
Inactivity harms the project; it may lead to unexpected delays, contributor attrition, and a loss of trust in the project. Contributors must be active to set an example and show commitment to the project.
Please communicate with the community team to avoid demotion or removal should your time commitments change; instead you can proactively choose to [step down for a while or move to emeritus status](#stepping-down-or-applying-for-emeritus-status).
## Teams
We manage teams using the [GitHub teams](https://docs.github.com/en/organizations/organizing-members-into-teams/about-teams) feature. When you are added to a team, it means that you have communicated your intent to be more closely involved in the project. This also means that you have some additional responsibilities and rights, as explained below:
- A person on a team is commonly added to the [CODEOWNERS](https://github.com/mdn/content/blob/main/.github/CODEOWNERS) file for their respective topic area(s) of interest.
- When a pull request touches files in your area of responsibility, based on the CODEOWNERS file, you will be added as a reviewer to a pull request automatically using GitHub's [load-balancing algorithm](https://docs.github.com/en/organizations/organizing-members-into-teams/managing-code-review-settings-for-your-team#routing-algorithms).
- Members of a team have a higher-level repository access. Repository permissions are assigned to only those repositories where a member needs access.
The teams in the [MDN GitHub organization](https://github.com/orgs/mdn/teams) include:
- `@Core`: Core MDN Web Docs team
- `@mdn-community-engagement`: People responsible for community engagement across our repositories
- `@mdn-product`: People responsible for the MDN Plus product
- `@localization-team-leads`: People who lead our individual localization teams
- `@OWD`: Contributors from the Open Web Docs non-profit organization
- `@sre`: Site reliability engineers who support MDN Web Docs
- `@yari-content`: The umbrella team for all MDN Web Docs content reviewers
- There is a subteam for the different topic areas — accessibility, Add-ons, CSS, HTML, HTTP, JavaScript, SVG, Web API, and WebAssembly. For example, there's `@yari-content-css` and `@yari-content-svg`.
- There are also subteams for different languages — Brazilian Portuguese, Chinese, French, Japanese, Korean, Russian, and Spanish. For example, there's `@yari-content-fr` and `@yari-content-ko`.
To become a member of a team, you must:
- Agree to abide by our [Community Participation Guidelines](https://www.mozilla.org/en-US/about/governance/policies/participation/).
- Agree to Mozilla's [Commit Access Requirements](https://www.mozilla.org/en-US/about/governance/policies/commit/requirements/).
- Set up [two-factor authentication](https://docs.github.com/en/authentication/securing-your-account-with-two-factor-authentication-2fa/configuring-two-factor-authentication) (2FA) on your GitHub account.
<!--
TODO: Update this process because currently there is no issue category on mdn/mdn to request for getting added to a team
If you wish to become a member of a team, you should start by [filing an issue in this repository](https://github.com/mdn/mdn/issues/new/choose).
After you have filed your issue, someone from our team will review it and give you the necessary privileges, provided our requirements are satisfied.
-->
## Contact the MDN team
For inquiries and feedback, please reach out to mdn-web-docs-community (at) mozilla (.com).
| 0 |
data/mdn-content/files/en-us/mdn/community | data/mdn-content/files/en-us/mdn/community/discussions/index.md | ---
title: Community discussions
slug: MDN/Community/Discussions
page-type: mdn-community-guide
---
{{MDNSidebar}}
On MDN Web Docs, we encourage our community to start and/or engage in discussions around topics related to the overall project. Discussions are categorized by different topic areas. We ask that you keep each discussion focused on the topic at hand instead of covering multiple topics in one discussion.
**Note:** `mdn-community/discussions` is not the place to report problems.
If you see something wrong on MDN Web Docs, it's best to open a GitHub issue in the [relevant MDN GitHub repository](https://github.com/mdn/).
If you're not sure whether to open an issue or start discussion, consider the following guidelines:
- Issues are for reporting a bug or a work item with clearly defined and actionable tasks and outcomes.
- Discussions are the right place if an issue needs a discussion to agree upon a course of action or define an actionable piece of work.
heck out the subject of each discussion category below so that you can start your discussion in the proper place.
<table>
<thead>
<tr>
<th scope="col">Discussion Category</th>
<th scope="col">Discussion Subject</th>
</tr>
</thead>
<tbody>
<tr>
<td>
📣
<a
href="https://github.com/orgs/mdn/discussions/categories/announcements"
>Announcements</a
>
</td>
<td>
This category is reserved for MDN Web Docs staff. While there is nothing
in place to prevent others from posting here, we ask that you choose one
of the other available categories.
</td>
</tr>
<tr>
<td>
🔮
<a
href="https://github.com/orgs/mdn/discussions/categories/browser-compatibility-data"
>Browser compatibility data</a
>
</td>
<td>
Discussions related to the
<a href="https://github.com/mdn/browser-compat-data"
>browser-compat-data</a
>
project which documents web platform compatibility data for browsers.
</td>
</tr>
<tr>
<td>
✏️
<a
href="https://github.com/orgs/mdn/discussions/categories/content"
>Content</a
>
</td>
<td>
Discussions related to the
<a href="https://github.com/mdn/content">content</a> on MDN Web Docs.
<em>Note:</em> This is not the place to ask for coding assistance.
If you're stuck, a good place to start is our
<a href="/en-US/docs/Learn">Learn Web Development</a> area.
</td>
</tr>
<tr>
<td>
🎨
<a
href="https://github.com/orgs/mdn/discussions/categories/design-system"
>Design system</a
>
</td>
<td>
Discussions related to design improvements. Design is subjective, but we
are always open to suggestions from the community. Any improvement that
can help the MDN Web Docs experience even better for a wider audience is
welcome. If you have constructive feedback around the design, user
experience, and accessibility of MDN Web Docs, we'd love to hear from
you.
</td>
</tr>
<tr>
<td>
👩💻
<a
href="https://github.com/orgs/mdn/discussions/categories/code-examples"
>Code examples</a
>
</td>
<td>
Discussions related to all code examples on MDN Web Docs. This includes
interactive examples, live samples and static code examples. For help
with general coding challenges on MDN Web Docs, see our
<a href="/en-US/docs/MDN/Community/Communication_channels">Communication channels</a>.
</td>
</tr>
<tr>
<td>
🌐
<a
href="https://github.com/orgs/mdn/discussions/categories/localization"
>Translated content</a
>
</td>
<td>
Discussions related to the
<a href="https://github.com/mdn/translated-content/"
>translated-content</a
>
repository covering our
<a href="https://github.com/mdn/translated-content/#locales"
>supported locales</a
>. This is also typically where
<a href="https://github.com/orgs/mdn/discussions/67"
>announcements of macro deprecation</a
>
will happen.
</td>
</tr>
<tr>
<td>
👾
<a
href="https://github.com/orgs/mdn/discussions/categories/mdn-plus"
>MDN Plus</a
>
</td>
<td>
Discussions related to the existing
<a href="/en-US/plus"
>MDN Plus feature set</a
>
as well as feature ideas. For MDN Plus support such as subscriptions,
please refer to our
<a href="https://support.mozilla.org/en-US/products/mdn-plus"
>official support channel</a
>.
</td>
</tr>
<tr>
<td>
🛠️
<a
href="https://github.com/orgs/mdn/discussions/categories/platform"
>Platform</a
>
</td>
<td>
Discussions related to the
<a href="https://github.com/mdn/yari">core</a> MDN Web Docs platform.
Your suggestions to improve the architecture and existing features, such
as navigation and search, are welcome. However, if you believe you found
a bug related to the platform, please
<a
href="https://github.com/mdn/yari/issues/choose?q=is%3Aissue+is%3Aopen+sort%3Aupdated-desc"
>report it</a
>
on the Yari repository. This is also the place for discussions related
to existing tooling, such as
<a href="https://github.com/mdn/bob">BoB</a>,
<a href="https://github.com/mdn/markdown/">markdown</a>,
<a href="https://github.com/mdn/workflows">reusable workflows</a>, etc.
NOTE: This category is not for MDN Plus-related feature discussions.
There is a separate discussion category for MDN Plus.
</td>
</tr>
<tr>
<td>
🤖
<a
href="https://github.com/orgs/mdn/discussions/categories/polls"
>Polls</a
>
</td>
<td>
This category is meant for use by the MDN Web Docs staff. We will use
this category to run polls around topics where we need your input. So,
keep your eyes peeled. 👀
</td>
</tr>
</tbody>
</table>
| 0 |
data/mdn-content/files/en-us/mdn/community | data/mdn-content/files/en-us/mdn/community/communication_channels/index.md | ---
title: Communication channels
slug: MDN/Community/Communication_channels
page-type: mdn-community-guide
---
{{MDNSidebar}}
There are various communication channels using which community can contact MDN Web Docs staff and participate in discussions.
## Chat rooms
Chat rooms are for meeting other people, asking questions and sharing information.
They are a great place to get to know other community members, share your work, and get help with your contributions.
### Discord server
The MDN Web Docs community Discord server is open to the public.
This server is a great place to see what staff and members of the community are doing on a daily basis.
You can ask questions, seek clarifications, find out how to get involved, and join specific channels based on your areas of interest.
Join the MDN Web Docs community via our [Discord invite](/discord).
### Matrix chat rooms
The Matrix chat rooms are an alternative to the Discord server.
- [MDN room](https://chat.mozilla.org/#/room/#mdn:mozilla.org) on Mozilla Element web app
- [MDN room](https://app.element.io/#/room/#mdn:mozilla.org) on Matrix Element web app
- [Add-ons room](https://chat.mozilla.org/#/room/#addons:mozilla.org)
- [List of all Mozilla rooms](https://wiki.mozilla.org/Matrix#Commonly_used_rooms)
## GitHub Discussions
[GitHub Discussions](https://github.com/orgs/mdn/discussions) on MDN Web Docs is the place to look out for project-wide [announcements](https://github.com/orgs/mdn/discussions/categories/announcements), to share the work you're planning to do if you think you will need a consensus on a good course of action.
You can also use GitHub Discussions for brainstorming your ideas to define an actionable piece of work, especially when the changes have a wide-ranging impact.
Use GitHub discussions to post your questions and propose your suggestions.
Choose the appropriate [discussion category](https://github.com/mdn/mdn-community#github-discussions) when starting a thread.
Your answered questions can be really useful for other people looking for similar information in the future.
Check out the MDN-specific [discussion guidelines](/en-US/docs/MDN/Community/Discussions) before you create a new submission.
## Social media
You can follow MDN Web Docs on [Mastodon](https://mozilla.social/@mdn) and [Twitter](https://twitter.com/MozDevNet).
Feel free to tag us in your posts if you want to share something with us or say hello, although we can't guarantee that we can respond to everything.
## Forums
You can use the forums listed below for discussing code problems.
- [MDN Discourse forum](https://discourse.mozilla.org/c/mdn/236)
- [MDN Discourse forum learning category](https://discourse.mozilla.org/c/mdn/learn/250)
- [Add-ons Discourse](https://discourse.mozilla.org/c/add-ons/35)
## Localization channels
Each localization team has its own [method of communication](/en-US/docs/MDN/Community/Contributing/Translated_content).
## Mailing list
For any nonpublic communication, send an email to [mdn-admins](mailto:[email protected]).
| 0 |
data/mdn-content/files/en-us/mdn/community | data/mdn-content/files/en-us/mdn/community/issues/index.md | ---
title: Guidelines to open and work on issues
slug: MDN/Community/Issues
page-type: mdn-community-guide
---
{{MDNSidebar}}
As a contributor, you can [report](#guidelines_for_reporting_an_issue) and [work](#guidelines_for_working_on_an_issue) on issues.
After you report an issue, the issue gets triaged. Issue [triaging](#guidelines_for_triaging_issues) is typically done by people assigned the role of a maintainer or an owner.
## General guidelines for participation
While reporting an issue or participating in a conversation in an issue, always ensure that your inputs are contributing to the overall progress of the project. Consider whether the issues you open and your comments in an issue are constructive and on topic and are not just adding noise.
Do the following:
- Before filing an issue, consider if you need to [discuss](/en-US/docs/MDN/Community/Communication_channels#chat_rooms) it with the staff/community. Use discussions to gain different viewpoints and to converge on an agreed-upon course of action. This helps to keep issues focused and productive.
- After filing an issue, try to fix the problem yourself. Read our [contribution guide](https://github.com/mdn/content/blob/main/CONTRIBUTING.md) to learn more.
- If you have a question, you can ask it in the [MDN Web Docs chat rooms](/en-US/docs/MDN/Community/Communication_channels#chat_rooms) instead of filing an issue.
Avoid doing the following:
- Complicating issues by trying to discuss multiple topics or by making off-topic comments.
- Opening lots of issues asking vague questions.
- Asking questions without trying to solve the problem yourself first.
## Guidelines for reporting an issue
[Issues](https://docs.github.com/en/github/managing-your-work-on-github/about-issues) are used to track bugs. An issue must be a single actionable task or a collection of related actionable tasks and must have a clear outcome.
### Before filing an issue
If you think you've found a bug with the content on MDN Web Docs or with the look and feel of the website, search the current open issues in the [relevant repository](/en-US/docs/MDN/Community/Contributing/Our_repositories) and make sure nobody else has reported the issue.
### Reporting an issue
- Depending on the type of problem you've discovered, report it by filing an issue on one of the followings:
- [documentation](https://github.com/mdn/content/issues/new/choose)
- [translation](https://github.com/mdn/translated-content/issues/new/choose)
- the website's [look and feel](https://github.com/mdn/yari/issues/new/choose)
- the "Try it" [interactive example](https://github.com/mdn/interactive-examples/issues/new/choose) section
- [DOM examples](https://github.com/mdn/dom-examples/issues)
- [Learning area](https://github.com/mdn/learning-area/issues)
- the [browser compatibility](https://github.com/mdn/browser-compat-data/issues/new/choose) information
- Choose the appropriate category to report the issue. For example, to report a content bug, use the [Content issue](https://github.com/mdn/content/issues/new?assignees=&labels=needs+triage&template=content-bug.yml) template in the `mdn/content` repository.
- Provide sufficient information while reporting the issue:
- **Issue title** must convey succinctly the _required action_.
- **Issue description** must clearly describe the bug and the action required to resolve the issue. It must also list the task or sub-tasks to be completed to resolve the issue. Some other guidelines include:
- Use the description field to indicate the status of the task or sub-tasks by using checklists.
- Update the status of a task in the issue description instead of commenting on the issue. Use [task lists](https://docs.github.com/en/get-started/writing-on-github/working-with-advanced-formatting/about-task-lists) in the description if an issue has multiple parts. This helps others who may otherwise need to scroll through comments on the issue to determine the status of various tasks.
- Comments in an issue should be limited to details or context that help resolve the issue.
- If the information you provide in the issue is incomplete, then you might be contacted later during the [issue triaging process](#review_issue_to_determine_completeness_of_information).
- If you find yourself in one of the following situations, move the conversation to [MDN's discussion on GitHub](https://github.com/orgs/mdn/discussions):
- A discussion needs to take place to clarify an issue.
- A discussion begins after opening the issue.
- The issue has no clear consensus on its resolution.
- The requirements for completing the task expand while it's being resolved or the work is unclear.
- For minor and small bugs, you can [make the changes yourself](#fixing_issues_yourself) and submit a pull request.
### Creating a task list issue
If the issue you're opening is not to report a bug but to perform a series of tasks, you can create the issue as a [task list](https://docs.github.com/en/get-started/writing-on-github/working-with-advanced-formatting/about-task-lists).
Explain the context or reason for performing the tasks in the description.
Ensure that you list all the actionable tasks as a checklist.
For example:
```markdown
// Issue title
Ensure sections follow the order defined in the CSS property template
### Description
The CSS property page template is defined [here](https://developer.mozilla.org/en-US/docs/MDN/Writing_guidelines/Page_structures/Page_types/CSS_property_page_template).
The task list in this issue will be used to compare the documented CSS properties with the template and track changes to the property pages for compliance.
### List of pages checked
- [x] [accent-color](/en-US/docs/Web/CSS/accent-color) - checked, okay
- [ ] [backdrop-filter](/en-US/docs/Web/CSS/backdrop-filter)
- [ ] [letter-spacing](/en-US/docs/Web/CSS/letter-spacing) - open pull request to move `Accessibility concerns` and `Internationalization concerns` sections before the `Specifications` section.
```
## Guidelines for working on an issue
Remember that if you take on an issue, the expectation is for the work to be completed in a timely manner. If you're not able to make any progress for a week after being assigned or can no longer complete the required task, leave a comment and unassign yourself from the issue.
These are the general steps for working on an issue:
1. **Find an issue:** If you're looking to contribute, search for issues with [`good first issue`, `help wanted`](#set_other_labels) or [`p3`](#set_a_priority_label) label. Most repositories have issues with these labels. You are welcome to browse and pick an issue that is suitable for your skill set. Another useful place to look for issues to work on is the [MDN Contributors Task Board](https://github.com/orgs/mdn/projects/25). This project view lists open issues from multiple repositories. You can filter the list based on the topics (`Labels` column) you're interested in. See the description of some of the [labels](#set_other_labels) that get applied during the issue triage process.
> **Note:** An issue with the `needs triage` label indicates that the MDN Web Docs core team has not reviewed the issue yet, and you shouldn't begin work on it.
2. **Assign the issue to yourself:** After finding an issue you'd like to work on, make sure that the issue is not assigned to anybody else. Add a comment saying you would like to work on the issue, and if you are able to, [assign the issue to yourself](https://docs.github.com/en/issues/tracking-your-work-with-issues/assigning-issues-and-pull-requests-to-other-github-users#assigning-an-individual-issue-or-pull-request).
3. **Do the research:** Most issues need some investigation before work can start.
- Scope out the work that needs to be done. If you need to ask questions, ask them in the [MDN Web Docs chat rooms](/en-US/docs/MDN/Community/Communication_channels#chat_rooms).
- If the issue is well-described, and the work is pretty obvious, go ahead and do it.
- If the issue is not well-described, and/or you are not sure what is needed, feel free to @mention the poster and ask for more information.
4. **Make the changes:** Fork and branch the repository. Do your work and open a [pull request](/en-US/docs/MDN/Community/Pull_requests) in the repository. [Reference the issue](https://docs.github.com/en/issues/tracking-your-work-with-issues/linking-a-pull-request-to-an-issue) in the pull request description. Depending on the files you've updated in the pull request, a reviewer will be assigned to your pull request automatically. (Teams per topic area are defined in the [CODEOWNERS](https://github.com/mdn/content/blob/main/.github/CODEOWNERS) file).
After opening the pull request, if you find you no longer have the time to make changes or incorporate review feedback, let the team know as soon as possible in a comment in the pull request. This will help the team assign another interested contributor to complete the work on the pull request and close the linked issue.
5. After your pull request has been reviewed and merged, you can mark the linked issue as closed. If you opened the pull request with `Fixes #<issue>` verbiage, the issue will be closed automatically when the pull request is merged.
### Fixing issues yourself
If you spot a bug — whether it's a problem with the website's look and feel or an error in documentation — you can try to fix it yourself. Learn how you can contribute by going through our [contribution guide](https://github.com/mdn/content/blob/main/CONTRIBUTING.md).
If the bug is small, such as a typo or a minor sentence improvement, or involves an uncontroversial fix, submit a pull request with the changes.
For all other type of bugs, begin by [opening the issue](#guidelines_for_reporting_an_issue). Add a comment about your intent to work on the issue and if possible, describe your proposed solution or steps to fix the issue.
Wait for the issue to be triaged, so that the MDN Web Docs team can verify that the issue is legit and approves your proposed solution.
> **Note:** If you open a pull request before the issue has been triaged, your time and effort might go waste if the linked issue is deemed invalid or the solution does not match the one expected by the MDN Web Docs team.
> After the issue is triaged, assign the issue to yourself.
Using the [guidelines on working on an issue](#guidelines_for_working_on_an_issue), try to fix the problem by updating the appropriate source, such as:
- The MDN Web Docs content (in English) in the [content](https://github.com/mdn/content) repository
- The MDN Web Docs translated content in the [translated-content](https://github.com/mdn/translated-content) repository
- The MDN Web Docs website look and feel in the [yari](https://github.com/mdn/yari) repository
Each repository includes useful information to guide you on how to contribute.
## Guidelines for triaging issues
If you are a maintainer or an owner in the MDN Web Docs GitHub organization, you are responsible for triaging issues in one or more MDN Web Docs repository.
The overall process for triaging includes some [general](#general_triaging_tasks) and some [issue-specific tasks](#issue-specific_triaging_tasks).
### General triaging tasks
- When an issue is opened, the `needs triage` label is set on the issue automatically. You can search for this label to look for issues that [need to be triaged](#issue-specific_triaging_tasks). Contributors or anybody else should not work on the issue until the issue has been triaged. (Triagers should remember to remove the `needs triage` label after triaging the issue.)
- In the [mdn/content repository](https://github.com/mdn/content/issues), an additional `Content:` label, such as `Content:CSS` or `Content:WebAPI`, is set on the issue automatically. This gets set based on the MDN URL mentioned in the issue. You can use the content-specific label to look for issues to be triaged in your specific topic area.
- If an issue concerns an active, non-en-US locale, set the appropriate label, such as `l10n-fr`, `l10n-zh`, or `l10n-ja`. The teams for those locales will pick these issues up and triage them.
- You don't need to actively triage issues all the time. Set aside time, say 30 minutes every week, to triage issues on a regular basis in your area of responsibility. Triaging doesn't have to be done as part of a synchronous meeting or even at the same time as everyone else, but it should be done regularly to make sure that the backlog of untriaged bugs doesn't get too high.
- Apart from triaging incoming issues every week, review the list of old bugs to see if there are any that are stalled, need closing, or are no longer relevant. The `idle` label is automatically set on issues that have had no activity for 30 days.
- Check assigned issues that are still open to see if the assignee is making progress. If there is no progress after a week of being assigned, ask them if they still have time to work on the issue. If another week passes by without any progress, unassign them and leave a comment indicating that you're making the issue available for other interested contributors.
- If a pull request has been opened to fix the issue but has not been reviewed for a week, give the reviewer a gentle ping to ask if they can get to it.
- If a pull request to fix the issue is waiting on review comments to be addressed after a week, then ask the author if they can respond to their review. If another week goes by, either fix the review comments yourself if you have time, or close the pull request and unassign the related issue.
### Issue-specific triaging tasks
These are the guidelines to follow while triaging each issue.
#### Review if the issue is valid
These are some of the things to keep in mind while reviewing the validity of an issue:
- Check if the issue raised is valid and if the fix will improve the content for the readers and the website.
- Evaluate if the impact of the fix will be small or site-wide.
- Evaluate if the fix for the issue will need a discussion first, in which case, point the author to open a [discussion](https://github.com/orgs/mdn/discussions) instead.
- Check if the issue complies with our [writing guidelines](/en-US/docs/MDN/Writing_guidelines/Writing_style_guide) and [templates](/en-US/docs/MDN/Writing_guidelines/Page_structures/Page_types).
- Check whether suggestions for adding links comply with our [external links policy](/en-US/docs/MDN/Writing_guidelines/Writing_style_guide#external_links).
#### Review the issue for completeness of information
Review each issue against the following checklist to ensure that the issue contains the described information for someone to start working on the bug:
- URL of the MDN Web Docs page with the problem or URL of an example MDN Web Docs page if the problem exists on multiple pages
- The specific heading or section on the MDN Web Docs page where the problem was found
- A clear description of the incorrect, unhelpful, incomplete, or missing information
If any of the above information is not present, then you should ask the author of the issue to provide these details, and add the `needs info` label to the issue. Resume triaging the issue only after those details have been provided (after which, you can remove the `needs info` label). It is okay to wait for up to a week to get a response from the author.
#### Set a priority label
For each bug, set a priority label based on the severity of the issue to help people who want to work on the most important issues or areas.
- Critical issue: This type of issue needs to be fixed as soon as possible, regardless of where it appears on the site. This type of issue could damage MDN's reputation severely and/or harm users. Examples of this issue include an incorrect code snippet, which if used in production, could create a severe security problem and undesirable content such as malware, profanity, pornography, hate speech, or links to such content.
- Label: `p0` (will be addressed immediately)
- Major issue: This type of issue could severely affect a page's usefulness. For example, a significant amount of out-of-date information, a complex and important code example that doesn't work, a significant amount of prose that is badly written and hard to understand, or a large number of broken links.
- Labels: `p1` (will be addressed soon) and `p2` (will be addressed soon, but higher priority items will take precedence)
- Minor issue: This is a type of improvement issue that can make the existing content better but does not affect learning or only has a minor effect on learning. Since these types of issues are not actively planned for, help from contributors to fix these issues is welcome and much appreciated. Fixing some of these issues can also provide the necessary practice to beginner contributors who are starting to get familiar with the contribution process. Examples include typos, bad grammar, a broken link, a small amount of out-of-date information or badly-written prose, or a code snippet that doesn't work.
- Labels: `p3` (no visibility when the issue will be addressed)
In general, critical issues should be fixed immediately and are most likely handled by MDN Web Docs staff and peers.
#### Add helpful information
If possible, add information that can help contributors to fix the issue. The information can be in the form of steps, general approach, links to other similar fixed issues, or reading resources. A well-laid out plan or steps is especially required in issues that are labeled `good first issue` and can help ramp up new contributors quickly. You can time-box this task to 5-10 minutes.
For example, as a triager, you can add the following information to the issue you are triaging:
```md
To whoever fixes this issue, it looks like the following is needed:
- Update the first paragraph below heading X to correct the problem with Y
- Add a description of X
- Update the compatibility data at Link-X
```
#### Set other labels
Next, set the following labels as appropriate:
- `effort: small`, `effort: medium`, `effort: large`: Some contributors like to search for bugs based on the time and effort that will be needed to fix the bug. So where possible, you should try to provide an estimate of the required effort.
- `good first issue`: Set this label on the issue if the fix for the issue is really simple and if fixing the issue would provide good practice for a newcomer who is getting used to the process.
- `help wanted`: Set this label if the issue requires help from someone who knows about or is familiar with the topic. This is a popular label and some contributors use it to search for issues to work on in open source projects in their areas of familiarity or expertise.
- `broken link external`: Set this label if the issue involves a broken link to an external page.
- `document not written`: Set this label if the issue involves a necessary document that has not been written yet, usually because a link points to it.
- `needs content update`: Set this label if the issue fix in another repository will need an equivalent fix in the `mdn/content` repository.
> **Note:** After the triage process is complete, remove the `needs triage` label.
| 0 |
data/mdn-content/files/en-us/mdn/community/issues | data/mdn-content/files/en-us/mdn/community/issues/content_suggestions_feature_proposals/index.md | ---
title: Proposing new content or features
slug: MDN/Community/Issues/Content_suggestions_feature_proposals
page-type: mdn-community-guide
---
{{MDNSidebar}}
We are always interested in hearing from our community about new content or feature suggestions you may have for MDN Web Docs. However, even though we are open to suggestions, we have to keep the following in mind:
- MDN Web Docs is run and managed by a small internal team. We also rely heavily on our partners and community to help us keep MDN Web Docs the best resource for web developers on the web. As such, we will sometimes have to say no to new content or features because we will simply be unable to maintain them long-term.
- MDN Web Docs is also focused on documenting open web standards; some content might not be a good fit. This does not mean the idea or content is not good, just that MDN Web Docs is not the best place for it.
Keeping that in mind, if you _do_ want to propose content or features for MDN Web Docs, please follow the below steps.
## Open a content suggestions and feature proposal issue
When you go to open a [new issue](https://github.com/mdn/mdn/issues/new/choose), you will find a template called "New content or feature suggestions." This is the issue template to use when suggesting new content or features. The issue template does require quite a bit of information but is very deliberate.
1. It ensures we have all the information we need to review your proposal without much back and forth.
2. It helps you to think through your proposal as you complete the form.
Once you have completed the form and submitted the issue, a core team member will get back to you within a week to two weeks, depending on the complexity of your proposal.
## Participate in the discussion and wait for approval
If we feel the proposal might be a good fit, we will [start a discussion](https://github.com/orgs/mdn/discussions) on our MDN community discussions repository. This is to get input from our partners and the wider community. We encourage you to monitor the discussion and join in as appropriate.
## Opening an issue
Suppose a consensus is reached that this is content we want to add or a feature we want to build. In that case, we will open an issue against the appropriate repository referencing the original proposal and the discussion and fill in any gaps so the issue is clearly actionable.
## Work is assigned
At this point, the work will be prioritized and assigned to those responsible for ensuring it is implemented and reviewed.
## Open pull request
Once the work is ready for review, a pull request should be opened, which again references the proposal, discussion, and issue. This ensures that we always have the full context of the work. Finally, the required people will be assigned, and the review process will start.
## Work is reviewed and merged
Here again, depending on the complexity of the content or feature, the review stage can be lengthy. We ask for your patience and that you continue to be involved as appropriate. Once we have approval from at least two internal team members, we are ready to merge the pull request.
This will conclude the entire process, and the content or feature will be available on MDN Web Docs.
| 0 |
data/mdn-content/files/en-us/mdn/community | data/mdn-content/files/en-us/mdn/community/contributing/index.md | ---
title: Contributing to MDN Web Docs
slug: MDN/Community/Contributing
page-type: mdn-community-guide
---
{{MDNSidebar}}
- [Getting started](/en-US/docs/MDN/Community/Contributing/Getting_started)
- [Our repositories](/en-US/docs/MDN/Community/Contributing/Our_repositories)
- [Translated content](/en-US/docs/MDN/Community/Contributing/Translated_content)
- [Security vulnerability response](/en-US/docs/MDN/Community/Contributing/Security_vulnerability_response)
| 0 |
data/mdn-content/files/en-us/mdn/community/contributing | data/mdn-content/files/en-us/mdn/community/contributing/translated_content/index.md | ---
title: MDN Web Docs Localization
slug: MDN/Community/Contributing/Translated_content
page-type: mdn-community-guide
---
{{MDNSidebar}}
Since December 14th 2020, MDN has been running on the new GitHub-based [Yari platform](https://github.com/mdn/yari). This has a lot of advantages for MDN, but we've needed to make radical changes to the way in which we handle localization. This is because we've ended up with a lot of unmaintained and out-of-date content in our non-English locales, and we want to manage it better in the future.
We have archived all locales, EXCEPT for the ones listed below, meaning that they are read-only on GitHub and cannot be viewed on MDN. The active locales have dedicated teams taking responsibility for maintaining them.
## How to contribute
If you want to contribute to one of the existing active locales, check out the [mdn/translated-content GitHub repository](https://github.com/mdn/translated-content). This repository contains all of the localized documents for all active locales, as well as issue tracking. We recommend reading the [translation guide](https://github.com/mdn/translated-content/tree/main/docs) first.
If you need help or have any questions, feel free to get in touch with one of the active members or communities listed below, or [contact us](/en-US/docs/MDN/Community/Communication_channels).
## Active locales
### Brazilian Portuguese (`pt-BR`)
- Discussions: [Telegram (`MDN localization in Brazilian Portuguese`)](https://t.me/mdn_l10n_pt_br)
- Current maintainers: [Nathália Pissuti](https://github.com/nathipg), [Josiel Rocha](https://github.com/josielrocha), [Clóvis Lima Júnior](https://github.com/clovislima)
### Chinese (`zh-CN`, `zh-TW`)
- Discussions: [Telegram (`Mozilla China`)](https://t.me/mozilla_china), [Telegram (`MozTW L10n`)](https://moztw.org/community/telegram/)
- Current maintainers: [Irvin](https://github.com/irvin), [t7yang](https://github.com/t7yang), [yin1999](https://github.com/yin1999), [jasonren0403](https://github.com/jasonren0403)
### French (`fr`)
- Discussions: [Matrix (`#l10n-fr`)](https://chat.mozilla.org/#/room/#l10n-fr:mozilla.org)
- Current maintainers: [cw118](https://github.com/cw118), [SphinxKnight](https://github.com/SphinxKnight), [tristantheb](https://github.com/tristantheb)
### Japanese (`ja`)
- Discussions: [Slack (`#translation`)](https://mozillajp.slack.com/), [GitHub (`mozilla-japan`)](https://github.com/mozilla-japan/translation), [Google Group (`mozilla-translations-ja`)](https://groups.google.com/forum/#!forum/mozilla-translations-ja)
- Current maintainers: [mfuji09](https://github.com/mfuji09), [hmatrjp](https://github.com/hmatrjp), [potappo](https://github.com/potappo), [dynamis](https://github.com/dynamis), [kenji-yamasaki](https://github.com/kenji-yamasaki)
### Korean (`ko`)
- Discussions: [Discord (`#korean`)](/discord), [Kakao Talk (`#MDN Korea`)](https://open.kakao.com/o/gdfG288c)
- Current maintainers: [hochan222](https://github.com/hochan222), [yechoi42](https://github.com/yechoi42), [cos18](https://github.com/cos18), [GwangYeol-Im](https://github.com/GwangYeol-Im), [pje1740](https://github.com/pje1740), [yujo11](https://github.com/yujo11), [wisedog](https://github.com/wisedog), [swimjiy](https://github.com/swimjiy), [jho2301](https://github.com/jho2301), [sunhpark42](https://github.com/sunhpark42)
### Russian (`ru`)
- Discussions: [Matrix (`#mdn-l10n-ru`)](https://chat.mozilla.org/#/room/#mdn-l10n-ru:mozilla.org)
- Current maintainers: [leon-win](https://github.com/leon-win), [sashasushko](https://github.com/sashasushko), [Saionaro](https://github.com/Saionaro), [yanaklose](https://github.com/yanaklose), [myshov](https://github.com/myshov), [lex111](https://github.com/lex111)
### Spanish (`es`)
- Discussions: [Matrix (`#mdn-l10n-es`)](https://chat.mozilla.org/#/room/#mdn-l10n-es:mozilla.org), [Telegram (`MDN l10n ES`)](https://t.me/+Dr6qKQCAepw4MjFj)
- Current maintainers: [JuanVqz](https://github.com/JuanVqz), [davbrito](https://github.com/davbrito), [Graywolf9](https://github.com/Graywolf9), [Vallejoanderson](https://github.com/Vallejoanderson), [marcelozarate](https://github.com/marcelozarate), [Jalkhov](https://github.com/Jalkhov)
## See also
- [MDN localization update, February 2021](https://hacks.mozilla.org/2021/02/mdn-localization-update-february-2021/) — the latest state of localization on MDN
- [An update on MDN Web Docs' localization strategy](https://hacks.mozilla.org/2020/12/an-update-on-mdn-web-docs-localization-strategy/) — updated strategy based on community feedback
- [MDN Web Docs evolves! Lowdown on the upcoming new platform](https://hacks.mozilla.org/2020/10/mdn-web-docs-evolves-lowdown-on-the-upcoming-new-platform/) — more on the advantages of the new platform, and the rationale behind the localization changes
- [MDN communication channels](/en-US/docs/MDN/Community/Communication_channels)
| 0 |
data/mdn-content/files/en-us/mdn/community/contributing | data/mdn-content/files/en-us/mdn/community/contributing/our_repositories/index.md | ---
title: MDN Web Docs Repositories
slug: MDN/Community/Contributing/Our_repositories
page-type: mdn-community-guide
---
{{MDNSidebar}}
[MDN Web Docs](/) is a complex project with lots of moving parts. It's a good idea to get familiar with the projects different repositories. This document intends to help you find the different repositories (repos) you may need when contributing to different parts of the MDN Web Docs project.
## Repository tiers
### Tier 1
Code in these repositories is core to the MDN Web Docs project and runs on Mozilla-owned domains.
- [mdn/content](https://github.com/mdn/content)
- [Yari](https://github.com/mdn/yari)
- [rumba](https://github.com/mdn/rumba)
- [browser-compat-data](https://github.com/mdn/browser-compat-data)
- [interactive-examples](https://github.com/mdn/interactive-examples)
- [bob](https://github.com/mdn/bob)
A Tier 1 project should have at least 3 members, including at least two with admin permissions.
### Tier 2
These repositories are mainly concentrated on supporting content such as code examples, the MDN Web Docs learn area, localization, and examples projects. Examples include:
- [dom-examples](https://github.com/mdn/dom-examples)
- [translated-content](https://github.com/mdn/translated-content)
- [learning-area](https://github.com/mdn/learning-area)
A Tier 2 project should have at least 2 members, including at least one with admin permissions.
### Tier 3
These are repository used for project planning, documenting the project itself, and community engagement. Examples include:
- [mdn-community](https://github.com/mdn/mdn-community)
- [mdn/mdn](https://github.com/mdn/mdn)
- [content-team-projects](https://github.com/mdn/content-team-projects)
A Tier 3 project needs 1 admin.
## Core repos
- **Core content**: <https://github.com/mdn/content>. The most important repo for MDN Web Docs content — this is where all the core English content of the site is stored, and where you'll make all standard changes to page content.
- **MDN Web Docs Platform**: <https://github.com/mdn/yari>. This is where the MDN Web Docs platform is stored, and where you'll go if you want to make changes to our high level page structure or rendering machinery.
- **Browser compatibility data**: <https://github.com/mdn/browser-compat-data>. This is where the data used to generate the browser compatibility tables found on our reference pages is stored ([example](/en-US/docs/Web/HTML/Element/progress#browser_compatibility)). If you have information about browser compatibility of Web features — or are willing and able to do some research and/or experimentation — you can help update MDN's [Browser Compatibility Data](https://github.com/mdn/browser-compat-data/blob/main/docs/contributing.md)
- **Interactive examples**: <https://github.com/mdn/interactive-examples>. This repo stores the example code blocks that are found at the top of many of our reference pages ([example](/en-US/docs/Web/JavaScript/Reference/Global_Objects/globalThis)). Edit those examples here.
- **Bob** aka Builder of Bits: <https://github.com/mdn/bob>
This repo stores the rendering code that produce the nice editable, copyable examples found at the top of many of our reference pages ([example](/en-US/docs/Web/JavaScript/Reference/Global_Objects/globalThis)).
- **Translated content**: <https://github.com/mdn/translated-content>. This is where localized content lives. Go here if you want to help translate pages into any of our [actively maintained locales](https://github.com/mdn/translated-content#locales).
- **Workflows**: <https://github.com/mdn/workflows>
A growing collection of reusable GitHub Actions for use on MDN Web Docs repositories.
## Code example
### Code examples and demos
[//]: # "TODO: UPDATE WITH REPO TRIAGE"
The MDN Web Docs GitHub org contains a huge number of example repos. These generally contain freestanding code examples that are often linked to from our pages, but occasionally you'll find one of these examples embedded into a page using a macro call like this — `\{{EmbedGHLiveSample("css-examples/learn/tasks/grid/grid1.html", '100%', 700)}}`.
Always remember, if you are updating the code on any given page, you'll need to update the corresponding example repo as well.
- [**dom-examples**](https://github.com/mdn/dom-examples)
- [**css-examples**](https://github.com/mdn/css-examples)
- [**webaudio-examples**](https://github.com/mdn/webaudio-examples)
- [**webassembly-examples**](https://github.com/mdn/webassembly-examples)
- [**indexeddb-examples**](https://github.com/mdn/indexeddb-examples)
- [**js-examples**](https://github.com/mdn/js-examples)
- [**html-examples**](https://github.com/mdn/html-examples)
- [**web-components-examples**](https://github.com/mdn/web-components-examples)
- [**webextension-examples**](https://github.com/mdn/webextensions-examples)
- [**pwa-examples**](https://github.com/mdn/pwa-examples)
- [**houdini-examples**](https://github.com/mdn/houdini-examples)
- [**headless-examples**](https://github.com/mdn/headless-examples)
- [**perf-examples**](https://github.com/mdn/perf-examples)
- [**devtools-examples**](https://github.com/mdn/devtools-examples)
| 0 |
data/mdn-content/files/en-us/mdn/community/contributing | data/mdn-content/files/en-us/mdn/community/contributing/getting_started/index.md | ---
title: Getting started with MDN Web Docs
slug: MDN/Community/Contributing/Getting_started
page-type: mdn-community-guide
---
{{MDNSidebar}}
We are an open community of developers, technical writers, and learners building resources for a better Web, regardless of brand, browser, or platform. Anyone can contribute, and each person who does contribute makes us stronger. Together we can continue to drive innovation on the Web to serve the greater good. It starts here, with you.
[Join us!](/en-US/docs/MDN/Community/Communication_channels)
## What can I do to help?
There are multiple avenues you can take to contribute to MDN, depending on your skill set and interests. Therefore, along with each task, we provide a short description and an approximate time each type of task typically takes.
> If you're unsure what to do, you can always ask for help in one of [our communication channels](/en-US/docs/MDN/Community/Communication_channels).
> Also note that our small but mighty docs team maintains this repo. To preserve our bandwidth, off-topic conversations will be closed.
## Primary contribution types
We have created a [contributors task board](https://github.com/orgs/mdn/projects/25/views/1) to help you find contribution opportunities that will meaningfully impact the project. The board has an overview and separate views for specific contribution types.
### Getting ready to contribute
To contribute, you will need a GitHub account. If you do not already have one, go ahead and [sign up](https://github.com/signup) for an account before continuing. If you are new to GitHub, we encourage you to take the following free, self-paced courses and reading material offered by GitHub. With this knowledge, you can focus on your contributions and not learn a new tool at the same time.
> NOTE: Do not feel overwhelmed or like you have to read through and complete _all_ of the course work. With the knowledge gained from the "Introduction to GitHub" course, you will be well on your way.
- [Introduction to GitHub](https://github.com/skills/introduction-to-github)
- [Setting up Git](https://docs.github.com/en/get-started/quickstart/set-up-git)
- [GitHub workflow](https://docs.github.com/en/get-started/quickstart/github-flow)
- [Using Markdown](https://github.com/skills/communicate-using-markdown)
### Additional reading and learning material
- [Basic etiquette for open source projects](/en-US/docs/MDN/Community/Open_source_etiquette): If you've never contributed to an open source project before, we encourage you to read this document.
- [Learn web development](/en-US/docs/Learn): If you are new to HTML, CSS, JavaScript, we have some great content to help you get started.
- [Deep dive into collaborating with pull requests](https://docs.github.com/en/pull-requests/collaborating-with-pull-requests)
Some writing-specific contribution opportunities will require a reasonable understanding of the English language. That said, do not let perfect be the enemy of "good enough." Even if your grammar isn't good, don't worry about it! We have a team of people who aim to ensure that MDN's contents are as good as possible. In addition, someone will be along to ensure your work is tidy and well-written.
Once you've decided what kind of task you want to work on, it is time to head over to the [contributors task board](https://github.com/orgs/mdn/projects/25/views/1), pick an issue, and let us know by commenting on the issue and tagging the `@mdn/mdn-community-engagement` team. Someone from the team will respond and assign the issue to you.
This ensures that two people do not work on the same issue, and you will know who to contact should you get stuck.
### Contributions
When contributing, you agree to make your contributions available under the [Attribution-ShareAlike license](https://creativecommons.org/licenses/by-sa/4.0/) (or an alternative license already specified by the page you are editing). In addition, code samples are available under [Creative Commons CC-0](https://creativecommons.org/share-your-work/public-domain/cc0/) (a Public Domain dedication).
> If you have any questions or concerns about anything discussed here, please [contact us](/en-US/docs/MDN/Community/Communication_channels).
| 0 |
data/mdn-content/files/en-us/mdn/community/contributing | data/mdn-content/files/en-us/mdn/community/contributing/security_vulnerability_response/index.md | ---
title: Security vulnerability response steps
slug: MDN/Community/Contributing/Security_vulnerability_response
page-type: mdn-community-guide
---
{{MDNSidebar}}
## A little history
On ~27 November 2018 an npm security vulnerability was announced for all users that depend, either directly or indirectly, on the [event-stream](https://snyk.io/blog/malicious-code-found-in-npm-package-event-stream) package. It was a very targeted attack, that only activated if the Copay bitcoin wallet was installed, whereupon it tried to steal the contents.
Two of our projects, namely [interactive-examples](https://github.com/mdn/interactive-examples/) and [BoB](https://github.com/mdn/bob/), depend on an npm package called [npm-run-all](https://www.npmjs.com/package/npm-run-all), which in turn depended on the event-stream package.
This meant that not only was staff at risk, but people who have forked either of these repositories might have been affected as well. Thankfully the maintainers of the affected package reacted swiftly and released an update to address the issue. Because we have the [Renovate bot](https://github.com/marketplace/renovate) running against these repositories, there was a [pull request](https://github.com/mdn/interactive-examples/pull/1239/) ready to merge.
This only resolved one part of the problem though. Our users still needed to be notified.
## Steps taken
The community for especially the interactive-examples project was rather large, and not everyone active, but we still needed a way to reach out to everyone. The first step was then to open an issue against each of the repositories detailing the problem:
- [interactive-examples](https://github.com/mdn/interactive-examples/issues/1242)
- [bob](https://github.com/mdn/bob/issues/184)
That by itself is not enough as users do not necessarily actively monitor issues. We, therefore, needed to look at all of the [forks](https://github.com/mdn/interactive-examples/network/members) of the project.
We then copied all of the usernames for these users and pinged them on the above issue, for example by [commenting](https://github.com/mdn/interactive-examples/issues/1242#issuecomment-442110598) in it.
This was very effective, judging from the responses the issue received, but we could not leave it there. The next step was to post a comment on each of the open pull requests informing the user of the problem and what their next steps should be. Here is an [example](https://github.com/mdn/interactive-examples/pull/1144) of our answer.
With this, we felt rather confident that between us reaching out, and coverage of the issue online by npm and other channels, would ensure that we ensured our users are safe.
As a final step, we tweeted from our official Twitter account to raise awareness of the issue.
### In closing
Hopefully, these types of incidents will be few and far between. Should this happen again however, the above provides a solid guideline on how to respond.
| 0 |
data/mdn-content/files/en-us/mdn/community | data/mdn-content/files/en-us/mdn/community/pull_requests/index.md | ---
title: Pull request submission and review guidelines
slug: MDN/Community/Pull_requests
page-type: mdn-community-guide
---
{{MDNSidebar}}
This document describes how contributors make changes to MDN Web Docs and how the changes are reviewed and land on the site.
Content changes to MDN Web Docs include:
- **Day-to-day improvements** for the documentation of APIs, CSS properties, platform updates and content additions.
This is usually done by MDN Web Docs staff working for Mozilla, Google, Open Web Docs, Samsung, but also by community volunteers.
- **Minor fixes** and small updates to the site for fixing typos, grammatical issues, and technical inaccuracies.
These issues are usually found by readers of MDN Web Docs.
- **Content bug fixes**, usually done by volunteers to close [issues on the `mdn/content` repository](https://github.com/mdn/content/issues).
Regardless of how content changes are done, they are submitted as pull requests on GitHub.
The content changes go through the following stages before they are published on MDN Web Docs:
1. **Submitting changes:** As a pull request author, you submit changes via opening a pull request.
See the sections [Before you start](#before_you_start), [Open a pull request](#open_a_pull_request), and [After you open a pull request](#after_you_open_a_pull_request) to learn more about our processes.
2. **Reviewing changes:** Your changes are reviewed by MDN members and volunteers.
See the section [Pull request review process](#pull_request_review_process) for more details.
3. **Viewing published changes:** Content updated on `mdn/content` goes live within a day of merging via a site rebuild once every 24 hours.
## Submitting changes
### Values and participation
We want MDN Web Docs to be a welcoming, friendly community that we can all be proud of.
All participants must follow our [Code of Conduct](https://github.com/mdn/content/blob/main/CODE_OF_CONDUCT.md) which means adhering to [Mozilla's Community Participation Guidelines](https://www.mozilla.org/en-US/about/governance/policies/participation/).
Be polite and constructive when opening pull requests, writing review comments, interacting with the pull request author or other community members.
If you or someone else has experienced behavior that is potentially illegal or makes you feel unsafe, unwelcome, or uncomfortable, we encourage you to [report it](https://www.mozilla.org/en-US/about/governance/policies/participation/reporting/).
### Before you start
Before you start work on MDN, please go through the recommendations and guidelines listed below.
**Pull requests must resolve or partially fix an existing issue.**
The reason why we have this restriction is to avoid that you start on any kind of task that someone else might already be working on.
Search through issues and pull requests in the [MDN repository](https://github.com/orgs/mdn/repositories) you want to contribute to and confirm that the work you want to start is not already being worked on.
When looking to contribute to the MDN project, you will find yourself in one of the following situations:
- **If you are looking to contribute to the project**, you can find tasks under 'Issues' in any of the [MDN GitHub repositories](https://github.com/orgs/mdn/repositories) (for example, [`mdn/content` issues](https://github.com/mdn/content/issues)) and our [public GitHub project boards](https://github.com/orgs/mdn/projects).
Make sure the issue isn't assigned to someone and no one has already opened a pull request for the task.
Issues labelled with `good first issue` are a good place to start.
- **If you have found a problem on MDN**, you should open an issue first.
**Issues need a response from maintainers before you start working** so that you know a problem addressed by a pull request is valid and that your pull request will be accepted.
More information on issues can be found on our [Community pages for GitHub issues](https://github.com/mdn/mdn/issues/new?labels=proposal%2Cneeds+triage&template=content-or-feature-suggestion.yml&title=Enter+your+proposal+here).
- **If you want to suggest new content or a new feature**, submit a proposal through the 'New content or feature suggestion' [GitHub issue template](https://github.com/mdn/mdn/issues/new/choose).
If you're not sure where to start, reach out to us on [the Discord server](/discord) and ask for feedback.
### Open a pull request
When you're ready to open a pull request, follow these guidelines:
- **Pull requests should be short and focused to one issue:** If possible, group related set of changes into multiple, small pull requests.
If a pull request becomes too large, the reviewer may close it and ask that you to submit pull requests for each logical set of changes that belong together.
- **Add a description of the changes:** Provide as much context and rationale for the pull request as possible.
- **Add the link to the issue you are closing:** In the pull request description, add 'Fixes' if it fully resolves the issue or 'Relates to' if it is a related issue.
More information about linking to issues in pull requests can be found in [GitHub docs](https://docs.github.com/en/issues/tracking-your-work-with-issues/linking-a-pull-request-to-an-issue#linking-a-pull-request-to-an-issue-using-a-keyword).
- **Add 'depends on'** with a link to a dependency if there are pull requests that must be merged first (e.g., code examples in other repositories).
- **Accompany code example changes with content changes:** This is important to ensure that updated examples are served correctly.
If you're making content changes that affect how examples are used, the related code examples should also be updated.
- **Add a reviewer:** You can add a reviewer, such as a team member or a topic owner, if you already know who should review your pull request.
- **Don't make grammar-only changes:**
MDN Web Docs contains technical documentation; you should not suggest prose style changes except where grammar is incorrect.
- **Don't unnecessarily add or remove line breaks** on pages that follow a certain formatting style.
- **Don't enable auto-merge.**
### After you open a pull request
- **Handle CI failures** from the automated tests that run as GitHub Actions (see `.github/workflows`).
If one or more of these tests fail, it is your responsibility to try to resolve them.
If you don't know how to resolve the underlying issues, ask for help.
- **Resolve merge conflicts** with the main branch; you are responsible for resolving these.
You can do this by merging the `mdn/main` branch into your branch.
For more information, see the GitHub documentation on [keeping your branch up to date](https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/proposing-changes-to-your-work-with-pull-requests/keeping-your-pull-request-in-sync-with-the-base-branch#about-keeping-your-pull-request-in-sync).
- **Be responsive to feedback.**
This means being prepared to make changes to the pull request based on the review.
If a review happens and the changes are not made, the pull request may be closed.
- **Be patient during the review process.**
The MDN organization receives a large volume of pull requests and the team may need time to review your contributions.
- **Don't reopen closed pull requests.**
If you must create a new pull request, it can reference the closed one.
## Pull request review process
Reviewer(s) are automatically assigned when you open a pull request based on a `CODEOWNERS` file, but if there is a specific person you want to request review from, you can [request a review](https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/proposing-changes-to-your-work-with-pull-requests/requesting-a-pull-request-review) manually.
We also use auto-labeling on pull requests to help us triage them.
Maintainers can further triage pull requests and add any additional labels, such as `needs-info` or `on-hold`, if needed based on context.
If you want to review a pull request but are not listed as a reviewer, you may add yourself as one.
It's polite to check with existing reviewers first by commenting on the pull request that you intend to start a review.
### Reviewers and assignees
The MDN Web Docs team uses reviewers and assignees to track the status of pull requests.
- **Reviewers** are people that assess the changes in pull request and provide feedback for the author.
- **Assignees** are people responsible for making sure the pull request is not blocked.
Not all pull requests have assignees, but if they do, they are responsible for making sure the pull request progresses.
An assignee helps the work reach a conclusion either by merging, closing, or undertaking unblocking work themselves.
A pull request reviewer or assignee is responsible for merging the changes.
Before you start with a review, check the pull request description to make sure no one specific should review it.
Ensure that all continuous integration (CI) tasks have been completed successfully and that there are no merge conflicts.
If any tasks fail or there are merge conflicts, communicate this to the author; it is their responsibility to address these.
You may set the author as an **assignee** to indicate that a pull request needs their attention before a review can start.
Do leave the door open to the author to ask for help, especially new contributors to the project.
### Reviewing a pull request
When it comes to the changes in a pull request, content and prose must adhere to the [MDN Writing style guide](/en-US/docs/MDN/Writing_guidelines/Writing_style_guide) and example code must follow the [code style guide](/en-US/docs/MDN/Writing_guidelines/Writing_style_guide/Code_style_guide).
When you are reviewing a pull request, you should:
- **Add a comment** to the pull request to let the author know you are aware of the pull request and will start the review.
This is to avoid cases when someone else starts to review the pull request at the same time unnecessarily.
- **Limit the scope of review** to the changes in the pull request only.
Open a follow-up issue or pull request to address other improvements not covered by the pull request.
- **Ask for help** and add the `review-help-needed` label if you need technical assistance with the review.
- **Close pull requests with unrelated changes** if it is too complex or contains multiple unrelated changes.
In such cases, ask the pull request author to submit their changes in smaller chunks.
- **Request load balancing** if your plate is full and you don't have bandwidth for the review.
Tag the `@core-yari-content` team and ask if someone else can step in.
- **Don't merge unless 'depends on'** pull requests are merged first.
- **Don't merge pull requests that have failing tests.**
It is good [open source etiquette](/en-US/docs/MDN/Community/Open_source_etiquette) to keep the `main` branch stable to avoid disruption for contributors, maintainers, and for automated processes.
An unstable `main` branch blocks all other pull requests and makes it difficult for others to review and merge contributions.
In addition, contributors who watch repositories receive high volumes of notifications and unnecessary noise caused by failing tests can be frustrating.
If you are not sure how to fix the failing tests, [ask for help](/en-US/docs/MDN/Community/Communication_channels) or assign the pull request to someone else.
If a pull request looks good apart from small typos or other minor issues, you may want to fix the problem directly.
You can do this provided the pull request [has been set up to allow changes](https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/working-with-forks/allowing-changes-to-a-pull-request-branch-created-from-a-fork).
It's recommended to use [comments with suggestions](https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/reviewing-changes-in-pull-requests/commenting-on-a-pull-request#adding-line-comments-to-a-pull-request) for fixing minor issues, as they can be batched and committed in one go.
When submitting your review you have three options, **approve**, **comment**, or **request changes**.
The following sections explain when to use each option.
### Requesting changes
Use the request changes option when the feedback you provided _needs_ to be addressed by the author and re-reviewed by the reviewer before the pull request can be approved and merged.
#### Comment
Use the comment option when your feedback is not critical and will not require a re-review.
In short, you trust the author and other reviewers to use good judgment.
#### Approve
Use the approve option when everything looks good and is ready to merge from your perspective.
After submitting your review, you can safely merge the pull request if there are no other reviewers or any outstanding review comments to address.
#### What to do if you are stuck
If you don't understand a content change or feel that it is too large and complex for you to deal with, don't panic!
A good place to start is by asking for information from the pull request author to help.
It is rare that you'll be required to review a large, complex content change with no warning.
If this does happen, however, the pull request description should link to an issue that explains the background information.
If you are still not sure or if you think the content is suspicious, reach out to the MDN Web Docs team and ask for help.
### Guidelines for turnaround times for authors and reviewers
This section provides details for expected turnaround times while responding to review comments if you're a pull request author and while reviewing pull requests if you're a reviewer.
- **Reviewing**:
The pull request reviewer should be able to review the changes in 2 weeks or less.
In the 2 weeks after a pull request is open, the reviewer can:
- Leave a comment about when they can start reviewing the pull request
- Ask for technical or resource help
- **Addressing requested changes:**
The pull request author should be able to respond to or fix the comments in 4 weeks or less.
If the pull request author is unable to respond or fix the review comments in that time, the reviewer can do one of the following:
- Commit the changes and merge the pull request
- Close the pull request
### External reviewers
Some pull requests on the MDN content repo relate to specific work by browser vendors or organizations with defined authors and reviewers.
The author will include the username of the reviewer in a line at the bottom of the pull request description in these cases, for example:
```md
reviewer: @jpmedley
```
If you receive a review request and you have been overridden with another reviewer in the manner described above, do not review the changes.
Once the reviewer mentioned in the description has approved the changes, they will ask for an approval required by the `CODEOWNERS`.
## Reading list
Reviewers are encouraged to read the following articles for help with common tasks:
- [The Art of Closing](https://blog.jessfraz.com/post/the-art-of-closing/) explains how to close an unfinished or rejected pull request
- [Kindness and Code Reviews: Improving the Way We Give Feedback](https://product.voxmedia.com/2018/8/21/17549400/kindness-and-code-reviews-improving-the-way-we-give-feedback) gives useful hints to give feedback
- [Code Review Guidelines for the Reviewer](https://phauer.com/2018/code-review-guidelines/#code-reviews-guidelines-for-the-reviewer) provides examples of good and bad feedback
| 0 |
data/mdn-content/files/en-us/mdn/community | data/mdn-content/files/en-us/mdn/community/open_source_etiquette/index.md | ---
title: Open source etiquette
slug: MDN/Community/Open_source_etiquette
page-type: mdn-community-guide
---
{{MDNSidebar}}
If you've not worked on an open source project (OSP) before, it is a good idea to read this article before starting to contribute to MDN Web Docs (or other open source projects). There are a few best practices to adopt that will help ensure that you and the other project contributors feel valued and safe, and stay productive.
This article won't teach you everything about contributing to open source; the aim here is more to give you some good starting points to think about as you get started with open source contributions.
## Think about why you are contributing to an OSP
Before you start contributing to an open source project, ask yourself why you want to do that. It is fine if the answer to this question is just "I'm bored and I want to find something productive to do with my time", but you can probably go deeper than that.
Even better reasons might include:
- I use this tool all the time and found a bug in it/want to help make it better.
- I want to help other people use the tool more successfully.
- I want to help other people contribute to the project more successfully.
- I want to improve my own skills.
- I want to publicly demonstrate my own skills as part of my college or university course.
- I want to publicly demonstrate my own skills to improve my chances of getting a job.
Some of these reasons are self-serving, and that's OK — if you are spending your time working on a project for free, then it is fair to expect to get something out of it. In addition, having a clear set of reasons for contributing will make it easier to decide what to work on first.
Your presence on the project should be productive, and it shouldn't stop others from being so too.
## Be polite, be kind, avoid incendiary or offensive language
We could abbreviate this to "be kind". This is our number one bit of advice for anyone starting open source contributions.
Be kind to the other contributors on the project, and it will be a happier and more productive place. This includes:
- Thanking people if they help you.
- Congratulating people where appropriate (for example if they land their first ever pull request, or fix a particularly difficult bug).
- Always responding respectfully to people, even if you feel like the answer to their question was a bit obvious, or that they are repeating themselves.
- Trying to help people to do better next time, in a supportive way, e.g. during pull request reviews or as you answer their questions. Saying "this is wrong" or "here is the answer" is nowhere near as helpful as saying "This is OK, but I feel that this would be better if you tried doing it more like this, here's a blog post for more ideas" or "you can find the answer here; also check out this link for more common answers".
You and the other contributors are (or should be) here because they want to make a positive contribution to the project, but beyond that, you can't assume anything about them. This includes their:
- Knowledge of the project and the technologies used to build it
- Gender, sexuality, age, languages spoken, location, political views, religion, or other personal attributes
- Experience with open source projects
- Confidence
- Expectations
- Sense of humor
You should therefore keep what you write on topic as much as possible, staying away from potential controversial off-topic subjects like religion or politics, and being supportive and respectful even if you disagree with someone, or don't like a decision they've made.
Also, you should refrain from any swearing / offensive language, even if it is not directed at anyone in particular. It is not needed for participation, and some people are really sensitive to it.
Be aware that there are rules in place in any good OSP to protect its contributors against being made to feel uncomfortable while contributing. This usually comes in the form of a CODE_OF_CONDUCT.md file on GitHub.
For example, MDN's repos are governed by the wide-reaching [Mozilla Community Participation Guidelines](https://www.mozilla.org/en-US/about/governance/policies/participation/). Usually mildly offensive behavior on MDN Web Docs repos (such as constantly being off-topic/disruptive, or being rude) will usually be first responded to by a warning on the repo, followed by a final warning, then a temporary or permanent ban. More serious behavioral problems such as hate speech or threats against another contributor will not be tolerated, and will likely result in an instant ban.
If you receive anything that makes you feel uncomfortable, you should always report it using the mechanism provided on the code of conduct.
## Choose effective contributions
Think about what you want to do on the project. For example, we have a large list of issues filed at on the [contributors task board](https://github.com/orgs/mdn/projects/25/views/1), broken up by various task types.
You could also contribute by opening [pull requests](/en-US/docs/MDN/Community/Pull_requests) to fix problems that you come across while reading MDN articles.
A lot of the work on MDN revolves around writing documentation and code examples, but there are other ways to contribute too:
- Help to triage issues that come in.
- Help fix typos.
- Help to improve grammar and make pages more understandable.
- Help to mentor people that are trying to make fixes.
Every fix is useful, no matter how small, and we won't turn any fix away. Nevertheless, try to make sure your fixes are productive. We'd like to advise against these kinds of contributions:
- Updating code styling just because "you like that style better".
- Updating language style "just because you like that style better".
- Changing pages from US English to British English.
- Adding or removing a bunch of punctuation when there's not really anything wrong.
- Changing the testing framework we are using for something else because you prefer it.
In many cases, things are like they are on OSPs for a reason. You should read their style guides if they have one, and if in doubt about whether something is productive, always ask first!
## Read the manual
Good OSPs will always make contributor documentation readily available. On GitHub projects, it is usually in the repo's CONTRIBUTING.md file, or sometimes in the project's README.md file. Being a documentation project, MDN content has a [README](https://github.com/mdn/content/blob/main/README.md) and a decent set of contributor docs on the site itself (see [Contributing to MDN Web Docs](/en-US/docs/MDN/Community/Contributing)).
Don't be afraid to ask for help, but ALWAYS try to find the answer to your question first before asking. This way you build up your knowledge of the project and become more independent, and don't put unnecessary burden on the other contributors.
Of course, the docs won't always be perfect. If an explanation is hard to find or not described very well, file an issue, or create a pull request to try to fix it yourself.
## Find out where to ask questions
Always find out where the best place is to ask questions. Good OSPs will always make this clear in their docs (see [Get in touch](/en-US/docs/MDN/Community#get_in_touch)). If you want to ask general questions, then always make use of these channels. Don't just file an issue on GitHub for every question, as it adds noise to the project (see "Make progress, not noise" below).
## Make progress, not noise
Think carefully about the way you handle communication in the project — make sure it is useful, and that it doesn't make other contributor's jobs harder. Submitting pull requests to fix bugs is great, but are they truly useful, and easy to review? Filing issues and joining in other conversations is fine, but are your issues and comments on topic, or are they just adding noise?
As a rule, do:
- Discuss one topic per issue — it is easy to keep issues focused and productive.
- Fix one issue per PR — it may be slightly more work for you, but it is much easier to review a single clear fix.
- Contribute to other threads if you have a useful point to make or can answer someone else's question.
- Ask questions using other mechanisms like chat rooms or forums if you are not sure whether something is useful or have a simple question.
- Read the manual first to try to answer the question yourself before asking it.
Don't:
- Complicate issues by trying to discuss multiple topics at once, or making off-topic comments.
- Try to cram multiple fixes into a single pull request. It makes it a lot harder to review, and raises suspicions (some people might think you are trying to hide some malicious code in between the valid changes).
- Open lots of issues asking vague questions.
- Ask questions without trying to solve the problem yourself first.
## OSPs are a democracy (almost)
OSPs are quite democratic — many decisions are voted on, and you are largely free to contribute how you want, as long as you don't impede anyone else from contributing.
However, some things will be largely decided by a small group of core contributors. You are free to make a case against any decision, but sometimes a moderator will make a call that goes against your opinion. You need to respect and accept these decisions.
It is useful to get to know any project's moderators, so you know who best to ask for help, for example in pull requests or issue threads.
## Be patient, be timely
Bear in mind that many people working on OSPs are doing it in their free time, without payment, and all people working on OSPs are generally very busy. If you are waiting for something like a pull request review, or an answer to a question, be patient.
It is reasonable to wait a few days and then ping someone politely to ask if they've had time to look at it. If they happen to be too busy, it may be best to wait a further week and try following up with them then.
It is NOT reasonable to start demanding things, like a quick reply.
If someone is waiting for you to do something for them, you should be extended the same courtesy, but at the same time, try to respond as promptly as you can. If you really can't find the time, let them know, and ask the maintainers to help you find someone else to do the task.
## See also
- [How to Contribute to Open Source](https://opensource.guide/how-to-contribute/)
- [More general freeCodeCamp "How to contribute to open source" list](https://github.com/freeCodeCamp/how-to-contribute-to-open-source)
- [Getting started with contributing to open source](https://stackoverflow.blog/2020/08/03/getting-started-with-contributing-to-open-source/)
| 0 |
data/mdn-content/files/en-us/mdn/community | data/mdn-content/files/en-us/mdn/community/learn_forum/index.md | ---
title: Learn forum
slug: MDN/Community/Learn_forum
page-type: mdn-community-guide
---
{{MDNSidebar}}
Our [Learn web development](/en-US/docs/Learn) pages get over a million views per month, and has an [active forum](https://discourse.mozilla.org/c/mdn/learn/250) where people go to ask for assistance.
We'd love some help with answering posts, and growing our learning community.
## What we need help with
We receive a high volume of questions asking for help based on topics that appear on the Learn web development section on MDN.
## How you can benefit
- Helping people with their code problems is a great way to learn more about web technologies — as you research a solution and write an answer to someone's question, you will gain a deeper understanding of the subject, and improve your skills.
- As you get more involved in the MDN community, you'll get to know Mozilla staff and other community members, giving you a valuable network of contacts for getting help with your own issues and increasing your visibility.
- Helping to answer coding questions is largely its own reward, but it will also demonstrate your expertise in web technologies and possibly even help you with your course, or job opportunities.
## What skills you need
- You should be knowledgeable in web technologies such as HTML, CSS, and JavaScript. Ideally you should also be good at explaining technical topics, and enjoy helping beginners learn to code.
- The language of the forum is English — you should have a reasonable proficiency with the English language, but it really doesn't need to be perfect. We have people from all over the world visiting our forums, and we want everyone who visits us to feel as comfortable and included as possible.
## How to help
1. Sign up for [Mozilla Discourse](https://discourse.mozilla.org/), if you haven't already.
2. Have a look at [Learn web development](/en-US/docs/Learn) section and gain a basic level of familiarity with what's there.
After you are set up, have a look at the [learning forum](https://discourse.mozilla.org/c/mdn/learn/250) and see if there are any posts that have no replies — this is the best place to start.
If the post you are replying to is a general ask for help, reply to them, and give them as much help as you've got time for.
If you need assistance with anything, ask for help in one of our [Communication channels](/en-US/docs/MDN/Community/Communication_channels).
> **Note:** Important: Above all, be patient, be friendly, be kind. Remember — most of these folks are beginners.
| 0 |
data/mdn-content/files/en-us/mdn | data/mdn-content/files/en-us/mdn/at_ten/index.md | ---
title: MDN at 10
slug: MDN/At_ten
page-type: guide
---
{{MDNSidebar}}
Celebrate 10 years of documenting your Web.
## The history of MDN
In early 2005, a small team of idealists set out to create a new, free, community-built online resource for all Web developers. Their brilliant but offbeat idea grew into today's Mozilla Developer Network—the premier resource for all open Web technologies. Ten years later, our global community is bigger than ever, and together we're still creating documentation, sample code and learning resources for all open Web technologies, including CSS, HTML, JavaScript and everything else that makes the open Web as powerful as it is.
[Learn more about the history](/en-US/docs/MDN/At_ten/History_of_MDN)
## Contributing to MDN
For ten years, the MDN community has been documenting the open Web. From fixing simple typos to writing entire suites of an entirely new API, everyone has something to offer and no contribution is too large or too small. We have over 90,000 pages of content that have been written or translated by members of our outstanding community of Mozillians. You can become one of them.
[Learn more about contributing](/en-US/docs/MDN/Community/Contributing)
## See also
- [The history of MDN](/en-US/docs/MDN/At_ten/History_of_MDN)
| 0 |
data/mdn-content/files/en-us/mdn/at_ten | data/mdn-content/files/en-us/mdn/at_ten/history_of_mdn/index.md | ---
title: The history of MDN
slug: MDN/At_ten/History_of_MDN
page-type: guide
---
{{MDNSidebar}}
In this talk from 2015, several contributors of the MDN project look at the past ten years of [developer.mozilla.org](/), and at the decade to come. You will hear the story of different wiki software migrations, how a documentation community was built, and many more highlights of the history of the site. The group then also talks about current challenges and projects the MDN community is working on this year.
<div id="audio"><pre class="brush: html hidden"><audio controls="controls">
Looks like your browser doesn't have a built-in audio player. Grab the file and play it yourself from here: https://videos.cdn.mozilla.net/uploads/mdn/MDN10/MDN_RoundTable.mp3
<source src="https://videos.cdn.mozilla.net/uploads/mdn/MDN10/MDN_RoundTable.mp3" type="audio/mp3">
</audio>
</pre><pre class="brush: css hidden">body{margin-top:8px;}
</pre></div>
{{ EmbedLiveSample('audio', '100%', '70px') }}
The [2015 Berlin "Hack on MDN"](https://blog.mozilla.org/community/2015/04/17/a-highly-productive-hack-on-mdn-weekend-in-berlin/), where this talk was recorded.
## Topics
Here's an overview of what was discussed, with timestamps and some additional details:
### What is MDN and who is it for?<br>A place for the Open Web community
Time: _0:00:00 - 0:07:15_
MDN provides useful information for Web technologies, and encourages learning, sharing, and teaching in the open Web community. On MDN, you come together and make things for yourself and for others.
MDN is also a place for Mozilla engineers, such as Gecko or Firefox hackers, add-on developers, and Firefox OS contributors.
### The history of MDN: Pre-wiki era – Netscape DevEdge
Time: _0:07:15 - 0:08:17_
In the early days there was _DevEdge_, the developer documentation from Netscape which formed the basis of some of MDN's documentation. Have a look at the past on [archive.org](https://web.archive.org/web/20020819120942/http://devedge.netscape.com/):
[](https://web.archive.org/web/20020819120942/http://devedge.netscape.com/)
On October 12, 2004, this popular developer website was shut down by AOL, Netscape's parent company. Only a few months later, in February 2005, [Mitchell Baker](https://blog.lizardwrangler.com/) was able [to rescue DevEdge](https://blog.lizardwrangler.com/2005/02/23/devmo-and-devedge-updates/) and reached an agreement with AOL that allowed Mozilla to post, modify, and create new documents based on the former Netscape DevEdge materials. In other words, what happened to the Mozilla source in 1998 finally happened for Netscape's developer documentation as well: **It became open source**.
Deb Richardson joined the Mozilla Foundation as a Technical Editor and lead the new _DevMo_ project for community driven developer documentation.
### MediaWiki<br>The first wiki engine
Time: _0:08:17 - 0:14:55_
With MediaWiki as the new underlying project platform, the Mozilla developer documentation has been made editable for anyone starting in July 2005. A new collaborative element in Mozilla was established and since then anyone is welcome to help making it better and to share knowledge. A new international community began to grow and to translate developer contents into other languages.
[](https://web.archive.org/web/20051226031957/https://developer.mozilla.org/en/docs/Main_Page)
### DekiWiki<br>The second wiki engine
Time: _0:14:55 - 0:26:08_
In August 2008, the Mozilla Developer Center switched to [MindTouch DekiWiki](https://sourceforge.net/projects/dekiwiki/), a powerful and new content management system and wiki system for technical documentation. This platform change was quite controversial in the community that was used to MediaWiki from 2005 on and built tools around it. During this phase, we started Doc Sprints to re-engage with the community.
[](https://web.archive.org/web/20080907231611/https://developer.mozilla.org/en)
### Kuma<br>The third and current wiki engine
Time: _0:26:08 - 0:31:50_ and _0:43:52 - 0:51:35_
[Kuma](https://github.com/mdn/kuma), forked from [Kitsune](https://github.com/mozilla/kitsune) in early 2011 and launched on August 3, 2012, is a Mozilla-built wiki platform based on Django with its own [KumaScript](https://github.com/mdn/yari/tree/main/docs/kumascript) macro system which uses Node.js.
With the code living on GitHub, the community started to contribute to MDN's CMS as well. From now on, hacking on MDN includes both writing documentation and Kuma coding.
[](https://web.archive.org/web/20121003233220/https://developer.mozilla.org/en-US/)
### Redesigning MDN<br>Kuma with the refreshed design
Time: _0:31:50 - 0:32:22_ and _0:51:35 - 0:58:05_
The redesign of MDN was a big project. [Sean Martell](https://twitter.com/mart3ll) designed the new MDN visual identity. It was then an iterative process with a beta user group of 3000 MDNers during several months. The new look was behind a "Waffle flag" (MDN's feature flag system). Major shout-outs also to [David Walsh](https://twitter.com/davidwalshblog/) who was really championing the entire redesign and gave MDN the front-end that it deserves.
### Community around Open Web docs<br>Community-driven, browser-agnostic Open Web documentation
Time: _0:32:22 - 0:36:55_
At some point in 2010, especially when [community members and Technical Writers met in Paris](https://hacks.mozilla.org/2010/10/web-standards-doc-sprint-finis/), it became more obvious that MDN's focus is clearly shifting from "Let's document all things Firefox!" to "Let's document the Web!". Documentation has been cleaned up and restructured over the last few years, so that MDN's open Web documentation is browser-agnostic. This material, useful for anyone developing for the Web, is our most popular and most widely used content.
Different browser vendors have joined every once in a while to help shape this part of MDN. This cross-browser collaboration has been very successful and is appreciated by MDN's readers.
### Localization communities<br>MDN serves a global audience in many languages
Time: _0:36:55 - 0:43:52_
Localization is a big part of the Mozilla community; it is a component of almost every project and product. Using Kuma, MDN is also very localizable and suited for the needs of [our l10n community](/en-US/docs/MDN/Community/Contributing/Translated_content). The W3C specifications and other resources describing the Web's functionality have no direct goals, and have communities that provide specs in multiple languages. Especially for beginners, MDN is the first step to explore web technologies, so it's our aim to be there for everyone. MDN has a broad audience and aims to include not only native English speakers. It is appreciated all around the globe.
### Learning Area
Time: _0:58:05 - 1:02:46_
The MDN [Learning Area](/en-US/docs/Learn) is a new effort to teach basic web skills. Over the last 10 years, MDN added a lot of advanced material, serving experts with valuable information. This project is focused on materials for beginners, and tries to fill in a lot of knowledge gaps.
### The future of MDN<br>What will be different when we celebrate 20 years of MDN?
Time: _1:02:46 - 1:11:39_
Everyone involved with MDN really cares about the web being open and accessible, and that's why we have the localization teams and all of the people contributing. MDN hopes to continue to be a key player in keeping the Web the way we feel it should be.
One big part of this future is going to be learning resources. There will be a lot more Web developers over the next ten years.
Another big part of our job is maintaining and updating the information we already have, so we can always serve relevant content to Web developers.
What is changing and will likely change more in the future, is how information is consumed. Today people searching for information and looking up documentation. In the future, MDN documentation might be delivered directly in code editors, Firefox Developer Tools, and many other developer tools and services.
## Speakers
These are the people who are sharing their memories and thoughts, in the order they appear:
### Justin Crawford<br>Product Manager, MDN
Justin moderates this talk and makes things with code, words, bike parts, and lumber. He is [@hoosteeno](https://twitter.com/hoosteeno) on Twitter.
### Eric "Sheppy" Shepherd<br>Technical Writer, MDN
Sheppy has been here documenting for Mozilla since 2006, and has a lot of history (and crazy ideas) when it comes to MDC and MDN over the years. He is [@sheppy](https://twitter.com/sheppy) on Twitter.
### Jérémie Patonnier<br>Technical Writer, MDN
Jérémie is a long time contributor to the Mozilla Developer Network, and a professional web developer since 2000. He's advocating web standards and write documentation about web technologies with the will to make them accessible to everybody. He is [@JeremiePat](https://twitter.com/JeremiePat) on Twitter.
### Janet Swisher<br>Community Manager, MDN
Janet is a Mozilla Community Manager for Mozilla Developer Network. She joined Mozilla in 2010, and has been involved in open source software since 2004 and in technical communication since the 20th century. She is [@jmswisher](https://twitter.com/jmswisher) on Twitter.
### Stormy Peters
Stormy is [@storming](https://twitter.com/storming) on Twitter.
### Ali Spivak<br>Herder of awesome MDN cats
Ali Spivak manages content & community on the Mozilla Developer Network and spends her time thinking of ways to help make the Web even more awesome. She is passionate about maintaining a free and open Web, and, after jumping into open source when she joined Mozilla in 2012, has focused on building and participating in the developer communities at Mozilla. She is [@alispivak](https://twitter.com/alispivak) on Twitter.
### Jean-Yves Perrier<br>Technical Writer, MDN
Jean-Yves has been a Technical Writer on MDN since 2010 and joined Mozilla full-time at the end of 2011. He is passionate about the open Web, with 15 years of C++ experience. He is Swiss but lives in London, UK. His Erdös number is 5 and he is [@Teoli2003](https://twitter.com/Teoli2003) on Twitter.
### Florian Scholz<br>Technical Writer, MDN
Florian is a Technical Writer at Mozilla focused on open web technologies. He is a wiki gnome, gardening the documentation as if it were flowers, and he likes to work with the community toward the goal of documenting the Web and making it accessible to everyone. Florian is passionate about open source, he is based in Bremen, Germany, and tweets as [@floscholz](https://twitter.com/floscholz) on Twitter.
### David Walsh<br>Web developer, MDN
Mozilla Sr. Web Developer, Front-End Engineer, MooTools Core Developer, JavaScript Fanatic, CSS Tinkerer, PHP Hacker, web and open source lover. David is [@davidwalshblog](https://twitter.com/davidwalshblog) on Twitter.
### Luke Crouch<br>Web developer, MDN
Luke Crouch is a home-brewer, soccer fan and web developer for Mozilla. He's been developing on the web since 1996, using Firefox since 2004, writing open source software since 2006, and joined Mozilla as the first staff MDN web dev in 2010. Luke is [@groovecoder](https://twitter.com/groovecoder) on Twitter.
### Julien (a.k.a. Sphinx)<br>French localization, MDN
Julien spent many nights and weekends over several month, translating JavaScript articles into French. He is not a developer, but has a background in IT and wants to learn more about new technologies. He contributes to MDN instead of watching TV.
### Biraj Karmakar<br>Mozilla Reps Mentor
Biraj is an Open Source Contributor, interested in the FOSS movement and Localizations.
## Our awesome contributors
Many more people have done amazing work on MDN:
- Les Orchard
- John Karahalis
- David Walsh
- Jannis Leidel
- Stephanie Hobson
- James Bennett
- Isac Lagerblad
- Piotrek Koszuliński
- Craig Cook
- Rob Hudson
- John Whitlock
- …
And many more [Kuma contributors.](https://github.com/mdn/kuma/graphs/contributors)
<!---->
- Chris Mills
- Will Bamberg
- David Bruant
- Thierry Régagnon
- ethertank
- Saurabh Nair
- Deb Richardson
- Sebastian Zartner
- Tooru Fujisawa
- Karen Scarfone
- Niklas Barning
- …
And hundreds more wiki collaborators.
| 0 |
data/mdn-content/files/en-us/mdn | data/mdn-content/files/en-us/mdn/changelog/index.md | ---
title: MDN Web Docs changelog
slug: MDN/Changelog
page-type: guide
---
{{MDNSidebar}}
This document provides a record of MDN content processes, constructs, and best practices that have changed, and when they changed. It is useful to allow regular contributors to check in and see what has changed about the process of creating content for MDN.
## October 2022
The [MDN project documentation](/en-US/docs/MDN) is refreshed and organized under two main categories:
- **Writing:** Documentation about how to write for MDN, what we document, definitions of experimental, style guidelines and so on are found under the [Writing guidelines](/en-US/docs/MDN/Writing_guidelines) pages.
- **Community:** Information about open source etiquette, discussions, processes for pull requests and issues, users and teams, and general hints for contributors are found under the [Community](/en-US/docs/MDN/Community) pages.
For more details on what has changed, see the [Revamp of MDN Web Docs Contribution Docs](https://hacks.mozilla.org/2022/10/revamp-of-mdn-web-docs-contribution-docs/) blog post published to Mozilla Hacks.
## November 2021
Conversion to Markdown is done, so remove the old CSS style guide and redirect to the Markdown in MDN page.
## July 2021
### Updates to CSS style guide for Markdown
Multiple updates to the CSS style guide to reflect the move towards Markdown, and encourage authors to write HTML in a Markdown-compatible way.
- Note and warning boxes no longer have a separate `<h4>` heading for the title (e.g. `<h4>Warning</h4>`).
See our [Markdown in MDN](/en-US/docs/MDN/Writing_guidelines/Howto/Markdown_in_MDN#notes_warnings_and_callouts) guide for the correct syntax.
- The `seoSummary` class should no longer be used.
- The `standard-table` class should no longer be used. The styling provided by this class is now applied to tables by default.
- The {{HTMLElement("details")}} element should no longer be used.
- The `hidden`, `example-good`, and `example-bad` classes used to be primarily for code blocks but could be used on other elements. Now they can only be used on code blocks.
## February 2021
### Multiline JavaScript and API syntax blocks
Previously, the syntax blocks of JavaScript builtin and WebAPI methods that can be used in multiple different ways (i.e. various parameters are optional) were commonly written using [BNF formal syntax notation](https://en.wikipedia.org/wiki/Backus%E2%80%93Naur_form). Most notably, square brackets were used to signify optional parameters.
This was problematic — many developers were confused by this, and it conflicts with valid syntax forms in other programming languages (e.g. `[]` is also an array in JavaScript).
As a result, going forward we are now writing multiple syntax forms of a method on separate lines inside the syntax block. See [Syntax sections > Multiple lines/Optional parameters](/en-US/docs/MDN/Writing_guidelines/Page_structures/Syntax_sections#multiple_linesoptional_parameters) for further information and examples.
### Documenting mixins
[Interface mixins](https://heycam.github.io/webidl/#idl-interface-mixins) in Web IDL are used in specifications to define Web APIs.
For web developers, they aren't observable directly; they act as helpers to avoid repeating API definitions.
Previously we commonly defined a landing page for a mixin class itself, and put the defined members on subpages underneath it,
before linking to those from the landing pages of the interfaces that implement those mixins.
This was confusing for readers because mixins are spec constructs — you never access the defined members using the mixin classes.
To avoid this confusion we've instead put the pages for members defined on mixins directly under the implementing class pages.
For more details, see the guide page on
[how to write an API reference](/en-US/docs/MDN/Writing_guidelines/Howto/Write_an_API_reference/Information_contained_in_a_WebIDL_file#mixins)
and the discussion leading to this change at [mdn/content#1940](https://github.com/mdn/content/issues/1940).
## January 2021
### Markup for note and warning boxes
Previously on MDN, note and warning boxes would be wrapped by `<div>` elements with `note` and `warning` classes, respectively. More often than not, their first paragraphs would start with a `<strong>`-wrapped `note` or `warning` text.
In January this changed — the `class` attribute should now include an additional `notecard` class, and the strong text is instead included in a heading at the top of the block.
See our [Markdown in MDN](/en-US/docs/MDN/Writing_guidelines/Howto/Markdown_in_MDN#notes_warnings_and_callouts) guide for further information and syntax guides.
| 0 |
data/mdn-content/files/en-us | data/mdn-content/files/en-us/learn/index.md | ---
title: Learn web development
slug: Learn
page-type: landing-page
---
{{LearnSidebar}}
Welcome to the MDN learning area. This set of articles aims to guide complete beginners to web development with all that they need to start coding websites.
The aim of this area of MDN is not to take you from "beginner" to "expert" but to take you from "beginner" to "comfortable." From there, you should be able to start making your way, learning from [the rest of MDN](/en-US/), and other intermediate to advanced resources that assume a lot of previous knowledge.
If you are a complete beginner, web development can be challenging — we will hold your hand and provide enough detail for you to feel comfortable and learn the topics properly. You should feel at home whether you are a student learning web development (on your own or as part of a class), a teacher looking for class materials, a hobbyist, or someone who just wants to understand more about how web technologies work.
> **Callout:**
>
> #### Looking to become a front-end web developer?
>
> We have put together a course that includes all the essential information you need to
> work towards your goal.
>
> [**Get started**](/en-US/docs/Learn/Front-end_web_developer)
## Where to start
- Complete beginner
- : If you are a complete beginner to web development, we'd recommend that you start by working through our [Getting started with the web](/en-US/docs/Learn/Getting_started_with_the_web) module, which provides a practical introduction to web development.
- Beyond the basics
- : If you have a bit of knowledge already, the next step is to learn {{glossary("HTML")}} and {{glossary("CSS")}} in detail: start with our [Introduction to HTML](/en-US/docs/Learn/HTML/Introduction_to_HTML) module and move on to our [CSS first steps](/en-US/docs/Learn/CSS/First_steps) module.
- Moving onto scripting
- : If you are comfortable with HTML and CSS already, or you are mainly interested in coding, you'll want to move on to {{glossary("JavaScript")}} or server-side development. Begin with our [JavaScript first steps](/en-US/docs/Learn/JavaScript/First_steps) and [Server-side first steps](/en-US/docs/Learn/Server-side/First_steps) modules.
- Frameworks and tooling
- : After mastering the essentials of vanilla HTML, CSS, and JavaScript, you should learn about [client-side web development tools](/en-US/docs/Learn/Tools_and_testing/Understanding_client-side_tools), and then consider digging into [client-side JavaScript frameworks](/en-US/docs/Learn/Tools_and_testing/Client-side_JavaScript_frameworks), and [server-side website programming](/en-US/docs/Learn/Server-side).
> **Note:** Our [glossary](/en-US/docs/Glossary) provides terminology definitions. Besides, if you have a specific question about web development, our [Common questions](/en-US/docs/Learn/Common_questions) section may have something to help you.
## Topics covered
The following is a list of all the topics we cover in the MDN learning area.
- [Getting started with the web](/en-US/docs/Learn/Getting_started_with_the_web)
- : Provides a practical introduction to web development for complete beginners.
- [HTML — Structuring the web](/en-US/docs/Learn/HTML)
- : HTML is the language that we use to structure the different parts of our content and define what their meaning or purpose is. This topic teaches HTML in detail.
- [CSS — Styling the web](/en-US/docs/Learn/CSS)
- : CSS is the language that we use to control our web content's style and layout, as well as adding behavior like animation. This topic provides comprehensive coverage of CSS.
- [JavaScript — Dynamic client-side scripting](/en-US/docs/Learn/JavaScript)
- : JavaScript is the scripting language used to add dynamic functionality to web pages. This topic teaches all the essentials needed to become comfortable with writing and understanding JavaScript.
- [Web forms — Working with user data](/en-US/docs/Learn/Forms)
- : Web forms are a potent tool for interacting with users — most commonly, they are used for collecting data from users, or allowing them to control a user interface. In the articles listed below, we'll cover all the essential aspects of structuring, styling, and interacting with web forms.
- [Accessibility — make the web usable by everyone](/en-US/docs/Learn/Accessibility)
- : Accessibility is the practice of making web content available to as many people as possible regardless of disability, device, locale, or other differentiating factors. This topic gives you all you need to know.
- [Web Performance — making websites fast and responsive](/en-US/docs/Learn/Performance)
- : Web performance is the art of making sure web applications download fast and are responsive to user interaction, regardless of a user's bandwidth, screen size, network, or device capabilities.
- [MathML](/en-US/docs/Learn/MathML)
- : MathML is the language that we can use to write mathematical formulas in web pages using fractions, scripts, radicals, matrices, integrals, series, etc. This topic covers MathML.
- [Tools and testing](/en-US/docs/Learn/Tools_and_testing)
- : This topic covers the tools developers use to facilitate their work, such as cross-browser testing tools, linters, formatters, transformation tools, version control systems, deployment tools, and client-side JavaScript frameworks.
- [Server-side website programming](/en-US/docs/Learn/Server-side)
- : Even if you are concentrating on client-side web development, it is still useful to know how servers and server-side code features work. This topic provides a general introduction to how the server-side works and detailed tutorials showing how to build up a server-side app using two popular frameworks: Django (Python) and Express (Node.js).
## Tasks and assessments
In the Learn web development section of MDN, there are many self-contained modules that contain articles, tasks, examples, and assessments for you to complete.
Here are some tips on how to get the most out of them.
There are two main types of tasks you'll encounter:
- "test your skills" tasks, for example in [Making decisions in your code — conditionals](/en-US/docs/Learn/JavaScript/Building_blocks/conditionals#test_your_skills!))
- more in-depth **assessments** at the end of some modules (e.g. see [Image gallery](/en-US/docs/Learn/JavaScript/Building_blocks/Image_gallery))
For most of these tasks, have a look at the GitHub repos associated with the learning area (most of the files are available in [`mdn/learning-area`](https://github.com/mdn/learning-area/), some are in [`mdn/css-examples`]https://github.com/mdn/css-examples/tree/main/learn).
Each assessment/skill test has an associated marking guide and recommended solution available to help you assess your work.
There are patterns that make it easier to find these resources, for example:
- The **test your skills** marking guide and resources are available at <https://github.com/mdn/learning-area/tree/main/javascript/building-blocks/tasks/conditionals>.
- The **assessment** marking guide and resources are available at <https://github.com/mdn/learning-area/tree/main/javascript/building-blocks/gallery>.
## Getting our code examples
The code examples you'll encounter in the Learning Area are all [available on GitHub](https://github.com/mdn/learning-area/).
If you want to copy them all to your computer, the easiest way is to [download a ZIP of the latest master code branch](https://codeload.github.com/mdn/learning-area/zip/main).
If you prefer to copy the repo in a more flexible way that allows for automatic updates, you can follow the more complex instructions:
1. [Install Git](https://git-scm.com/downloads) on your machine. This is the underlying version control system software that GitHub works on top of.
2. Open your computer's [command prompt](https://www.lifewire.com/how-to-open-command-prompt-2618089) (Windows) or terminal ([Linux](https://help.ubuntu.com/community/UsingTheTerminal), [macOS](https://blog.teamtreehouse.com/introduction-to-the-mac-os-x-command-line)).
3. To copy the learning area repo to a folder called learning-area in the current location your command prompt/terminal is pointing to, use the following command:
```bash
git clone https://github.com/mdn/learning-area
```
4. You can now enter the directory and find the files you are after (either using your Finder/File Explorer or the [`cd` command](<https://en.wikipedia.org/wiki/Cd_(command)>)).
You can update the `learning-area` repository with any changes made to the master version on GitHub with the following steps:
1. In your command prompt/terminal, go inside the `learning-area` directory using `cd`. For example, if you were in the parent directory:
```bash
cd learning-area
```
2. Update the repository using the following command:
```bash
git pull
```
## Contact us
If you want to get in touch with us about anything, use the [communication channels](/en-US/docs/MDN/Community/Communication_channels). We'd like to hear from you about anything you think is wrong or missing on the site, requests for new learning topics, requests for help with items you don't understand, or any other questions or concerns.
If you're interested in helping develop/improve the content, take a look at [how you can help](/en-US/docs/MDN/Community/Contributing) and get in touch! We are more than happy to talk to you, whether you are a learner, teacher, experienced web developer, or someone else interested in helping to improve the learning experience.
## See also
- [MDN Blog](/en-US/blog/)
- : The MDN blog has articles from the MDN team and guest writers about new developments on the site, HTML, CSS, JavaScript, and other web development news.
- [Mozilla developer newsletter](https://www.mozilla.org/en-US/newsletter/developer/)
- : Our newsletter for web developers, which is an excellent resource for all levels of experience.
- [Learn JavaScript](https://learnjavascript.online/)
- : An excellent resource for aspiring web developers — Learn JavaScript in an interactive environment, with short lessons and interactive tests, guided by automated assessment. The first 40 lessons are free, and the complete course is available for a small one-time payment.
- [Web demystified](https://www.youtube.com/playlist?list=PLo3w8EB99pqLEopnunz-dOOBJ8t-Wgt2g)
- : A great series of videos explaining web fundamentals, aimed at absolute beginners to web development. Created by [Jérémie Patonnier](https://github.com/JeremiePat).
- [Codecademy](https://www.codecademy.com/)
- : A great interactive site for learning programming languages from scratch.
- [BitDegree](https://www.bitdegree.org/learn/)
- : Basic coding theory with a gamified learning process. Mainly focused on beginners.
- [Code.org](https://code.org/)
- : Basic coding theory and practice, primarily aimed at children/complete beginners.
- [freeCodeCamp.org](https://www.freecodecamp.org/)
- : Interactive site with tutorials and projects to learn web development.
- [The Odin Project](https://www.theodinproject.com/)
- : Features a free and open-source full-stack curriculum, from beginner to advanced.
- [Web literacy map](https://foundation.mozilla.org/en/initiatives/web-literacy/core-curriculum/)
- : A framework for entry-level web literacy and 21st-century skills, which also provides access to teaching activities sorted by category.
- [Edabit](https://edabit.com/challenges/javascript)
- : Thousands of interactive JavaScript challenges.
| 0 |
data/mdn-content/files/en-us/learn | data/mdn-content/files/en-us/learn/server-side/index.md | ---
title: Server-side website programming
slug: Learn/Server-side
page-type: learn-topic
---
{{LearnSidebar}}
The **_Dynamic Websites_** – **Server-side programming** topic is a series of modules that show how to create dynamic websites; websites that deliver customized information in response to HTTP requests. The modules provide a general introduction to server-side programming, along with specific beginner-level guides on how to use the Django (Python) and Express (Node.js/JavaScript) web frameworks to create basic applications.
Most major websites use some kind of server-side technology to dynamically display data as required. For example, imagine how many products are available on Amazon, and imagine how many posts have been written on Facebook. Displaying all of these using different static pages would be extremely inefficient, so instead such sites display static templates (built using [HTML](/en-US/docs/Learn/HTML), [CSS](/en-US/docs/Learn/CSS), and [JavaScript](/en-US/docs/Learn/JavaScript)), and then dynamically update the data displayed inside those templates when needed, such as when you want to view a different product on Amazon.
In the modern world of web development, learning about server-side development is highly recommended.
## Learning pathway
Getting started with server-side programming is usually easier than client-side development, because dynamic websites tend to perform a lot of very similar operations (retrieving data from a database and displaying it in a page, validating user-entered data and saving it in a database, checking user permissions and logging users in, etc.), and are constructed using web frameworks that make these and other common web server operations easy.
Basic knowledge of programming concepts (or of a particular programming language) is useful, but not essential. Similarly, expertise in client-side coding is not required, but a basic knowledge will help you work better with the developers creating your client-side web "front end".
You will need to understand "how the web works". We recommend that you first read the following topics:
- [What is a web server](/en-US/docs/Learn/Common_questions/Web_mechanics/What_is_a_web_server)
- [What software do I need to build a website?](/en-US/docs/Learn/Common_questions/Tools_and_setup/What_software_do_I_need)
- [How do you upload files to a web server?](/en-US/docs/Learn/Common_questions/Tools_and_setup/Upload_files_to_a_web_server)
With that basic understanding, you'll be ready to work your way through the modules in this section.
## Modules
This topic contains the following modules. You should start with the first module, then go on to one of the following modules, which show how to work with two very popular server-side languages using appropriate web frameworks.
- [Server-side website programming first steps](/en-US/docs/Learn/Server-side/First_steps)
- : This module provides technology-agnostic information about server-side website programming such as "what is it?", "how does it differ from client-side programming?", and "why is it useful?". This module also outlines some of the more popular server-side web frameworks and gives guidance on how to select the best one for your site. Lastly, an introduction to web server security is provided.
- [Django Web Framework (Python)](/en-US/docs/Learn/Server-side/Django)
- : Django is an extremely popular and fully featured server-side web framework, written in Python. The module explains why Django is such a good web server framework, how to set up a development environment and how to perform common tasks with it.
- [Express Web Framework (Node.js/JavaScript)](/en-US/docs/Learn/Server-side/Express_Nodejs)
- : Express is a popular web framework, written in JavaScript and hosted within the Node.js runtime environment. The module explains some of the key benefits of this framework, how to set up your development environment and how to perform common web development and deployment tasks.
## See also
- [Node server without framework](/en-US/docs/Learn/Server-side/Node_server_without_framework)
- : This article provides a simple static file server built with pure Node.js, for those of you not wanting to use a framework.
- [Properly configuring server MIME types](/en-US/docs/Learn/Server-side/Configuring_server_MIME_types)
- : Configuring your server to send the correct {{Glossary("MIME type", "MIME types")}} (also known as media types or content types) to browsers is important for browsers to be able to properly process and display the content. It is also important to prevent malicious content from masquerading as benign content.
| 0 |
data/mdn-content/files/en-us/learn/server-side | data/mdn-content/files/en-us/learn/server-side/node_server_without_framework/index.md | ---
title: Node.js server without a framework
slug: Learn/Server-side/Node_server_without_framework
page-type: guide
---
{{LearnSidebar}}
This article provides a simple static file server built with pure [Node.js](https://nodejs.org/en/) without the use of a framework.
The current state of Node.js is such that almost everything we needed is provided by the inbuilt APIs and just a few lines of code.
## Example
A simple static file server built with Node.js:
```js
import * as fs from "node:fs";
import * as http from "node:http";
import * as path from "node:path";
const PORT = 8000;
const MIME_TYPES = {
default: "application/octet-stream",
html: "text/html; charset=UTF-8",
js: "application/javascript",
css: "text/css",
png: "image/png",
jpg: "image/jpg",
gif: "image/gif",
ico: "image/x-icon",
svg: "image/svg+xml",
};
const STATIC_PATH = path.join(process.cwd(), "./static");
const toBool = [() => true, () => false];
const prepareFile = async (url) => {
const paths = [STATIC_PATH, url];
if (url.endsWith("/")) paths.push("index.html");
const filePath = path.join(...paths);
const pathTraversal = !filePath.startsWith(STATIC_PATH);
const exists = await fs.promises.access(filePath).then(...toBool);
const found = !pathTraversal && exists;
const streamPath = found ? filePath : STATIC_PATH + "/404.html";
const ext = path.extname(streamPath).substring(1).toLowerCase();
const stream = fs.createReadStream(streamPath);
return { found, ext, stream };
};
http
.createServer(async (req, res) => {
const file = await prepareFile(req.url);
const statusCode = file.found ? 200 : 404;
const mimeType = MIME_TYPES[file.ext] || MIME_TYPES.default;
res.writeHead(statusCode, { "Content-Type": mimeType });
file.stream.pipe(res);
console.log(`${req.method} ${req.url} ${statusCode}`);
})
.listen(PORT);
console.log(`Server running at http://127.0.0.1:${PORT}/`);
```
### Breakdown
The following lines import internal Node.js modules.
```js
import * as fs from "node:fs";
import * as http from "node:http";
import * as path from "node:path";
```
Next we have a function for creating the server. `https.createServer` returns a `Server` object, which we can start up by listening on `PORT`.
```js
http
.createServer((req, res) => {
/* handle http requests */
})
.listen(PORT);
console.log(`Server running at http://127.0.0.1:${PORT}/`);
```
The asynchronous function `prepareFile` returns the structure: `{ found: boolean , ext: string, stream: ReadableStream }`.
If the file can be served (the server process has access and no path-traversal vulnerability is found), we will return the HTTP status of `200` as a `statusCode` indicating success (otherwise we return `HTTP 404`).
Note that other status codes can be found in `http.STATUS_CODES`.
With `404` status we will return content of `'/404.html'` file.
The extension of the file being requested will be parsed and lower-cased. After that we will search `MIME_TYPES` collection for the right [MIME types](/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types). If no matches are found, we use the `application/octet-stream` as the default type.
Finally, if there are no errors, we send the requested file. The `file.stream` will contain a `Readable` stream that will be piped into `res` (an instance of the `Writable` stream).
```js
res.writeHead(statusCode, { "Content-Type": mimeType });
file.stream.pipe(res);
```
| 0 |
data/mdn-content/files/en-us/learn/server-side | data/mdn-content/files/en-us/learn/server-side/django/index.md | ---
title: Django Web Framework (Python)
slug: Learn/Server-side/Django
page-type: learn-module
---
{{LearnSidebar}}
Django is an extremely popular and fully featured server-side web framework, written in Python. This module shows you why Django is one of the most popular web server frameworks, how to set up a development environment, and how to start using it to create your own web applications.
## Prerequisites
Before starting this module you don't need to have any knowledge of Django. Ideally, you would need to understand what server-side web programming and web frameworks are by reading the topics in our [Server-side website programming first steps](/en-US/docs/Learn/Server-side/First_steps) module.
A general knowledge of programming concepts and [Python](/en-US/docs/Glossary/Python) is recommended, but is not essential to understanding the core concepts.
> **Note:** Python is one of the easiest programming languages for novices to read and understand. That said, if you want to understand this module better, there are numerous free books and tutorials available on the internet to help you out (new programmers might want to check out the [Python for Non Programmers](https://wiki.python.org/moin/BeginnersGuide/NonProgrammers) page on the python.org wiki).
## Guides
- [Django introduction](/en-US/docs/Learn/Server-side/Django/Introduction)
- : In this first Django article we answer the question "What is Django?" and give you an overview of what makes this web framework special. We'll outline the main features, including some advanced functionality that we won't have time to cover in detail in this module. We'll also show you some of the main building blocks of a Django application, to give you an idea of what it can do before you set it up and start playing.
- [Setting up a Django development environment](/en-US/docs/Learn/Server-side/Django/development_environment)
- : Now that you know what Django is for, we'll show you how to set up and test a Django development environment on Windows, Linux (Ubuntu), and macOS — whatever common operating system you are using, this article should give you what you need to be able to start developing Django apps.
- [Django Tutorial: The Local Library website](/en-US/docs/Learn/Server-side/Django/Tutorial_local_library_website)
- : The first article in our practical tutorial series explains what you'll learn, and provides an overview of the "local library" — an example website we'll be working through and evolving in subsequent articles.
- [Django Tutorial Part 2: Creating a skeleton website](/en-US/docs/Learn/Server-side/Django/skeleton_website)
- : This article shows how you can create a "skeleton" website project, which you can then go on to populate with site-specific settings, URLs, models, views, and templates.
- [Django Tutorial Part 3: Using models](/en-US/docs/Learn/Server-side/Django/Models)
- : This article shows how to define models for the _LocalLibrary_ website — models represent the data structures we want to store our app's data in, and also allow Django to store data in a database for us (and modify it later on). It explains what a model is, how it is declared, and some of the main field types. It also briefly shows a few of the main ways you can access model data.
- [Django Tutorial Part 4: Django admin site](/en-US/docs/Learn/Server-side/Django/Admin_site)
- : Now that we've created models for the _LocalLibrary_ website, we'll use the Django Admin site to add some "real" book data. First, we'll show you how to register the models with the admin site, then we'll show you how to login and create some data. At the end, we show some ways in which you can further improve the presentation of the admin site.
- [Django Tutorial Part 5: Creating our home page](/en-US/docs/Learn/Server-side/Django/Home_page)
- : We're now ready to add the code to display our first full page — a home page for the _LocalLibrary_ that shows how many records we have of each model type, and provides sidebar navigation links to our other pages. Along the way we'll gain practical experience in writing basic URL maps and views, getting records from the database, and using templates.
- [Django Tutorial Part 6: Generic list and detail views](/en-US/docs/Learn/Server-side/Django/Generic_views)
- : This tutorial extends our _LocalLibrary_ website, adding list and detail pages for books and authors. Here we'll learn about generic class-based views, and show how they can reduce the amount of code you have to write for common use cases. We'll also go into URL handling in greater detail, showing how to perform basic pattern matching.
- [Django Tutorial Part 7: Sessions framework](/en-US/docs/Learn/Server-side/Django/Sessions)
- : This tutorial extends our _LocalLibrary_ website, adding a session-based visit-counter to the home page. This is a relatively simple example, but it does show how you can use the session framework to provide persistent behavior for anonymous users on your own sites.
- [Django Tutorial Part 8: User authentication and permissions](/en-US/docs/Learn/Server-side/Django/Authentication)
- : In this tutorial we'll show you how to allow users to login to your site with their own accounts, and how to control what they can do and see based on whether or not they are logged in and their _permissions_. As part of this demonstration, we'll extend the _LocalLibrary_ website, adding login and logout pages, and user- and staff-specific pages for viewing books that have been borrowed.
- [Django Tutorial Part 9: Working with forms](/en-US/docs/Learn/Server-side/Django/Forms)
- : In this tutorial we'll show you how to work with [HTML Forms](/en-US/docs/Learn/Forms) in Django, and in particular the easiest way to write forms to create, update and delete model instances. As part of this demonstration, we'll extend the _LocalLibrary_ website so that librarians can renew books, and create, update, and delete authors using our own forms (rather than using the admin application).
- [Django Tutorial Part 10: Testing a Django web application](/en-US/docs/Learn/Server-side/Django/Testing)
- : As websites grow they become harder to test manually — not only is there more to test, but, as the interactions between components become more complex, a small change in one area can require many additional tests to verify its impact on other areas. One way to mitigate these problems is to write automated tests, which can easily and reliably be run every time you make a change. This tutorial shows how to automate _unit testing_ of your website using Django's test framework.
- [Django Tutorial Part 11: Deploying Django to production](/en-US/docs/Learn/Server-side/Django/Deployment)
- : Now you've created (and tested) an awesome _LocalLibrary_ website, you're going to want to install it on a public web server so that it can be accessed by library staff and members over the internet. This article provides an overview of how you might go about finding a host to deploy your website, and what you need to do in order to get your site ready for production.
- [Django web application security](/en-US/docs/Learn/Server-side/Django/web_application_security)
- : Protecting user data is an essential part of any website design. We previously explained some of the more common security threats in the article [Web security](/en-US/docs/Web/Security) — this article provides a practical demonstration of how Django's built-in protections handle such threats.
## Assessments
The following assessment will test your understanding of how to create a website using Django, as described in the guides listed above.
- [DIY Django mini blog](/en-US/docs/Learn/Server-side/Django/django_assessment_blog)
- : In this assessment you'll use some of the knowledge you've learned from this module to create your own blog.
| 0 |
data/mdn-content/files/en-us/learn/server-side/django | data/mdn-content/files/en-us/learn/server-side/django/sessions/index.md | ---
title: "Django Tutorial Part 7: Sessions framework"
slug: Learn/Server-side/Django/Sessions
page-type: learn-module-chapter
---
{{LearnSidebar}}{{PreviousMenuNext("Learn/Server-side/Django/Generic_views", "Learn/Server-side/Django/authentication_and_sessions", "Learn/Server-side/Django")}}
This tutorial extends our [LocalLibrary](/en-US/docs/Learn/Server-side/Django/Tutorial_local_library_website) website, adding a session-based visit-counter to the home page.
This is a relatively simple example, but it does show how you can use the session framework to provide persistent behavior for anonymous users in your own sites.
<table>
<tbody>
<tr>
<th scope="row">Prerequisites:</th>
<td>
Complete all previous tutorial topics, including <a
href="/en-US/docs/Learn/Server-side/Django/Generic_views"
>Django Tutorial Part 6: Generic list and detail views</a
>
</td>
</tr>
<tr>
<th scope="row">Objective:</th>
<td>To understand how sessions are used.</td>
</tr>
</tbody>
</table>
## Overview
The [LocalLibrary](/en-US/docs/Learn/Server-side/Django/Tutorial_local_library_website) website we created in the previous tutorials allows users to browse books and authors in the catalog. While the content is dynamically generated from the database, every user will essentially have access to the same pages and types of information when they use the site.
In a "real" library you may wish to provide individual users with a customized experience, based on their previous use of the site, preferences, etc.
For example, you could hide warning messages that the user has previously acknowledged next time they visit the site, or store and respect their preferences (such as, the number of search results that they want to be displayed on each page).
The session framework lets you implement this sort of behavior, allowing you to store and retrieve arbitrary data on a per-site-visitor basis.
## What are sessions?
All communication between web browsers and servers is via {{Glossary("HTTP")}}, which is _stateless_. The fact that the protocol is stateless means that messages between the client and server are completely independent of each other — there is no notion of "sequence" or behavior based on previous messages. As a result, if you want to have a site that keeps track of the ongoing relationships with a client, you need to implement that yourself.
Sessions are the mechanism used by Django (and most of the Internet) for keeping track of the "state" between the site and a particular browser. Sessions allow you to store arbitrary data per browser, and have this data available to the site whenever the browser connects. Individual data items associated with the session are then referenced by a "key", which is used both to store and retrieve the data.
Django uses a cookie containing a special _session id_ to identify each browser and its associated session with the site. The actual session _data_ is stored in the site database by default (this is more secure than storing the data in a cookie, where they are more vulnerable to malicious users). You can configure Django to store the session data in other places (cache, files, "secure" cookies), but the default location is a good and relatively secure option.
## Enabling sessions
Sessions were enabled automatically when we [created the skeleton website](/en-US/docs/Learn/Server-side/Django/skeleton_website) (in tutorial 2).
The configuration is set up in the `INSTALLED_APPS` and `MIDDLEWARE` sections of the project file (**locallibrary/locallibrary/settings.py**), as shown below:
```python
INSTALLED_APPS = [
# …
'django.contrib.sessions',
# …
MIDDLEWARE = [
# …
'django.contrib.sessions.middleware.SessionMiddleware',
# …
```
## Using sessions
You can access the `session` attribute within a view from the `request` parameter (an `HttpRequest` passed in as the first argument to the view).
This session attribute represents the specific connection to the current user (or to be more precise, the connection to the current _browser_, as identified by the session id in the browser's cookie for this site).
The `session` attribute is a dictionary-like object that you can read and write as many times as you like in your view, modifying it as wished. You can do all the normal dictionary operations, including clearing all data, testing if a key is present, looping through data, etc. Most of the time though, you'll just use the standard "dictionary" API to get and set values.
The code fragments below show how you can get, set, and delete some data with the key "`my_car`", associated with the current session (browser).
> **Note:** One of the great things about Django is that you don't need to think about the mechanisms that tie the session to your current request in your view. If we were to use the fragments below in our view, we'd know that the information about `my_car` is associated only with the browser that sent the current request.
```python
# Get a session value by its key (e.g. 'my_car'), raising a KeyError if the key is not present
my_car = request.session['my_car']
# Get a session value, setting a default if it is not present ('mini')
my_car = request.session.get('my_car', 'mini')
# Set a session value
request.session['my_car'] = 'mini'
# Delete a session value
del request.session['my_car']
```
The API also offers a number of other methods that are mostly used to manage the associated session cookie. For example, there are methods to test that cookies are supported in the client browser, to set and check cookie expiry dates, and to clear expired sessions from the data store. You can find out about the full API in [How to use sessions](https://docs.djangoproject.com/en/4.2/topics/http/sessions/) (Django docs).
## Saving session data
By default, Django only saves to the session database and sends the session cookie to the client when the session has been _modified_ (assigned) or _deleted_. If you're updating some data using its session key as shown in the previous section, then you don't need to worry about this! For example:
```python
# This is detected as an update to the session, so session data is saved.
request.session['my_car'] = 'mini'
```
If you're updating some information _within_ session data, then Django will not recognize that you've made a change to the session and save the data (for example, if you were to change "`wheels`" data inside your "`my_car`" data, as shown below). In this case you will need to explicitly mark the session as having been modified.
```python
# Session object not directly modified, only data within the session. Session changes not saved!
request.session['my_car']['wheels'] = 'alloy'
# Set session as modified to force data updates/cookie to be saved.
request.session.modified = True
```
> **Note:** You can change the behavior so the site will update the database/send cookie on every request by adding `SESSION_SAVE_EVERY_REQUEST = True` into your project settings (**locallibrary/locallibrary/settings.py**).
## Simple example — getting visit counts
As a simple real-world example we'll update our library to tell the current user how many times they have visited the _LocalLibrary_ home page.
Open **/locallibrary/catalog/views.py**, and add the lines that contain `num_visits` into `index()` (as shown below).
```python
def index(request):
# …
num_authors = Author.objects.count() # The 'all()' is implied by default.
# Number of visits to this view, as counted in the session variable.
num_visits = request.session.get('num_visits', 0)
request.session['num_visits'] = num_visits + 1
context = {
'num_books': num_books,
'num_instances': num_instances,
'num_instances_available': num_instances_available,
'num_authors': num_authors,
'num_visits': num_visits,
}
# Render the HTML template index.html with the data in the context variable.
return render(request, 'index.html', context=context)
```
Here we first get the value of the `'num_visits'` session key, setting the value to 0 if it has not previously been set. Each time a request is received, we then increment the value and store it back in the session (for the next time the user visits the page). The `num_visits` variable is then passed to the template in our context variable.
> **Note:** We might also test whether cookies are even supported in the browser here (see [How to use sessions](https://docs.djangoproject.com/en/4.2/topics/http/sessions/) for examples) or design our UI so that it doesn't matter whether or not cookies are supported.
Add the line shown at the bottom of the following block to your main HTML template (**/locallibrary/catalog/templates/index.html**) at the bottom of the "Dynamic content" section to display the `num_visits` context variable.
```django
<h2>Dynamic content</h2>
<p>The library has the following record counts:</p>
<ul>
<li><strong>Books:</strong> \{{ num_books }}</li>
<li><strong>Copies:</strong> \{{ num_instances }}</li>
<li><strong>Copies available:</strong> \{{ num_instances_available }}</li>
<li><strong>Authors:</strong> \{{ num_authors }}</li>
</ul>
<p>
You have visited this page \{{ num_visits }} time\{{ num_visits|pluralize }}.
</p>
```
Note that we use the Django built-in template tag [pluralize](https://docs.djangoproject.com/en/4.2/ref/templates/builtins/#pluralize) to add an "s" when the page has been visited multiple time**s**.
Save your changes and restart the test server. Every time you refresh the page, the number should update.
## Summary
You now know how easy it is to use sessions to improve your interaction with _anonymous_ users.
In our next articles we'll explain the authentication and authorization (permission) framework, and show you how to support user accounts.
## See also
- [How to use sessions](https://docs.djangoproject.com/en/4.2/topics/http/sessions/) (Django docs)
{{PreviousMenuNext("Learn/Server-side/Django/Generic_views", "Learn/Server-side/Django/Authentication", "Learn/Server-side/Django")}}
| 0 |
data/mdn-content/files/en-us/learn/server-side/django | data/mdn-content/files/en-us/learn/server-side/django/deployment/index.md | ---
title: "Django Tutorial Part 11: Deploying Django to production"
slug: Learn/Server-side/Django/Deployment
page-type: learn-module-chapter
---
{{LearnSidebar}}{{PreviousMenuNext("Learn/Server-side/Django/Testing", "Learn/Server-side/Django/web_application_security", "Learn/Server-side/Django")}}
Now you've created (and tested) an awesome [LocalLibrary](/en-US/docs/Learn/Server-side/Django/Tutorial_local_library_website) website, you're going to want to install it on a public web server so that it can be accessed by library staff and members over the internet. This article provides an overview of how you might go about finding a host to deploy your website, and what you need to do in order to get your site ready for production.
<table>
<tbody>
<tr>
<th scope="row">Prerequisites:</th>
<td>
Complete all previous tutorial topics, including <a href="/en-US/docs/Learn/Server-side/Django/Testing">Django Tutorial Part 10: Testing a Django web application</a>.
</td>
</tr>
<tr>
<th scope="row">Objective:</th>
<td>To learn where and how you can deploy a Django app to production.</td>
</tr>
</tbody>
</table>
## Overview
Once your site is finished (or finished "enough" to start public testing) you're going to need to host it somewhere more public and accessible than your personal development computer.
Up to now you've been working in a development environment, using the Django development web server to share your site to the local browser/network, and running your website with (insecure) development settings that expose debug and other private information. Before you can host a website externally you're first going to have to:
- Make a few changes to your project settings.
- Choose an environment for hosting the Django app.
- Choose an environment for hosting any static files.
- Set up a production-level infrastructure for serving your website.
This tutorial provides some guidance on your options for choosing a hosting site, a brief overview of what you need to do in order to get your Django app ready for production, and a working example of how to install the LocalLibrary website onto the [Railway](https://railway.app/) cloud hosting service.
## What is a production environment?
The production environment is the environment provided by the server computer where you will run your website for external consumption. The environment includes:
- Computer hardware on which the website runs.
- Operating system (e.g. Linux, Windows).
- Programming language runtime and framework libraries on top of which your website is written.
- Web server used to serve pages and other content (e.g. Nginx, Apache).
- Application server that passes "dynamic" requests between your Django website and the web server.
- Databases on which your website is dependent.
> **Note:** Depending on how your production environment is configured you might also have a reverse proxy, load balancer, and so on.
The server computer could be located on your premises and connected to the internet by a fast link, but it is far more common to use a computer that is hosted "in the cloud". What this actually means is that your code is run on some remote computer (or possibly a "virtual" computer) in your hosting company's data center(s). The remote server will usually offer some guaranteed level of computing resources (CPU, RAM, storage memory, etc.) and internet connectivity for a certain price.
This sort of remotely accessible computing/networking hardware is referred to as _Infrastructure as a Service (IaaS)_. Many IaaS vendors provide options to preinstall a particular operating system, onto which you must install the other components of your production environment. Other vendors allow you to select more fully-featured environments, perhaps including a complete Django and web-server setup.
> **Note:** Pre-built environments can make setting up your website very easy because they reduce the configuration, but the available options may limit you to an unfamiliar server (or other components) and may be based on an older version of the OS. Often it is better to install components yourself, so that you get the ones that you want, and when you need to upgrade parts of the system, you have some idea of where to start!
Other hosting providers support Django as part of a _Platform as a Service_ (PaaS) offering. In this sort of hosting you don't need to worry about most of your production environment (web server, application server, load balancers) as the host platform takes care of those for you — along with most of what you need to do in order to scale your application.
That makes deployment quite easy, because you just need to concentrate on your web application and not all the other server infrastructure.
Some developers will choose the increased flexibility provided by IaaS over PaaS, while others will appreciate the reduced maintenance overhead and easier scaling of PaaS. When you're getting started, setting up your website on a PaaS system is much easier, and so that is what we'll do in this tutorial.
> **Note:** If you choose a Python/Django-friendly hosting provider they should provide instructions on how to set up a Django website using different configurations of web server, application server, reverse proxy, and so on. (this won't be relevant if you choose a PaaS). For example, there are many step-by-step guides for various configurations in the [Digital Ocean Django community docs](https://www.digitalocean.com/community/tutorials?q=django).
## Choosing a hosting provider
There are many hosting providers that are known to either actively support or work well with Django, including: [Heroku](https://www.heroku.com/), [Digital Ocean](https://www.digitalocean.com/), [Railway](https://railway.app/), [Python Anywhere](https://www.pythonanywhere.com/), [Amazon Web Services](https://aws.amazon.com/), [Azure](https://azure.microsoft.com/en-us/), [Google Cloud](https://cloud.google.com/), [Hetzner](https://www.hetzner.com/), and [Vultr Cloud Compute](https://www.vultr.com/news/new-free-tier-plan/) — to name just a few.
These vendors provide different types of environments (IaaS, PaaS), and different levels of computing and network resources at different prices.
Some of the things to consider when choosing a host:
- How busy your site is likely to be and the cost of data and computing resources required to meet that demand.
- Level of support for scaling horizontally (adding more machines) and vertically (upgrading to more powerful machines) and the costs of doing so.
- Where the supplier has data centres, and hence where access is likely to be fastest.
- The host's historical uptime and downtime performance.
- Tools provided for managing the site — are they easy to use and are they secure (e.g. SFTP vs. FTP).
- Inbuilt frameworks for monitoring your server.
- Known limitations. Some hosts will deliberately block certain services (e.g. email). Others offer only a certain number of hours of "live time" in some price tiers, or only offer a small amount of storage.
- Additional benefits. Some providers will offer free domain names and support for TLS certificates that you would otherwise have to pay for.
- Whether the "free" tier you're relying on expires over time, and whether the cost of migrating to a more expensive tier means you would have been better off using some other service in the first place!
The good news when you're starting out is that there are quite a few sites that provide "free" computing environments that are intended for evaluation and testing.
These are usually fairly resource constrained/limited environments, and you do need to be aware that they may expire after some introductory period or have other constraints.
They are however great for testing low traffic sites in a hosted environment, and can provide an easy migration to paying for more resources when your site gets busier.
Popular choices in this category include [Vultr Cloud Compute](https://www.vultr.com/news/new-free-tier-plan/), [Python Anywhere](https://www.pythonanywhere.com/), [Amazon Web Services](https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/billing-free-tier.html), [Microsoft Azure](https://azure.microsoft.com/pricing/details/app-service/), and so on.
Most providers also offer a "basic" tier that is intended for small production sites, and which provide more useful levels of computing power and fewer limitations.
[Railway](https://railway.app/), [Heroku](https://www.heroku.com/), and [Digital Ocean](https://www.digitalocean.com/) are examples of popular hosting providers that have a relatively inexpensive basic computing tier (in the $5 to $10 USD per month range).
> **Note:** Remember that price is not the only selection criterion. If your website is successful, it may turn out that scalability is the most important consideration.
## Getting your website ready to publish
The [Django skeleton website](/en-US/docs/Learn/Server-side/Django/skeleton_website) created using the _django-admin_ and _manage.py_ tools are configured to make development easier. Many of the Django project settings (specified in **settings.py**) should be different for production, either for security or performance reasons.
> **Note:** It is common to have a separate **settings.py** file for production, and/or to conditionally import sensitive settings from a separate file or an environment variable. This file should then be protected, even if the rest of the source code is available on a public repository.
The critical settings that you must check are:
- `DEBUG`. This should be set as `False` in production (`DEBUG = False`). This stops the sensitive/confidential debug trace and variable information from being displayed.
- `SECRET_KEY`. This is a large random value used for CSRF protection, etc. It is important that the key used in production is not in source control or accessible outside the production server. The Django documents suggest that this might best be loaded from an environment variable or read from a server-only file.
```python
# Read SECRET_KEY from an environment variable
import os
SECRET_KEY = os.environ['SECRET_KEY']
# OR
# Read secret key from a file
with open('/etc/secret_key.txt') as f:
SECRET_KEY = f.read().strip()
```
Let's change the _LocalLibrary_ application so that we read our `SECRET_KEY` and `DEBUG` variables from environment variables if they are defined, but otherwise use the default values in the configuration file.
Open **/locallibrary/settings.py**, disable the original `SECRET_KEY` configuration and add the new lines as shown below.
During development no environment variable will be specified for the key, so the default value will be used (it shouldn't matter what key you use here, or if the key "leaks", because you won't use it in production).
```python
# SECURITY WARNING: keep the secret key used in production secret!
# SECRET_KEY = 'django-insecure-&psk#na5l=p3q8_a+-$4w1f^lt3lx1c@d*p4x$ymm_rn7pwb87'
import os
SECRET_KEY = os.environ.get('DJANGO_SECRET_KEY', 'django-insecure-&psk#na5l=p3q8_a+-$4w1f^lt3lx1c@d*p4x$ymm_rn7pwb87')
```
Then comment out the existing `DEBUG` setting and add the new line shown below.
```python
# SECURITY WARNING: don't run with debug turned on in production!
# DEBUG = True
DEBUG = os.environ.get('DJANGO_DEBUG', '') != 'False'
```
The value of the `DEBUG` will be `True` by default, but will only be `False` if the value of the `DJANGO_DEBUG` environment variable is set to `False`. Please note that environment variables are strings and not Python types. We therefore need to compare strings. The only way to set the `DEBUG` variable to `False` is to actually set it to the string `False`.
You can set the environment variable to "False" on Linux by issuing the following command:
```bash
export DJANGO_DEBUG=False
```
A full checklist of settings you might want to change is provided in [Deployment checklist](https://docs.djangoproject.com/en/4.2/howto/deployment/checklist/) (Django docs). You can also list a number of these using the terminal command below:
```python
python3 manage.py check --deploy
```
#### Gunicorn
[Gunicorn](https://gunicorn.org/) is a pure-Python HTTP server that is commonly used for serving Django WSGI applications.
While we don't need _Gunicorn_ to serve our LocalLibrary application during development, we'll install it locally so that it becomes part of our [requirements](#requirements) when the application is deployed.
First make sure that you're in the Python virtual environment that was created when you [set up the development environment](/en-US/docs/Learn/Server-side/Django/development_environment) (use the `workon [name-of-virtual-environment]` command).
Then install _Gunicorn_ locally on the command line using _pip_:
```bash
pip3 install gunicorn
```
#### Database configuration
SQLite, the default Django database that you've been using for development, is a reasonable choice for small to medium websites.
Unfortunately it cannot be used on some popular hosting services, such as Heroku, because they don't provide persistent data storage in the application environment (a requirement of SQLite).
While that might not affect us for the example deployment(s), we'll show you another approach that will work on Railway, Heroku, and some other services.
The approach is to use a database that runs in its own process somewhere on the Internet, and is accessed by the Django library application using an address passed as an environment variable.
In this case we'll use a Postgres database that is also hosted on Railway, but you could use any database hosting service you like.
The database connection information will be supplied to Django using an environment variable named `DATABASE_URL`.
Rather than hard-coding this information into Django, we'll use the [dj-database-url](https://pypi.org/project/dj-database-url/) package to parse the `DATABASE_URL` environment variable and automatically convert it to Django's desired configuration format.
In addition to installing the _dj-database-url_ package we'll also need to install [psycopg2](https://www.psycopg.org/), as Django needs this to interact with Postgres databases.
##### dj-database-url
_dj-database-url_ is used to extract the Django database configuration from an environment variable.
Install it locally so that it becomes part of our [requirements](#requirements) to set up on the deployment server:
```bash
pip3 install dj-database-url
```
##### settings.py
Open **/locallibrary/settings.py** and copy the following configuration into the bottom of the file:
```python
# Update database configuration from $DATABASE_URL environment variable (if defined)
import dj_database_url
if 'DATABASE_URL' in os.environ:
DATABASES['default'] = dj_database_url.config(
conn_max_age=500,
conn_health_checks=True,
)
```
Django will now use the database configuration in `DATABASE_URL` if the environment variable is set; otherwise it uses the default SQLite database.
The value `conn_max_age=500` makes the connection persistent, which is far more efficient than recreating the connection on every request cycle (this is optional and can be removed if needed).
##### psycopg2
<!-- Django 4.2 now supports Psycopg (3) : https://docs.djangoproject.com/en/4.2/releases/4.2/#psycopg-3-support
But didn't work on Railway!
Try again to update in next release.
-->
Django needs _psycopg2_ to work with Postgres databases.
Install it locally so that it becomes part of our [requirements](#requirements) for Railway to set up on the remote server:
```bash
pip3 install psycopg2-binary
```
Note that Django will use the SQLite database during development by default, unless `DATABASE_URL` is set.
You can switch to Postgres completely and use the same hosted database for development and production by setting the same environment variable in your development environment (Railway makes it easy to use the same environment for production and development).
Alternatively you can also install and use a [self-hosted Postgres database](https://www.psycopg.org/docs/install.html) on your local computer.
#### Serving static files in production
During development we use Django and the Django development web server to serve both our dynamic HTML and our static files (CSS, JavaScript, etc.).
This is inefficient for static files, because the requests have to pass through Django even though Django doesn't do anything with them.
While this doesn't matter during development, it would have a significant performance impact if we were to use the same approach in production.
In the production environment we typically separate the static files from the Django web application, making it easier to serve them directly from the web server or from a content delivery network (CDN).
The important setting variables are:
- `STATIC_URL`: This is the base URL location from which static files will be served, for example on a CDN.
- `STATIC_ROOT`: This is the absolute path to a directory where Django's _collectstatic_ tool will gather any static files referenced in our templates. Once collected, these can then be uploaded as a group to wherever the files are to be hosted.
- `STATICFILES_DIRS`: This lists additional directories that Django's _collectstatic_ tool should search for static files.
Django templates refer to static file locations relative to a `static` tag (you can see this in the base template defined in [Django Tutorial Part 5: Creating our home page](/en-US/docs/Learn/Server-side/Django/Home_page#the_locallibrary_base_template)), which in turn maps to the `STATIC_URL` setting.
Static files can therefore be uploaded to any host and you can update your application to find them using this setting.
The _collectstatic_ tool is used to collect static files into the folder defined by the `STATIC_ROOT` project setting.
It is called with the following command:
```bash
python3 manage.py collectstatic
```
For this tutorial, _collectstatic_ can be run before the application is uploaded, copying all the static files in the application to the location specified in `STATIC_ROOT`.
`Whitenoise` then finds the files from the location defined by `STATIC_ROOT` (by default) and serves them at the base URL defined by `STATIC_URL`.
##### settings.py
Open **/locallibrary/settings.py** and copy the following configuration into the bottom of the file.
The `BASE_DIR` should already have been defined in your file (the `STATIC_URL` may already have been defined within the file when it was created.
While it will cause no harm, you might as well delete the duplicate previous reference).
```python
# Static files (CSS, JavaScript, Images)
# https://docs.djangoproject.com/en/4.2/howto/static-files/
# The absolute path to the directory where collectstatic will collect static files for deployment.
STATIC_ROOT = BASE_DIR / 'staticfiles'
# The URL to use when referring to static files (where they will be served from)
STATIC_URL = '/static/'
```
We'll actually do the file serving using a library called [WhiteNoise](https://pypi.org/project/whitenoise/), which we install and configure in the next section.
#### Whitenoise
There are many ways to serve static files in production (we saw the relevant Django settings in the previous sections).
The [WhiteNoise](https://pypi.org/project/whitenoise/) project provides one of the easiest methods for serving static assets directly from Gunicorn in production.
Check out [WhiteNoise](https://pypi.org/project/whitenoise/) documentation for an explanation of how it works and why the implementation is a relatively efficient method for serving these files.
The steps to set up _WhiteNoise_ to use with the project are [given here](https://whitenoise.evans.io/en/stable/django.html) (and reproduced below):
##### Install whitenoise
Install whitenoise locally using the following command:
```bash
pip3 install whitenoise
```
##### settings.py
To install _WhiteNoise_ into your Django application, open **/locallibrary/settings.py**, find the `MIDDLEWARE` setting and add the `WhiteNoiseMiddleware` near the top of the list, just below the `SecurityMiddleware`:
```python
MIDDLEWARE = [
'django.middleware.security.SecurityMiddleware',
'whitenoise.middleware.WhiteNoiseMiddleware',
'django.contrib.sessions.middleware.SessionMiddleware',
'django.middleware.common.CommonMiddleware',
'django.middleware.csrf.CsrfViewMiddleware',
'django.contrib.auth.middleware.AuthenticationMiddleware',
'django.contrib.messages.middleware.MessageMiddleware',
'django.middleware.clickjacking.XFrameOptionsMiddleware',
]
```
Optionally, you can reduce the size of the static files when they are served (this is more efficient).
Just add the following to the bottom of **/locallibrary/settings.py**:
```python
# Static file serving.
# https://whitenoise.readthedocs.io/en/stable/django.html#add-compression-and-caching-support
STORAGES = {
# ...
"staticfiles": {
"BACKEND": "whitenoise.storage.CompressedManifestStaticFilesStorage",
},
}
```
You don't need to do anything else to configure _WhiteNoise_ because it uses your project settings for `STATIC_ROOT` and `STATIC_URL` by default.
#### Requirements
The Python requirements of your web application should be stored in a file **requirements.txt** in the root of your repository.
Many hosting services will automatically install dependencies in this file (in others you have to do this yourself).
You can create this file using _pip_ on the command line (run the following in the repo root):
```bash
pip3 freeze > requirements.txt
```
After installing all the different dependencies above, your **requirements.txt** file should have _at least_ these items listed (though the version numbers may be different).
Please delete any other dependencies not listed below, unless you've explicitly added them for this application.
```plain
Django==4.2.3
dj-database-url==2.0.0
gunicorn==21.2.3
psycopg2-binary==2.9.6
wheel==0.38.1
whitenoise==6.5.0
```
### Update your application repository in GitHub
Many hosting services allow you to import and/or synchronize projects from a local repository or from cloud-based source version control platforms.
This can make deployment and iterative development much easier.
You should already be using GitHub to store the local library source code (this was set up in [Source code management with Git and GitHub](/en-US/docs/Learn/Server-side/Django/development_environment#source_code_management_with_git_and_github) as part of setting up your development environment.
This is a good point to make a backup of your "vanilla" project — while some of the changes we're going to be making in the following sections might be useful for deployment on any hosting service (or for development) others might not.
Assuming you have already backed up all the changes made so far to the `main` branch on GitHub you can create a new branch to backup your changes as shown:
```bash
# Fetch the latest main branch
git checkout main
git pull origin main
# Create branch vanilla_deployment from the current branch (main)
git checkout -b vanilla_deployment
# Push the new branch to GitHub
git push origin vanilla_deployment
# Switch back to main
git checkout main
# Make any further changes in a new branch
git checkout -b my_changes_for_deployment # Create a new branch
```
## Example: Hosting on PythonAnywhere
This section provides a practical demonstration of how to host _LocalLibrary_ on [PythonAnywhere](https://www.pythonanywhere.com/).
### Why PythonAnywhere?
We are choosing to use PythonAnywhere for several reasons:
- PythonAnywhere has a [free beginner plan](https://www.pythonanywhere.com/pricing/) that is _really_ free, albeit with some limitations.
The fact that it is affordable for all developers is really important to MDN!
> **Note:** This tutorial has been hosted on Heroku, Railway, and now PythonAnywhere, migrating when the previously free plans were discontinued.
> We've chosen PythonAnywhere because we think this plan is likely to remain free.
> We've kept the Railway example too, which is not free, for comparison, and because it allows us to more easily demonstrate features such as integration with a Postgres databases running on a different service.
- PythonAnywhere takes care of the infrastructure so you don't have to.
Not having to worry about servers, load balancers, reverse proxies, and so on, makes it much easier to get started.
- The skills and concepts you will learn when using PythonAnywhere are transferrable.
- The service and plan limitations do not particularly impact us using PythonAnywhere for the tutorial.
For example:
- The beginner plan allows one web app at `<your-username>.pythonanywhere.com`, restricted outbound Internet access from your apps, low CPU/bandwidth, no IPython/Jupyter notebook support, no free Postgres database.
But there is enough space for our basic site to run!
- Custom domains are not supported (at time of writing).
- The environment shuts down when not in use, so may be slow to restart.
You can run it forever, but you will need to visit the site every three months and renew the web application.
- There is free support for a separate MySQL database, but not Postgres.
In this demonstration we'll just use the default Django SQLite database.
PythonAnywhere is appropriate for hosting this demonstration, and can be scaled to larger projects if needed.
You should take the time to determine if it is [suitable for your own website](#choosing_a_hosting_provider).
### How does PythonAnywhere work?
PythonAnywhere provides an entirely web-based interface for uploading, editing, and otherwise working with your application.
Through the interface you can launch a bash console to a Ubuntu Linux environment in which you can create your application.
In this demonstration we'll use the console to clone our local library GitHub repository, and create a Python environment in which we can run the web application.
The free plan doesn't provides separate Postgres support.
While we could use some other hosting service for our database, we'll just use the default SQLite database created by Django in the hosted Ubuntu environment (there is more than enough space for demonstrating the library functionality).
Once the application is running, it can be configured for production by setting environment variables through the bash console.
That's all the overview you need to get started.
### Get a PythonAnywhere account
To start using PythonAnywhere you will first need to create an account:
- Go to PythonAnywhere [Plans and pricing](https://www.pythonanywhere.com/pricing/) page, and select the **Create a Beginner account** button.
- Create an account with your username, email, and password, acknowledge the terms and conditions, and then select **Register**.
- You'll then be logged in and redirected to the PythonAnywhere dashboard: `https://www.pythonanywhere.com/user/<your_user_name>/`.
### Install library from GitHub
Next we're going open a Bash prompt, set up a virtual environment, and fetch the local library source code from Github.
We'll also configure the default database and collect static files so that they can be served by PythonAnywhere.
1. First open the Console management screen by selecting **Consoles** in the top application bar.
2. Then select the **Bash** link to create and launch a new console:
Note that any console that you create is saved for your later re-use, along with all its history.
The green arrow above shows that this account has a console we could have opened instead.
3. In the console, enter the following command to create a Python 3.10 virtual environment named "env_local_library" for installing the local library dependencies.
```bash
mkvirtualenv --python=python3.10 env_local_library
```
This is exactly the same process as covered in [Setting up a Django development environment](/en-US/docs/Learn/Server-side/Django/development_environment).
We could have named the environment anything, and we can deactivate it and reactivate it using the commands below:
```bash
deactivate
workon env_local_library
```
4. Next get the library sources from GitHub.
PythonAnywhere expects you to install applications in a folder named after your site URL.
> **Note:** Because we're using the free account you can only name your account `<your_pythonaware_username>.pythonanywhere.com` (for example, if your username is "Odtsetseg" you will have to put the local library source into a folder named `odtsetseg.pythonanywhere.com`).
Enter the following command to clone your library sources into an appropriately named folder (you will need to replace the username values with your own name):
```bash
git clone https://github.com/<github_username>/django-locallibrary-tutorial.git <pythonaware_username>.pythonanywhere.com
# Navigate into the new folder
cd <pythonaware_username>.pythonanywhere.com
```
5. Install the library dependencies using the `requirements.txt` file:
```bash
pip3 install -r requirements.txt
```
6. Create and configure an SQLite database on the hosting computer (just as we did during development).
```bash
python manage.py migrate
```
> **Note:** For the Railway example we will [Configure a Postgres database](/en-US/docs/Learn/Server-side/Django/Deployment#provision_and_connect_a_postgres_sql_database), and connect to it by setting the `DATABASE_URL` environment variable.
> It is important that `migrate` is called _after_ configuring what database to use database.
7. Collect all the static files into a location where they can be [served in production](#serving_static_files_in_production):
```bash
python manage.py collectstatic --no-input
```
8. Create a superuser for accessing the site (as covered in the [Django admin site](/en-US/docs/Learn/Server-side/Django/Admin_site#creating_a_superuser) section):
```bash
python manage.py createsuperuser
```
Note the details, as you'll need them to test your site.
### Setup the web app
After getting the local library sources and installing the dependencies in a virtual environment, we need to tell PythonAnywhere how to find them and use them as a web app.
1. Navigate to the _Web_ section of the site and select the **Add a new web app** link:
The _Create new web app_ wizard will then open to guide you through configuring the main properties of the web app.
2. Select **Next** to skip through the web app domain name configuration.
The free account will create the domain based on your user name: `<user_name>.pythonanywhere.com`.
3. In the _Select a Python Web framework_ screen select **Manual configuration**.
Manual configuration allows us complete control over how the environment is configured.
This doesn't matter so much now, but it would if we were hosting multiple sites, potentially with different versions of Python and/or Django.
4. In the _Select a Python version_ screen select **3.10**
More generally you should select the latest version of Python allowed by the version of Django that you are using.
5. In the _Manual configuration_ screen select **Next** (the screen just explains some of the options for configuration)
The web app is created, and displayed in the Web section as shown.
The screen has a **Reload** button that you can use to reload the web application after you make any further changes.
As noted on the screen, you'll need to click the **Run until 3 months from today** button to keep the site alive for another three months (and ongoing).
6. Scroll down to the "Code" section of the _Web_ tab and select the link to the WSGI configuration file.
This will have a name with the form `/var/www/<user_name>_pythonanywhere_com_wsgi.py`.
Replace the content in the file with the following text (first updating "hamishwillee" with your own username), and then select the **Save** button.
```py
import os
import sys
path = '/home/hamishwillee/hamishwillee.pythonanywhere.com'
if path not in sys.path:
sys.path.append(path)
os.environ['DJANGO_SETTINGS_MODULE'] = 'locallibrary.settings'
from django.core.wsgi import get_wsgi_application
application = get_wsgi_application()
```
Note that the role of the WGSI file is to help the Gunicorn server find the local library application.
PythonAnywhere expects this file to be in this location, which is why the WSGI file already in the project cannot be used.
7. Scroll down to the "Virtualenv" section of the _Web_ tab.
Select the link **Enter the path to a virtual env, if desired** and enter the path of the virtual evironment created in the previous section.
If you named it "env_local_library" as suggested, the path will be: `/home/<user_name>/.virtualenvs/env_local_library`
8. Scroll down to the "Static files" section of the _Web_ tab.
Select the **Enter URL** link and enter `\static_files\`.
This is the `STATIC_URL` in the [application settings](/en-US/docs/Learn/Server-side/Django/Deployment#settings.py_2), and reflects the location where files were copied when we ran `collectstatic` in the previous section.
9. Near the top of the _Web_ tab select the **Reload** button to restart the site.
Then then select the site URL link to launch the live site:
### Set ALLOWED_HOSTS and CSRF_TRUSTED_ORIGINS
When the site is opened, at this point you'll see an error debug screen as shown below.
This is a Django security error that is raised because our source code is not running on an "allowed host".
> **Note:** This kind of debug information is very useful when you're getting set up, but is a security risk in a deployed site.
> In the next section we'll show you how to disable this level of logging on the live site using [environment variables](/en-US/docs/Learn/Server-side/Django/Deployment#using_environment_variables_on_pythonanywhere).
Open **/locallibrary/settings.py** in your GitHub project and change the [ALLOWED_HOSTS](https://docs.djangoproject.com/en/4.2/ref/settings/#allowed-hosts) setting to include your PythonAnywhere site URL:
```python
## For example, for a site URL at 'hamishwillee.pythonanywhere.com'
## (replace the string below with your own site URL):
ALLOWED_HOSTS = ['hamishwillee.pythonanywhere.com', '127.0.0.1']
# During development, you can instead set just the base URL
# (you might decide to change the site a few times).
# ALLOWED_HOSTS = ['.pythonanywhere.com','127.0.0.1']
```
Since the applications uses CSRF protection, you will also need to set the [CSRF_TRUSTED_ORIGINS](https://docs.djangoproject.com/en/4.2/ref/settings/#csrf-trusted-origins) key.
Open **/locallibrary/settings.py** and add a line like the one below:
```python
## For example, for a site URL is at 'web-production-3640.up.railway.app'
## (replace the string below with your own site URL):
CSRF_TRUSTED_ORIGINS = ['https://hamishwillee.pythonanywhere.com']
# During development/for this tutorial you can instead set just the base URL
# CSRF_TRUSTED_ORIGINS = ['https://*.pythonanywhere.com']
```
Save these settings and commit them to your GitHub repo.
You will then need to update the version of your project on PythonAnywhere.
Assuming you're using your Bash prompt in the folder `<user_name>.pythonanywhere.com`, and you have pushed the changes to the main branch, then you could import them in the Bash prompt using the command:
```Bash
git pull origin main
```
Use the **Restart** button on the `Web` tab to restart the application.
If you refresh your hosted site, it should now open and display the home page of the site.
You should be able to log in with the superuser account you created above, and create authors, genres, books, and so on, just as you did on your local computer.
### Using environment variables on PythonAnywhere
In the section on [Getting your website ready to publish](/en-US/docs/Learn/Server-side/Django/Deployment#getting_your_website_ready_to_publish) we modified the application so that it can be configured using environment variables in production.
Specifically we set up the library so that you can set:
- `DJANGO_DEBUG=False` to reduce the debug tracing shown to the user when there is an error.
- `DJANGO_SECRET_KEY` to some secret value in production.
- `DATABASE_URL` if your application uses a hosted database (we do not in this example).
The way that environment variables are set depends on the hosting service.
[PythonAnywhere recommends that you read them from an environment file](https://help.pythonanywhere.com/pages/environment-variables-for-web-apps).
The steps are:
1. Open a PythonAware Bash prompt.
2. Navigate to your application directory (replacing `<user-name>` with your own account):
```bash
cd ~/<user-name>.pythonanywhere.com
```
3. Make sure that the virtual environment used by the server is active.
If not, activate it using:
```bash
workon env_local_library
```
4. Install [python-dotenv](https://pypi.org/project/python-dotenv/), a tool for reading key-value pairs out of a file and saving them as environment variables.
```bash
pip install python-dotenv
```
Note that you might also add _python-dotenv_ to your `requirements.txt` file.
5. You can set the environment variables by writing them as key-value pairs to the `.env` file.
For example, to set `DJANGO_DEBUG` to `False` in the Bash console, enter the following following command:
```bash
echo "DJANGO_DEBUG=False" >> .env
```
Note that these are _secrets_!
You must not save them to GitHub, and you might want to add `.env` to your `.gitignore` file so that it is not added by accident.
6. The final step is to ensure that variables in the `.env` file are read into the environment.
Open the _Web_ tab and scroll down to the "Code" section.
Select the link to open the WSGI configuration file.
Add the following lines to the top of the file (after `import sys`), replacing the `<user-name>` with your own account, and then press the **Save** button.
```py
from dotenv import load_dotenv
project_folder = os.path.expanduser('~/<user-name>.pythonanywhere.com') # adjust as appropriate
load_dotenv(os.path.join(project_folder, '.env'))
```
7. Restart the application.
You can test that the operation worked by attempting to open a record that that does not exist (for example, create a genre, then increment the number in the URL bar to open a record that has not yet been created).
If the environment variable has been loaded you'll get a "Not found" message rather than a detailed debug trace.
## Example: Hosting on Railway
This section provides a practical demonstration of how to install _LocalLibrary_ on [Railway](https://railway.app/).
### Why Railway?
> **Warning:** Railway no longer has a completely free starter tier.
> We've kept these instructions because Railway has some great features, and will be a better option for some users.
Railway is an attractive hosting option for several reasons:
- Railway takes care of most of the infrastructure so you don't have to.
Not having to worry about servers, load balancers, reverse proxies, and so on, makes it much easier to get started.
- Railway has a [focus on developer experience for development and deployment](https://docs.railway.app/reference/compare-to-heroku), which leads to a faster and softer learning curve than many other alternatives.
- The skills and concepts you will learn when using Railway are transferrable.
While Railway has some excellent new features, other popular hosting services use many of the same ideas and approaches.
- [Railway documentation](https://docs.railway.app/) is clear and complete.
- The service appears to be very reliable, and if you end up loving it, the pricing is predictable, and scaling your app is very easy.
You should take the time to determine if Railway is [suitable for your own website](#choosing_a_hosting_provider).
### How does Railway work?
Web applications are each run in their own isolated and independent virtualized container.
In order to execute your application, Railway needs to be able to set up the appropriate environment and dependencies, and also understand how it is launched.
For Django apps we provide this information in a number of text files:
- **runtime.txt**: states the programming language and version to use.
- **requirements.txt**: lists the Python dependencies needed for your site, including Django.
- **Procfile**: A list of processes to be executed to start the web application.
For Django this will usually be the Gunicorn web application server (with a `.wsgi` script).
- **wsgi.py**: [WSGI](https://wsgi.readthedocs.io/en/latest/what.html) configuration to call our Django application in the Railway environment.
Once the application is running it can configure itself using information provided in [environment variables](https://docs.railway.app/develop/variables).
For example, an application that uses a database can get the address using the variable `DATABASE_URL`.
The database service itself may be hosted by Railway or some other provider.
Developers interact with Railway through the Railway site, and using a special [Command Line Interface (CLI)](https://docs.railway.app/develop/cli) tool.
The CLI allows you to associate a local GitHub repository with a railway project, upload the repository from the local branch to the live site, inspect the logs of the running process, set and get configuration variables and much more.
One of the most useful features is that you can use the CLI to run your local project with the same environment variables as the live project.
In order to get our application to work on Railway, we'll need to put our Django web application into a git repository, add the files above, integrate with a database add-on, and make changes to properly handle static files.
Once we've done all that, we can set up a Railway account, get the Railway client, and install our website.
That's all the overview you need in order to get started.
### Update the app for Railway
This section explains the changes you'll need to make to our _LocalLibrary_ application to get it to work on Railway.
We really only have to create a `Procfile` and `runtime.txt` file, because almost everything else is already present.
Note that these changes will not prevent you using the local testing and workflows we've already learned.
#### Procfile
A _Procfile_ is the web application "entry point".
It lists the commands that will be executed by Railway to start your site.
Create the file `Procfile` (with no file extension) in the root of your GitHub repo and copy/paste in the following text:
```plain
web: python manage.py migrate && python manage.py collectstatic --no-input && gunicorn locallibrary.wsgi
```
The `web:` prefix tells Railway that this is a web process and can be sent HTTP traffic.
We then call the command Django migration command `python manage.py migrate` to set up the database tables.
Next, we call the Django command `python manage.py collectstatic` to collect static files into the folder defined by the `STATIC_ROOT` project setting (see the section [serving static files in production](#serving_static_files_in_production) below).
Finally, we start the _gunicorn_ process, a popular web application server, passing it configuration information in the module `locallibrary.wsgi` (created with our application skeleton: **/locallibrary/wsgi.py**).
You will note that we already set up the project to include _gunicorn_ and support serving static files!
You can also use the Procfile to start worker processes or to run other non-interactive tasks before the release is deployed.
#### Runtime
The **runtime.txt** file, if defined, tells Railway which version of Python to use.
Create the file in the root of the repo and add the following text:
```plain
python-3.10.2
```
> **Note:** Hosting providers do not necessarily support every Python runtime minor version.
> They will generally use the closest supported version to the value that you specify.
#### Re-test and save changes to GitHub
Before you proceed, first test the site again locally and make sure it wasn't broken by any of the changes above.
Run the development web server as usual and then check the site still works as you expect on your browser.
```bash
python3 manage.py runserver
```
Next, lets `push` the changes to GitHub.
In the terminal (after having navigated to our local repository), enter the following commands:
```python
git checkout -b railway_changes
git add -A
git commit -m "Added files and changes required for deployment"
git push origin railway_changes
```
Then create and merge the PR on GitHub.
We should now be ready to start deploying LocalLibrary on Railway.
### Get a Railway account
To start using Railway you will first need to create an account:
- Go to [railway.app](https://railway.app/) and click the **Login** link in the top toolbar.
- Select GitHub in the popup to login using your GitHub credentials
- You may then need to go to your email and verify your account.
- You'll then be logged in to the Railway.app dashboard: <https://railway.app/dashboard>.
### Deploy on Railway from GitHub
Next we'll set up Railway to deploy our library from GitHub.
First choose the **Dashboard** option from the site top menu, then select the **New Project** button:
Railway will display a list of options for the new project, including the option to deploy a project from a template that is first created in your GitHub account, and a number of databases.
Select **Deploy from GitHub repo**.
All projects in the GitHub repos you shared with Railway during setup are displayed.
Select your GitHub repository for the local library: `<user-name>/django-locallibrary-tutorial`.
Confirm your deployment by selecting **Deploy Now**.
Railway will then load and deploy your project, displaying progress on the deployments tab.
When deployment successfully completes, you'll see a screen like the one below.
You can click the site URL (highlighted above) to open the site in a browser (it still won't work, because the setup is not complete).
### Set ALLOWED_HOSTS and CSRF_TRUSTED_ORIGINS
When the site is opened, at this point you'll see an error debug screen as shown below.
This is a Django security error that is raised because our source code is not running on an "allowed host".
> **Note:** This kind of debug information is very useful when you're getting set up, but is a security risk in a deployed site.
> We'll show you how to disable it once the site is up and running.
Open **/locallibrary/settings.py** in your GitHub project and change the [ALLOWED_HOSTS](https://docs.djangoproject.com/en/4.2/ref/settings/#allowed-hosts) setting to include your Railway site URL:
```python
## For example, for a site URL at 'web-production-3640.up.railway.app'
## (replace the string below with your own site URL):
ALLOWED_HOSTS = ['web-production-3640.up.railway.app', '127.0.0.1']
# During development, you can instead set just the base URL
# (you might decide to change the site a few times).
# ALLOWED_HOSTS = ['.railway.com','127.0.0.1']
```
Since the applications uses CSRF protection, you will also need to set the [CSRF_TRUSTED_ORIGINS](https://docs.djangoproject.com/en/4.2/ref/settings/#csrf-trusted-origins) key.
Open **/locallibrary/settings.py** and add a line like the one below:
```python
## For example, for a site URL is at 'web-production-3640.up.railway.app'
## (replace the string below with your own site URL):
CSRF_TRUSTED_ORIGINS = ['https://web-production-3640.up.railway.app']
# During development/for this tutorial you can instead set just the base URL
# CSRF_TRUSTED_ORIGINS = ['https://*.railway.app']
```
Then save your settings and commit them to your GitHub repo (Railway will automatically update and redeploy your application).
### Provision and connect a Postgres SQL database
Next we need to create a Postgres database and connect it to the Django application that we just deployed.
(If you open the site now you'll get a new error because the database cannot be accessed).
We will create the database as part of the application project, although you can create the database in its own separate project.
On Railway, choose the **Dashboard** option from the site top menu and then select your application project.
At this stage it just contains a single service for your application (this can be selected to set variables and other details of the service).
The **Settings** button can be selected to change project-wide settings.
Select the **New** button, which is used to add services to the project.
Select **Database** when prompted about the type of service to add:
Then select **Add PostgreSQL** to start adding the database
Railway will then provision a service containing an empty database in the same project.
On completion you will now see both the application and database services in the project view.
Select the web service and then the _Variables_ tab.
Select **New Variable** and then in the _Variable name_ box, select **Add reference**.
Scroll down and select `DATABASE_URL` (this is the name of the variable that we set up the locallibrary to read as an environment variable).
Then select **Add** to add the variable reference and finally **Deploy** (this will appear in a popup).
Note that you could also have opened the Postgres database, then its variable tab, and copied the variable across.
If you open the project now it should display just as it did locally.
Note however that there is no way to populate the library with data yet, because we have not yet created a superuser account.
We'll do that using the [CLI](https://docs.railway.app/develop/cli) tool on our local computer.
### Install the client
Download and install the Railway client for your local operating system by following the [instructions here](https://docs.railway.app/develop/cli).
After the client is installed you will be able to run commands.
Some of the more important operations include deploying the current directory of your computer to an associated Railway project (without having to upload to GitHub), and running your Django project locally using the same settings as you have on the production server.
We show these in the next sections.
You can get a list of all the possible commands by entering the following in a terminal.
```bash
railway help
```
> **Note:** In the following section we use `railway login` and `railway link` to link the current project to a directory.
> If you are logged out by the system, you will need to call both commands again to re-link the project.
### Configure a superuser
In order to create a superuser, we need to call the Django `createsuperuser` command against the production database (this is the same operation as we ran locally in [Django Tutorial Part 4: Django admin site > Creating a superuser](/en-US/docs/Learn/Server-side/Django/Admin_site#creating_a_superuser)).
Railway doesn't provide direct terminal access to the server, and we can't add this command to the [Procfile](#procfile) because it is interactive.
What we can do is call this command locally on our Django project when it is connected to the _production_ database.
The Railway client makes this easy by providing a mechanism to run commands locally using the same environment variables as the production server, including the database connection string.
First open a terminal or command prompt in a git clone of your locallibrary project.
Then login to your browser account using the `login` or `login --browserless` command (follow any resulting prompts and instructions from the client or website to complete the login):
```bash
railway login
```
Once logged in, link your current locallibrary directory to the associated Railway project using the following command.
Note that you will need to select/enter a particular project when prompted:
```bash
railway link
```
Now that the local directory and project are _linked_ you can run the local Django project with settings from the production environment.
First ensure that your normal [Django development environment](/en-US/docs/Learn/Server-side/Django/development_environment) is ready.
Then call the following command, entering name, email, and password as required:
```bash
railway run python manage.py createsuperuser
```
You should now be able to open your website admin area (`https://[your-url].railway.app/admin/`) and populate the database, just as shown in [Django Tutorial Part 4: Django admin site](/en-US/docs/Learn/Server-side/Django/Admin_site)).
### Setting configuration variables
The final step is to make the site secure.
Specifically, we need to disable debug logging and set a secret CSRF key.
The work to read the needed values from environment variables was done in [getting your website ready to publish](#getting_your_website_ready_to_publish) (see `DJANGO_DEBUG` and `DJANGO_SECRET_KEY`).
Open the information screen for the project and select the _Variables_ tab.
This should already have the `DATABASE_URL` as shown below.
There are many ways to generate a cryptographically secret key.
A simple way is to run the following Python command on your development computer:
```bash
python -c "import secrets; print(secrets.token_urlsafe())"
```
Select the **New Variable** button and enter the key `DJANGO_SECRET_KEY` with your secret value (then select **Add**).
Then enter the key `DJANGO_DEBUG` with the value `False`.
The final set of variables should look like this:
### Debugging
The Railway client provides the logs command to show the tail of logs (a more full log is available on the site for each project):
```bash
railway logs
```
If you need more information than this can provide you will need to start looking into [Django Logging](https://docs.djangoproject.com/en/4.2/topics/logging/).
## Summary
That's the end of this tutorial on setting up Django apps in production, and also the series of tutorials on working with Django. We hope you've found them useful. You can check out a fully worked-through version of the [source code on GitHub here](https://github.com/mdn/django-locallibrary-tutorial).
The next step is to read our last few articles, and then complete the assessment task.
## See also
- [Deploying Django](https://docs.djangoproject.com/en/4.2/howto/deployment/) (Django docs)
- [Deployment checklist](https://docs.djangoproject.com/en/4.2/howto/deployment/checklist/) (Django docs)
- [Deploying static files](https://docs.djangoproject.com/en/4.2/howto/static-files/deployment/) (Django docs)
- [How to deploy with WSGI](https://docs.djangoproject.com/en/4.2/howto/deployment/wsgi/) (Django docs)
- [How to use Django with Apache and mod_wsgi](https://docs.djangoproject.com/en/4.2/howto/deployment/wsgi/modwsgi/) (Django docs)
- [How to use Django with Gunicorn](https://docs.djangoproject.com/en/4.2/howto/deployment/wsgi/gunicorn/) (Django docs)
- Railway Docs
- [CLI](https://docs.railway.app/develop/cli)
- Digital Ocean
- [How To Serve Django Applications with uWSGI and Nginx on Ubuntu 16.04](https://www.digitalocean.com/community/tutorials/how-to-serve-django-applications-with-uwsgi-and-nginx-on-ubuntu-16-04)
- [Other Digital Ocean Django community docs](https://www.digitalocean.com/community/tutorials?q=django)
- Heroku Docs (similar setup concepts)
- [Configuring Django apps for Heroku](https://devcenter.heroku.com/articles/django-app-configuration) (Heroku docs)
- [Getting Started on Heroku with Django](https://devcenter.heroku.com/articles/getting-started-with-python#introduction) (Heroku docs)
- [Django and Static Assets](https://devcenter.heroku.com/articles/django-assets) (Heroku docs)
- [Concurrency and Database Connections in Django](https://devcenter.heroku.com/articles/python-concurrency-and-database-connections) (Heroku docs)
- [How Heroku works](https://devcenter.heroku.com/articles/how-heroku-works) (Heroku docs)
- [Dynos and the Dyno Manager](https://devcenter.heroku.com/articles/dynos) (Heroku docs)
- [Configuration and Config Vars](https://devcenter.heroku.com/articles/config-vars) (Heroku docs)
- [Limits](https://devcenter.heroku.com/articles/limits) (Heroku docs)
- [Deploying Python applications with Gunicorn](https://devcenter.heroku.com/articles/python-gunicorn) (Heroku docs)
- [Deploying Python and Django apps on Heroku](https://devcenter.heroku.com/articles/deploying-python) (Heroku docs)
{{PreviousMenuNext("Learn/Server-side/Django/Testing", "Learn/Server-side/Django/web_application_security", "Learn/Server-side/Django")}}
| 0 |
data/mdn-content/files/en-us/learn/server-side/django | data/mdn-content/files/en-us/learn/server-side/django/home_page/index.md | ---
title: "Django Tutorial Part 5: Creating our home page"
slug: Learn/Server-side/Django/Home_page
page-type: learn-module-chapter
---
{{LearnSidebar}}{{PreviousMenuNext("Learn/Server-side/Django/Admin_site", "Learn/Server-side/Django/Generic_views", "Learn/Server-side/Django")}}
We're now ready to add the code that displays our first complete page — a home page for the [LocalLibrary](/en-US/docs/Learn/Server-side/Django/Tutorial_local_library_website) website. The home page will show the number of records we have for each model type and provide sidebar navigation links to our other pages. Along the way we'll gain practical experience in writing basic URL maps and views, getting records from the database, and using templates.
<table>
<tbody>
<tr>
<th scope="row">Prerequisites:</th>
<td>
Read the <a href="/en-US/docs/Learn/Server-side/Django/Introduction">Django Introduction</a>. Complete previous tutorial topics (including <a href="/en-US/docs/Learn/Server-side/Django/Admin_site">Django Tutorial Part 4: Django admin site</a>).
</td>
</tr>
<tr>
<th scope="row">Objective:</th>
<td>
Learn to create simple URL maps and views (where no data is encoded in the URL), get data from models, and create templates.
</td>
</tr>
</tbody>
</table>
## Overview
After we defined our models and created some initial library records to work with, it's time to write the code that presents that information to users. The first thing we need to do is determine what information we want to display in our pages, and define the URLs to use for returning those resources. Then we'll create a URL mapper, views, and templates to display the pages.
The following diagram describes the main data flow, and the components required when handling HTTP requests and responses. As we already implemented the model, the main components we'll create are:
- URL mappers to forward the supported URLs (and any information encoded in the URLs) to the appropriate view functions.
- View functions to get the requested data from the models, create HTML pages that display the data, and return the pages to the user to view in the browser.
- Templates to use when rendering data in the views.
As you'll see in the next section, we have 5 pages to display, which is too much information to document in a single article. Therefore, this article will focus on how to implement the home page, and we'll cover the other pages in a subsequent article. This should give you a good end-to-end understanding of how URL mappers, views, and models work in practice.
## Defining the resource URLs
As this version of [LocalLibrary](/en-US/docs/Learn/Server-side/Django/Tutorial_local_library_website) is essentially read-only for end users, we just need to provide a landing page for the site (a home page), and pages that _display_ list and detail views for books and authors.
The URLs that we'll need for our pages are:
- `catalog/` — The home (index) page.
- `catalog/books/` — A list of all books.
- `catalog/authors/` — A list of all authors.
- `catalog/book/<id>` — The detail view for a particular book, with a field primary key of `<id>` (the default). For example, the URL for the third book added to the list will be `/catalog/book/3`.
- `catalog/author/<id>` — The detail view for the specific author with a primary key field of `<id>`. For example, the URL for the 11th author added to the list will be `/catalog/author/11`.
The first three URLs will return the index page, books list, and authors list. These URLs do not encode any additional information, and the queries that fetch data from the database will always be the same. However, the results that the queries return will depend on the contents of the database.
By contrast the final two URLs will display detailed information about a specific book or author. These URLs encode the identity of the item to display (represented by `<id>` above). The URL mapper will extract the encoded information and pass it to the view, and the view will dynamically determine what information to get from the database. By encoding the information in the URL we will use a single set of a URL mapping, a view, and a template to handle all books (or authors).
> **Note:** With Django, you can construct your URLs however you require — you can encode information in the body of the URL as shown above, or include `GET` parameters in the URL, for example `/book/?id=6`. Whichever approach you use, the URLs should be kept clean, logical, and readable, as [recommended by the W3C](https://www.w3.org/Provider/Style/URI).
> The Django documentation recommends encoding information in the body of the URL to achieve better URL design.
As mentioned in the overview, the rest of this article describes how to construct the index page.
## Creating the index page
The first page we'll create is the index page (`catalog/`). The index page will include some static HTML, along with generated "counts" of different records in the database. To make this work we'll create a URL mapping, a view, and a template.
> **Note:** It's worth paying a little extra attention in this section. Most of the information also applies to the other pages we'll create.
### URL mapping
When we created the [skeleton website](/en-US/docs/Learn/Server-side/Django/skeleton_website), we updated the **locallibrary/urls.py** file to ensure that whenever a URL that starts with `catalog/` is received, the _URLConf_ module `catalog.urls` will process the remaining substring.
The following code snippet from **locallibrary/urls.py** includes the `catalog.urls` module:
```python
urlpatterns += [
path('catalog/', include('catalog.urls')),
]
```
> **Note:** Whenever Django encounters the import function [`django.urls.include()`](https://docs.djangoproject.com/en/4.2/ref/urls/#django.urls.include), it splits the URL string at the designated end character and sends the remaining substring to the included _URLconf_ module for further processing.
We also created a placeholder file for the _URLConf_ module, named **/catalog/urls.py**.
Add the following lines to that file:
```python
urlpatterns = [
path('', views.index, name='index'),
]
```
The `path()` function defines the following:
- A URL pattern, which is an empty string: `''`. We'll discuss URL patterns in detail when working on the other views.
- A view function that will be called if the URL pattern is detected: `views.index`, which is the function named `index()` in the **views.py** file.
The `path()` function also specifies a `name` parameter, which is a unique identifier for _this_ particular URL mapping. You can use the name to "reverse" the mapper, i.e. to dynamically create a URL that points to the resource that the mapper is designed to handle.
For example, we can use the name parameter to link to our home page from any other page by adding the following link in a template:
```django
<a href="{% url 'index' %}">Home</a>.
```
> **Note:** We can hard code the link as in `<a href="/catalog/">Home</a>`), but if we change the pattern for our home page, for example, to `/catalog/index`) the templates will no longer link correctly. Using a reversed URL mapping is more robust.
### View (function-based)
A view is a function that processes an HTTP request, fetches the required data from the database, renders the data in an HTML page using an HTML template, and then returns the generated HTML in an HTTP response to display the page to the user. The index view follows this model — it fetches information about the number of `Book`, `BookInstance`, available `BookInstance` and `Author` records that we have in the database, and passes that information to a template for display.
Open **catalog/views.py** and note that the file already imports the [render()](https://docs.djangoproject.com/en/4.2/topics/http/shortcuts/#django.shortcuts.render) shortcut function to generate an HTML file using a template and data:
```python
from django.shortcuts import render
# Create your views here.
```
Paste the following lines at the bottom of the file:
```python
from .models import Book, Author, BookInstance, Genre
def index(request):
"""View function for home page of site."""
# Generate counts of some of the main objects
num_books = Book.objects.all().count()
num_instances = BookInstance.objects.all().count()
# Available books (status = 'a')
num_instances_available = BookInstance.objects.filter(status__exact='a').count()
# The 'all()' is implied by default.
num_authors = Author.objects.count()
context = {
'num_books': num_books,
'num_instances': num_instances,
'num_instances_available': num_instances_available,
'num_authors': num_authors,
}
# Render the HTML template index.html with the data in the context variable
return render(request, 'index.html', context=context)
```
The first line imports the model classes that we'll use to access data in all our views.
The first part of the view function fetches the number of records using the `objects.all()` attribute on the model classes. It also gets a list of `BookInstance` objects that have a value of 'a' (Available) in the status field. You can find more information about how to access model data in our previous tutorial [Django Tutorial Part 3: Using models > Searching for records](/en-US/docs/Learn/Server-side/Django/Models#searching_for_records).
At the end of the view function we call the `render()` function to create an HTML page and return the page as a response. This shortcut function wraps a number of other functions to simplify a very common use case. The `render()` function accepts the following parameters:
- the original `request` object, which is an `HttpRequest`.
- an HTML template with placeholders for the data.
- a `context` variable, which is a Python dictionary, containing the data to insert into the placeholders.
We'll talk more about templates and the `context` variable in the next section. Let's get to creating our template so we can actually display something to the user!
### Template
A template is a text file that defines the structure or layout of a file (such as an HTML page), it uses placeholders to represent actual content.
A Django application created using **startapp** (like the skeleton of this example) will look for templates in a subdirectory named '**templates**' of your applications. For example, in the index view that we just added, the `render()` function will expect to find the file **_index.html_** in **/locallibrary/catalog/templates/** and will raise an error if the file is not present.
You can check this by saving the previous changes and accessing `127.0.0.1:8000` in your browser - it will display a fairly intuitive error message: "`TemplateDoesNotExist at /catalog/`", and other details.
> **Note:** Based on your project's settings file, Django will look for templates in a number of places, searching in your installed applications by default. You can find out more about how Django finds templates and what template formats it supports in [the Templates section of the Django documentation](https://docs.djangoproject.com/en/4.2/topics/templates/).
#### Extending templates
The index template will need standard HTML markup for the head and body, along with navigation sections to link to the other pages of the site (which we haven't created yet), and to sections that display introductory text and book data.
Much of the HTML and navigation structure will be the same in every page of our site. Instead of duplicating boilerplate code on every page, you can use the Django templating language to declare a base template, and then extend it to replace just the bits that are different for each specific page.
The following code snippet is a sample base template from a **base_generic.html** file.
We'll be creating the template for LocalLibrary shortly.
The sample below includes common HTML with sections for a title, a sidebar, and main contents marked with the named `block` and `endblock` template tags.
You can leave the blocks empty, or include default content to use when rendering pages derived from the template.
> **Note:** Template _tags_ are functions that you can use in a template to loop through lists, perform conditional operations based on the value of a variable, and so on. In addition to template tags, the template syntax allows you to reference variables that are passed into the template from the view, and use _template filters_ to format variables (for example, to convert a string to lower case).
```django
<!DOCTYPE html>
<html lang="en">
<head>
{% block title %}
<title>Local Library</title>
{% endblock %}
</head>
<body>
{% block sidebar %}
<!-- insert default navigation text for every page -->
{% endblock %}
{% block content %}
<!-- default content text (typically empty) -->
{% endblock %}
</body>
</html>
```
When defining a template for a particular view, we first specify the base template using the `extends` template tag — see the code sample below. Then we declare what sections from the template we want to replace (if any), using `block`/`endblock` sections as in the base template.
For example, the code snippet below shows how to use the `extends` template tag and override the `content` block. The generated HTML will include the code and structure defined in the base template, including the default content you defined in the `title` block, but the new `content` block in place of the default one.
```django
{% extends "base_generic.html" %}
{% block content %}
<h1>Local Library Home</h1>
<p>
Welcome to LocalLibrary, a website developed by
<em>Mozilla Developer Network</em>!
</p>
{% endblock %}
```
#### The LocalLibrary base template
We will use the following code snippet as the base template for the _LocalLibrary_ website. As you can see, it contains some HTML code and defines blocks for `title`, `sidebar`, and `content`. We have a default title and a default sidebar with links to lists of all books and authors, both enclosed in blocks to be easily changed in the future.
> **Note:** We also introduce two additional template tags: `url` and `load static`. These tags will be explained in following sections.
Create a new file **base_generic.html** in **/locallibrary/catalog/templates/** and paste the following code to the file:
```django
<!DOCTYPE html>
<html lang="en">
<head>
{% block title %}
<title>Local Library</title>
{% endblock %}
<meta charset="utf-8" />
<meta name="viewport" content="width=device-width, initial-scale=1" />
<link href="https://cdn.jsdelivr.net/npm/[email protected]/dist/css/bootstrap.min.css"
rel="stylesheet"
integrity="sha384-T3c6CoIi6uLrA9TneNEoa7RxnatzjcDSCmG1MXxSR1GAsXEV/Dwwykc2MPK8M2HN"
crossorigin="anonymous">
<!-- Add additional CSS in static file -->
{% load static %}
<link rel="stylesheet" href="{% static 'css/styles.css' %}" />
</head>
<body>
<div class="container-fluid">
<div class="row">
<div class="col-sm-2">
{% block sidebar %}
<ul class="sidebar-nav">
<li><a href="{% url 'index' %}">Home</a></li>
<li><a href="">All books</a></li>
<li><a href="">All authors</a></li>
</ul>
{% endblock %}
</div>
<div class="col-sm-10 ">{% block content %}{% endblock %}</div>
</div>
</div>
</body>
</html>
```
The template includes CSS from [Bootstrap](https://getbootstrap.com/) to improve the layout and presentation of the HTML page. Using Bootstrap (or another client-side web framework) is a quick way to create an attractive page that displays well on different screen sizes.
The base template also references a local CSS file (**styles.css**) that provides additional styling. Create a **styles.css** file in **/locallibrary/catalog/static/css/** and paste the following code in the file:
```css
.sidebar-nav {
margin-top: 20px;
padding: 0;
list-style: none;
}
```
#### The index template
Create a new HTML file **index.html** in **/locallibrary/catalog/templates/** and paste the following code in the file.
This code extends our base template on the first line, and then replaces the default `content` block for the template.
```django
{% extends "base_generic.html" %}
{% block content %}
<h1>Local Library Home</h1>
<p>
Welcome to LocalLibrary, a website developed by
<em>Mozilla Developer Network</em>!
</p>
<h2>Dynamic content</h2>
<p>The library has the following record counts:</p>
<ul>
<li><strong>Books:</strong> \{{ num_books }}</li>
<li><strong>Copies:</strong> \{{ num_instances }}</li>
<li><strong>Copies available:</strong> \{{ num_instances_available }}</li>
<li><strong>Authors:</strong> \{{ num_authors }}</li>
</ul>
{% endblock %}
```
In the _Dynamic content_ section we declare placeholders (_template variables_) for the information from the view that we want to include.
The variables are enclosed with double brace (handlebars).
> **Note:** You can easily recognize template variables and template tags (functions) - variables are enclosed in double braces (`\{{ num_books }}`), and tags are enclosed in single braces with percentage signs (`{% extends "base_generic.html" %}`).
The important thing to note here is that variables are named with the _keys_ that we pass into the `context` dictionary in the `render()` function of our view (see sample below).
Variables will be replaced with their associated _values_ when the template is rendered.
```python
context = {
'num_books': num_books,
'num_instances': num_instances,
'num_instances_available': num_instances_available,
'num_authors': num_authors,
}
return render(request, 'index.html', context=context)
```
#### Referencing static files in templates
Your project is likely to use static resources, including JavaScript, CSS, and images. Because the location of these files might not be known (or might change), Django allows you to specify the location in your templates relative to the `STATIC_URL` global setting. The default skeleton website sets the value of `STATIC_URL` to '`/static/`', but you might choose to host these on a content delivery network or elsewhere.
Within the template you first call the `load` template tag specifying "static" to add the template library, as shown in the code sample below. You can then use the `static` template tag and specify the relative URL to the required file.
```django
<!-- Add additional CSS in static file -->
{% load static %}
<link rel="stylesheet" href="{% static 'css/styles.css' %}" />
```
You can add an image into the page in a similar way, for example:
```django
{% load static %}
<img
src="{% static 'catalog/images/local_library_model_uml.png' %}"
alt="UML diagram"
style="width:555px;height:540px;" />
```
> **Note:** The samples above specify where the files are located, but Django does not serve them by default. We configured the development web server to serve files by modifying the global URL mapper (**/locallibrary/locallibrary/urls.py**) when we [created the website skeleton](/en-US/docs/Learn/Server-side/Django/skeleton_website), but still need to enable file serving in production. We'll look at this later.
For more information on working with static files see [Managing static files](https://docs.djangoproject.com/en/4.2/howto/static-files/) in the Django documentation.
#### Linking to URLs
The base template above introduced the `url` template tag.
```django
<li><a href="{% url 'index' %}">Home</a></li>
```
This tag accepts the name of a `path()` function called in your **urls.py** and the values for any arguments that the associated view will receive from that function, and returns a URL that you can use to link to the resource.
#### Configuring where to find the templates
The location where Django searches for templates is specified in the `TEMPLATES` object in the **settings.py** file.
The default **settings.py** (as created for this tutorial) looks something like this:
```python
TEMPLATES = [
{
'BACKEND': 'django.template.backends.django.DjangoTemplates',
'DIRS': [],
'APP_DIRS': True,
'OPTIONS': {
'context_processors': [
'django.template.context_processors.debug',
'django.template.context_processors.request',
'django.contrib.auth.context_processors.auth',
'django.contrib.messages.context_processors.messages',
],
},
},
]
```
The setting of `'APP_DIRS': True`, is the most important, as it tells Django to search for templates in a subdirectory of each application in the project, named "templates" (this makes it easier to group templates with their associated application for easy re-use).
We can also specify specific locations for Django to search for directories using `'DIRS': []` (but that isn't needed yet).
> **Note:** You can find out more about how Django finds templates and what template formats it supports in [the Templates section of the Django documentation](https://docs.djangoproject.com/en/4.2/topics/templates/).
## What does it look like?
At this point we have created all required resources to display the index page. Run the server (`python3 manage.py runserver`) and open `http://127.0.0.1:8000/` in your browser. If everything is configured correctly, your site should look like the following screenshot.
> **Note:** The **All books** and **All authors** links will not work yet because the paths, views, and templates for those pages are not defined. We just inserted placeholders for those links in the `base_generic.html` template.
## Challenge yourself
Here are a couple of tasks to test your familiarity with model queries, views, and templates.
1. The LocalLibrary [base template](#the_locallibrary_base_template) includes a `title` block. Override this block in the [index template](#the_index_template) and create a new title for the page.
> **Note:** The section [Extending templates](#extending_templates) explains how to create blocks and extend a block in another template.
2. Modify the [view](<#view_(function-based)>) to generate counts for _genres_ and _books_ that contain a particular word (case insensitive), and pass the results to the `context`. You accomplish this in a similar way to creating and using `num_books` and `num_instances_available`. Then update the [index template](#the_index_template) to include these variables.
## Summary
We just created the home page for our site — an HTML page that displays a number of records from the database and links to other yet-to-be-created pages. Along the way we learned fundamental information about URL mappers, views, querying the database with models, passing information to a template from a view, and creating and extending templates.
In the next article we'll build upon this knowledge to create the remaining four pages of our website.
## See also
- [Writing your first Django app, part 3: Views and Templates](https://docs.djangoproject.com/en/4.2/intro/tutorial03/) (Django docs)
- [URL dispatcher](https://docs.djangoproject.com/en/4.2/topics/http/urls/) (Django docs)
- [View functions](https://docs.djangoproject.com/en/4.2/topics/http/views/) (DJango docs)
- [Templates](https://docs.djangoproject.com/en/4.2/topics/templates/) (Django docs)
- [Managing static files](https://docs.djangoproject.com/en/4.2/howto/static-files/) (Django docs)
- [Django shortcut functions](https://docs.djangoproject.com/en/4.2/topics/http/shortcuts/#django.shortcuts.render) (Django docs)
{{PreviousMenuNext("Learn/Server-side/Django/Admin_site", "Learn/Server-side/Django/Generic_views", "Learn/Server-side/Django")}}
| 0 |
data/mdn-content/files/en-us/learn/server-side/django | data/mdn-content/files/en-us/learn/server-side/django/admin_site/index.md | ---
title: "Django Tutorial Part 4: Django admin site"
slug: Learn/Server-side/Django/Admin_site
page-type: learn-module-chapter
---
{{LearnSidebar}}{{PreviousMenuNext("Learn/Server-side/Django/Models", "Learn/Server-side/Django/Home_page", "Learn/Server-side/Django")}}
Now that we've created models for the [LocalLibrary](/en-US/docs/Learn/Server-side/Django/Tutorial_local_library_website) website, we'll use the Django Admin site to add some "real" book data. First we'll show you how to register the models with the admin site, then we'll show you how to login and create some data. At the end of the article we will show some of the ways you can further improve the presentation of the Admin site.
<table>
<tbody>
<tr>
<th scope="row">Prerequisites:</th>
<td>
First complete: <a href="/en-US/docs/Learn/Server-side/Django/Models"
>Django Tutorial Part 3: Using models</a
>.
</td>
</tr>
<tr>
<th scope="row">Objective:</th>
<td>
To understand the benefits and limitations of the Django admin site, and use it to create some records for our models.
</td>
</tr>
</tbody>
</table>
## Overview
The Django admin _application_ can use your models to automatically build a site area that you can use to create, view, update, and delete records. This can save you a lot of time during development, making it very easy to test your models and get a feel for whether you have the _right_ data. The admin application can also be useful for managing data in production, depending on the type of website. The Django project recommends it only for internal data management (i.e. just for use by admins, or people internal to your organization), as the model-centric approach is not necessarily the best possible interface for all users, and exposes a lot of unnecessary detail about the models.
All the configuration required to include the admin application in your website was done automatically when you [created the skeleton project](/en-US/docs/Learn/Server-side/Django/skeleton_website) (for information about actual dependencies needed, see the [Django docs here](https://docs.djangoproject.com/en/4.2/ref/contrib/admin/)). As a result, all you **must** do to add your models to the admin application is to _register_ them. At the end of this article we'll provide a brief demonstration of how you might further configure the admin area to better display our model data.
After registering the models we'll show how to create a new "superuser", login to the site, and create some books, authors, book instances, and genres. These will be useful for testing the views and templates we'll start creating in the next tutorial.
## Registering models
First, open **admin.py** in the catalog application (**/locallibrary/catalog/admin.py**). It currently looks like this — note that it already imports `django.contrib.admin`:
```python
from django.contrib import admin
# Register your models here.
```
Register the models by copying the following text into the bottom of the file. This code imports the models and then calls `admin.site.register` to register each of them.
```python
from .models import Author, Genre, Book, BookInstance, Language
admin.site.register(Book)
admin.site.register(Author)
admin.site.register(Genre)
admin.site.register(BookInstance)
admin.site.register(Language)
```
> **Note:** The lines above assume that you accepted the challenge to create a model to represent the natural language of a book ([see the models tutorial article](/en-US/docs/Learn/Server-side/Django/Models))!
This is the simplest way of registering a model, or models, with the site. The admin site is highly customizable, and we'll talk more about the other ways of registering your models further down.
## Creating a superuser
In order to log into the admin site, we need a user account with _Staff_ status enabled. In order to view and create records we also need this user to have permissions to manage all our objects. You can create a "superuser" account that has full access to the site and all needed permissions using **manage.py**.
Call the following command, in the same directory as **manage.py**, to create the superuser. You will be prompted to enter a username, email address, and _strong_ password.
```bash
python3 manage.py createsuperuser
```
Once this command completes a new superuser will have been added to the database. Now restart the development server so we can test the login:
```bash
python3 manage.py runserver
```
## Logging in and using the site
To login to the site, open the _/admin_ URL (e.g. `http://127.0.0.1:8000/admin`) and enter your new superuser userid and password credentials (you'll be redirected to the _login_ page, and then back to the _/admin_ URL after you've entered your details).
This part of the site displays all our models, grouped by installed application. You can click on a model name to go to a screen that lists all its associated records, and you can further click on those records to edit them. You can also directly click the **Add** link next to each model to start creating a record of that type.
Click on the **Add** link to the right of _Books_ to create a new book (this will display a dialog much like the one below). Note how the titles of each field, the type of widget used, and the `help_text` (if any) match the values you specified in the model.
Enter values for the fields. You can create new authors or genres by pressing the **+** button next to the respective fields (or select existing values from the lists if you've already created them). When you're done you can press **SAVE**, **Save and add another**, or **Save and continue editing** to save the record.
> **Note:** At this point we'd like you to spend some time adding a few books, authors, languages, and genres (e.g. Fantasy) to your application. Make sure that each author and genre includes a couple of different books (this will make your list and detail views more interesting when we implement them later on in the article series).
When you've finished adding books, click on the **Home** link in the top bookmark to be taken back to the main admin page. Then click on the **Books** link to display the current list of books (or on one of the other links to see other model lists). Now that you've added a few books, the list might look similar to the screenshot below. The title of each book is displayed; this is the value returned in the Book model's `__str__()` method that we specified in the last article.
From this list you can delete books by selecting the checkbox next to the book you don't want, selecting the _delete…_ action from the _Action_ drop-down list, and then pressing the **Go** button. You can also add new books by pressing the **ADD BOOK** button.
You can edit a book by selecting its name in the link. The edit page for a book, shown below, is almost identical to the "Add" page. The main differences are the page title (_Change book_) and the addition of **Delete**, **HISTORY** and **VIEW ON SITE** buttons (this last button appears because we defined the `get_absolute_url()` method in our model).
> **Note:** Clicking the **VIEW ON SITE** button raises a `NoReverseMatch` exception because the `get_absolute_url()` method attempts to `reverse()` a named URL mapping ('book-detail') that has not yet been defined.
> We'll define a URL mapping and associated view in [Django Tutorial Part 6: Generic list and detail views](/en-US/docs/Learn/Server-side/Django/Generic_views).
Now navigate back to the **Home** page (using the _Home_ link in the breadcrumb trail) and then view the **Author** and **Genre** lists — you should already have quite a few created from when you added the new books, but feel free to add some more.
What you won't have is any _Book Instances_, because these are not created from Books (although you can create a `Book` from a `BookInstance` — this is the nature of the `ForeignKey` field). Navigate back to the _Home_ page and press the associated **Add** button to display the _Add book instance_ screen below. Note the large, globally unique Id, which can be used to separately identify a single copy of a book in the library.
Create a number of these records for each of your books. Set the status as _Available_ for at least some records and _On loan_ for others. If the status is **not** _Available_, then also set a future _Due back_ date.
That's it! You've now learned how to set up and use the administration site. You've also created records for `Book`, `BookInstance`, `Genre`, `Language` and `Author` that we'll be able to use once we create our own views and templates.
## Advanced configuration
Django does a pretty good job of creating a basic admin site using the information from the registered models:
- Each model has a list of individual records, identified by the string created with the model's `__str__()` method, and linked to detail views/forms for editing. By default, this view has an action menu at the top that you can use to perform bulk delete operations on records.
- The model detail record forms for editing and adding records contain all the fields in the model, laid out vertically in their declaration order.
You can further customize the interface to make it even easier to use. Some of the things you can do are:
- List views:
- Add additional fields/information displayed for each record.
- Add filters to select which records are listed, based on date or some other selection value (e.g. Book loan status).
- Add additional options to the actions menu in list views and choose where this menu is displayed on the form.
- Detail views
- Choose which fields to display (or exclude), along with their order, grouping, whether they are editable, the widget used, orientation etc.
- Add related fields to a record to allow inline editing (e.g. add the ability to add and edit book records while you're creating their author record).
In this section we're going to look at a few changes that will improve the interface for our _LocalLibrary_, including adding more information to `Book` and `Author` model lists, and improving the layout of their edit views. We won't change the `Language` and `Genre` model presentation because they only have one field each, so there is no real benefit in doing so!
You can find a complete reference of all the admin site customization choices in [The Django Admin site](https://docs.djangoproject.com/en/4.2/ref/contrib/admin/) (Django Docs).
### Register a ModelAdmin class
To change how a model is displayed in the admin interface you define a [ModelAdmin](https://docs.djangoproject.com/en/4.2/ref/contrib/admin/#modeladmin-objects) class (which describes the layout) and register it with the model.
Let's start with the `Author` model. Open **admin.py** in the catalog application (**/locallibrary/catalog/admin.py**). Comment out your original registration (prefix it with a #) for the `Author` model:
```python
# admin.site.register(Author)
```
Now add a new `AuthorAdmin` and registration as shown below.
```python
# Define the admin class
class AuthorAdmin(admin.ModelAdmin):
pass
# Register the admin class with the associated model
admin.site.register(Author, AuthorAdmin)
```
Now we'll add `ModelAdmin` classes for `Book`, and `BookInstance`. We again need to comment out the original registrations:
```python
# admin.site.register(Book)
# admin.site.register(BookInstance)
```
Now to create and register the new models; for the purpose of this demonstration, we'll instead use the `@register` decorator to register the models (this does exactly the same thing as the `admin.site.register()` syntax):
```python
# Register the Admin classes for Book using the decorator
@admin.register(Book)
class BookAdmin(admin.ModelAdmin):
pass
# Register the Admin classes for BookInstance using the decorator
@admin.register(BookInstance)
class BookInstanceAdmin(admin.ModelAdmin):
pass
```
Currently all of our admin classes are empty (see `pass`) so the admin behavior will be unchanged! We can now extend these to define our model-specific admin behavior.
### Configure list views
The _LocalLibrary_ currently lists all authors using the object name generated from the model `__str__()` method. This is fine when you only have a few authors, but once you have many you may end up having duplicates. To differentiate them, or just because you want to show more interesting information about each author, you can use [list_display](https://docs.djangoproject.com/en/4.2/ref/contrib/admin/#django.contrib.admin.ModelAdmin.list_display) to add additional fields to the view.
Replace your `AuthorAdmin` class with the code below. The field names to be displayed in the list are declared in a _tuple_ in the required order, as shown (these are the same names as specified in your original model).
```python
class AuthorAdmin(admin.ModelAdmin):
list_display = ('last_name', 'first_name', 'date_of_birth', 'date_of_death')
```
Now navigate to the author list in your website. The fields above should now be displayed, like so:
For our `Book` model we'll additionally display the `author` and `genre`. The `author` is a `ForeignKey` field (one-to-many) relationship, and so will be represented by the `__str__()` value for the associated record. Replace the `BookAdmin` class with the version below.
```python
class BookAdmin(admin.ModelAdmin):
list_display = ('title', 'author', 'display_genre')
```
Unfortunately we can't directly specify the `genre` field in `list_display` because it is a `ManyToManyField` (Django prevents this because there would be a large database access "cost" in doing so). Instead we'll define a `display_genre` function to get the information as a string (this is the function we've called above; we'll define it below).
> **Note:** Getting the `genre` may not be a good idea here, because of the "cost" of the database operation. We're showing you how because calling functions in your models can be very useful for other reasons — for example to add a _Delete_ link next to every item in the list.
Add the following code into your `Book` model (**models.py**). This creates a string from the first three values of the `genre` field (if they exist) and creates a `short_description` that can be used in the admin site for this method.
```python
def display_genre(self):
"""Create a string for the Genre. This is required to display genre in Admin."""
return ', '.join(genre.name for genre in self.genre.all()[:3])
display_genre.short_description = 'Genre'
```
After saving the model and updated admin, open your website and go to the _Books_ list page; you should see a book list like the one below:
The `Genre` model (and the `Language` model, if you defined one) both have a single field, so there is no point creating an additional model for them to display additional fields.
> **Note:** It is worth updating the `BookInstance` model list to show at least the status and the expected return date. We've added that as a challenge at the end of this article!
### Add list filters
Once you've got a lot of items in a list, it can be useful to be able to filter which items are displayed.
This is done by listing fields in the `list_filter` attribute.
Replace your current `BookInstanceAdmin` class with the code fragment below.
```python
class BookInstanceAdmin(admin.ModelAdmin):
list_filter = ('status', 'due_back')
```
The list view will now include a filter box to the right. Note how you can choose dates and status to filter the values:
### Organize detail view layout
By default, the detail views lay out all fields vertically, in their order of declaration in the model. You can change the order of declaration, which fields are displayed (or excluded), whether sections are used to organize the information, whether fields are displayed horizontally or vertically, and even what edit widgets are used in the admin forms.
> **Note:** The _LocalLibrary_ models are relatively simple so there isn't a huge need for us to change the layout; we'll make some changes anyway however, just to show you how.
#### Controlling which fields are displayed and laid out
Update your `AuthorAdmin` class to add the `fields` line, as shown below:
```python
class AuthorAdmin(admin.ModelAdmin):
list_display = ('last_name', 'first_name', 'date_of_birth', 'date_of_death')
fields = ['first_name', 'last_name', ('date_of_birth', 'date_of_death')]
```
The `fields` attribute lists just those fields that are to be displayed on the form, in order. Fields are displayed vertically by default, but will display horizontally if you further group them in a tuple (as shown in the "date" fields above).
In your website go to the author detail view — it should now appear as shown below:
> **Note:** You can also use the `exclude` attribute to declare a list of attributes to be excluded from the form (all other attributes in the model will be displayed).
#### Sectioning the detail view
You can add "sections" to group related model information within the detail form, using the [fieldsets](https://docs.djangoproject.com/en/4.2/ref/contrib/admin/#django.contrib.admin.ModelAdmin.fieldsets) attribute.
In the `BookInstance` model we have information related to what the book is (i.e. `name`, `imprint`, and `id`) and when it will be available (`status`, `due_back`). We can add these to our `BookInstanceAdmin` class as shown below, using the `fieldsets` property.
```python
@admin.register(BookInstance)
class BookInstanceAdmin(admin.ModelAdmin):
list_filter = ('status', 'due_back')
fieldsets = (
(None, {
'fields': ('book', 'imprint', 'id')
}),
('Availability', {
'fields': ('status', 'due_back')
}),
)
```
Each section has its own title (or `None`, if you don't want a title) and an associated tuple of fields in a dictionary — the format is complicated to describe, but fairly easy to understand if you look at the code fragment immediately above.
Now navigate to a book instance view in your website; the form should appear as shown below:
### Inline editing of associated records
Sometimes it can make sense to be able to add associated records at the same time. For example, it may make sense to have both the book information and information about the specific copies you've got on the same detail page.
You can do this by declaring [inlines](https://docs.djangoproject.com/en/4.2/ref/contrib/admin/#django.contrib.admin.ModelAdmin.inlines), of type [TabularInline](https://docs.djangoproject.com/en/4.2/ref/contrib/admin/#django.contrib.admin.TabularInline) (horizontal layout) or [StackedInline](https://docs.djangoproject.com/en/4.2/ref/contrib/admin/#django.contrib.admin.StackedInline) (vertical layout, just like the default model layout). You can add the `BookInstance` information inline to our `Book` detail by specifying `inlines` in your `BookAdmin`:
```python
class BooksInstanceInline(admin.TabularInline):
model = BookInstance
@admin.register(Book)
class BookAdmin(admin.ModelAdmin):
list_display = ('title', 'author', 'display_genre')
inlines = [BooksInstanceInline]
```
Now navigate to a view for a `Book` in your website — at the bottom you should now see the book instances relating to this book (immediately below the book's genre fields):
In this case all we've done is declare our tabular inline class, which just adds all fields from the _inlined_ model. You can specify all sorts of additional information for the layout, including the fields to display, their order, whether they are read only or not, etc. (see [TabularInline](https://docs.djangoproject.com/en/4.2/ref/contrib/admin/#django.contrib.admin.TabularInline) for more information).
> **Note:** There are some painful limits in this functionality! In the screenshot above we have three existing book instances, followed by three placeholders for new book instances (which look very similar!). It would be better to have NO spare book instances by default and just add them with the **Add another Book instance** link, or to be able to just list the `BookInstance`s as non-readable links from here. The first option can be done by setting the `extra` attribute to `0` in `BooksInstanceInline` model, try it by yourself.
## Challenge yourself
We've learned a lot in this section, so now it is time for you to try a few things.
1. For the `BookInstance` list view, add code to display the book, status, due back date, and id (rather than the default `__str__()` text).
2. Add an inline listing of `Book` items to the `Author` detail view using the same approach as we did for `Book`/`BookInstance`.
## Summary
That's it! You've now learned how to set up the administration site in both its simplest and improved form, how to create a superuser, and how to navigate the admin site and view, delete, and update records. Along the way you've created a bunch of Books, BookInstances, Genres, and Authors that we'll be able to list and display once we create our own view and templates.
## Further reading
- [Writing your first Django app, part 2: Introducing the Django Admin](https://docs.djangoproject.com/en/4.2/intro/tutorial02/#introducing-the-django-admin) (Django docs)
- [The Django Admin site](https://docs.djangoproject.com/en/4.2/ref/contrib/admin/) (Django Docs)
{{PreviousMenuNext("Learn/Server-side/Django/Models", "Learn/Server-side/Django/Home_page", "Learn/Server-side/Django")}}
| 0 |
data/mdn-content/files/en-us/learn/server-side/django | data/mdn-content/files/en-us/learn/server-side/django/generic_views/index.md | ---
title: "Django Tutorial Part 6: Generic list and detail views"
slug: Learn/Server-side/Django/Generic_views
page-type: learn-module-chapter
---
{{LearnSidebar}}{{PreviousMenuNext("Learn/Server-side/Django/Home_page", "Learn/Server-side/Django/Sessions", "Learn/Server-side/Django")}}
This tutorial extends our [LocalLibrary](/en-US/docs/Learn/Server-side/Django/Tutorial_local_library_website) website, adding list and detail pages for books and authors. Here we'll learn about generic class-based views, and show how they can reduce the amount of code you have to write for common use cases. We'll also go into URL handling in greater detail, showing how to perform basic pattern matching.
<table>
<tbody>
<tr>
<th scope="row">Prerequisites:</th>
<td>
Complete all previous tutorial topics, including <a href="/en-US/docs/Learn/Server-side/Django/Home_page">Django Tutorial Part 5: Creating our home page</a>.
</td>
</tr>
<tr>
<th scope="row">Objective:</th>
<td>
To understand where and how to use generic class-based views, and how to extract patterns from URLs and pass the information to views.
</td>
</tr>
</tbody>
</table>
## Overview
In this tutorial we're going to complete the first version of the [LocalLibrary](/en-US/docs/Learn/Server-side/Django/Tutorial_local_library_website) website by adding list and detail pages for books and authors (or to be more precise, we'll show you how to implement the book pages, and get you to create the author pages yourself!)
The process is similar to creating the index page, which we showed in the previous tutorial. We'll still need to create URL maps, views, and templates. The main difference is that for the detail pages, we'll have the additional challenge of extracting information from patterns in the URL and passing it to the view. For these pages, we're going to demonstrate a completely different type of view: generic class-based list and detail views. These can significantly reduce the amount of view code needed, making them easier to write and maintain.
The final part of the tutorial will demonstrate how to paginate your data when using generic class-based list views.
## Book list page
The book list page will display a list of all the available book records in the page, accessed using the URL: `catalog/books/`. The page will display a title and author for each record, with the title being a hyperlink to the associated book detail page. The page will have the same structure and navigation as all other pages in the site, and we can, therefore, extend the base template (**base_generic.html**) we created in the previous tutorial.
### URL mapping
Open **/catalog/urls.py** and copy in the line setting the path for `'books/'`, as shown below.
Just as for the index page, this `path()` function defines a pattern to match against the URL (**'books/'**), a view function that will be called if the URL matches (`views.BookListView.as_view()`), and a name for this particular mapping.
```python
urlpatterns = [
path('', views.index, name='index'),
path('books/', views.BookListView.as_view(), name='books'),
]
```
As discussed in the previous tutorial the URL must already have matched `/catalog`, so the view will actually be called for the URL: `/catalog/books/`.
The view function has a different format than before — that's because this view will actually be implemented as a class. We will be inheriting from an existing generic view function that already does most of what we want this view function to do, rather than writing our own from scratch.
For Django class-based views we access an appropriate view function by calling the class method `as_view()`. This does all the work of creating an instance of the class, and making sure that the right handler methods are called for incoming HTTP requests.
### View (class-based)
We could quite easily write the book list view as a regular function (just like our previous index view), which would query the database for all books, and then call `render()` to pass the list to a specified template. Instead, however, we're going to use a class-based generic list view (`ListView`) — a class that inherits from an existing view. Because the generic view already implements most of the functionality we need and follows Django best-practice, we will be able to create a more robust list view with less code, less repetition, and ultimately less maintenance.
Open **catalog/views.py**, and copy the following code into the bottom of the file:
```python
from django.views import generic
class BookListView(generic.ListView):
model = Book
```
That's it! The generic view will query the database to get all records for the specified model (`Book`) then render a template located at **/locallibrary/catalog/templates/catalog/book_list.html** (which we will create below). Within the template you can access the list of books with the template variable named `object_list` OR `book_list` (i.e. generically "`<the model name>_list`").
> **Note:** This awkward path for the template location isn't a misprint — the generic views look for templates in `/application_name/the_model_name_list.html` (`catalog/book_list.html` in this case) inside the application's `/application_name/templates/` directory (`/catalog/templates/)`.
You can add attributes to change the default behavior above. For example, you can specify another template file if you need to have multiple views that use this same model, or you might want to use a different template variable name if `book_list` is not intuitive for your particular template use-case. Possibly the most useful variation is to change/filter the subset of results that are returned — so instead of listing all books you might list top 5 books that were read by other users.
```python
class BookListView(generic.ListView):
model = Book
context_object_name = 'book_list' # your own name for the list as a template variable
queryset = Book.objects.filter(title__icontains='war')[:5] # Get 5 books containing the title war
template_name = 'books/my_arbitrary_template_name_list.html' # Specify your own template name/location
```
#### Overriding methods in class-based views
While we don't need to do so here, you can also override some of the class methods.
For example, we can override the `get_queryset()` method to change the list of records returned. This is more flexible than just setting the `queryset` attribute as we did in the preceding code fragment (though there is no real benefit in this case):
```python
class BookListView(generic.ListView):
model = Book
def get_queryset(self):
return Book.objects.filter(title__icontains='war')[:5] # Get 5 books containing the title war
```
We might also override `get_context_data()` in order to pass additional context variables to the template (e.g. the list of books is passed by default). The fragment below shows how to add a variable named "`some_data`" to the context (it would then be available as a template variable).
```python
class BookListView(generic.ListView):
model = Book
def get_context_data(self, **kwargs):
# Call the base implementation first to get the context
context = super(BookListView, self).get_context_data(**kwargs)
# Create any data and add it to the context
context['some_data'] = 'This is just some data'
return context
```
When doing this it is important to follow the pattern used above:
- First get the existing context from our superclass.
- Then add your new context information.
- Then return the new (updated) context.
> **Note:** Check out [Built-in class-based generic views](https://docs.djangoproject.com/en/4.2/topics/class-based-views/generic-display/) (Django docs) for many more examples of what you can do.
### Creating the List View template
Create the HTML file **/locallibrary/catalog/templates/catalog/book_list.html** and copy in the text below. As discussed above, this is the default template file expected by the generic class-based list view (for a model named `Book` in an application named `catalog`).
Templates for generic views are just like any other templates (although of course the context/information passed to the template may differ).
As with our _index_ template, we extend our base template in the first line and then replace the block named `content`.
```django
{% extends "base_generic.html" %}
{% block content %}
<h1>Book List</h1>
{% if book_list %}
<ul>
{% for book in book_list %}
<li>
<a href="\{{ book.get_absolute_url }}">\{{ book.title }}</a>
(\{{book.author}})
</li>
{% endfor %}
</ul>
{% else %}
<p>There are no books in the library.</p>
{% endif %}
{% endblock %}
```
The view passes the context (list of books) by default as `object_list` and `book_list` aliases; either will work.
#### Conditional execution
We use the [`if`](https://docs.djangoproject.com/en/4.2/ref/templates/builtins/#if), `else`, and `endif` template tags to check whether the `book_list` has been defined and is not empty.
If `book_list` is empty, then the `else` clause displays text explaining that there are no books to list.
If `book_list` is not empty, then we iterate through the list of books.
```django
{% if book_list %}
<!-- code here to list the books -->
{% else %}
<p>There are no books in the library.</p>
{% endif %}
```
The condition above only checks for one case, but you can test on additional conditions using the `elif` template tag (e.g. `{% elif var2 %}`).
For more information about conditional operators see: [if](https://docs.djangoproject.com/en/4.2/ref/templates/builtins/#if), [ifequal/ifnotequal](https://docs.djangoproject.com/en/4.2/ref/templates/builtins/#ifequal-and-ifnotequal), and [ifchanged](https://docs.djangoproject.com/en/4.2/ref/templates/builtins/#ifchanged) in [Built-in template tags and filters](https://docs.djangoproject.com/en/4.2/ref/templates/builtins/) (Django Docs).
#### For loops
The template uses the [for](https://docs.djangoproject.com/en/4.2/ref/templates/builtins/#for) and `endfor` template tags to loop through the book list, as shown below.
Each iteration populates the `book` template variable with information for the current list item.
```django
{% for book in book_list %}
<li><!-- code here get information from each book item --></li>
{% endfor %}
```
You might also use the `{% empty %}` template tag to define what happens if the book list is empty (although our template chooses to use a conditional instead):
```django
<ul>
{% for book in book_list %}
<li><!-- code here get information from each book item --></li>
{% empty %}
<p>There are no books in the library.</p>
{% endfor %}
</ul>
```
While not used here, within the loop Django will also create other variables that you can use to track the iteration.
For example, you can test the `forloop.last` variable to perform conditional processing the last time that the loop is run.
#### Accessing variables
The code inside the loop creates a list item for each book that shows both the title (as a link to the yet-to-be-created detail view) and the author.
```django
<a href="\{{ book.get_absolute_url }}">\{{ book.title }}</a> (\{{book.author}})
```
We access the _fields_ of the associated book record using the "dot notation" (e.g. `book.title` and `book.author`), where the text following the `book` item is the field name (as defined in the model).
We can also call _functions_ in the model from within our template — in this case we call `Book.get_absolute_url()` to get a URL you could use to display the associated detail record. This works provided the function does not have any arguments (there is no way to pass arguments!)
> **Note:** We have to be a little careful of "side effects" when calling functions in templates. Here we just get a URL to display, but a function can do pretty much anything — we wouldn't want to delete our database (for example) just by rendering our template!
#### Update the base template
Open the base template (**/locallibrary/catalog/templates/_base_generic.html_**) and insert **{% url 'books' %}** into the URL link for **All books**, as shown below. This will enable the link in all pages (we can successfully put this in place now that we've created the "books" URL mapper).
```django
<li><a href="{% url 'index' %}">Home</a></li>
<li><a href="{% url 'books' %}">All books</a></li>
<li><a href="">All authors</a></li>
```
### What does it look like?
You won't be able to build the book list yet, because we're still missing a dependency — the URL map for the book detail pages, which is needed to create hyperlinks to individual books. We'll show both list and detail views after the next section.
## Book detail page
The book detail page will display information about a specific book, accessed using the URL `catalog/book/<id>` (where `<id>` is the primary key for the book). In addition to fields in the `Book` model (author, summary, ISBN, language, and genre), we'll also list the details of the available copies (`BookInstances`) including the status, expected return date, imprint, and id. This will allow our readers to not only learn about the book, but also to confirm whether/when it is available.
### URL mapping
Open **/catalog/urls.py** and add the path named '**book-detail**' shown below.
This `path()` function defines a pattern, associated generic class-based detail view, and a name.
```python
urlpatterns = [
path('', views.index, name='index'),
path('books/', views.BookListView.as_view(), name='books'),
path('book/<int:pk>', views.BookDetailView.as_view(), name='book-detail'),
]
```
For the _book-detail_ path the URL pattern uses a special syntax to capture the specific id of the book that we want to see.
The syntax is very simple: angle brackets define the part of the URL to be captured, enclosing the name of the variable that the view can use to access the captured data.
For example, **\<something>**, will capture the marked pattern and pass the value to the view as a variable "something". You can optionally precede the variable name with a [converter specification](https://docs.djangoproject.com/en/4.2/topics/http/urls/#path-converters) that defines the type of data (int, str, slug, uuid, path).
In this case we use `'<int:pk>'` to capture the book id, which must be a specially formatted string and pass it to the view as a parameter named `pk` (short for primary key). This is the id that is being used to store the book uniquely in the database, as defined in the Book Model.
> **Note:** As discussed previously, our matched URL is actually `catalog/book/<digits>` (because we are in the **catalog** application, `/catalog/` is assumed).
> **Warning:** The generic class-based detail view _expects_ to be passed a parameter named **pk**. If you're writing your own function view you can use whatever parameter name you like, or indeed pass the information in an unnamed argument.
#### Advanced path matching/regular expression primer
> **Note:** You won't need this section to complete the tutorial! We provide it because knowing this option is likely to be useful in your Django-centric future.
The pattern matching provided by `path()` is simple and useful for the (very common) cases where you just want to capture _any_ string or integer. If you need more refined filtering (for example, to filter only strings that have a certain number of characters) then you can use the [re_path()](https://docs.djangoproject.com/en/4.2/ref/urls/#django.urls.re_path) method.
This method is used just like `path()` except that it allows you to specify a pattern using a [Regular expression](https://docs.python.org/3/library/re.html). For example, the previous path could have been written as shown below:
```python
re_path(r'^book/(?P<pk>\d+)$', views.BookDetailView.as_view(), name='book-detail'),
```
_Regular expressions_ are an incredibly powerful pattern mapping tool. They are, frankly, quite unintuitive and can be intimidating for beginners. Below is a very short primer!
The first thing to know is that regular expressions should usually be declared using the raw string literal syntax (i.e. they are enclosed as shown: **r'\<your regular expression text goes here>'**).
The main parts of the syntax you will need to know for declaring the pattern matches are:
<table class="standard-table no-markdown">
<thead>
<tr>
<th scope="col">Symbol</th>
<th scope="col">Meaning</th>
</tr>
</thead>
<tbody>
<tr>
<td>^</td>
<td>Match the beginning of the text</td>
</tr>
<tr>
<td>$</td>
<td>Match the end of the text</td>
</tr>
<tr>
<td>\d</td>
<td>Match a digit (0, 1, 2, … 9)</td>
</tr>
<tr>
<td>\w</td>
<td>
Match a word character, e.g. any upper- or lower-case character in the
alphabet, digit or the underscore character (_)
</td>
</tr>
<tr>
<td>+</td>
<td>
Match one or more of the preceding character. For example, to match one
or more digits you would use <code>\d+</code>. To match one or more "a"
characters, you could use <code>a+</code>
</td>
</tr>
<tr>
<td>*</td>
<td>
Match zero or more of the preceding character. For example, to match
nothing or a word you could use <code>\w*</code>
</td>
</tr>
<tr>
<td>( )</td>
<td>
Capture the part of the pattern inside the parentheses. Any captured values
will be passed to the view as unnamed parameters (if multiple patterns
are captured, the associated parameters will be supplied in the order
that the captures were declared).
</td>
</tr>
<tr>
<td>(?P<<em>name</em>>...)</td>
<td>
Capture the pattern (indicated by ...) as a named variable (in this case
"name"). The captured values are passed to the view with the name
specified. Your view must therefore declare a parameter with the same
name!
</td>
</tr>
<tr>
<td>[ ]</td>
<td>
Match against one character in the set. For example, [abc] will match on
'a' or 'b' or 'c'. [-\w] will match on the '-' character or any word
character.
</td>
</tr>
</tbody>
</table>
Most other characters can be taken literally!
Let's consider a few real examples of patterns:
<table class="standard-table">
<thead>
<tr>
<th scope="col">Pattern</th>
<th scope="col">Description</th>
</tr>
</thead>
<tbody>
<tr>
<td><strong>r'^book/(?P<pk>\d+)$'</strong></td>
<td>
<p>
This is the RE used in our URL mapper. It matches a string that has
<code>book/</code> at the start of the line (<strong>^book/</strong>),
then has one or more digits (<code>\d+</code>), and then ends (with no
non-digit characters before the end of line marker).
</p>
<p>
It also captures all the digits <strong>(?P<pk>\d+)</strong> and
passes them to the view in a parameter named 'pk'.
<strong>The captured values are always passed as a string!</strong>
</p>
<p>
For example, this would match <code>book/1234</code>, and send a
variable <code>pk='1234'</code> to the view.
</p>
</td>
</tr>
<tr>
<td><strong>r'^book/(\d+)$'</strong></td>
<td>
This matches the same URLs as the preceding case. The captured
information would be sent as an unnamed argument to the view.
</td>
</tr>
<tr>
<td><strong>r'^book/(?P<stub>[-\w]+)$'</strong></td>
<td>
<p>
This matches a string that has <code>book/</code> at the start of the
line (<strong>^book/</strong>), then has one or more characters that
are <em>either</em> a '-' or a word character
(<strong>[-\w]+</strong>), and then ends. It also captures this set of
characters and passes them to the view in a parameter named 'stub'.
</p>
<p>
This is a fairly typical pattern for a "stub". Stubs are URL-friendly
word-based primary keys for data. You might use a stub if you wanted
your book URL to be more informative. For example
<code>/catalog/book/the-secret-garden</code> rather than
<code>/catalog/book/33</code>.
</p>
</td>
</tr>
</tbody>
</table>
You can capture multiple patterns in the one match, and hence encode lots of different information in a URL.
> **Note:** As a challenge, consider how you might encode a URL to list all books released in a particular year, month, day, and the RE that could be used to match it.
#### Passing additional options in your URL maps
One feature that we haven't used here, but which you may find valuable, is that you can pass a [dictionary containing additional options](https://docs.djangoproject.com/en/4.2/topics/http/urls/#views-extra-options) to the view (using the third un-named argument to the `path()` function). This approach can be useful if you want to use the same view for multiple resources, and pass data to configure its behavior in each case.
For example, given the path shown below, for a request to `/myurl/halibut/` Django will call `views.my_view(request, fish='halibut', my_template_name='some_path')`.
```python
path('myurl/<fish>', views.my_view, {'my_template_name': 'some_path'}, name='aurl'),
```
> **Note:** Both named captured patterns and dictionary options are passed to the view as _named_ arguments. If you use the **same name** for both a capture pattern and a dictionary key, then the dictionary option will be used.
### View (class-based)
Open **catalog/views.py**, and copy the following code into the bottom of the file:
```python
class BookDetailView(generic.DetailView):
model = Book
```
That's it! All you need to do now is create a template called **/locallibrary/catalog/templates/catalog/book_detail.html**, and the view will pass it the database information for the specific `Book` record extracted by the URL mapper. Within the template you can access the book's details with the template variable named `object` OR `book` (i.e. generically "`the_model_name`").
If you need to, you can change the template used and the name of the context object used to reference the book in the template. You can also override methods to, for example, add additional information to the context.
#### What happens if the record doesn't exist?
If a requested record does not exist then the generic class-based detail view will raise an `Http404` exception for you automatically — in production, this will automatically display an appropriate "resource not found" page, which you can customize if desired.
Just to give you some idea of how this works, the code fragment below demonstrates how you would implement the class-based view as a function if you were **not** using the generic class-based detail view.
```python
def book_detail_view(request, primary_key):
try:
book = Book.objects.get(pk=primary_key)
except Book.DoesNotExist:
raise Http404('Book does not exist')
return render(request, 'catalog/book_detail.html', context={'book': book})
```
The view first tries to get the specific book record from the model. If this fails the view should raise an `Http404` exception to indicate that the book is "not found". The final step is then, as usual, to call `render()` with the template name and the book data in the `context` parameter (as a dictionary).
Another way you could do this if you were not using a generic view would be to call the `get_object_or_404()` function.
This is a shortcut to raise an `Http404` exception if the record is not found.
```python
from django.shortcuts import get_object_or_404
def book_detail_view(request, primary_key):
book = get_object_or_404(Book, pk=primary_key)
return render(request, 'catalog/book_detail.html', context={'book': book})
```
### Creating the Detail View template
Create the HTML file **/locallibrary/catalog/templates/catalog/book_detail.html** and give it the below content. As discussed above, this is the default template file name expected by the generic class-based _detail_ view (for a model named `Book` in an application named `catalog`).
```django
{% extends "base_generic.html" %}
{% block content %}
<h1>Title: \{{ book.title }}</h1>
<p><strong>Author:</strong> <a href="">\{{ book.author }}</a></p>
<!-- author detail link not yet defined -->
<p><strong>Summary:</strong> \{{ book.summary }}</p>
<p><strong>ISBN:</strong> \{{ book.isbn }}</p>
<p><strong>Language:</strong> \{{ book.language }}</p>
<p><strong>Genre:</strong> \{{ book.genre.all|join:", " }}</p>
<div style="margin-left:20px;margin-top:20px">
<h4>Copies</h4>
{% for copy in book.bookinstance_set.all %}
<hr />
<p
class="{% if copy.status == 'a' %}text-success{% elif copy.status == 'm' %}text-danger{% else %}text-warning{% endif %}">
\{{ copy.get_status_display }}
</p>
{% if copy.status != 'a' %}
<p><strong>Due to be returned:</strong> \{{ copy.due_back }}</p>
{% endif %}
<p><strong>Imprint:</strong> \{{ copy.imprint }}</p>
<p class="text-muted"><strong>Id:</strong> \{{ copy.id }}</p>
{% endfor %}
</div>
{% endblock %}
```
> **Note:** The author link in the template above has an empty URL because we've not yet created an author detail page to link to.
> Once the detail page exists we can get its URL with either of these two approaches:
>
> - Use the `url` template tag to reverse the 'author-detail' URL (defined in the URL mapper), passing it the author instance for the book:
>
> ```django
> <a href="{% url 'author-detail' book.author.pk %}">\{{ book.author }}</a>
> ```
>
> - Call the author model's `get_absolute_url()` method (this performs the same reversing operation):
>
> ```django
> <a href="\{{ book.author.get_absolute_url }}">\{{ book.author }}</a>
> ```
>
> While both methods effectively do the same thing, `get_absolute_url()` is preferred because it helps you write more consistent and maintainable code (any changes only need to be done in one place: the author model).
Though a little larger, almost everything in this template has been described previously:
- We extend our base template and override the "content" block.
- We use conditional processing to determine whether or not to display specific content.
- We use `for` loops to loop through lists of objects.
- We access the context fields using the dot notation (because we've used the detail generic view, the context is named `book`; we could also use "`object`")
The first interesting thing we haven't seen before is the function `book.bookinstance_set.all()`. This method is "automagically" constructed by Django in order to return the set of `BookInstance` records associated with a particular `Book`.
```django
{% for copy in book.bookinstance_set.all %}
<!-- code to iterate across each copy/instance of a book -->
{% endfor %}
```
This method is needed because you declare a `ForeignKey` (one-to many) field only in the "many" side of the relationship (the `BookInstance`). Since you don't do anything to declare the relationship in the other ("one") model, it (the `Book`) doesn't have any field to get the set of associated records. To overcome this problem, Django constructs an appropriately named "reverse lookup" function that you can use. The name of the function is constructed by lower-casing the model name where the `ForeignKey` was declared, followed by `_set` (i.e. so the function created in `Book` is `bookinstance_set()`).
> **Note:** Here we use `all()` to get all records (the default). While you can use the `filter()` method to get a subset of records in code, you can't do this directly in templates because you can't specify arguments to functions.
>
> Beware also that if you don't define an order (on your class-based view or model), you will also see errors from the development server like this one:
>
> ```plain
> [29/May/2017 18:37:53] "GET /catalog/books/?page=1 HTTP/1.1" 200 1637
> /foo/local_library/venv/lib/python3.5/site-packages/django/views/generic/list.py:99: UnorderedObjectListWarning: Pagination may yield inconsistent results with an unordered object_list: <QuerySet [<Author: Ortiz, David>, <Author: H. McRaven, William>, <Author: Leigh, Melinda>]>
> allow_empty_first_page=allow_empty_first_page, **kwargs)
> ```
>
> That happens because the [paginator object](https://docs.djangoproject.com/en/4.2/topics/pagination/#paginator-objects) expects to see some ORDER BY being executed on your underlying database. Without it, it can't be sure the records being returned are actually in the right order!
>
> This tutorial hasn't covered **Pagination** (yet!), but since you can't use `sort_by()` and pass a parameter (the same with `filter()` described above) you will have to choose between three choices:
>
> 1. Add a `ordering` inside a `class Meta` declaration on your model.
> 2. Add a `queryset` attribute in your custom class-based view, specifying an `order_by()`.
> 3. Adding a `get_queryset` method to your custom class-based view and also specify the `order_by()`.
>
> If you decide to go with a `class Meta` for the `Author` model (probably not as flexible as customizing the class-based view, but easy enough), you will end up with something like this:
>
> ```python
> class Author(models.Model):
> first_name = models.CharField(max_length=100)
> last_name = models.CharField(max_length=100)
> date_of_birth = models.DateField(null=True, blank=True)
> date_of_death = models.DateField('Died', null=True, blank=True)
>
> def get_absolute_url(self):
> return reverse('author-detail', args=[str(self.id)])
>
> def __str__(self):
> return f'{self.last_name}, {self.first_name}'
>
> class Meta:
> ordering = ['last_name']
> ```
>
> Of course, the field doesn't need to be `last_name`: it could be any other.
>
> Last but not least, you should sort by an attribute/column that actually has an index (unique or not) on your database to avoid performance issues. Of course, this will not be necessary here (we are probably getting ahead of ourselves with so few books and users), but it is something worth keeping in mind for future projects.
The second interesting (and non-obvious) thing in the template is where we display the status text for each book instance ("available", "maintenance", etc.).
Astute readers will note that the method `BookInstance.get_status_display()` that we use to get the status text does not appear elsewhere in the code.
```django
<p class="{% if copy.status == 'a' %}text-success{% elif copy.status == 'm' %}text-danger{% else %}text-warning{% endif %}">
\{{ copy.get_status_display }} </p>
```
This function is automatically created because `BookInstance.status` is a [choices field](https://docs.djangoproject.com/en/4.2/ref/models/fields/#choices).
Django automatically creates a method `get_FOO_display()` for every choices field "`Foo`" in a model, which can be used to get the current value of the field.
## What does it look like?
At this point, we should have created everything needed to display both the book list and book detail pages. Run the server (`python3 manage.py runserver`) and open your browser to `http://127.0.0.1:8000/`.
> **Warning:** Don't click any author or author detail links yet — you'll create those in the challenge!
Click the **All books** link to display the list of books.
Then click a link to one of your books. If everything is set up correctly, you should see something like the following screenshot.
## Pagination
If you've just got a few records, our book list page will look fine. However, as you get into the tens or hundreds of records the page will take progressively longer to load (and have far too much content to browse sensibly). The solution to this problem is to add pagination to your list views, reducing the number of items displayed on each page.
Django has excellent inbuilt support for pagination. Even better, this is built into the generic class-based list views so you don't have to do very much to enable it!
### Views
Open **catalog/views.py**, and add the `paginate_by` line shown below.
```python
class BookListView(generic.ListView):
model = Book
paginate_by = 10
```
With this addition, as soon as you have more than 10 records the view will start paginating the data it sends to the template.
The different pages are accessed using GET parameters — to access page 2 you would use the URL `/catalog/books/?page=2`.
### Templates
Now that the data is paginated, we need to add support to the template to scroll through the results set. Because we might want paginate all list views, we'll add this to the base template.
Open **/locallibrary/catalog/templates/_base_generic.html_** and find the "content block" (as shown below).
```django
{% block content %}{% endblock %}
```
Copy in the following pagination block immediately following the `{% endblock %}`. The code first checks if pagination is enabled on the current page. If so, it adds _next_ and _previous_ links as appropriate (and the current page number).
```django
{% block pagination %}
{% if is_paginated %}
<div class="pagination">
<span class="page-links">
{% if page_obj.has_previous %}
<a href="\{{ request.path }}?page=\{{ page_obj.previous_page_number }}">previous</a>
{% endif %}
<span class="page-current">
Page \{{ page_obj.number }} of \{{ page_obj.paginator.num_pages }}.
</span>
{% if page_obj.has_next %}
<a href="\{{ request.path }}?page=\{{ page_obj.next_page_number }}">next</a>
{% endif %}
</span>
</div>
{% endif %}
{% endblock %}
```
The `page_obj` is a [Paginator](https://docs.djangoproject.com/en/4.2/topics/pagination/#paginator-objects) object that will exist if pagination is being used on the current page. It allows you to get all the information about the current page, previous pages, how many pages there are, etc.
We use `\{{ request.path }}` to get the current page URL for creating the pagination links. This is useful because it is independent of the object that we're paginating.
That's it!
### What does it look like?
The screenshot below shows what the pagination looks like — if you haven't entered more than 10 titles into your database, then you can test it more easily by lowering the number specified in the `paginate_by` line in your **catalog/views.py** file. To get the below result we changed it to `paginate_by = 2`.
The pagination links are displayed on the bottom, with next/previous links being displayed depending on which page you're on.
## Challenge yourself
The challenge in this article is to create the author detail and list views required to complete the project. These should be made available at the following URLs:
- `catalog/authors/` — The list of all authors.
- `catalog/author/<id>` — The detail view for the specific author with a primary key field named `<id>`
The code required for the URL mappers and the views should be virtually identical to the `Book` list and detail views we created above. The templates will be different but will share similar behavior.
> **Note:**
>
> - Once you've created the URL mapper for the author list page you will also need to update the **All authors** link in the base template.
> Follow the [same process](#update_the_base_template) as we did when we updated the **All books** link.
> - Once you've created the URL mapper for the author detail page, you should also update the [book detail view template](#creating_the_detail_view_template) (**/locallibrary/catalog/templates/catalog/book_detail.html**) so that the author link points to your new author detail page (rather than being an empty URL).
> The recommended way to do this is to call `get_absolute_url()` on the author model as shown below.
>
> ```django
> <p>
> <strong>Author:</strong>
> <a href="\{{ book.author.get_absolute_url }}">\{{ book.author }}</a>
> </p>
> ```
When you are finished, your pages should look something like the screenshots below.
## Summary
Congratulations, our basic library functionality is now complete!
In this article, we've learned how to use the generic class-based list and detail views and used them to create pages to view our books and authors. Along the way we've learned about pattern matching with regular expressions, and how you can pass data from URLs to your views. We've also learned a few more tricks for using templates. Last of all we've shown how to paginate list views so that our lists are manageable even when we have many records.
In our next articles, we'll extend this library to support user accounts, and thereby demonstrate user authentication, permissions, sessions, and forms.
## See also
- [Built-in class-based generic views](https://docs.djangoproject.com/en/4.2/topics/class-based-views/generic-display/) (Django docs)
- [Generic display views](https://docs.djangoproject.com/en/4.2/ref/class-based-views/generic-display/) (Django docs)
- [Introduction to class-based views](https://docs.djangoproject.com/en/4.2/topics/class-based-views/intro/) (Django docs)
- [Built-in template tags and filters](https://docs.djangoproject.com/en/4.2/ref/templates/builtins/) (Django docs)
- [Pagination](https://docs.djangoproject.com/en/4.2/topics/pagination/) (Django docs)
- [Making queries > Related objects](https://docs.djangoproject.com/en/4.2/topics/db/queries/#related-objects) (Django docs)
{{PreviousMenuNext("Learn/Server-side/Django/Home_page", "Learn/Server-side/Django/Sessions", "Learn/Server-side/Django")}}
| 0 |
data/mdn-content/files/en-us/learn/server-side/django | data/mdn-content/files/en-us/learn/server-side/django/testing/index.md | ---
title: "Django Tutorial Part 10: Testing a Django web application"
slug: Learn/Server-side/Django/Testing
page-type: learn-module-chapter
---
{{LearnSidebar}}{{PreviousMenuNext("Learn/Server-side/Django/Forms", "Learn/Server-side/Django/Deployment", "Learn/Server-side/Django")}}
As websites grow they become harder to test manually. Not only is there more to test, but, as interactions between components become more complex, a small change in one area can impact other areas, so more changes will be required to ensure everything keeps working and errors are not introduced as more changes are made. One way to mitigate these problems is to write automated tests, which can easily and reliably be run every time you make a change. This tutorial shows how to automate _unit testing_ of your website using Django's test framework.
<table>
<tbody>
<tr>
<th scope="row">Prerequisites:</th>
<td>
Complete all previous tutorial topics, including <a href="/en-US/docs/Learn/Server-side/Django/Forms">Django Tutorial Part 9: Working with forms</a>.
</td>
</tr>
<tr>
<th scope="row">Objective:</th>
<td>To understand how to write unit tests for Django-based websites.</td>
</tr>
</tbody>
</table>
## Overview
The [Local Library](/en-US/docs/Learn/Server-side/Django/Tutorial_local_library_website) currently has pages to display lists of all books and authors, detail views for `Book` and `Author` items, a page to renew `BookInstance` items, and pages to create, update, and delete `Author` items (and `Book` records too, if you completed the _challenge_ in the [forms tutorial](/en-US/docs/Learn/Server-side/Django/Forms)). Even with this relatively small site, manually navigating to each page and _superficially_ checking that everything works as expected can take several minutes. As we make changes and grow the site, the time required to manually check that everything works "properly" will only grow. If we were to continue as we are, eventually we'd be spending most of our time testing, and very little time improving our code.
Automated tests can really help with this problem! The obvious benefits are that they can be run much faster than manual tests, can test to a much lower level of detail, and test exactly the same functionality every time (human testers are nowhere near as reliable!) Because they are fast, automated tests can be executed more regularly, and if a test fails, they point to exactly where code is not performing as expected.
In addition, automated tests can act as the first real-world "user" of your code, forcing you to be rigorous about defining and documenting how your website should behave. Often they are the basis for your code examples and documentation. For these reasons, some software development processes start with test definition and implementation, after which the code is written to match the required behavior (e.g. [test-driven](https://en.wikipedia.org/wiki/Test-driven_development) and [behavior-driven](https://en.wikipedia.org/wiki/Behavior-driven_development) development).
This tutorial shows how to write automated tests for Django, by adding a number of tests to the _LocalLibrary_ website.
### Types of testing
There are numerous types, levels, and classifications of tests and testing approaches. The most important automated tests are:
- Unit tests
- : Verify functional behavior of individual components, often to class and function level.
- Regression tests
- : Tests that reproduce historic bugs. Each test is initially run to verify that the bug has been fixed, and then re-run to ensure that it has not been reintroduced following later changes to the code.
- Integration tests
- : Verify how groupings of components work when used together. Integration tests are aware of the required interactions between components, but not necessarily of the internal operations of each component. They may cover simple groupings of components through to the whole website.
> **Note:** Other common types of tests include black box, white box, manual, automated, canary, smoke, conformance, acceptance, functional, system, performance, load, and stress tests. Look them up for more information.
### What does Django provide for testing?
Testing a website is a complex task, because it is made of several layers of logic – from HTTP-level request handling, to model queries, to form validation and processing, and template rendering.
Django provides a test framework with a small hierarchy of classes that build on the Python standard [`unittest`](https://docs.python.org/3/library/unittest.html#module-unittest) library. Despite the name, this test framework is suitable for both unit and integration tests. The Django framework adds API methods and tools to help test web and Django-specific behavior. These allow you to simulate requests, insert test data, and inspect your application's output. Django also provides an API ([LiveServerTestCase](https://docs.djangoproject.com/en/4.2/topics/testing/tools/#liveservertestcase)) and tools for [using different testing frameworks](https://docs.djangoproject.com/en/4.2/topics/testing/advanced/#other-testing-frameworks), for example you can integrate with the popular [Selenium](/en-US/docs/Learn/Tools_and_testing/Cross_browser_testing/Your_own_automation_environment) framework to simulate a user interacting with a live browser.
To write a test you derive from any of the Django (or _unittest_) test base classes ([SimpleTestCase](https://docs.djangoproject.com/en/4.2/topics/testing/tools/#simpletestcase), [TransactionTestCase](https://docs.djangoproject.com/en/4.2/topics/testing/tools/#transactiontestcase), [TestCase](https://docs.djangoproject.com/en/4.2/topics/testing/tools/#testcase), [LiveServerTestCase](https://docs.djangoproject.com/en/4.2/topics/testing/tools/#liveservertestcase)) and then write separate methods to check that specific functionality works as expected (tests use "assert" methods to test that expressions result in `True` or `False` values, or that two values are equal, etc.) When you start a test run, the framework executes the chosen test methods in your derived classes. The test methods are run independently, with common setup and/or tear-down behavior defined in the class, as shown below.
```python
class YourTestClass(TestCase):
def setUp(self):
# Setup run before every test method.
pass
def tearDown(self):
# Clean up run after every test method.
pass
def test_something_that_will_pass(self):
self.assertFalse(False)
def test_something_that_will_fail(self):
self.assertTrue(False)
```
The best base class for most tests is [django.test.TestCase](https://docs.djangoproject.com/en/4.2/topics/testing/tools/#testcase). This test class creates a clean database before its tests are run, and runs every test function in its own transaction. The class also owns a test [Client](https://docs.djangoproject.com/en/4.2/topics/testing/tools/#django.test.Client) that you can use to simulate a user interacting with the code at the view level. In the following sections we're going to concentrate on unit tests, created using this [TestCase](https://docs.djangoproject.com/en/4.2/topics/testing/tools/#testcase) base class.
> **Note:** The [django.test.TestCase](https://docs.djangoproject.com/en/4.2/topics/testing/tools/#testcase) class is very convenient, but may result in some tests being slower than they need to be (not every test will need to set up its own database or simulate the view interaction). Once you're familiar with what you can do with this class, you may want to replace some of your tests with the available simpler test classes.
### What should you test?
You should test all aspects of your own code, but not any libraries or functionality provided as part of Python or Django.
So for example, consider the `Author` model defined below. You don't need to explicitly test that `first_name` and `last_name` have been stored properly as `CharField` in the database because that is something defined by Django (though of course in practice you will inevitably test this functionality during development). Nor do you need to test that the `date_of_birth` has been validated to be a date field, because that is again something implemented in Django.
However you should check the text used for the labels (_First name, Last name, Date of birth, Died_), and the size of the field allocated for the text (_100 chars_), because these are part of your design and something that could be broken/changed in future.
```python
class Author(models.Model):
first_name = models.CharField(max_length=100)
last_name = models.CharField(max_length=100)
date_of_birth = models.DateField(null=True, blank=True)
date_of_death = models.DateField('Died', null=True, blank=True)
def get_absolute_url(self):
return reverse('author-detail', args=[str(self.id)])
def __str__(self):
return '%s, %s' % (self.last_name, self.first_name)
```
Similarly, you should check that the custom methods `get_absolute_url()` and `__str__()` behave as required because they are your code/business logic. In the case of `get_absolute_url()` you can trust that the Django `reverse()` method has been implemented properly, so what you're testing is that the associated view has actually been defined.
> **Note:** Astute readers may note that we would also want to constrain the date of birth and death to sensible values, and check that death comes after birth.
> In Django this constraint would be added to your form classes (although you can define validators for model fields and model validators these are only used at the form level if they are called by the model's `clean()` method. This requires a `ModelForm`, or the model's `clean()` method needs to be specifically called.)
With that in mind let's start looking at how to define and run tests.
## Test structure overview
Before we go into the detail of "what to test", let's first briefly look at _where_ and _how_ tests are defined.
Django uses the unittest module's [built-in test discovery](https://docs.python.org/3/library/unittest.html#unittest-test-discovery), which will discover tests under the current working directory in any file named with the pattern **test\*.py**. Provided you name the files appropriately, you can use any structure you like. We recommend that you create a module for your test code, and have separate files for models, views, forms, and any other types of code you need to test. For example:
```plain
catalog/
/tests/
__init__.py
test_models.py
test_forms.py
test_views.py
```
Create a file structure as shown above in your _LocalLibrary_ project. The **\_\_init\_\_.py** should be an empty file (this tells Python that the directory is a package). You can create the three test files by copying and renaming the skeleton test file **/catalog/tests.py**.
> **Note:** The skeleton test file **/catalog/tests.py** was created automatically when we [built the Django skeleton website](/en-US/docs/Learn/Server-side/Django/skeleton_website). It is perfectly "legal" to put all your tests inside it, but if you test properly, you'll quickly end up with a very large and unmanageable test file.
>
> Delete the skeleton file as we won't need it.
Open **/catalog/tests/test_models.py**. The file should import `django.test.TestCase`, as shown:
```python
from django.test import TestCase
# Create your tests here.
```
Often you will add a test class for each model/view/form you want to test, with individual methods for testing specific functionality. In other cases you may wish to have a separate class for testing a specific use case, with individual test functions that test aspects of that use-case (for example, a class to test that a model field is properly validated, with functions to test each of the possible failure cases). Again, the structure is very much up to you, but it is best if you are consistent.
Add the test class below to the bottom of the file. The class demonstrates how to construct a test case class by deriving from `TestCase`.
```python
class YourTestClass(TestCase):
@classmethod
def setUpTestData(cls):
print("setUpTestData: Run once to set up non-modified data for all class methods.")
pass
def setUp(self):
print("setUp: Run once for every test method to set up clean data.")
pass
def test_false_is_false(self):
print("Method: test_false_is_false.")
self.assertFalse(False)
def test_false_is_true(self):
print("Method: test_false_is_true.")
self.assertTrue(False)
def test_one_plus_one_equals_two(self):
print("Method: test_one_plus_one_equals_two.")
self.assertEqual(1 + 1, 2)
```
The new class defines two methods that you can use for pre-test configuration (for example, to create any models or other objects you will need for the test):
- `setUpTestData()` is called once at the beginning of the test run for class-level setup. You'd use this to create objects that aren't going to be modified or changed in any of the test methods.
- `setUp()` is called before every test function to set up any objects that may be modified by the test (every test function will get a "fresh" version of these objects).
> **Note:** The test classes also have a `tearDown()` method which we haven't used. This method isn't particularly useful for database tests, since the `TestCase` base class takes care of database teardown for you.
Below those we have a number of test methods, which use `Assert` functions to test whether conditions are true, false or equal (`AssertTrue`, `AssertFalse`, `AssertEqual`). If the condition does not evaluate as expected then the test will fail and report the error to your console.
The `AssertTrue`, `AssertFalse`, `AssertEqual` are standard assertions provided by **unittest**. There are other standard assertions in the framework, and also [Django-specific assertions](https://docs.djangoproject.com/en/4.2/topics/testing/tools/#assertions) to test if a view redirects (`assertRedirects`), to test if a particular template has been used (`assertTemplateUsed`), etc.
> **Note:** You should **not** normally include **print()** functions in your tests as shown above. We do that here only so that you can see the order that the setup functions are called in the console (in the following section).
## How to run the tests
The easiest way to run all the tests is to use the command:
```bash
python3 manage.py test
```
This will discover all files named with the pattern **test\*.py** under the current directory and run all tests defined using appropriate base classes (here we have a number of test files, but only **/catalog/tests/test_models.py** currently contains any tests.) By default the tests will individually report only on test failures, followed by a test summary.
> **Note:** If you get errors similar to: `ValueError: Missing staticfiles manifest entry...` this may be because testing does not run _collectstatic_ by default, and your app is using a storage class that requires it (see [manifest_strict](https://docs.djangoproject.com/en/4.2/ref/contrib/staticfiles/#django.contrib.staticfiles.storage.ManifestStaticFilesStorage.manifest_strict) for more information). There are a number of ways you can overcome this problem - the easiest is to run _collectstatic_ before running the tests:
>
> ```bash
> python3 manage.py collectstatic
> ```
Run the tests in the root directory of _LocalLibrary_. You should see an output like the one below.
```bash
> python3 manage.py test
Creating test database for alias 'default'...
setUpTestData: Run once to set up non-modified data for all class methods.
setUp: Run once for every test method to set up clean data.
Method: test_false_is_false.
setUp: Run once for every test method to set up clean data.
Method: test_false_is_true.
setUp: Run once for every test method to set up clean data.
Method: test_one_plus_one_equals_two.
.
======================================================================
FAIL: test_false_is_true (catalog.tests.tests_models.YourTestClass)
----------------------------------------------------------------------
Traceback (most recent call last):
File "D:\GitHub\django_tmp\library_w_t_2\locallibrary\catalog\tests\tests_models.py", line 22, in test_false_is_true
self.assertTrue(False)
AssertionError: False is not true
----------------------------------------------------------------------
Ran 3 tests in 0.075s
FAILED (failures=1)
Destroying test database for alias 'default'...
```
Here we see that we had one test failure, and we can see exactly what function failed and why (this failure is expected, because `False` is not `True`!).
> **Note:** The most important thing to learn from the test output above is that it is much more valuable if you use descriptive/informative names for your objects and methods.
The output of the `print()` functions shows how the `setUpTestData()` method is called once for the class and `setUp()` is called before each method.
Again, remember that normally you would not add this kind of `print()` to your tests.
The next sections show how you can run specific tests, and how to control how much information the tests display.
### Showing more test information
If you want to get more information about the test run you can change the _verbosity_. For example, to list the test successes as well as failures (and a whole bunch of information about how the testing database is set up) you can set the verbosity to "2" as shown:
```bash
python3 manage.py test --verbosity 2
```
The allowed verbosity levels are 0, 1, 2, and 3, with the default being "1".
### Speeding things up
If your tests are independent, on a multiprocessor machine you can significantly speed them up by running them in parallel.
The use of `--parallel auto` below runs one test process per available core.
The `auto` is optional, and you can also specify a particular number of cores to use.
```bash
python3 manage.py test --parallel auto
```
For more information, including what to do if your tests are not independent, see [DJANGO_TEST_PROCESSES](https://docs.djangoproject.com/en/4.2/ref/django-admin/#envvar-DJANGO_TEST_PROCESSES).
### Running specific tests
If you want to run a subset of your tests you can do so by specifying the full dot path to the package(s), module, `TestCase` subclass or method:
```bash
# Run the specified module
python3 manage.py test catalog.tests
# Run the specified module
python3 manage.py test catalog.tests.test_models
# Run the specified class
python3 manage.py test catalog.tests.test_models.YourTestClass
# Run the specified method
python3 manage.py test catalog.tests.test_models.YourTestClass.test_one_plus_one_equals_two
```
### Other test runner options
The test runner provides many other options, including the ability to shuffle tests (`--shuffle`), run them in debug mode (`--debug-mode`), and use the Python logger to capture the results.
For more information see the Django [test runner](https://docs.djangoproject.com/en/4.2/ref/django-admin/#test) documentation.
## LocalLibrary tests
Now we know how to run our tests and what sort of things we need to test, let's look at some practical examples.
> **Note:** We won't write every possible test, but this should give you an idea of how tests work, and what more you can do.
### Models
As discussed above, we should test anything that is part of our design or that is defined by code that we have written, but not libraries/code that is already tested by Django or the Python development team.
For example, consider the `Author` model below. Here we should test the labels for all the fields, because even though we haven't explicitly specified most of them, we have a design that says what these values should be. If we don't test the values, then we don't know that the field labels have their intended values. Similarly while we trust that Django will create a field of the specified length, it is worthwhile to specify a test for this length to ensure that it was implemented as planned.
```python
class Author(models.Model):
first_name = models.CharField(max_length=100)
last_name = models.CharField(max_length=100)
date_of_birth = models.DateField(null=True, blank=True)
date_of_death = models.DateField('Died', null=True, blank=True)
def get_absolute_url(self):
return reverse('author-detail', args=[str(self.id)])
def __str__(self):
return f'{self.last_name}, {self.first_name}'
```
Open our **/catalog/tests/test_models.py**, and replace any existing code with the following test code for the `Author` model.
Here you'll see that we first import `TestCase` and derive our test class (`AuthorModelTest`) from it, using a descriptive name so we can easily identify any failing tests in the test output. We then call `setUpTestData()` to create an author object that we will use but not modify in any of the tests.
```python
from django.test import TestCase
from catalog.models import Author
class AuthorModelTest(TestCase):
@classmethod
def setUpTestData(cls):
# Set up non-modified objects used by all test methods
Author.objects.create(first_name='Big', last_name='Bob')
def test_first_name_label(self):
author = Author.objects.get(id=1)
field_label = author._meta.get_field('first_name').verbose_name
self.assertEqual(field_label, 'first name')
def test_date_of_death_label(self):
author = Author.objects.get(id=1)
field_label = author._meta.get_field('date_of_death').verbose_name
self.assertEqual(field_label, 'died')
def test_first_name_max_length(self):
author = Author.objects.get(id=1)
max_length = author._meta.get_field('first_name').max_length
self.assertEqual(max_length, 100)
def test_object_name_is_last_name_comma_first_name(self):
author = Author.objects.get(id=1)
expected_object_name = f'{author.last_name}, {author.first_name}'
self.assertEqual(str(author), expected_object_name)
def test_get_absolute_url(self):
author = Author.objects.get(id=1)
# This will also fail if the urlconf is not defined.
self.assertEqual(author.get_absolute_url(), '/catalog/author/1')
```
The field tests check that the values of the field labels (`verbose_name`) and that the size of the character fields are as expected. These methods all have descriptive names, and follow the same pattern:
```python
# Get an author object to test
author = Author.objects.get(id=1)
# Get the metadata for the required field and use it to query the required field data
field_label = author._meta.get_field('first_name').verbose_name
# Compare the value to the expected result
self.assertEqual(field_label, 'first name')
```
The interesting things to note are:
- We can't get the `verbose_name` directly using `author.first_name.verbose_name`, because `author.first_name` is a _string_ (not a handle to the `first_name` object that we can use to access its properties). Instead we need to use the author's `_meta` attribute to get an instance of the field and use that to query for the additional information.
- We chose to use `assertEqual(field_label,'first name')` rather than `assertTrue(field_label == 'first name')`. The reason for this is that if the test fails the output for the former tells you what the label actually was, which makes debugging the problem just a little easier.
> **Note:** Tests for the `last_name` and `date_of_birth` labels, and also the test for the length of the `last_name` field have been omitted. Add your own versions now, following the naming conventions and approaches shown above.
We also need to test our custom methods. These essentially just check that the object name was constructed as we expected using "Last Name", "First Name" format, and that the URL we get for an `Author` item is as we would expect.
```python
def test_object_name_is_last_name_comma_first_name(self):
author = Author.objects.get(id=1)
expected_object_name = f'{author.last_name}, {author.first_name}'
self.assertEqual(str(author), expected_object_name)
def test_get_absolute_url(self):
author = Author.objects.get(id=1)
# This will also fail if the urlconf is not defined.
self.assertEqual(author.get_absolute_url(), '/catalog/author/1')
```
Run the tests now. If you created the Author model as we described in the models tutorial it is quite likely that you will get an error for the `date_of_death` label as shown below. The test is failing because it was written expecting the label definition to follow Django's convention of not capitalizing the first letter of the label (Django does this for you).
```bash
======================================================================
FAIL: test_date_of_death_label (catalog.tests.test_models.AuthorModelTest)
----------------------------------------------------------------------
Traceback (most recent call last):
File "D:\...\locallibrary\catalog\tests\test_models.py", line 32, in test_date_of_death_label
self.assertEqual(field_label,'died')
AssertionError: 'Died' != 'died'
- Died
? ^
+ died
? ^
```
This is a very minor bug, but it does highlight how writing tests can more thoroughly check any assumptions you may have made.
> **Note:** Change the label for the `date_of_death` field (**/catalog/models.py**) to "died" and re-run the tests.
The patterns for testing the other models are similar so we won't continue to discuss these further. Feel free to create your own tests for our other models.
### Forms
The philosophy for testing your forms is the same as for testing your models; you need to test anything that you've coded or your design specifies, but not the behavior of the underlying framework and other third party libraries.
Generally this means that you should test that the forms have the fields that you want, and that these are displayed with appropriate labels and help text. You don't need to verify that Django validates the field type correctly (unless you created your own custom field and validation) — i.e. you don't need to test that an email field only accepts emails. However you would need to test any additional validation that you expect to be performed on the fields and any messages that your code will generate for errors.
Consider our form for renewing books. This has just one field for the renewal date, which will have a label and help text that we will need to verify.
```python
class RenewBookForm(forms.Form):
"""Form for a librarian to renew books."""
renewal_date = forms.DateField(help_text="Enter a date between now and 4 weeks (default 3).")
def clean_renewal_date(self):
data = self.cleaned_data['renewal_date']
# Check if a date is not in the past.
if data < datetime.date.today():
raise ValidationError(_('Invalid date - renewal in past'))
# Check if date is in the allowed range (+4 weeks from today).
if data > datetime.date.today() + datetime.timedelta(weeks=4):
raise ValidationError(_('Invalid date - renewal more than 4 weeks ahead'))
# Remember to always return the cleaned data.
return data
```
Open our **/catalog/tests/test_forms.py** file and replace any existing code with the following test code for the `RenewBookForm` form. We start by importing our form and some Python and Django libraries to help test time-related functionality. We then declare our form test class in the same way as we did for models, using a descriptive name for our `TestCase`-derived test class.
```python
import datetime
from django.test import TestCase
from django.utils import timezone
from catalog.forms import RenewBookForm
class RenewBookFormTest(TestCase):
def test_renew_form_date_field_label(self):
form = RenewBookForm()
self.assertTrue(form.fields['renewal_date'].label is None or form.fields['renewal_date'].label == 'renewal date')
def test_renew_form_date_field_help_text(self):
form = RenewBookForm()
self.assertEqual(form.fields['renewal_date'].help_text, 'Enter a date between now and 4 weeks (default 3).')
def test_renew_form_date_in_past(self):
date = datetime.date.today() - datetime.timedelta(days=1)
form = RenewBookForm(data={'renewal_date': date})
self.assertFalse(form.is_valid())
def test_renew_form_date_too_far_in_future(self):
date = datetime.date.today() + datetime.timedelta(weeks=4) + datetime.timedelta(days=1)
form = RenewBookForm(data={'renewal_date': date})
self.assertFalse(form.is_valid())
def test_renew_form_date_today(self):
date = datetime.date.today()
form = RenewBookForm(data={'renewal_date': date})
self.assertTrue(form.is_valid())
def test_renew_form_date_max(self):
date = timezone.localtime() + datetime.timedelta(weeks=4)
form = RenewBookForm(data={'renewal_date': date})
self.assertTrue(form.is_valid())
```
The first two functions test that the field's `label` and `help_text` are as expected. We have to access the field using the fields dictionary (e.g. `form.fields['renewal_date']`). Note here that we also have to test whether the label value is `None`, because even though Django will render the correct label it returns `None` if the value is not _explicitly_ set.
The rest of the functions test that the form is valid for renewal dates just inside the acceptable range and invalid for values outside the range. Note how we construct test date values around our current date (`datetime.date.today()`) using `datetime.timedelta()` (in this case specifying a number of days or weeks). We then just create the form, passing in our data, and test if it is valid.
> **Note:** Here we don't actually use the database or test client. Consider modifying these tests to use [SimpleTestCase](https://docs.djangoproject.com/en/4.2/topics/testing/tools/#django.test.SimpleTestCase).
>
> We also need to validate that the correct errors are raised if the form is invalid, however this is usually done as part of view processing, so we'll take care of that in the next section.
> **Warning:** If you use the [ModelForm](/en-US/docs/Learn/Server-side/Django/Forms#modelforms) class `RenewBookModelForm(forms.ModelForm)` instead of class `RenewBookForm(forms.Form)`, then the form field name would be **'due_back'** instead of **'renewal_date'**.
That's all for forms; we do have some others, but they are automatically created by our generic class-based editing views, and should be tested there! Run the tests and confirm that our code still passes!
### Views
To validate our view behavior we use the Django test [Client](https://docs.djangoproject.com/en/4.2/topics/testing/tools/#django.test.Client). This class acts like a dummy web browser that we can use to simulate `GET` and `POST` requests on a URL and observe the response. We can see almost everything about the response, from low-level HTTP (result headers and status codes) through to the template we're using to render the HTML and the context data we're passing to it. We can also see the chain of redirects (if any) and check the URL and status code at each step. This allows us to verify that each view is doing what is expected.
Let's start with one of our simplest views, which provides a list of all Authors. This is displayed at URL **/catalog/authors/** (a URL named 'authors' in the URL configuration).
```python
class AuthorListView(generic.ListView):
model = Author
paginate_by = 10
```
As this is a generic list view almost everything is done for us by Django. Arguably if you trust Django then the only thing you need to test is that the view is accessible at the correct URL and can be accessed using its name. However if you're using a test-driven development process you'll start by writing tests that confirm that the view displays all Authors, paginating them in lots of 10.
Open the **/catalog/tests/test_views.py** file and replace any existing text with the following test code for `AuthorListView`. As before we import our model and some useful classes. In the `setUpTestData()` method we set up a number of `Author` objects so that we can test our pagination.
```python
from django.test import TestCase
from django.urls import reverse
from catalog.models import Author
class AuthorListViewTest(TestCase):
@classmethod
def setUpTestData(cls):
# Create 13 authors for pagination tests
number_of_authors = 13
for author_id in range(number_of_authors):
Author.objects.create(
first_name=f'Dominique {author_id}',
last_name=f'Surname {author_id}',
)
def test_view_url_exists_at_desired_location(self):
response = self.client.get('/catalog/authors/')
self.assertEqual(response.status_code, 200)
def test_view_url_accessible_by_name(self):
response = self.client.get(reverse('authors'))
self.assertEqual(response.status_code, 200)
def test_view_uses_correct_template(self):
response = self.client.get(reverse('authors'))
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response, 'catalog/author_list.html')
def test_pagination_is_ten(self):
response = self.client.get(reverse('authors'))
self.assertEqual(response.status_code, 200)
self.assertTrue('is_paginated' in response.context)
self.assertTrue(response.context['is_paginated'] == True)
self.assertEqual(len(response.context['author_list']), 10)
def test_lists_all_authors(self):
# Get second page and confirm it has (exactly) remaining 3 items
response = self.client.get(reverse('authors')+'?page=2')
self.assertEqual(response.status_code, 200)
self.assertTrue('is_paginated' in response.context)
self.assertTrue(response.context['is_paginated'] == True)
self.assertEqual(len(response.context['author_list']), 3)
```
All the tests use the client (belonging to our `TestCase`'s derived class) to simulate a `GET` request and get a response. The first version checks a specific URL (note, just the specific path without the domain) while the second generates the URL from its name in the URL configuration.
```python
response = self.client.get('/catalog/authors/')
response = self.client.get(reverse('authors'))
```
Once we have the response we query it for its status code, the template used, whether or not the response is paginated, the number of items returned, and the total number of items.
> **Note:** If you set the `paginate_by` variable in your **/catalog/views.py** file to a number other than 10, make sure to update the lines that test that the correct number of items are displayed in paginated templates above and in following sections. For example, if you set the variable for the author list page to 5, update the line above to:
>
> ```python
> self.assertTrue(len(response.context['author_list']) == 5)
> ```
The most interesting variable we demonstrate above is `response.context`, which is the context variable passed to the template by the view.
This is incredibly useful for testing, because it allows us to confirm that our template is getting all the data it needs. In other words we can check that we're using the intended template and what data the template is getting, which goes a long way to verifying that any rendering issues are solely due to template.
#### Views that are restricted to logged in users
In some cases you'll want to test a view that is restricted to just logged in users. For example our `LoanedBooksByUserListView` is very similar to our previous view but is only available to logged in users, and only displays `BookInstance` records that are borrowed by the current user, have the 'on loan' status, and are ordered "oldest first".
```python
from django.contrib.auth.mixins import LoginRequiredMixin
class LoanedBooksByUserListView(LoginRequiredMixin, generic.ListView):
"""Generic class-based view listing books on loan to current user."""
model = BookInstance
template_name ='catalog/bookinstance_list_borrowed_user.html'
paginate_by = 10
def get_queryset(self):
return BookInstance.objects.filter(borrower=self.request.user).filter(status__exact='o').order_by('due_back')
```
Add the following test code to **/catalog/tests/test_views.py**. Here we first use `SetUp()` to create some user login accounts and `BookInstance` objects (along with their associated books and other records) that we'll use later in the tests. Half of the books are borrowed by each test user, but we've initially set the status of all books to "maintenance". We've used `SetUp()` rather than `setUpTestData()` because we'll be modifying some of these objects later.
> **Note:** The `setUp()` code below creates a book with a specified `Language`, but _your_ code may not include the `Language` model as this was created as a _challenge_. If this is the case, comment out the parts of the code that create or import Language objects. You should also do this in the `RenewBookInstancesViewTest` section that follows.
```python
import datetime
from django.utils import timezone
# Get user model from settings
from django.contrib.auth import get_user_model
User = get_user_model()
from catalog.models import BookInstance, Book, Genre, Language
class LoanedBookInstancesByUserListViewTest(TestCase):
def setUp(self):
# Create two users
test_user1 = User.objects.create_user(username='testuser1', password='1X<ISRUkw+tuK')
test_user2 = User.objects.create_user(username='testuser2', password='2HJ1vRV0Z&3iD')
test_user1.save()
test_user2.save()
# Create a book
test_author = Author.objects.create(first_name='John', last_name='Smith')
test_genre = Genre.objects.create(name='Fantasy')
test_language = Language.objects.create(name='English')
test_book = Book.objects.create(
title='Book Title',
summary='My book summary',
isbn='ABCDEFG',
author=test_author,
language=test_language,
)
# Create genre as a post-step
genre_objects_for_book = Genre.objects.all()
test_book.genre.set(genre_objects_for_book) # Direct assignment of many-to-many types not allowed.
test_book.save()
# Create 30 BookInstance objects
number_of_book_copies = 30
for book_copy in range(number_of_book_copies):
return_date = timezone.localtime() + datetime.timedelta(days=book_copy%5)
the_borrower = test_user1 if book_copy % 2 else test_user2
status = 'm'
BookInstance.objects.create(
book=test_book,
imprint='Unlikely Imprint, 2016',
due_back=return_date,
borrower=the_borrower,
status=status,
)
def test_redirect_if_not_logged_in(self):
response = self.client.get(reverse('my-borrowed'))
self.assertRedirects(response, '/accounts/login/?next=/catalog/mybooks/')
def test_logged_in_uses_correct_template(self):
login = self.client.login(username='testuser1', password='1X<ISRUkw+tuK')
response = self.client.get(reverse('my-borrowed'))
# Check our user is logged in
self.assertEqual(str(response.context['user']), 'testuser1')
# Check that we got a response "success"
self.assertEqual(response.status_code, 200)
# Check we used correct template
self.assertTemplateUsed(response, 'catalog/bookinstance_list_borrowed_user.html')
```
To verify that the view will redirect to a login page if the user is not logged in we use `assertRedirects`, as demonstrated in `test_redirect_if_not_logged_in()`. To verify that the page is displayed for a logged in user we first log in our test user, and then access the page again and check that we get a `status_code` of 200 (success).
The rest of the tests verify that our view only returns books that are on loan to our current borrower. Copy the code below and paste it onto the end of the test class above.
```python
def test_only_borrowed_books_in_list(self):
login = self.client.login(username='testuser1', password='1X<ISRUkw+tuK')
response = self.client.get(reverse('my-borrowed'))
# Check our user is logged in
self.assertEqual(str(response.context['user']), 'testuser1')
# Check that we got a response "success"
self.assertEqual(response.status_code, 200)
# Check that initially we don't have any books in list (none on loan)
self.assertTrue('bookinstance_list' in response.context)
self.assertEqual(len(response.context['bookinstance_list']), 0)
# Now change all books to be on loan
books = BookInstance.objects.all()[:10]
for book in books:
book.status = 'o'
book.save()
# Check that now we have borrowed books in the list
response = self.client.get(reverse('my-borrowed'))
# Check our user is logged in
self.assertEqual(str(response.context['user']), 'testuser1')
# Check that we got a response "success"
self.assertEqual(response.status_code, 200)
self.assertTrue('bookinstance_list' in response.context)
# Confirm all books belong to testuser1 and are on loan
for bookitem in response.context['bookinstance_list']:
self.assertEqual(response.context['user'], bookitem.borrower)
self.assertEqual(bookitem.status, 'o')
def test_pages_ordered_by_due_date(self):
# Change all books to be on loan
for book in BookInstance.objects.all():
book.status='o'
book.save()
login = self.client.login(username='testuser1', password='1X<ISRUkw+tuK')
response = self.client.get(reverse('my-borrowed'))
# Check our user is logged in
self.assertEqual(str(response.context['user']), 'testuser1')
# Check that we got a response "success"
self.assertEqual(response.status_code, 200)
# Confirm that of the items, only 10 are displayed due to pagination.
self.assertEqual(len(response.context['bookinstance_list']), 10)
last_date = 0
for book in response.context['bookinstance_list']:
if last_date == 0:
last_date = book.due_back
else:
self.assertTrue(last_date <= book.due_back)
last_date = book.due_back
```
You could also add pagination tests, should you so wish!
#### Testing views with forms
Testing views with forms is a little more complicated than in the cases above, because you need to test more code paths: initial display, display after data validation has failed, and display after validation has succeeded. The good news is that we use the client for testing in almost exactly the same way as we did for display-only views.
To demonstrate, let's write some tests for the view used to renew books (`renew_book_librarian()`):
```python
from catalog.forms import RenewBookForm
@permission_required('catalog.can_mark_returned')
def renew_book_librarian(request, pk):
"""View function for renewing a specific BookInstance by librarian."""
book_instance = get_object_or_404(BookInstance, pk=pk)
# If this is a POST request then process the Form data
if request.method == 'POST':
# Create a form instance and populate it with data from the request (binding):
book_renewal_form = RenewBookForm(request.POST)
# Check if the form is valid:
if form.is_valid():
# process the data in form.cleaned_data as required (here we just write it to the model due_back field)
book_instance.due_back = form.cleaned_data['renewal_date']
book_instance.save()
# redirect to a new URL:
return HttpResponseRedirect(reverse('all-borrowed'))
# If this is a GET (or any other method) create the default form
else:
proposed_renewal_date = datetime.date.today() + datetime.timedelta(weeks=3)
book_renewal_form = RenewBookForm(initial={'renewal_date': proposed_renewal_date})
context = {
'book_renewal_form': book_renewal_form,
'book_instance': book_instance,
}
return render(request, 'catalog/book_renew_librarian.html', context)
```
We'll need to test that the view is only available to users who have the `can_mark_returned` permission, and that users are redirected to an HTTP 404 error page if they attempt to renew a `BookInstance` that does not exist. We should check that the initial value of the form is seeded with a date three weeks in the future, and that if validation succeeds we're redirected to the "all-borrowed books" view. As part of checking the validation-fail tests we'll also check that our form is sending the appropriate error messages.
Add the first part of the test class (shown below) to the bottom of **/catalog/tests/test_views.py**.
This creates two users and two book instances, but only gives one user the permission required to access the view.
```python
import uuid
from django.contrib.auth.models import Permission # Required to grant the permission needed to set a book as returned.
class RenewBookInstancesViewTest(TestCase):
def setUp(self):
# Create a user
test_user1 = User.objects.create_user(username='testuser1', password='1X<ISRUkw+tuK')
test_user2 = User.objects.create_user(username='testuser2', password='2HJ1vRV0Z&3iD')
test_user1.save()
test_user2.save()
# Give test_user2 permission to renew books.
permission = Permission.objects.get(name='Set book as returned')
test_user2.user_permissions.add(permission)
test_user2.save()
# Create a book
test_author = Author.objects.create(first_name='John', last_name='Smith')
test_genre = Genre.objects.create(name='Fantasy')
test_language = Language.objects.create(name='English')
test_book = Book.objects.create(
title='Book Title',
summary='My book summary',
isbn='ABCDEFG',
author=test_author,
language=test_language,
)
# Create genre as a post-step
genre_objects_for_book = Genre.objects.all()
test_book.genre.set(genre_objects_for_book) # Direct assignment of many-to-many types not allowed.
test_book.save()
# Create a BookInstance object for test_user1
return_date = datetime.date.today() + datetime.timedelta(days=5)
self.test_bookinstance1 = BookInstance.objects.create(
book=test_book,
imprint='Unlikely Imprint, 2016',
due_back=return_date,
borrower=test_user1,
status='o',
)
# Create a BookInstance object for test_user2
return_date = datetime.date.today() + datetime.timedelta(days=5)
self.test_bookinstance2 = BookInstance.objects.create(
book=test_book,
imprint='Unlikely Imprint, 2016',
due_back=return_date,
borrower=test_user2,
status='o',
)
```
Add the following tests to the bottom of the test class. These check that only users with the correct permissions (_testuser2_) can access the view. We check all the cases: when the user is not logged in, when a user is logged in but does not have the correct permissions, when the user has permissions but is not the borrower (should succeed), and what happens when they try to access a `BookInstance` that doesn't exist. We also check that the correct template is used.
```python
def test_redirect_if_not_logged_in(self):
response = self.client.get(reverse('renew-book-librarian', kwargs={'pk': self.test_bookinstance1.pk}))
# Manually check redirect (Can't use assertRedirect, because the redirect URL is unpredictable)
self.assertEqual(response.status_code, 302)
self.assertTrue(response.url.startswith('/accounts/login/'))
def test_forbidden_if_logged_in_but_not_correct_permission(self):
login = self.client.login(username='testuser1', password='1X<ISRUkw+tuK')
response = self.client.get(reverse('renew-book-librarian', kwargs={'pk': self.test_bookinstance1.pk}))
self.assertEqual(response.status_code, 403)
def test_logged_in_with_permission_borrowed_book(self):
login = self.client.login(username='testuser2', password='2HJ1vRV0Z&3iD')
response = self.client.get(reverse('renew-book-librarian', kwargs={'pk': self.test_bookinstance2.pk}))
# Check that it lets us login - this is our book and we have the right permissions.
self.assertEqual(response.status_code, 200)
def test_logged_in_with_permission_another_users_borrowed_book(self):
login = self.client.login(username='testuser2', password='2HJ1vRV0Z&3iD')
response = self.client.get(reverse('renew-book-librarian', kwargs={'pk': self.test_bookinstance1.pk}))
# Check that it lets us login. We're a librarian, so we can view any users book
self.assertEqual(response.status_code, 200)
def test_HTTP404_for_invalid_book_if_logged_in(self):
# unlikely UID to match our bookinstance!
test_uid = uuid.uuid4()
login = self.client.login(username='testuser2', password='2HJ1vRV0Z&3iD')
response = self.client.get(reverse('renew-book-librarian', kwargs={'pk':test_uid}))
self.assertEqual(response.status_code, 404)
def test_uses_correct_template(self):
login = self.client.login(username='testuser2', password='2HJ1vRV0Z&3iD')
response = self.client.get(reverse('renew-book-librarian', kwargs={'pk': self.test_bookinstance1.pk}))
self.assertEqual(response.status_code, 200)
# Check we used correct template
self.assertTemplateUsed(response, 'catalog/book_renew_librarian.html')
```
Add the next test method, as shown below. This checks that the initial date for the form is three weeks in the future. Note how we are able to access the value of the initial value of the form field (`response.context['form'].initial['renewal_date'])`.
```python
def test_form_renewal_date_initially_has_date_three_weeks_in_future(self):
login = self.client.login(username='testuser2', password='2HJ1vRV0Z&3iD')
response = self.client.get(reverse('renew-book-librarian', kwargs={'pk': self.test_bookinstance1.pk}))
self.assertEqual(response.status_code, 200)
date_3_weeks_in_future = datetime.date.today() + datetime.timedelta(weeks=3)
self.assertEqual(response.context['form'].initial['renewal_date'], date_3_weeks_in_future)
```
The next test (add this to the class too) checks that the view redirects to a list of all borrowed books if renewal succeeds. What differs here is that for the first time we show how you can `POST` data using the client. The post _data_ is the second argument to the post function, and is specified as a dictionary of key/values.
```python
def test_redirects_to_all_borrowed_book_list_on_success(self):
login = self.client.login(username='testuser2', password='2HJ1vRV0Z&3iD')
valid_date_in_future = datetime.date.today() + datetime.timedelta(weeks=2)
response = self.client.post(reverse('renew-book-librarian', kwargs={'pk':self.test_bookinstance1.pk,}), {'renewal_date':valid_date_in_future})
self.assertRedirects(response, reverse('all-borrowed'))
```
> **Warning:** The _all-borrowed_ view was added as a _challenge_, and your code may instead redirect to the home page '/'. If so, modify the last two lines of the test code to be like the code below. The `follow=True` in the request ensures that the request returns the final destination URL (hence checking `/catalog/` rather than `/`).
>
> ```python
> response = self.client.post(reverse('renew-book-librarian', kwargs={'pk':self.test_bookinstance1.pk,}), {'renewal_date':valid_date_in_future}, follow=True)
> self.assertRedirects(response, '/catalog/')
> ```
Copy the last two functions into the class, as seen below. These again test `POST` requests, but in this case with invalid renewal dates. We use `assertFormError()` to verify that the error messages are as expected.
```python
def test_form_invalid_renewal_date_past(self):
login = self.client.login(username='testuser2', password='2HJ1vRV0Z&3iD')
date_in_past = datetime.date.today() - datetime.timedelta(weeks=1)
response = self.client.post(reverse('renew-book-librarian', kwargs={'pk': self.test_bookinstance1.pk}), {'renewal_date': date_in_past})
self.assertEqual(response.status_code, 200)
self.assertFormError(response.context['form'], 'renewal_date', 'Invalid date - renewal in past')
def test_form_invalid_renewal_date_future(self):
login = self.client.login(username='testuser2', password='2HJ1vRV0Z&3iD')
invalid_date_in_future = datetime.date.today() + datetime.timedelta(weeks=5)
response = self.client.post(reverse('renew-book-librarian', kwargs={'pk': self.test_bookinstance1.pk}), {'renewal_date': invalid_date_in_future})
self.assertEqual(response.status_code, 200)
self.assertFormError(response.context['form'], 'renewal_date', 'Invalid date - renewal more than 4 weeks ahead')
```
The same sorts of techniques can be used to test the other view.
### Templates
Django provides test APIs to check that the correct template is being called by your views, and to allow you to verify that the correct information is being sent. There is however no specific API support for testing in Django that your HTML output is rendered as expected.
## Other recommended test tools
Django's test framework can help you write effective unit and integration tests — we've only scratched the surface of what the underlying **unittest** framework can do, let alone Django's additions (for example, check out how you can use [unittest.mock](https://docs.python.org/3/library/unittest.mock-examples.html) to patch third party libraries so you can more thoroughly test your own code).
While there are numerous other test tools that you can use, we'll just highlight two:
- [Coverage](https://coverage.readthedocs.io/en/latest/): This Python tool reports on how much of your code is actually executed by your tests. It is particularly useful when you're getting started, and you are trying to work out exactly what you should test.
- [Selenium](/en-US/docs/Learn/Tools_and_testing/Cross_browser_testing/Your_own_automation_environment) is a framework to automate testing in a real browser. It allows you to simulate a real user interacting with the site, and provides a great framework for system testing your site (the next step up from integration testing).
## Challenge yourself
There are a lot more models and views we can test. As a challenge, try to create a test case for the `AuthorCreate` view.
```python
class AuthorCreate(PermissionRequiredMixin, CreateView):
model = Author
fields = ['first_name', 'last_name', 'date_of_birth', 'date_of_death']
initial = {'date_of_death': '11/11/2023'}
permission_required = 'catalog.add_author'
```
Remember that you need to check anything that you specify or that is part of the design.
This will include who has access, the initial date, the template used, and where the view redirects on success.
You might use the following code to set up your test and assign your user the appropriate permission
```python
class AuthorCreateViewTest(TestCase):
"""Test case for the AuthorCreate view (Created as Challenge)."""
def setUp(self):
# Create a user
test_user = User.objects.create_user(
username='test_user', password='some_password')
content_typeAuthor = ContentType.objects.get_for_model(Author)
permAddAuthor = Permission.objects.get(
codename="add_author",
content_type=content_typeAuthor,
)
test_user.user_permissions.add(permAddAuthor)
test_user.save()
```
## Summary
Writing test code is neither fun nor glamorous, and is consequently often left to last (or not at all) when creating a website. It is however an essential part of making sure that your code is safe to release after making changes, and cost-effective to maintain.
In this tutorial we've shown you how to write and run tests for your models, forms, and views. Most importantly we've provided a brief summary of what you should test, which is often the hardest thing to work out when you're getting started. There is a lot more to know, but even with what you've learned already you should be able to create effective unit tests for your websites.
The next and final tutorial shows how you can deploy your wonderful (and fully tested!) Django website.
## See also
- [Writing and running tests](https://docs.djangoproject.com/en/4.2/topics/testing/overview/) (Django docs)
- [Writing your first Django app, part 5 > Introducing automated testing](https://docs.djangoproject.com/en/4.2/intro/tutorial05/) (Django docs)
- [Testing tools reference](https://docs.djangoproject.com/en/4.2/topics/testing/tools/) (Django docs)
- [Advanced testing topics](https://docs.djangoproject.com/en/4.2/topics/testing/advanced/) (Django docs)
- [A Guide to Testing in Django](https://toastdriven.com/blog/2011/apr/09/guide-to-testing-in-django/) (Toast Driven Blog, 2011)
- [Workshop: Test-Driven Web Development with Django](https://test-driven-django-development.readthedocs.io/en/latest/index.html) (San Diego Python, 2014)
- [Testing in Django (Part 1) - Best Practices and Examples](https://realpython.com/testing-in-django-part-1-best-practices-and-examples/) (RealPython, 2013)
{{PreviousMenuNext("Learn/Server-side/Django/Forms", "Learn/Server-side/Django/Deployment", "Learn/Server-side/Django")}}
| 0 |
data/mdn-content/files/en-us/learn/server-side/django | data/mdn-content/files/en-us/learn/server-side/django/web_application_security/index.md | ---
title: Django web application security
slug: Learn/Server-side/Django/web_application_security
page-type: learn-module-chapter
---
{{LearnSidebar}}{{PreviousMenuNext("Learn/Server-side/Django/Deployment", "Learn/Server-side/Django/django_assessment_blog", "Learn/Server-side/Django")}}
Protecting user data is an essential part of any website design. We previously explained some of the more common security threats in the article [Web security](/en-US/docs/Web/Security) — this article provides a practical demonstration of how Django's in-built protections handle such threats.
<table>
<tbody>
<tr>
<th scope="row">Prerequisites:</th>
<td>
Read the Server-side programming "<a href="/en-US/docs/Learn/Server-side/First_steps/Website_security">Website security</a>" topic.
Complete the Django tutorial topics up to (and including) at least <a href="/en-US/docs/Learn/Server-side/Django/Forms">Django Tutorial Part 9: Working with forms</a>.
</td>
</tr>
<tr>
<th scope="row">Objective:</th>
<td>
To understand the main things you need to do (or not do) to secure your Django web application.
</td>
</tr>
</tbody>
</table>
## Overview
The [Website security](/en-US/docs/Web/Security) topic provides an overview of what website security means for server-side design, and some of the more common threats that you should protect against. One of the key messages in that article is that almost all attacks are successful when the web application trusts data from the browser.
> **Warning:** The single most important lesson you can learn about website security is to **never trust data from the browser**. This includes `GET` request data in URL parameters, `POST` data, HTTP headers and cookies, user-uploaded files, etc. Always check and sanitize all incoming data. Always assume the worst.
The good news for Django users is that many of the more common threats are handled by the framework! The [Security in Django](https://docs.djangoproject.com/en/4.2/topics/security/) (Django docs) article explains Django's security features and how to secure a Django-powered website.
## Common threats/protections
Rather than duplicate the Django documentation here, in this article we'll demonstrate just a few of the security features in the context of our Django [LocalLibrary](/en-US/docs/Learn/Server-side/Django/Tutorial_local_library_website) tutorial.
### Cross site scripting (XSS)
XSS is a term used to describe a class of attacks that allow an attacker to inject client-side scripts _through_ the website into the browsers of other users. This is usually achieved by storing malicious scripts in the database where they can be retrieved and displayed to other users, or by getting users to click a link that will cause the attacker's JavaScript to be executed by the user's browser.
Django's template system protects you against the majority of XSS attacks by [escaping specific characters](https://docs.djangoproject.com/en/4.2/ref/templates/language/#automatic-html-escaping) that are "dangerous" in HTML. We can demonstrate this by attempting to inject some JavaScript into our LocalLibrary website using the Create-author form we set up in [Django Tutorial Part 9: Working with forms](/en-US/docs/Learn/Server-side/Django/Forms).
1. Start the website using the development server (`python3 manage.py runserver`).
2. Open the site in your local browser and login to your superuser account.
3. Navigate to the author-creation page (which should be at URL: `http://127.0.0.1:8000/catalog/author/create/`).
4. Enter names and date details for a new user, and then append the following text to the Last Name field:
`<script>alert('Test alert');</script>`.
> **Note:** This is a harmless script that, if executed, will display an alert box in your browser. If the alert is displayed when you submit the record then the site is vulnerable to XSS threats.
5. Press **Submit** to save the record.
6. When you save the author it will be displayed as shown below. Because of the XSS protections the `alert()` should not be run. Instead the script is displayed as plain text.
If you view the page HTML source code, you can see that the dangerous characters for the script tags have been turned into their harmless escape code equivalents (for example, `>` is now `>`)
```html
<h1>
Author: Boon<script>alert('Test alert');</script>, David
(Boonie)
</h1>
```
Using Django templates protects you against the majority of XSS attacks. However it is possible to turn off this protection, and the protection isn't automatically applied to all tags that wouldn't normally be populated by user input (for example, the `help_text` in a form field is usually not user-supplied, so Django doesn't escape those values).
It is also possible for XSS attacks to originate from other untrusted source of data, such as cookies, Web services or uploaded files (whenever the data is not sufficiently sanitized before including in a page). If you're displaying data from these sources, then you may need to add your own sanitization code.
### Cross site request forgery (CSRF) protection
CSRF attacks allow a malicious user to execute actions using the credentials of another user without that user's knowledge or consent. For example consider the case where we have a hacker who wants to create additional authors for our LocalLibrary.
> **Note:** Obviously our hacker isn't in this for the money! A more ambitious hacker could use the same approach on other sites to perform much more harmful tasks (such as transferring money to their own accounts, and so on.)
In order to do this, they might create an HTML file like the one below, which contains an author-creation form (like the one we used in the previous section) that is submitted as soon as the file is loaded.
They would then send the file to all the Librarians and suggest that they open the file (it contains some harmless information, honest!). If the file is opened by any logged in librarian, then the form would be submitted with their credentials and a new author would be created.
```html
<html lang="en">
<body onload="document.EvilForm.submit()">
<form
action="http://127.0.0.1:8000/catalog/author/create/"
method="post"
name="EvilForm">
<table>
<tr>
<th><label for="id_first_name">First name:</label></th>
<td>
<input
id="id_first_name"
maxlength="100"
name="first_name"
type="text"
value="Mad"
required />
</td>
</tr>
<tr>
<th><label for="id_last_name">Last name:</label></th>
<td>
<input
id="id_last_name"
maxlength="100"
name="last_name"
type="text"
value="Man"
required />
</td>
</tr>
<tr>
<th><label for="id_date_of_birth">Date of birth:</label></th>
<td>
<input id="id_date_of_birth" name="date_of_birth" type="text" />
</td>
</tr>
<tr>
<th><label for="id_date_of_death">Died:</label></th>
<td>
<input
id="id_date_of_death"
name="date_of_death"
type="text"
value="12/10/2016" />
</td>
</tr>
</table>
<input type="submit" value="Submit" />
</form>
</body>
</html>
```
Run the development web server, and log in with your superuser account. Copy the text above into a file and then open it in the browser. You should get a CSRF error, because Django has protection against this kind of thing!
The way the protection is enabled is that you include the `{% csrf_token %}` template tag in your form definition. This token is then rendered in your HTML as shown below, with a value that is specific to the user on the current browser.
```html
<input
type="hidden"
name="csrfmiddlewaretoken"
value="0QRWHnYVg776y2l66mcvZqp8alrv4lb8S8lZ4ZJUWGZFA5VHrVfL2mpH29YZ39PW" />
```
Django generates a user/browser specific key and will reject forms that do not contain the field, or that contain an incorrect field value for the user/browser.
To use this type of attack the hacker now has to discover and include the CSRF key for the specific target user. They also can't use the "scattergun" approach of sending a malicious file to all librarians and hoping that one of them will open it, since the CSRF key is browser specific.
Django's CSRF protection is turned on by default. You should always use the `{% csrf_token %}` template tag in your forms and use `POST` for requests that might change or add data to the database.
### Other protections
Django also provides other forms of protection (most of which would be hard or not particularly useful to demonstrate):
- SQL injection protection
- : SQL injection vulnerabilities enable malicious users to execute arbitrary SQL code on a database, allowing data to be accessed, modified, or deleted irrespective of the user's permissions. In almost every case you'll be accessing the database using Django's querysets/models, so the resulting SQL will be properly escaped by the underlying database driver. If you do need to write raw queries or custom SQL then you'll need to explicitly think about preventing SQL injection.
- Clickjacking protection
- : In this attack a malicious user hijacks clicks meant for a visible top level site and routes them to a hidden page beneath. This technique might be used, for example, to display a legitimate bank site but capture the login credentials in an invisible [`<iframe>`](/en-US/docs/Web/HTML/Element/iframe) controlled by the attacker. Django contains [clickjacking](/en-US/docs/Glossary/Clickjacking) protection in the form of the [`X-Frame-Options middleware`](https://docs.djangoproject.com/en/4.0/ref/middleware/#django.middleware.clickjacking.XFrameOptionsMiddleware) which, in a supporting browser, can prevent a site from being rendered inside a frame.
- Enforcing TLS/HTTPS
- : TLS/HTTPS can be enabled on the web server in order to encrypt all traffic between the site and browser, including authentication credentials that would otherwise be sent in plain text (enabling HTTPS is highly recommended). If HTTPS is enabled then Django provides a number of other protections you can use:
- [`SECURE_PROXY_SSL_HEADER`](https://docs.djangoproject.com/en/4.2/ref/settings/#std:setting-SECURE_PROXY_SSL_HEADER) can be used to check whether content is secure, even if it is incoming from a non-HTTP proxy.
- [`SECURE_SSL_REDIRECT`](https://docs.djangoproject.com/en/4.2/ref/settings/#std:setting-SECURE_SSL_REDIRECT) is used to redirect all HTTP requests to HTTPS.
- Use [HTTP Strict Transport Security](https://docs.djangoproject.com/en/4.2/ref/middleware/#http-strict-transport-security) (HSTS). This is an HTTP header that informs a browser that all future connections to a particular site should always use HTTPS. Combined with redirecting HTTP requests to HTTPS, this setting ensures that HTTPS is always used after a successful connection has occurred. HSTS may either be configured with [`SECURE_HSTS_SECONDS`](https://docs.djangoproject.com/en/4.2/ref/settings/#std:setting-SECURE_HSTS_SECONDS) and [`SECURE_HSTS_INCLUDE_SUBDOMAINS`](https://docs.djangoproject.com/en/4.2/ref/settings/#std:setting-SECURE_HSTS_INCLUDE_SUBDOMAINS) or on the Web server.
- Use 'secure' cookies by setting [`SESSION_COOKIE_SECURE`](https://docs.djangoproject.com/en/4.2/ref/settings/#std:setting-SESSION_COOKIE_SECURE) and [`CSRF_COOKIE_SECURE`](https://docs.djangoproject.com/en/4.2/ref/settings/#std:setting-CSRF_COOKIE_SECURE) to `True`. This will ensure that cookies are only ever sent over HTTPS.
- Host header validation
- : Use [`ALLOWED_HOSTS`](https://docs.djangoproject.com/en/4.2/ref/settings/#std:setting-ALLOWED_HOSTS) to only accept requests from trusted hosts.
There are many other protections, and caveats to the usage of the above mechanisms. While we hope that this has given you an overview of what Django offers, you should still read the Django security documentation.
## Summary
Django has effective protections against a number of common threats, including XSS and CSRF attacks. In this article we've demonstrated how those particular threats are handled by Django in our _LocalLibrary_ website. We've also provided a brief overview of some of the other protections.
This has been a very brief foray into web security. We strongly recommend that you read [Security in Django](https://docs.djangoproject.com/en/4.2/topics/security/) to gain a deeper understanding.
The next and final step in this module about Django is to complete the [assessment task](/en-US/docs/Learn/Server-side/Django/django_assessment_blog).
## See also
- [Security in Django](https://docs.djangoproject.com/en/4.2/topics/security/) (Django docs)
- [Server side website security](/en-US/docs/Web/Security) (MDN)
- [Securing your site](/en-US/docs/Web/Security/Securing_your_site) (MDN)
{{PreviousMenuNext("Learn/Server-side/Django/Deployment", "Learn/Server-side/Django/django_assessment_blog", "Learn/Server-side/Django")}}
| 0 |
data/mdn-content/files/en-us/learn/server-side/django | data/mdn-content/files/en-us/learn/server-side/django/development_environment/index.md | ---
title: Setting up a Django development environment
slug: Learn/Server-side/Django/development_environment
page-type: learn-module-chapter
---
{{LearnSidebar}}{{PreviousMenuNext("Learn/Server-side/Django/Introduction", "Learn/Server-side/Django/Tutorial_local_library_website", "Learn/Server-side/Django")}}
Now that you know what Django is for, we'll show you how to set up and test a Django development environment on Windows, Linux (Ubuntu), and macOS — whatever common operating system you are using, this article should give you what you need to be able to start developing Django apps.
<table>
<tbody>
<tr>
<th scope="row">Prerequisites:</th>
<td>
Basic knowledge of using a terminal/command line and how to install software packages on your development computer's operating system.
</td>
</tr>
<tr>
<th scope="row">Objective:</th>
<td>
To have a development environment for Django (4.*) running on your computer.
</td>
</tr>
</tbody>
</table>
## Django development environment overview
Django makes it very easy to set up your own computer so that you can start developing web applications. This section explains what you get with the development environment, and provides an overview of some of your setup and configuration options. The remainder of the article explains the _recommended_ method of installing the Django development environment on Ubuntu, macOS, and Windows, and how you can test it.
### What is the Django development environment?
The development environment is an installation of Django on your local computer that you can use for developing and testing Django apps prior to deploying them to a production environment.
The main tools that Django itself provides are a set of Python scripts for creating and working with Django projects, along with a simple _development web server_ that you can use to test local (i.e. on your computer, not on an external web server) Django web applications on your computer's web browser.
There are other peripheral tools, which form part of the development environment, that we won't be covering here. These include things like a [text editor](/en-US/docs/Learn/Common_questions/Tools_and_setup/Available_text_editors) or IDE for editing code, and a source control management tool like [Git](https://git-scm.com/) for safely managing different versions of your code. We are assuming that you've already got a text editor installed.
### What are the Django setup options?
Django is extremely flexible in terms of how and where it can be installed and configured. Django can be:
- Installed on different operating systems.
- Installed from source, from the Python Package Index (PyPi) and in many cases from the host computer's package manager application.
- Configured to use one of several databases, which may also need to be separately installed and configured.
- Run in the main system Python environment or within separate Python virtual environments.
Each of these options requires a slightly different configuration and setup. The following subsections explain some of your choices. For the rest of the article, we'll show you how to set up Django on a small number of operating systems, and that setup will be assumed throughout the rest of this module.
> **Note:** Other possible installation options are covered in the official Django documentation. We link to the [appropriate documents below](#see_also).
#### What operating systems are supported?
Django web applications can be run on almost any machine that can run the Python 3 programming language: Windows, macOS, Linux/Unix, Solaris, to name just a few.
Almost any computer should have the necessary performance to run Django during development.
In this article, we'll provide instructions for Windows, macOS, and Linux/Unix.
#### What version of Python should be used?
You can use any Python version supported by your target Django release.
For Django 4.2 the allowed versions are Python 3.8 to 3.11 (see [FAQ:Installation](https://docs.djangoproject.com/en/4.2/faq/install/#what-python-version-can-i-use-with-django)).
The Django project _recommends_ (and "officially supports") using the newest available supported Python release.
#### Where can we download Django?
There are three places to download Django:
- The Python Package Repository (PyPi), using the _pip_ tool. This is the best way to get the latest stable version of Django.
- Use a version from your computer's package manager. Distributions of Django that are bundled with operating systems offer a familiar installation mechanism. Note however that the packaged version may be quite old, and can only be installed into the system Python environment (which may not be what you want).
- Install from source. You can get and install the latest bleeding-edge version of Django from the source. This is not recommended for beginners but is needed when you're ready to start contributing back to Django itself.
This article shows how to install Django from PyPi, in order to get the latest stable version.
#### Which database?
Django officially supports the PostgreSQL, MariaDB, MySQL, Oracle, and SQLite databases, and there are community libraries that provide varying levels of support for other popular SQL and NoSQL databases. We recommend that you select the same database for both production and development (although Django abstracts many of the database differences using its Object-Relational Mapper (ORM), there are still [potential issues](https://docs.djangoproject.com/en/4.2/ref/databases/) that are better to avoid).
For this article (and most of this module) we will be using the _SQLite_ database, which stores its data in a file. SQLite is intended for use as a lightweight database and can't support a high level of concurrency. It is, however, an excellent choice for applications that are primarily read-only.
> **Note:** Django is configured to use SQLite by default when you start your website project using the standard tools (_django-admin_). It's a great choice when you're getting started because it requires no additional configuration or setup.
#### Installing system-wide or in a Python virtual environment?
When you install Python3 you get a single global environment that is shared by all Python3 code. While you can install whatever Python packages you like in the environment, you can only install one particular version of each package at a time.
> **Note:** Python applications installed into the global environment can potentially conflict with each other (i.e. if they depend on different versions of the same package).
If you install Django into the default/global environment then you will only be able to target one version of Django on the computer. This can be a problem if you want to create new websites (using the latest version of Django) while still maintaining websites that rely on older versions.
As a result, experienced Python/Django developers typically run Python apps within independent _Python virtual environments_. This enables multiple different Django environments on a single computer. The Django developer team itself recommends that you use Python virtual environments!
This module assumes that you've installed Django into a virtual environment, and we'll show you how below.
## Installing Python 3
In order to use Django you must have Python 3 on your operating system.
You will also need the [Python Package Index](https://pypi.org/) tool — _pip3_ — which is used to manage (install, update, and remove) Python packages/libraries used by Django and your other Python apps.
This section briefly explains how you can check what versions of Python are present, and install new versions as needed, for Ubuntu Linux 20.04, macOS, and Windows 10.
> **Note:** Depending on your platform, you may also be able to install Python/pip from the operating system's own package manager or via other mechanisms. For most platforms, you can download the required installation files from <https://www.python.org/downloads/> and install them using the appropriate platform-specific method.
### Ubuntu 20.04
Ubuntu Linux 20.04 LTS includes Python 3.8.10 by default.
You can confirm this by running the following command in the bash terminal:
```bash
python3 -V
# Output: Python 3.8.10
```
However, the Python Package Index tool (_pip3_) you'll need to install packages for Python 3 (including Django) is **not** available by default.
You can install _pip3_ in the bash terminal using:
```bash
sudo apt install python3-pip
```
> **Note:** Python 3.8 is the oldest version [supported by Django 4.2](https://docs.djangoproject.com/en/4.2/faq/install/#what-python-version-can-i-use-with-django).
> While Django recommend you update to the latest version, you don't _need_ to use the latest version for this tutorial.
> If you want to update Python, then there are instructions on the internet.
### macOS
macOS does not include Python 3 by default (Python 2 is included on older versions).
You can confirm this by running the following command in the terminal:
```bash
python3 -V
```
This will either display the Python version number, which indicates that Python 3 is installed, or `python3: command not found`, which indicates Python 3 was not found.
You can easily install Python 3 (along with the _pip3_ tool) from [python.org](https://www.python.org/):
1. Download the required installer:
1. Go to <https://www.python.org/downloads/macos/>
2. Download the most recent [supported version](https://docs.djangoproject.com/en/4.2/faq/install/#what-python-version-can-i-use-with-django) that works with Django 4.2.
(at time of writing this is Python 3.11.4).
2. Locate the file using _Finder_, and double-click the package file. Following the installation prompts.
You can now confirm successful installation by running `python3 -V` again and checking for the Python version number.
You can similarly check that _pip3_ is installed by listing the available packages:
```bash
pip3 list
```
### Windows 10 or 11
Windows doesn't include Python by default, but you can easily install it (along with the _pip3_ tool) from [python.org](https://www.python.org/):
1. Download the required installer:
1. Go to <https://www.python.org/downloads/windows/>
2. Download the most recent [supported version](https://docs.djangoproject.com/en/4.2/faq/install/#what-python-version-can-i-use-with-django) that works with Django 4.2.
(at time of writing this is Python 3.11.4).
2. Install Python by double-clicking on the downloaded file and following the installation prompts
3. Be sure to check the box labeled "Add Python to PATH"
You can then verify that Python 3 was installed by entering the following text into the command prompt:
```bash
py -3 -V
```
The Windows installer incorporates _pip3_ (the Python package manager) by default.
You can list installed packages as shown:
```bash
py -3 -m pip list
```
> **Note:** The installer should set up everything you need for the above command to work.
> If however you get a message that Python cannot be found, you may have forgotten to add it to your system path.
> You can do this by running the installer again, selecting "Modify", and checking the box labeled "Add Python to environment variables" on the second page.
## Calling Python 3 and pip3
You will note that in the previous sections we use different commands to call Python 3 and pip on different operating systems.
If you only have Python 3 installed (and not Python 2), the bare commands `python` and `pip` can generally be used to run Python and pip on any operating system.
If this is allowed on your system you will get a version "3" string when you run `-V` with the bare commands, as shown:
```bash
python -V
pip -V
```
If Python 2 is installed then to use version 3 you should prefix commands with `python3` and `pip3` on Linux/macOS, and `py -3` and `py -3 -m pip` on Windows:
```bash
# Linux/macOS
python3 -V
pip3 -V
# Windows
py -3 -V
py -3 -m pip list
```
The instructions below show the platform specific commands as they work on more systems.
## Using Django inside a Python virtual environment
The libraries we'll use for creating our virtual environments are [virtualenvwrapper](https://virtualenvwrapper.readthedocs.io/en/latest/index.html) (Linux and macOS) and [virtualenvwrapper-win](https://pypi.org/project/virtualenvwrapper-win/) (Windows), which in turn both use the [virtualenv](https://virtualenv.pypa.io/en/latest/) tool. The wrapper tools creates a consistent interface for managing interfaces on all platforms.
### Installing the virtual environment software
#### Ubuntu virtual environment setup
After installing Python and pip you can install _virtualenvwrapper_ (which includes _virtualenv_). The official installation guide can be found [here](https://virtualenvwrapper.readthedocs.io/en/latest/install.html), or follow the instructions below.
Install the tool using _pip3_:
```bash
sudo pip3 install virtualenvwrapper
```
Then add the following lines to the end of your shell startup file (this is a hidden file name **.bashrc** in your home directory). These set the location where the virtual environments should live, the location of your development project directories, and the location of the script installed with this package:
```bash
export WORKON_HOME=$HOME/.virtualenvs
export VIRTUALENVWRAPPER_PYTHON=/usr/bin/python3
export VIRTUALENVWRAPPER_VIRTUALENV_ARGS=' -p /usr/bin/python3 '
export PROJECT_HOME=$HOME/Devel
source /usr/local/bin/virtualenvwrapper.sh
```
> **Note:** The `VIRTUALENVWRAPPER_PYTHON` and `VIRTUALENVWRAPPER_VIRTUALENV_ARGS` variables point to the normal installation location for Python 3, and `source /usr/local/bin/virtualenvwrapper.sh` points to the normal location of the `virtualenvwrapper.sh` script. If the _virtualenv_ doesn't work when you test it, one thing to check is that Python and the script are in the expected location (and then change the startup file appropriately).
>
> You can find the correct locations for your system using the commands `which virtualenvwrapper.sh` and `which python3`.
Then reload the startup file by running the following command in the terminal:
```bash
source ~/.bashrc
```
At this point you should see a bunch of scripts being run as shown below:
```bash
virtualenvwrapper.user_scripts creating /home/ubuntu/.virtualenvs/premkproject
virtualenvwrapper.user_scripts creating /home/ubuntu/.virtualenvs/postmkproject
# …
virtualenvwrapper.user_scripts creating /home/ubuntu/.virtualenvs/preactivate
virtualenvwrapper.user_scripts creating /home/ubuntu/.virtualenvs/postactivate
virtualenvwrapper.user_scripts creating /home/ubuntu/.virtualenvs/get_env_details
```
Now you can create a new virtual environment with the `mkvirtualenv` command.
#### macOS virtual environment setup
Setting up _virtualenvwrapper_ on macOS is almost exactly the same as on Ubuntu (again, you can follow the instructions from either the [official installation guide](https://virtualenvwrapper.readthedocs.io/en/latest/install.html) or below).
Install _virtualenvwrapper_ (and bundling _virtualenv_) using _pip_ as shown.
```bash
sudo pip3 install virtualenvwrapper
```
Then add the following lines to the end of your shell startup file (these are the same lines as for Ubuntu).
If you're using the _zsh shell_ then the startup file will be a hidden file named **.zshrc** in your home directory. If you're using the _bash shell_ then it will be a hidden file named **.bash_profile**. You may need to create the file if it does not yet exist.
```bash
export WORKON_HOME=$HOME/.virtualenvs
export VIRTUALENVWRAPPER_PYTHON=/usr/bin/python3
export PROJECT_HOME=$HOME/Devel
source /usr/local/bin/virtualenvwrapper.sh
```
> **Note:** The `VIRTUALENVWRAPPER_PYTHON` variable points to the normal installation location for Python 3, and `source /usr/local/bin/virtualenvwrapper.sh` points to the normal location of the `virtualenvwrapper.sh` script. If the _virtualenv_ doesn't work when you test it, one thing to check is that Python and the script are in the expected location (and then change the startup file appropriately).
>
> For example, one installation test on macOS ended up with the following lines being necessary in the startup file:
>
> ```bash
> export WORKON_HOME=$HOME/.virtualenvs
> export VIRTUALENVWRAPPER_PYTHON=/Library/Frameworks/Python.framework/Versions/3.7/bin/python3
> export PROJECT_HOME=$HOME/Devel
> source /Library/Frameworks/Python.framework/Versions/3.7/bin/virtualenvwrapper.sh
> ```
>
> You can find the correct locations for your system using the commands `which virtualenvwrapper.sh` and `which python3`.
Then reload the startup file by making the following call in the terminal:
```bash
source ~/.bash_profile
```
At this point, you may see a bunch of scripts being run (the same scripts as for the Ubuntu installation). You should now be able to create a new virtual environment with the `mkvirtualenv` command.
> **Note:** If you can't find the startup file to edit in the finder, you can also open this in the terminal using nano.
>
> Assuming you're using bash, the commands look something like this:
>
> ```bash
> cd ~ # Navigate to my home directory
> ls -la #List the content of the directory. You should see .bash_profile
> nano .bash_profile # Open the file in the nano text editor, within the terminal
> # Scroll to the end of the file, and copy in the lines above
> # Use Ctrl+X to exit nano, choose Y to save the file.
> ```
#### Windows virtual environment setup
Installing [virtualenvwrapper-win](https://pypi.org/project/virtualenvwrapper-win/) is even simpler than setting up _virtualenvwrapper_ because you don't need to configure where the tool stores virtual environment information (there is a default value). All you need to do is run the following command in the command prompt:
```bash
py -3 -m pip install virtualenvwrapper-win
```
Now you can create a new virtual environment with the `mkvirtualenv` command
### Creating a virtual environment
Once you've installed _virtualenvwrapper_ or _virtualenvwrapper-win_ then working with virtual environments is very similar on all platforms.
Now you can create a new virtual environment with the `mkvirtualenv` command. As this command runs you'll see the environment being set up (what you see is slightly platform-specific). When the command completes the new virtual environment will be active — you can see this because the start of the prompt will be the name of the environment in parentheses (below we show this for Ubuntu, but the final line is similar for Windows/macOS).
```bash
mkvirtualenv my_django_environment
```
You should see output similar to the following:
```plain
Running virtualenv with interpreter /usr/bin/python3
# …
virtualenvwrapper.user_scripts creating /home/ubuntu/.virtualenvs/t_env7/bin/get_env_details
(my_django_environment) ubuntu@ubuntu:~$
```
Now you're inside the virtual environment you can install Django and start developing.
> **Note:** From now on in this article (and indeed the module) please assume that any commands are run within a Python virtual environment like the one we set up above.
### Using a virtual environment
There are just a few other useful commands that you should know (there are more in the tool documentation, but these are the ones you'll use regularly):
- `deactivate` — Exit out of the current Python virtual environment
- `workon` — List available virtual environments
- `workon name_of_environment` — Activate the specified Python virtual environment
- `rmvirtualenv name_of_environment` — Remove the specified environment.
## Installing Django
Once you've created a virtual environment, and called `workon` to enter it, you can use _pip3_ to install Django.
```bash
# Linux/macOS
python3 -m pip install django~=4.2
# Windows
py -3 -m pip install django~=4.2
```
You can test that Django is installed by running the following command (this just tests that Python can find the Django module):
```bash
# Linux/macOS
python3 -m django --version
# Windows
py -3 -m django --version
```
> **Note:** If the above Windows command does not show a django module present, try:
>
> ```bash
> py -m django --version
> ```
>
> In Windows _Python 3_ scripts are launched by prefixing the command with `py -3`, although this can vary depending on your specific installation.
> Try omitting the `-3` modifier if you encounter any problems with commands.
> In Linux/macOS, the command is `python3.`
> **Warning:** The rest of this **module** uses the _Linux_ command for invoking Python 3 (`python3`). If you're working on _Windows_ replace this prefix with: `py -3`
## Source code management with Git and GitHub
Source Code Management (SCM) and versioning tools allow you to reliably store and recover versions of your source code, try out changes, and share code between your experiments and "known good code" when you need to.
There are many different SCM tools, including git, Mercurial, Perforce, SVN (Subversion), CVS (Concurrent Versions System), etc., and cloud SCM hosting sources such as Bitbucket, GitHub, and GitLab.
For this tutorial we'll hosting our code on [GitHub](https://github.com/), one of the most popular cloud based source code hosting services, and using the **git** tool to manage our source code locally and send it to Github when needed.
> **Note:** Using SCM tools is good software development practice!
> Ths instructions provide a basic introduction to git and GitHub.
> To learn more, see [Learning Git](https://docs.github.com/en/get-started/quickstart/git-and-github-learning-resources).
### Key concepts
Git (and Github) use repositories ("repos") as the top level "bucket" for storing code, where each repo normally contains the source code for just one application or module.
Repositories can be public, in which case the code is visible to everyone on the internet, or private, in which case they are restricted to the owning organization or user account.
All work is done on a particular "branch" of code in your repo.
When you want to backup some changes to a branch you can create a "commit", which stores all changes since your last commit to the current branch.
The repo is created with a default branch named "main". You can spawn other branches off this using git, which initially have all the commits of the original branch.
You can evolve branches separately by adding commits, and then later on use a "Pull Request" (PR) on GitHub to merge changes from one branch to another.
You can also use git to switch between branches on your local compute, for example to try out different things.
In addition to branches, it is possible to create `tags` on any branch and later recover that branch at that point.
### Create an account and repository on GitHub
First we will create a free account on GitHub.
With a free account you can't create private repos, but you can create as many _public_ repositories ("repos") as you like.
Then we create and configure a repository named "django_local_library" for storing the [Local library website](/en-US/docs/Learn/Server-side/Django/Tutorial_local_library_website) as we evolve it in the rest of this tutorial.
The steps are:
1. Visit <https://github.com/> and create an account.
2. Once you are logged in, click the **+** link in the top toolbar and select **New repository**.
3. Fill in all the fields on this form.
While these are not compulsory, they are strongly recommended.
- Enter a repository name: "django_local_library".
- Enter a new repository description: "Local Library website written in Django".
- Select "Public" for the repository (the default).
> **Warning:** This will make _all_ source code visible.
> Remember not to store credentials or other sensitive material in your repo unless it is private.
- Choose **Python** in the _Add .gitignore_ selection list.
- Choose your preferred license in the _Add license_ selection list.
MDN uses "Creative Commons Zero v1.0 Universal" for this example.
- Check **Initialize this repository with a README**.
4. Press **Create repository**.
The repository will be created, containing just the files `README.txt` and `.gitignore`.
### Clone the repo to your local computer
Now that the repository ("repo") is created on GitHub we are going to want to clone (copy) it to our local computer:
1. On GitHub, click the green **Code** button.
In the "Clone" section, select the "HTTPS" tab, and copy the URL.
If you used the repository name "django_local_library", the URL should be something like: `https://github.com/<your_git_user_id>/django_local_library.git`.
2. Install _git_ for your local computer (you can find versions for different platforms [here](https://git-scm.com/downloads)).
3. Open a command prompt/terminal and clone your repo using the URL you copied above:
```bash
git clone https://github.com/<your_git_user_id>/django_local_library.git
```
This will create the repository inside the current directory.
4. Navigate into the repo folder.
```bash
cd django_local_library
```
### Modify and sync changes
Now we're going to modify the `.gitignore` file on the local computer, commit the change, and update the repository on GitHub.
This is a useful change to make, but mostly we're doing it to show you how to pull changes from GitHub, make changes locally, and then push them to GitHub.
1. In the command prompt/terminal we first "fetch" (get) and then pull (get and merge into the current branch) the latest version of the source from GitHub:
> **Note:** This step isn't strictly necessary as we have just cloned the source and know it is up to date.
> However in general you should update your sources from GitHub before making changes.
```bash
git fetch origin main
git pull origin main
```
The "origin" is a _remote_, which represents the location of the repo where the source is located, and "main" is the branch.
You can verify that origin is our repo on GitHub using the command: `git remote -v`.
2. Next we checkout a new branch to store our changes:
```bash
git checkout -b update_gitignore
```
The `checkout` command is used to switch some branch to be the current branch that you are working on.
The `-b` flag indicates that we intend to create a new branch named "update_gitignore" instead of selecting an existing branch with that name.
3. Open the **.gitignore** file, copy the following lines into the bottom of it, and then save:
```plain
# Text backup files
*.bak
# Database
*.sqlite3
```
Note that `.gitignore` is used to indicate files that should not be backed up by git automatically, such as temporary files and other build artifacts.
4. Use the `add` command to add all changed files (that aren't ignored by the **.gitignore** file) to the "staging area" for the current branch.
```bash
git add -A
```
5. Use the `status` command to check that all files you are about to `commit` are correct (you want to include source files, not binaries, temporary files etc.).
It should look a bit like the listing below.
```bash
> git status
On branch main
Your branch is up-to-date with 'origin/update_gitignore'.
Changes to be committed:
(use "git reset HEAD <file>..." to unstage)
modified: .gitignore
```
6. When you're satisfied, `commit` the files to your local repo, using the `-m` flag to specify a concise but clear commit message.
This is equivalent to signing off on the changes and making them an official part of the local repo.
```bash
git commit -m ".gitignore: add .bak and .sqlite3"
```
7. At this point, the remote repo has not been changed.
We can push the `update_gitignore` branch to the "origin" repo (Github) using the following command:
```bash
git push origin update_gitignore
```
8. Go back to the page on GitHub where you created your repo and refresh the page.
A banner should appear with a button to press if you want to "Compare and pull request" the branch you just uploaded.
Select the button and then follow the instructions to create and then merge a pull request.
After merging, the "main" branch on the repo on Github will contain your changes to `.gitignore`.
9. You can continue to update your local repo as files change using this add/commit/push cycle.
In the next topic we'll use this repo to store our local library website source code.
## Other Python tools
Experienced Python developers may install additional tools, such as linters (which help detect common errors in code).
Note that you should use a Django-aware linter such as [pylint-django](https://pypi.org/project/pylint-django/), because some common Python linters (such as `pylint`) incorrectly report errors in the standard files generated for Django.
## Testing your installation
The above test works, but it isn't very much fun. A more interesting test is to create a skeleton project and see it working. To do this, first navigate in your command prompt/terminal to where you want to store your Django apps. Create a folder for your test site and navigate into it.
```bash
mkdir django_test
cd django_test
```
You can then create a new skeleton site called "_mytestsite_" using the **django-admin** tool as shown. After creating the site you can navigate into the folder where you will find the main script for managing projects, called **manage.py**.
```bash
django-admin startproject mytestsite
cd mytestsite
```
We can run the _development web server_ from within this folder using **manage.py** and the `runserver` command, as shown.
```bash
# Linux/macOS
python3 manage.py runserver
# Windows
py -3 manage.py runserver
```
> **Note:** You can ignore the warnings about "unapplied migration(s)" at this point!
Once the server is running you can view the site by navigating to the following URL on your local web browser: `http://127.0.0.1:8000/`. You should see a site that looks like this:
## Summary
You now have a Django development environment up and running on your computer.
In the testing section you also briefly saw how we can create a new Django website using `django-admin startproject`, and run it in your browser using the development web server (`python3 manage.py runserver`). In the next article, we expand on this process, building a simple but complete web application.
## See also
- [Quick Install Guide](https://docs.djangoproject.com/en/4.2/intro/install/) (Django docs)
- [How to install Django — Complete guide](https://docs.djangoproject.com/en/4.2/topics/install/) (Django docs) — also covers how to remove Django
- [How to install Django on Windows](https://docs.djangoproject.com/en/4.2/howto/windows/) (Django docs)
{{PreviousMenuNext("Learn/Server-side/Django/Introduction", "Learn/Server-side/Django/Tutorial_local_library_website", "Learn/Server-side/Django")}}
| 0 |
data/mdn-content/files/en-us/learn/server-side/django | data/mdn-content/files/en-us/learn/server-side/django/django_assessment_blog/index.md | ---
title: "Assessment: DIY Django mini blog"
slug: Learn/Server-side/Django/django_assessment_blog
page-type: learn-module-assessment
---
{{LearnSidebar}}{{PreviousMenu("Learn/Server-side/Django/web_application_security", "Learn/Server-side/Django")}}
In this assessment you'll use the Django knowledge you've picked up in the [Django Web Framework (Python)](/en-US/docs/Learn/Server-side/Django) module to create a very basic blog.
<table>
<tbody>
<tr>
<th scope="row">Prerequisites:</th>
<td>
Before attempting this assessment you should have already worked through all the articles in this module.
</td>
</tr>
<tr>
<th scope="row">Objective:</th>
<td>
To test comprehension of Django fundamentals, including URL configurations, models, views, forms, and templates.
</td>
</tr>
</tbody>
</table>
## Project brief
The pages that need to be displayed, their URLs, and other requirements, are listed below:
<table class="standard-table">
<thead>
<tr>
<th scope="col">Page</th>
<th scope="col">URL</th>
<th scope="col">Requirements</th>
</tr>
</thead>
<tbody>
<tr>
<td>Home page</td>
<td><code>/</code> and <code>/blog/</code></td>
<td>An index page describing the site.</td>
</tr>
<tr>
<td>List of all blog posts</td>
<td><code>/blog/blogs/</code></td>
<td>
<p>List of all blog posts:</p>
<ul>
<li>Accessible to all users from a sidebar link.</li>
<li>List sorted by post date (newest to oldest).</li>
<li>List paginated in groups of 5 articles.</li>
<li>List items display the blog title, post date, and author.</li>
<li>Blog post names are linked to blog detail pages.</li>
<li>
Blogger (author names) are linked to blog author detail pages.
</li>
</ul>
</td>
</tr>
<tr>
<td>Blog author (blogger) detail page</td>
<td>
<code>/blog/blogger/<em><author-id></em></code>
</td>
<td>
<p>
Information for a specified author (by id) and list of their blog posts:
</p>
<ul>
<li>Accessible to all users from author links in blog posts etc.</li>
<li>
Contains some biographical information about the blogger/author.
</li>
<li>List sorted by post date (newest to oldest).</li>
<li>Not paginated.</li>
<li>List items display just the blog post name and post date.</li>
<li>Blog post names are linked to blog detail pages.</li>
</ul>
</td>
</tr>
<tr>
<td>Blog post detail page</td>
<td>
<code>/blog/<em><blog-id></em></code>
</td>
<td>
<p>Blog post details.</p>
<ul>
<li>Accessible to all users from blog post lists.</li>
<li>
Page contains the blog post: name, author, post date, and content.
</li>
<li>Comments for the blog post should be displayed at bottom.</li>
<li>Comments should be sorted in order: oldest to most recent.</li>
<li>
Contains link to add comments at end for logged in users (see Comment form page)
</li>
<li>
Blog posts and comments need only display plain text.
There is no need to support any sort of HTML markup (e.g. links, images, bold/italic, etc.).
</li>
</ul>
</td>
</tr>
<tr>
<td>List of all bloggers</td>
<td><code>/blog/bloggers/</code></td>
<td>
<p>List of bloggers on system:</p>
<ul>
<li>Accessible to all users from site sidebar</li>
<li>Blogger names are linked to Blog author detail pages.</li>
</ul>
</td>
</tr>
<tr>
<td>Comment form page</td>
<td><code>/blog/<em><blog-id></em>/create</code></td>
<td>
<p>Create comment for blog post:</p>
<ul>
<li>
Accessible to logged-in users (only) from link at bottom of blog post detail pages.
</li>
<li>
Displays form with description for entering comments (post date and blog is not editable).
</li>
<li>
After a comment has been posted, the page will redirect back to the associated blog post page.
</li>
<li>Users cannot edit or delete their posts.</li>
<li>
Logged out users will be directed to the login page to log in,
before they can add comments. After logging in, they will be
redirected back to the blog page they wanted to comment on.
</li>
<li>
Comment pages should include the name/link to the blog post being commented on.
</li>
</ul>
</td>
</tr>
<tr>
<td>User authentication pages</td>
<td>
<code>/accounts/<em><standard urls></em></code>
</td>
<td>
<p>
Standard Django authentication pages for logging in, out and setting the password:
</p>
<ul>
<li>Login/out should be accessible via sidebar links.</li>
</ul>
</td>
</tr>
<tr>
<td>Admin site</td>
<td>
<code>/admin/<em><standard urls></em></code>
</td>
<td>
<p>
Admin site should be enabled to allow create/edit/delete of blog
posts, blog authors and blog comments (this is the mechanism for
bloggers to create new blog posts):
</p>
<ul>
<li>
Admin site blog posts records should display the list of associated comments inline (below each blog post).
</li>
<li>
Comment names in the Admin site are created by truncating the comment description to 75 characters.
</li>
<li>Other types of records can use basic registration.</li>
</ul>
</td>
</tr>
</tbody>
</table>
In addition you should write some basic tests to verify:
- All model fields have the correct label and length.
- All models have the expected object name (e.g. `__str__()` returns the expected value).
- Models have the expected URL for individual Blog and Comment records (e.g. `get_absolute_url()` returns the expected URL).
- The BlogListView (all-blog page) is accessible at the expected location (e.g. /blog/blogs)
- The BlogListView (all-blog page) is accessible at the expected named URL (e.g. 'blogs')
- The BlogListView (all-blog page) uses the expected template (e.g. the default)
- The BlogListView paginates records by 5 (at least on the first page)
> **Note:** There are of course many other tests you can run. Use your discretion, but we'll expect you to do at least the tests above.
The following section shows [screenshots](#screenshots) of a site that implements the requirements above.
## Screenshots
The following screenshots provide an example of what the finished program should output.
### List of all blog posts
This displays the list of all blog posts (accessible from the "All blogs" link in the sidebar). Things to note:
- The sidebar also lists the logged in user.
- Individual blog posts and bloggers are accessible as links in the page.
- Pagination is enabled (in groups of 5)
- Ordering is newest to oldest.
### List of all bloggers
This provides links to all bloggers, as linked from the "All bloggers" link in the sidebar. In this case we can see from the sidebar that no user is logged in.
### Blog detail page
This shows the detail page for a particular blog.
Note that the comments have a date _and_ time, and are ordered from oldest to newest (opposite of blog ordering). At the end we have a link for accessing the form to add a new comment. If a user is not logged in we'd instead see a suggestion to log in.
### Add comment form
This is the form to add comments. Note that we're logged in. When this succeeds we should be taken back to the associated blog post page.
### Author bio
This displays bio information for a blogger along with their blog posts list.
## Steps to complete
The following sections describe what you need to do.
1. Create a skeleton project and web application for the site (as described in [Django Tutorial Part 2: Creating a skeleton website](/en-US/docs/Learn/Server-side/Django/skeleton_website)). You might use 'diyblog' for the project name and 'blog' for the application name.
2. Create models for the Blog posts, Comments, and any other objects needed. When thinking about your design, remember:
- Each comment will have only one blog, but a blog may have many comments.
- Blog posts and comments must be sorted by post date.
- Not every user will necessarily be a blog author though any user may be a commenter.
- Blog authors must also include bio information.
3. Run migrations for your new models and create a superuser.
4. Use the admin site to create some example blog posts and blog comments.
5. Create views, templates, and URL configurations for blog post and blogger list pages.
6. Create views, templates, and URL configurations for blog post and blogger detail pages.
7. Create a page with a form for adding new comments (remember to make this only available to logged in users!)
## Hints and tips
This project is very similar to the [LocalLibrary](/en-US/docs/Learn/Server-side/Django/Tutorial_local_library_website) tutorial. You will be able to set up the skeleton, user login/logout behavior, support for static files, views, URLs, forms, base templates and admin site configuration using almost all the same approaches.
Some general hints:
1. The index page can be implemented as a basic function view and template (just like for the locallibrary).
2. The list view for blog posts and bloggers, and the detail view for blog posts can be created using the [generic list and detail views](/en-US/docs/Learn/Server-side/Django/Generic_views).
3. The list of blog posts for a particular author can be created by using a generic blog list view and filtering for blog objects that match the specified author.
- You will have to implement `get_queryset(self)` to do the filtering (much like in our library class `LoanedBooksAllListView`) and get the author information from the URL.
- You will also need to pass the name of the author to the page in the context. To do this in a class-based view you need to implement `get_context_data()` (discussed below).
4. The _add comment_ form can be created using a function-based view (and associated model and form) or using a generic `CreateView`. If you use a `CreateView` (recommended) then:
- You will also need to pass the name of the blog post to the comment page in the context (implement `get_context_data()` as discussed below).
- The form should only display the comment "description" for user entry (date and associated blog post should not be editable). Since they won't be in the form itself, your code will need to set the comment's author in the `form_valid()` function so it can be saved into the model ([as described here](https://docs.djangoproject.com/en/4.2/topics/class-based-views/generic-editing/#models-and-request-user) — Django docs). In that same function we set the associated blog. A possible implementation is shown below (`pk` is a blog id passed in from the URL/URL configuration).
```python
def form_valid(self, form):
"""
Add author and associated blog to form data before setting it as valid (so it is saved to model)
"""
#Add logged-in user as author of comment
form.instance.author = self.request.user
#Associate comment with blog based on passed id
form.instance.blog=get_object_or_404(Blog, pk = self.kwargs['pk'])
# Call super-class form validation behavior
return super(BlogCommentCreate, self).form_valid(form)
```
- You will need to provide a success URL to redirect to after the form validates; this should be the original blog. To do this you will need to override `get_success_url()` and "reverse" the URL for the original blog. You can get the required blog ID using the `self.kwargs` attribute, as shown in the `form_valid()` method above.
We briefly talked about passing a context to the template in a class-based view in the [Django Tutorial Part 6: Generic list and detail views](/en-US/docs/Learn/Server-side/Django/Generic_views#overriding_methods_in_class-based_views) topic. To do this you need to override `get_context_data()` (first getting the existing context, updating it with whatever additional variables you want to pass to the template, and then returning the updated context). For example, the code fragment below shows how you can add a blogger object to the context based on their `BlogAuthor` id.
```python
class SomeView(generic.ListView):
# …
def get_context_data(self, **kwargs):
# Call the base implementation first to get a context
context = super(SomeView, self).get_context_data(**kwargs)
# Get the blogger object from the "pk" URL parameter and add it to the context
context['blogger'] = get_object_or_404(BlogAuthor, pk = self.kwargs['pk'])
return context
```
## Assessment
The assessment for this task is [available on GitHub here](https://github.com/mdn/django-diy-blog/blob/main/MarkingGuide.md). This assessment is primarily based on how well your application meets the requirements we listed above, though there are some parts of the assessment that check your code uses appropriate models, and that you have written at least some test code.
When you're done, you can check out [the finished example](https://github.com/mdn/django-diy-blog) which reflects a "full marks" project.
Once you've completed this module you've also finished all the MDN content for learning basic Django server-side website programming! We hope you enjoyed this module and feel you have a good grasp of the basics!
{{PreviousMenu("Learn/Server-side/Django/web_application_security", "Learn/Server-side/Django")}}
| 0 |
data/mdn-content/files/en-us/learn/server-side/django | data/mdn-content/files/en-us/learn/server-side/django/skeleton_website/index.md | ---
title: "Django Tutorial Part 2: Creating a skeleton website"
slug: Learn/Server-side/Django/skeleton_website
page-type: learn-module-chapter
---
{{LearnSidebar}}{{PreviousMenuNext("Learn/Server-side/Django/Tutorial_local_library_website", "Learn/Server-side/Django/Models", "Learn/Server-side/Django")}}
This second article in our [Django Tutorial](/en-US/docs/Learn/Server-side/Django/Tutorial_local_library_website) shows how you can create a "skeleton" website project as a basis, which you can then populate with site-specific settings, paths, models, views, and templates.
<table>
<tbody>
<tr>
<th scope="row">Prerequisites:</th>
<td>
<a href="/en-US/docs/Learn/Server-side/Django/development_environment">Set up a Django development environment</a>.
Review the <a href="/en-US/docs/Learn/Server-side/Django/Tutorial_local_library_website">Django Tutorial</a>.
</td>
</tr>
<tr>
<th scope="row">Objective:</th>
<td>
To be able to use Django's tools to start your own new website projects.
</td>
</tr>
</tbody>
</table>
## Overview
This article shows how you can create a "skeleton" website, which you can then populate with site-specific settings, paths, models, views, and templates (we discuss these in later articles).
To get started:
1. Use the `django-admin` tool to generate a project folder, the basic file templates, and **manage.py**, which serves as your project management script.
2. Use **manage.py** to create one or more _applications_.
> **Note:** A website may consist of one or more sections. For example, main site, blog, wiki, downloads area, etc. Django encourages you to develop these components as separate _applications_, which could then be re-used in different projects if desired.
3. Register the new applications to include them in the project.
4. Hook up the **url/path** mapper for each application.
For the [Local Library website](/en-US/docs/Learn/Server-side/Django/Tutorial_local_library_website), the website and project folders are named _locallibrary_, and includes one application named _catalog_.
The top-level folder structure will therefore be as follows:
```bash
locallibrary/ # Website folder
manage.py # Script to run Django tools for this project (created using django-admin)
locallibrary/ # Website/project folder (created using django-admin)
catalog/ # Application folder (created using manage.py)
```
The following sections discuss the process steps in detail, and show how you can test your changes.
At the end of this article, we discuss other site-wide configuration you might also do at this stage.
## Creating the project
To create the project:
1. Open a command shell (or a terminal window), and make sure you are in your [virtual environment](/en-US/docs/Learn/Server-side/Django/development_environment#using_a_virtual_environment).
2. Navigate to the folder where you want to store your local library application.
This should be the folder named "django_local_library" that you [created as a local Github repository](/en-US/docs/Learn/Server-side/Django/development_environment#clone_the_repo_to_your_local_computer) when setting up the development environment.
3. Create the new project using the `django-admin startproject` command as shown, and then change into the project folder:
```bash
django-admin startproject locallibrary
cd locallibrary
```
The `django-admin` tool creates a folder/file structure as follows:
```bash
locallibrary/
manage.py
locallibrary/
__init__.py
settings.py
urls.py
wsgi.py
asgi.py
```
Our current working directory should look something like this:
```bash
../django_local_library/locallibrary/
```
The _locallibrary_ project sub-folder is the entry point for the website:
- **\_\_init\_\_.py** is an empty file that instructs Python to treat this directory as a Python package.
- **settings.py** contains all the website settings, including registering any applications we create, the location of our static files, database configuration details, etc.
- **urls.py** defines the site URL-to-view mappings. While this could contain _all_ the URL mapping code, it is more common to delegate some of the mappings to particular applications, as you'll see later.
- **wsgi.py** is used to help your Django application communicate with the web server. You can treat this as boilerplate.
- **asgi.py** is a standard for Python asynchronous web apps and servers to communicate with each other. Asynchronous Server Gateway Interface (ASGI) is the asynchronous successor to Web Server Gateway Interface (WSGI). ASGI provides a standard for both asynchronous and synchronous Python apps, whereas WSGI provided a standard for synchronous apps only. ASGI is backward-compatible with WSGI and supports multiple servers and application frameworks.
The **manage.py** script is used to create applications, work with databases, and start the development web server.
## Creating the catalog application
Next, run the following command to create the _catalog_ application that will live inside our _locallibrary_ project. Make sure to run this command from the same folder as your project's **manage.py**:
```bash
# Linux/macOS
python3 manage.py startapp catalog
# Windows
py manage.py startapp catalog
```
> **Note:** The rest of the tutorial uses the Linux/macOS syntax.
> If you're working on Windows, wherever you see a command starting with `python3` you should instead use `py` (or `py -3`).
The tool creates a new folder and populates it with files for the different parts of the application (shown in the following example).
Most of the files are named after their purpose (e.g. views should be stored in **views.py**, models in **models.py**, tests in **tests.py**, administration site configuration in **admin.py**, application registration in **apps.py**) and contain some minimal boilerplate code for working with the associated objects.
The updated project directory should now look like this:
```bash
locallibrary/
manage.py
locallibrary/
catalog/
admin.py
apps.py
models.py
tests.py
views.py
__init__.py
migrations/
```
In addition we now have:
- A _migrations_ folder, used to store "migrations" — files that allow you to automatically update your database as you modify your models.
- **\_\_init\_\_.py** — an empty file created here so that Django/Python will recognize the folder as a [Python Package](https://docs.python.org/3/tutorial/modules.html#packages) and allow you to use its objects within other parts of the project.
> **Note:** Have you noticed what is missing from the files list above? While there is a place for your views and models, there is nowhere for you to put your URL mappings, templates, and static files. We'll show you how to create them further along (these aren't needed in every website but they are needed in this example).
## Registering the catalog application
Now that the application has been created, we have to register it with the project so that it will be included when any tools are run (like adding models to the database for example). Applications are registered by adding them to the `INSTALLED_APPS` list in the project settings.
Open the project settings file, **django_projects/locallibrary/locallibrary/settings.py**, and find the definition for the `INSTALLED_APPS` list. Then add a new line at the end of the list, as shown below:
```bash
INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
# Add our new application
'catalog.apps.CatalogConfig', #This object was created for us in /catalog/apps.py
]
```
The new line specifies the application configuration object (`CatalogConfig`) that was generated for you in **/locallibrary/catalog/apps.py** when you created the application.
> **Note:** You'll notice that there are already a lot of other `INSTALLED_APPS` (and `MIDDLEWARE`, further down in the settings file). These enable support for the [Django administration site](/en-US/docs/Learn/Server-side/Django/Admin_site) and the functionality it uses (including sessions, authentication, etc.).
## Specifying the database
This is also the point where you would normally specify the database to be used for the project. It makes sense to use the same database for development and production where possible, in order to avoid minor differences in behavior. You can find out about the different options in [Databases](https://docs.djangoproject.com/en/4.2/ref/settings/#databases) (Django docs).
We'll use the default SQLite database for this example, because we don't expect to require a lot of concurrent access on a demonstration database, and it requires no additional work to set up! You can see how this database is configured in **settings.py**:
```python
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.sqlite3',
'NAME': BASE_DIR / 'db.sqlite3',
}
}
```
Because we are using SQLite, we don't need to do any further setup here. Let's move on!
## Other project settings
The **settings.py** file is also used for configuring a number of other settings, but at this point, you probably only want to change the [TIME_ZONE](https://docs.djangoproject.com/en/4.2/ref/settings/#std:setting-TIME_ZONE) — this should be made equal to a string from the standard [List of tz database time zones](https://en.wikipedia.org/wiki/List_of_tz_database_time_zones) (the TZ column in the table contains the values you want). Change your `TIME_ZONE` value to one of these strings appropriate for your time zone, for example:
```python
TIME_ZONE = 'Europe/London'
```
There are two other settings you won't change now, but that you should be aware of:
- `SECRET_KEY`. This is a secret key that is used as part of Django's website security strategy. If you're not protecting this code in development, you'll need to use a different code (perhaps read from an environment variable or file) when putting it into production.
- `DEBUG`. This enables debugging logs to be displayed on error, rather than HTTP status code responses. This should be set to `False` in production as debug information is useful for attackers, but for now we can keep it set to `True`.
## Hooking up the URL mapper
The website is created with a URL mapper file (**urls.py**) in the project folder. While you can use this file to manage all your URL mappings, it is more usual to defer mappings to the associated application.
Open **locallibrary/locallibrary/urls.py** and note the instructional text which explains some of the ways to use the URL mapper.
```python
"""
URL configuration for locallibrary project.
The `urlpatterns` list routes URLs to views. For more information please see:
https://docs.djangoproject.com/en/4.2/topics/http/urls/
Examples:
Function views
1. Add an import: from my_app import views
2. Add a URL to urlpatterns: path('', views.home, name='home')
Class-based views
1. Add an import: from other_app.views import Home
2. Add a URL to urlpatterns: path('', Home.as_view(), name='home')
Including another URLconf
1. Import the include() function: from django.urls import include, path
2. Add a URL to urlpatterns: path('blog/', include('blog.urls'))
"""
from django.contrib import admin
from django.urls import path
urlpatterns = [
path('admin/', admin.site.urls),
]
```
The URL mappings are managed through the `urlpatterns` variable, which is a Python _list_ of `path()` functions. Each `path()` function either associates a URL pattern to a _specific view_, which will be displayed when the pattern is matched, or with another list of URL pattern testing code (in this second case, the pattern becomes the "base URL" for patterns defined in the target module). The `urlpatterns` list initially defines a single function that maps all URLs with the pattern _admin/_ to the module `admin.site.urls`, which contains the Administration application's own URL mapping definitions.
> **Note:** The route in `path()` is a string defining a URL pattern to match. This string might include a named variable (in angle brackets), e.g. `'catalog/<id>/'`. This pattern will match a URL like **catalog/_any_chars_/** and pass _`any_chars`_ to the view as a string with the parameter name `id`. We discuss path methods and route patterns further in later topics.
To add a new list item to the `urlpatterns` list, add the following lines to the bottom of the file. This new item includes a `path()` that forwards requests with the pattern `catalog/` to the module `catalog.urls` (the file with the relative URL **catalog/urls.py**).
```python
# Use include() to add paths from the catalog application
from django.urls import include
urlpatterns += [
path('catalog/', include('catalog.urls')),
]
```
> **Note:** Note that we included the import line (`from django.urls import include`) with the code that uses it (so it is easy to see what we've added), but it is common to include all your import lines at the top of a Python file.
Now let's redirect the root URL of our site (i.e. `127.0.0.1:8000`) to the URL `127.0.0.1:8000/catalog/`. This is the only app we'll be using in this project. To do this, we'll use a special view function, `RedirectView`, which takes the new relative URL to redirect to (`/catalog/`) as its first argument when the URL pattern specified in the `path()` function is matched (the root URL, in this case).
Add the following lines to the bottom of the file:
```python
#Add URL maps to redirect the base URL to our application
from django.views.generic import RedirectView
urlpatterns += [
path('', RedirectView.as_view(url='catalog/', permanent=True)),
]
```
Leave the first parameter of the path function empty to imply '/'. If you write the first parameter as '/' Django will give you the following warning when you start the development server:
```python
System check identified some issues:
WARNINGS:
?: (urls.W002) Your URL pattern '/' has a route beginning with a '/'.
Remove this slash as it is unnecessary.
If this pattern is targeted in an include(), ensure the include() pattern has a trailing '/'.
```
Django does not serve static files like CSS, JavaScript, and images by default, but it can be useful for the development web server to do so while you're creating your site. As a final addition to this URL mapper, you can enable the serving of static files during development by appending the following lines.
Add the following final block to the bottom of the file now:
```python
# Use static() to add URL mapping to serve static files during development (only)
from django.conf import settings
from django.conf.urls.static import static
urlpatterns += static(settings.STATIC_URL, document_root=settings.STATIC_ROOT)
```
> **Note:** There are a number of ways to extend the `urlpatterns` list (previously, we just appended a new list item using the `+=` operator to clearly separate the old and new code). We could have instead just included this new pattern-map in the original list definition:
>
> ```python
> urlpatterns = [
> path('admin/', admin.site.urls),
> path('catalog/', include('catalog.urls')),
> path('', RedirectView.as_view(url='catalog/')),
> ] + static(settings.STATIC_URL, document_root=settings.STATIC_ROOT)
> ```
As a final step, create a file inside your catalog folder called **urls.py**, and add the following text to define the (empty) imported `urlpatterns`. This is where we'll add our patterns as we build the application.
```python
from django.urls import path
from . import views
urlpatterns = [
]
```
## Testing the website framework
At this point we have a complete skeleton project. The website doesn't actually _do_ anything yet, but it's worth running it to make sure that none of our changes have broken anything.
Before we do that, we should first run a _database migration_. This updates our database (to include any models in our installed applications) and removes some build warnings.
### Running database migrations
Django uses an Object-Relational-Mapper (ORM) to map model definitions in the Django code to the data structure used by the underlying database. As we change our model definitions, Django tracks the changes and can create database migration scripts (in **/locallibrary/catalog/migrations/**) to automatically migrate the underlying data structure in the database to match the model.
When we created the website, Django automatically added a number of models for use by the admin section of the site (which we'll look at later). Run the following commands to define tables for those models in the database (make sure you are in the directory that contains **manage.py**):
```bash
python3 manage.py makemigrations
python3 manage.py migrate
```
> **Warning:** You'll need to run these commands every time your models change in a way that will affect the structure of the data that needs to be stored (including both addition and removal of whole models and individual fields).
The `makemigrations` command _creates_ (but does not apply) the migrations for all applications installed in your project. You can specify the application name as well to just run a migration for a single app. This gives you a chance to check out the code for these migrations before they are applied. If you're a Django expert, you may choose to tweak them slightly!
The `migrate` command is what applies the migrations to your database. Django tracks which ones have been added to the current database.
> **Note:** See [Migrations](https://docs.djangoproject.com/en/4.2/topics/migrations/) (Django docs) for additional information about the lesser-used migration commands.
### Running the website
During development, you can serve the website first using the _development web server_, and then viewing it on your local web browser.
> **Note:** The development web server is not robust or performant enough for production use, but it is a very easy way to get your Django website up and running during development to give it a convenient quick test. By default it will serve the site to your local computer (`http://127.0.0.1:8000/)`, but you can also specify other computers on your network to serve to. For more information see [django-admin and manage.py: runserver](https://docs.djangoproject.com/en/4.2/ref/django-admin/#runserver) (Django docs).
Run the _development web server_ by calling the `runserver` command (in the same directory as **manage.py**):
```bash
python3 manage.py runserver
```
Once the server is running, you can view the site by navigating to `http://127.0.0.1:8000/` in your local web browser. You should see a site error page that looks like this:
Don't worry! This error page is expected because we don't have any pages/urls defined in the `catalog.urls` module (which we're redirected to when we get a URL to the root of the site).
> **Note:** The example page demonstrates a great Django feature — automated debug logging. Whenever a page cannot be found, Django displays an error screen with useful information or any error raised by the code. In this case, we can see that the URL we've supplied doesn't match any of our URL patterns (as listed). Logging is turned off in production (which is when we put the site live on the Web), in which case a less informative but more user-friendly page will be served.
At this point, we know that Django is working!
> **Note:** You should re-run migrations and re-test the site whenever you make significant changes. It doesn't take very long!
## Don't forget to backup to Github
We've just done some significant work, so now is a good time to backup the project.
You can use a similar set of commands to those in the [Modify and sync changes](/en-US/docs/Learn/Server-side/Django/development_environment#modify_and_sync_changes) section of the _Development environment_ topic:
```bash
git checkout -b skeleton_website # Create and activate a new branch "skeleton_website"
git add -A # Add all changed files to the staging area
git commit -m "Create Skeleton framework for LocalLibrary" # Commit the changed files
git push origin skeleton_website # Push the branch to GitHub
```
The create and merge a PR from your GitHub repo.
Note that if you don't delete the `skeleton_website` branch you can always switch back to it at some later point.
We won't necessarily mention this in future, but you may find it useful to create new branches at the end of each section in this tutorial.
## Challenge yourself
The **catalog/** directory contains files for the views, models, and other parts of the application. Open these files and inspect the boilerplate.
As you saw previously, a URL-mapping for the Admin site has already been added in the project's **urls.py**. Navigate to the admin area in your browser and see what happens (you can infer the correct URL from the mapping).
## Summary
You have now created a complete skeleton website project, which you can go on to populate with URLs, models, views, and templates.
Now that the skeleton for the [Local Library website](/en-US/docs/Learn/Server-side/Django/Tutorial_local_library_website) is complete and running, it's time to start writing the code that makes this website do what it is supposed to do.
## See also
- [Writing your first Django app - part 1](https://docs.djangoproject.com/en/4.2/intro/tutorial01/) (Django docs)
- [Applications](https://docs.djangoproject.com/en/4.2/ref/applications/#configuring-applications) (Django Docs).
Contains information on configuring applications.
{{PreviousMenuNext("Learn/Server-side/Django/Tutorial_local_library_website", "Learn/Server-side/Django/Models", "Learn/Server-side/Django")}}
| 0 |
data/mdn-content/files/en-us/learn/server-side/django | data/mdn-content/files/en-us/learn/server-side/django/tutorial_local_library_website/index.md | ---
title: "Django Tutorial: The Local Library website"
slug: Learn/Server-side/Django/Tutorial_local_library_website
page-type: learn-module-chapter
---
{{LearnSidebar}}{{PreviousMenuNext("Learn/Server-side/Django/development_environment", "Learn/Server-side/Django/skeleton_website", "Learn/Server-side/Django")}}
The first article in our practical tutorial series explains what you'll learn, and provides an overview of the "local library" example website we'll be working through and evolving in subsequent articles.
<table>
<tbody>
<tr>
<th scope="row">Prerequisites:</th>
<td>
Read the <a href="/en-US/docs/Learn/Server-side/Django/Introduction">Django Introduction</a>.
For the following articles you'll also need to have <a href="/en-US/docs/Learn/Server-side/Django/development_environment">set up a Django development environment</a>.
</td>
</tr>
<tr>
<th scope="row">Objective:</th>
<td>
To introduce the example application used in this tutorial, and allow readers to understand what topics will be covered.
</td>
</tr>
</tbody>
</table>
## Overview
Welcome to the MDN "Local Library" Django tutorial, in which we develop a website that might be used to manage the catalog for a local library.
In this series of tutorial articles you will:
- Use Django's tools to create a skeleton website and application.
- Start and stop the development server.
- Create models to represent your application's data.
- Use the Django admin site to populate your site's data.
- Create views to retrieve specific data in response to different requests, and templates to render the data as HTML to be displayed in the browser.
- Create mappers to associate different URL patterns with specific views.
- Add user authorization and sessions to control site behavior and access.
- Work with forms.
- Write test code for your app.
- Use Django's security effectively.
- Deploy your application to production.
You have learned about some of these topics already, and touched briefly on others. By the end of the tutorial series you should know enough to develop simple Django apps by yourself.
## The LocalLibrary website
_LocalLibrary_ is the name of the website that we'll create and evolve over the course of this series of tutorials. As you'd expect, the purpose of the website is to provide an online catalog for a small local library, where users can browse available books and manage their accounts.
This example has been carefully chosen because it can scale to show as much or as little detail as we need, and can be used to show off almost any Django feature. More importantly, it allows us to provide a _guided_ path through the most important functionality in the Django web framework:
- In the first few tutorial articles we will define a simple _browse-only_ library that library members can use to find out what books are available. This allows us to explore the operations that are common to almost every website: reading and displaying content from a database.
- As we progress, the library example naturally extends to demonstrate more advanced Django features. For example we can extend the library to allow users to reserve books, and use this to demonstrate how to use forms, and support user authentication.
Even though this is a very extensible example, it's called _**Local**Library_ for a reason — we're hoping to show the minimum information that will help you get up and running with Django quickly. As a result we'll store information about books, copies of books, authors and other key information. We won't however be storing information about other items a library might store, or provide the infrastructure needed to support multiple library sites or other "big library" features.
## I'm stuck, where can I get the source?
As you work through the tutorial we'll provide the appropriate code snippets for you to copy and paste at each point, and there will be other code that we hope you'll extend yourself (with some guidance).
If you get stuck, you can find the fully developed version of the website [on GitHub here](https://github.com/mdn/django-locallibrary-tutorial).
## Summary
Now that you know a bit more about the _LocalLibrary_ website and what you're going to learn, it's time to start creating a [skeleton project](/en-US/docs/Learn/Server-side/Django/skeleton_website) to contain our example.
{{PreviousMenuNext("Learn/Server-side/Django/development_environment", "Learn/Server-side/Django/skeleton_website", "Learn/Server-side/Django")}}
| 0 |
data/mdn-content/files/en-us/learn/server-side/django | data/mdn-content/files/en-us/learn/server-side/django/models/index.md | ---
title: "Django Tutorial Part 3: Using models"
slug: Learn/Server-side/Django/Models
page-type: learn-module-chapter
---
{{LearnSidebar}}{{PreviousMenuNext("Learn/Server-side/Django/skeleton_website", "Learn/Server-side/Django/Admin_site", "Learn/Server-side/Django")}}
This article shows how to define models for the LocalLibrary website. It explains what a model is, how it is declared, and some of the main field types. It also briefly shows a few of the main ways you can access model data.
<table>
<tbody>
<tr>
<th scope="row">Prerequisites:</th>
<td>
<a href="/en-US/docs/Learn/Server-side/Django/skeleton_website">Django Tutorial Part 2: Creating a skeleton website</a>.
</td>
</tr>
<tr>
<th scope="row">Objective:</th>
<td>
<p>
To be able to design and create your own models, choosing fields appropriately.
</p>
</td>
</tr>
</tbody>
</table>
## Overview
Django web applications access and manage data through Python objects referred to as models. Models define the _structure_ of stored data, including the field _types_ and possibly also their maximum size, default values, selection list options, help text for documentation, label text for forms, etc. The definition of the model is independent of the underlying database — you can choose one of several as part of your project settings. Once you've chosen what database you want to use, you don't need to talk to it directly at all — you just write your model structure and other code, and Django handles all the dirty work of communicating with the database for you.
This tutorial shows how to define and access the models for the [LocalLibrary website](/en-US/docs/Learn/Server-side/Django/Tutorial_local_library_website) example.
## Designing the LocalLibrary models
Before you jump in and start coding the models, it's worth taking a few minutes to think about what data we need to store and the relationships between the different objects.
We know that we need to store information about books (title, summary, author, written language, category, ISBN) and that we might have multiple copies available (with globally unique id, availability status, etc.). We might need to store more information about the author than just their name, and there might be multiple authors with the same or similar names. We want to be able to sort information based on book title, author, written language, and category.
When designing your models, it makes sense to have separate models for every "object" (a group of related information). In this case, the obvious objects are books, book instances, and authors.
You might also want to use models to represent selection-list options (e.g. like a drop down list of choices), rather than hard coding the choices into the website itself — this is recommended when all the options aren't known up front or may change. Obvious candidates for models, in this case, include the book genre (e.g. Science Fiction, French Poetry, etc.) and language (English, French, Japanese).
Once we've decided on our models and field, we need to think about the relationships. Django allows you to define relationships that are one to one (`OneToOneField`), one to many (`ForeignKey`) and many to many (`ManyToManyField`).
With that in mind, the UML association diagram below shows the models we'll define in this case (as boxes).
We've created models for the book (the generic details of the book), book instance (status of specific physical copies of the book available in the system), and author. We have also decided to have a model for the genre so that values can be created/selected through the admin interface. We've decided not to have a model for the `BookInstance:status` — we've hardcoded the values (`LOAN_STATUS`) because we don't expect these to change. Within each of the boxes, you can see the model name, the field names, and types, and also the methods and their return types.
The diagram also shows the relationships between the models, including their _multiplicities_. The multiplicities are the numbers on the diagram showing the numbers (maximum and minimum) of each model that may be present in the relationship. For example, the connecting line between the boxes shows that Book and a Genre are related. The numbers close to the Genre model show that a book must have one or more Genres (as many as you like), while the numbers on the other end of the line next to the Book model show that a Genre can have zero or many associated books.
> **Note:** The next section provides a basic primer explaining how models are defined and used. As you read it, consider how we will construct each of the models in the diagram above.
## Model primer
This section provides a brief overview of how a model is defined and some of the more important fields and field arguments.
### Model definition
Models are usually defined in an application's **models.py** file. They are implemented as subclasses of `django.db.models.Model`, and can include fields, methods and metadata. The code fragment below shows a "typical" model, named `MyModelName`:
```python
from django.db import models
from django.urls import reverse
class MyModelName(models.Model):
"""A typical class defining a model, derived from the Model class."""
# Fields
my_field_name = models.CharField(max_length=20, help_text='Enter field documentation')
# …
# Metadata
class Meta:
ordering = ['-my_field_name']
# Methods
def get_absolute_url(self):
"""Returns the URL to access a particular instance of MyModelName."""
return reverse('model-detail-view', args=[str(self.id)])
def __str__(self):
"""String for representing the MyModelName object (in Admin site etc.)."""
return self.my_field_name
```
In the below sections we'll explore each of the features inside the model in detail:
#### Fields
A model can have an arbitrary number of fields, of any type — each one represents a column of data that we want to store in one of our database tables. Each database record (row) will consist of one of each field value. Let's look at the example seen below:
```python
my_field_name = models.CharField(max_length=20, help_text='Enter field documentation')
```
Our above example has a single field called `my_field_name`, of type `models.CharField` — which means that this field will contain strings of alphanumeric characters. The field types are assigned using specific classes, which determine the type of record that is used to store the data in the database, along with validation criteria to be used when values are received from an HTML form (i.e. what constitutes a valid value). The field types can also take arguments that further specify how the field is stored or can be used. In this case we are giving our field two arguments:
- `max_length=20` — States that the maximum length of a value in this field is 20 characters.
- `help_text='Enter field documentation'` — helpful text that may be displayed in a form to help users understand how the field is used.
The field name is used to refer to it in queries and templates.
Fields also have a label, which is specified using the `verbose_name` argument (with a default value of `None`).
If `verbose_name` is not set, the label is created from the field name by replacing any underscores with a space, and capitalizing the first letter (for example, the field `my_field_name` would have a default label of _My field name_ when used in forms).
The order that fields are declared will affect their default order if a model is rendered in a form (e.g. in the Admin site), though this may be overridden.
##### Common field arguments
The following common arguments can be used when declaring many/most of the different field types:
- [help_text](https://docs.djangoproject.com/en/4.2/ref/models/fields/#help-text): Provides a text label for HTML forms (e.g. in the admin site), as described above.
- [verbose_name](https://docs.djangoproject.com/en/4.2/ref/models/fields/#verbose-name): A human-readable name for the field used in field labels. If not specified, Django will infer the default verbose name from the field name.
- [default](https://docs.djangoproject.com/en/4.2/ref/models/fields/#default): The default value for the field. This can be a value or a callable object, in which case the object will be called every time a new record is created.
- [null](https://docs.djangoproject.com/en/4.2/ref/models/fields/#null): If `True`, Django will store blank values as `NULL` in the database for fields where this is appropriate (a `CharField` will instead store an empty string). The default is `False`.
- [blank](https://docs.djangoproject.com/en/4.2/ref/models/fields/#blank): If `True`, the field is allowed to be blank in your forms. The default is `False`, which means that Django's form validation will force you to enter a value. This is often used with `null=True`, because if you're going to allow blank values, you also want the database to be able to represent them appropriately.
- [choices](https://docs.djangoproject.com/en/4.2/ref/models/fields/#choices): A group of choices for this field. If this is provided, the default corresponding form widget will be a select box with these choices instead of the standard text field.
- [unique](https://docs.djangoproject.com/en/4.2/ref/models/fields/#unique):
If `True`, ensures that the field value is unique across the database.
This can be used to prevent duplication of fields that can't have the same values.
The default is `False`.
- [primary_key](https://docs.djangoproject.com/en/4.2/ref/models/fields/#primary-key):
If `True`, sets the current field as the primary key for the model (A primary key is a special database column designated to uniquely identify all the different table records).
If no field is specified as the primary key, Django will automatically add a field for this purpose.
The type of auto-created primary key fields can be specified for each app in [`AppConfig.default_auto_field`](https://docs.djangoproject.com/en/4.2/ref/applications/#django.apps.AppConfig.default_auto_field) or globally in the [`DEFAULT_AUTO_FIELD`](https://docs.djangoproject.com/en/4.2/ref/settings/#std:setting-DEFAULT_AUTO_FIELD) setting.
> **Note:** Apps created using **manage.py** set the type of the primary key to a [BigAutoField](https://docs.djangoproject.com/en/4.2/ref/models/fields/#bigautofield).
> You can see this in the local library **catalog/apps.py** file:
>
> ```py
> class CatalogConfig(AppConfig):
> default_auto_field = 'django.db.models.BigAutoField'
> ```
There are many other options — you can view the [full list of field options here](https://docs.djangoproject.com/en/4.2/ref/models/fields/#field-options).
##### Common field types
The following list describes some of the more commonly used types of fields.
- [CharField](https://docs.djangoproject.com/en/4.2/ref/models/fields/#django.db.models.CharField) is used to define short-to-mid sized fixed-length strings. You must specify the `max_length` of the data to be stored.
- [TextField](https://docs.djangoproject.com/en/4.2/ref/models/fields/#django.db.models.TextField) is used for large arbitrary-length strings. You may specify a `max_length` for the field, but this is used only when the field is displayed in forms (it is not enforced at the database level).
- [IntegerField](https://docs.djangoproject.com/en/4.2/ref/models/fields/#django.db.models.IntegerField) is a field for storing integer (whole number) values, and for validating entered values as integers in forms.
- [DateField](https://docs.djangoproject.com/en/4.2/ref/models/fields/#datefield) and [DateTimeField](https://docs.djangoproject.com/en/4.2/ref/models/fields/#datetimefield) are used for storing/representing dates and date/time information (as Python `datetime.date` and `datetime.datetime` objects, respectively). These fields can additionally declare the (mutually exclusive) parameters `auto_now=True` (to set the field to the current date every time the model is saved), `auto_now_add` (to only set the date when the model is first created), and `default` (to set a default date that can be overridden by the user).
- [EmailField](https://docs.djangoproject.com/en/4.2/ref/models/fields/#emailfield) is used to store and validate email addresses.
- [FileField](https://docs.djangoproject.com/en/4.2/ref/models/fields/#filefield) and [ImageField](https://docs.djangoproject.com/en/4.2/ref/models/fields/#imagefield) are used to upload files and images respectively (the `ImageField` adds additional validation that the uploaded file is an image). These have parameters to define how and where the uploaded files are stored.
- [AutoField](https://docs.djangoproject.com/en/4.2/ref/models/fields/#autofield) is a special type of `IntegerField` that automatically increments. A primary key of this type is automatically added to your model if you don't explicitly specify one.
- [ForeignKey](https://docs.djangoproject.com/en/4.2/ref/models/fields/#foreignkey) is used to specify a one-to-many relationship to another database model (e.g. a car has one manufacturer, but a manufacturer can make many cars). The "one" side of the relationship is the model that contains the "key" (models containing a "foreign key" referring to that "key", are on the "many" side of such a relationship).
- [ManyToManyField](https://docs.djangoproject.com/en/4.2/ref/models/fields/#manytomanyfield) is used to specify a many-to-many relationship (e.g. a book can have several genres, and each genre can contain several books). In our library app we will use these very similarly to `ForeignKeys`, but they can be used in more complicated ways to describe the relationships between groups. These have the parameter `on_delete` to define what happens when the associated record is deleted (e.g. a value of `models.SET_NULL` would set the value to `NULL`).
There are many other types of fields, including fields for different types of numbers (big integers, small integers, floats), booleans, URLs, slugs, unique ids, and other "time-related" information (duration, time, etc.). You can view the [full list here](https://docs.djangoproject.com/en/4.2/ref/models/fields/#field-types).
#### Metadata
You can declare model-level metadata for your Model by declaring `class Meta`, as shown.
```python
class Meta:
ordering = ['-my_field_name']
```
One of the most useful features of this metadata is to control the _default ordering_ of records returned when you query the model type. You do this by specifying the match order in a list of field names to the `ordering` attribute, as shown above. The ordering will depend on the type of field (character fields are sorted alphabetically, while date fields are sorted in chronological order). As shown above, you can prefix the field name with a minus symbol (-) to reverse the sorting order.
So as an example, if we chose to sort books like this by default:
```python
ordering = ['title', '-pubdate']
```
the books would be sorted alphabetically by title, from A-Z, and then by publication date inside each title, from newest to oldest.
Another common attribute is `verbose_name`, a verbose name for the class in singular and plural form:
```python
verbose_name = 'BetterName'
```
Other useful attributes allow you to create and apply new "access permissions" for the model (default permissions are applied automatically), allow ordering based on another field, or to declare that the class is "abstract" (a base class that you cannot create records for, and will instead be derived from to create other models).
Many of the other metadata options control what database must be used for the model and how the data is stored (these are really only useful if you need to map a model to an existing database).
The full list of metadata options are available here: [Model metadata options](https://docs.djangoproject.com/en/4.2/ref/models/options/) (Django docs).
#### Methods
A model can also have methods.
**Minimally, in every model you should define the standard Python class method `__str__()` to return a human-readable string for each object.** This string is used to represent individual records in the administration site (and anywhere else you need to refer to a model instance). Often this will return a title or name field from the model.
```python
def __str__(self):
return self.my_field_name
```
Another common method to include in Django models is `get_absolute_url()`, which returns a URL for displaying individual model records on the website (if you define this method then Django will automatically add a "View on Site" button to the model's record editing screens in the Admin site). A typical pattern for `get_absolute_url()` is shown below.
```python
def get_absolute_url(self):
"""Returns the URL to access a particular instance of the model."""
return reverse('model-detail-view', args=[str(self.id)])
```
> **Note:** Assuming you will use URLs like `/myapplication/mymodelname/2` to display individual records for your model (where "2" is the `id` for a particular record), you will need to create a URL mapper to pass the response and id to a "model detail view" (which will do the work required to display the record). The `reverse()` function above is able to "reverse" your URL mapper (in the above case named _'model-detail-view'_) in order to create a URL of the right format.
>
> Of course to make this work you still have to write the URL mapping, view, and template!
You can also define any other methods you like, and call them from your code or templates (provided that they don't take any parameters).
### Model management
Once you've defined your model classes you can use them to create, update, or delete records, and to run queries to get all records or particular subsets of records. We'll show you how to do that in the tutorial when we define our views, but here is a brief summary.
#### Creating and modifying records
To create a record you can define an instance of the model and then call `save()`.
```python
# Create a new record using the model's constructor.
record = MyModelName(my_field_name="Instance #1")
# Save the object into the database.
record.save()
```
> **Note:** If you haven't declared any field as a `primary_key`, the new record will be given one automatically, with the field name `id`. You could query this field after saving the above record, and it would have a value of 1.
You can access the fields in this new record using the dot syntax, and change the values. You have to call `save()` to store modified values to the database.
```python
# Access model field values using Python attributes.
print(record.id) # should return 1 for the first record.
print(record.my_field_name) # should print 'Instance #1'
# Change record by modifying the fields, then calling save().
record.my_field_name = "New Instance Name"
record.save()
```
#### Searching for records
You can search for records that match certain criteria using the model's `objects` attribute (provided by the base class).
> **Note:** Explaining how to search for records using "abstract" model and field names can be a little confusing. In the discussion below, we'll refer to a `Book` model with `title` and `genre` fields, where genre is also a model with a single field `name`.
We can get all records for a model as a `QuerySet`, using `objects.all()`. The `QuerySet` is an iterable object, meaning that it contains a number of objects that we can iterate/loop through.
```python
all_books = Book.objects.all()
```
Django's `filter()` method allows us to filter the returned `QuerySet` to match a specified **text** or **numeric** field against particular criteria. For example, to filter for books that contain "wild" in the title and then count them, we could do the following.
```python
wild_books = Book.objects.filter(title__contains='wild')
number_wild_books = wild_books.count()
```
The fields to match and the type of match are defined in the filter parameter name, using the format: `field_name__match_type` (note the _double underscore_ between `title` and `contains` above). Above we're filtering `title` with a case-sensitive match. There are many other types of matches you can do: `icontains` (case insensitive), `iexact` (case-insensitive exact match), `exact` (case-sensitive exact match) and `in`, `gt` (greater than), `startswith`, etc. The [full list is here](https://docs.djangoproject.com/en/4.2/ref/models/querysets/#field-lookups).
In some cases, you'll need to filter on a field that defines a one-to-many relationship to another model (e.g. a `ForeignKey`). In this case, you can "index" to fields within the related model with additional double underscores.
So for example to filter for books with a specific genre pattern, you will have to index to the `name` through the `genre` field, as shown below:
```python
# Will match on: Fiction, Science fiction, non-fiction etc.
books_containing_genre = Book.objects.filter(genre__name__icontains='fiction')
```
> **Note:** You can use underscores (`__`) to navigate as many levels of relationships (`ForeignKey`/`ManyToManyField`) as you like.
> For example, a `Book` that had different types, defined using a further "cover" relationship might have a parameter name: `type__cover__name__exact='hard'.`
There is a lot more you can do with queries, including backwards searches from related models, chaining filters, returning a smaller set of values, etc. For more information, see [Making queries](https://docs.djangoproject.com/en/4.2/topics/db/queries/) (Django Docs).
## Defining the LocalLibrary Models
In this section we will start defining the models for the library. Open `models.py` (in /locallibrary/catalog/). The boilerplate at the top of the page imports the _models_ module, which contains the model base class `models.Model` that our models will inherit from.
```python
from django.db import models
# Create your models here.
```
### Genre model
Copy the `Genre` model code shown below and paste it into the bottom of your `models.py` file. This model is used to store information about the book category — for example whether it is fiction or non-fiction, romance or military history, etc.
As mentioned above, we've created the genre as a model rather than as free text or a selection list so that the possible values can be managed through the database rather than being hard coded.
```python
from django.urls import reverse # Used to generate URLs by reversing the URL patterns
class Genre(models.Model):
"""Model representing a book genre."""
name = models.CharField(
max_length=200,
unique=True,
help_text="Enter a book genre (e.g. Science Fiction, French Poetry etc.)"
)
def __str__(self):
"""String for representing the Model object."""
return self.name
def get_absolute_url(self):
"""Returns the url to access a particular genre instance."""
return reverse('genre-detail', args=[str(self.id)])
```
The model has a single `CharField` field (`name`), which is used to describe the genre (this is limited to 200 characters and has some `help_text`).
We've set this field to be unique (`unique=True`) because there should only be one record for each genre.
After the field, we declare a `__str__()` method, which returns the name of the genre defined by a particular record. No verbose name has been defined, so the field will be called `Name` in forms.
The final method, `get_absolute_url()` returns a URL that can be used to access a detail record for this model (for this to work, we will have to define a URL mapping that has the name `genre-detail`, and define an associated view and template).
### Book model
Copy the `Book` model below and again paste it into the bottom of your file. The `Book` model represents all information about an available book in a general sense, but not a particular physical "instance" or "copy" available for loan.
The model uses a `CharField` to represent the book's `title` and `isbn`.
For `isbn`, note how the first unnamed parameter explicitly sets the label as "ISBN" (otherwise, it would default to "Isbn"). We also set the parameter `unique` as `true` to ensure all books have a unique ISBN (the unique parameter makes the field value globally unique in a table).
Unlike for the `isbn` (and the genre name), the `title` is not set to be unique, because it is possible for different books to have the same name.
The model uses `TextField` for the `summary`, because this text may need to be quite long.
```python
class Book(models.Model):
"""Model representing a book (but not a specific copy of a book)."""
title = models.CharField(max_length=200)
author = models.ForeignKey('Author', on_delete=models.RESTRICT, null=True)
# Foreign Key used because book can only have one author, but authors can have multiple books.
# Author as a string rather than object because it hasn't been declared yet in file.
summary = models.TextField(
max_length=1000, help_text="Enter a brief description of the book")
isbn = models.CharField('ISBN', max_length=13,
unique=True,
help_text='13 Character <a href="https://www.isbn-international.org/content/what-isbn'
'">ISBN number</a>')
# ManyToManyField used because genre can contain many books. Books can cover many genres.
# Genre class has already been defined so we can specify the object above.
genre = models.ManyToManyField(
Genre, help_text="Select a genre for this book")
def __str__(self):
"""String for representing the Model object."""
return self.title
def get_absolute_url(self):
"""Returns the URL to access a detail record for this book."""
return reverse('book-detail', args=[str(self.id)])
```
The genre is a `ManyToManyField`, so that a book can have multiple genres and a genre can have many books. The author is declared as `ForeignKey`, so each book will only have one author, but an author may have many books (in practice a book might have multiple authors, but not in this implementation!)
In both field types the related model class is declared as the first unnamed parameter using either the model class or a string containing the name of the related model. You must use the name of the model as a string if the associated class has not yet been defined in this file before it is referenced! The other parameters of interest in the `author` field are `null=True`, which allows the database to store a `Null` value if no author is selected, and `on_delete=models.RESTRICT`, which will prevent the book's associated author being deleted if it is referenced by any book.
> **Warning:** By default `on_delete=models.CASCADE`, which means that if the author was deleted, this book would be deleted too! We use `RESTRICT` here, but we could also use `PROTECT` to prevent the author being deleted while any book uses it or `SET_NULL` to set the book's author to `Null` if the record is deleted.
The model also defines `__str__()`, using the book's `title` field to represent a `Book` record. The final method, `get_absolute_url()` returns a URL that can be used to access a detail record for this model (we will have to define a URL mapping that has the name `book-detail`, and define an associated view and template).
### BookInstance model
Next, copy the `BookInstance` model (shown below) under the other models. The `BookInstance` represents a specific copy of a book that someone might borrow, and includes information about whether the copy is available or on what date it is expected back, "imprint" or version details, and a unique id for the book in the library.
Some of the fields and methods will now be familiar. The model uses:
- `ForeignKey` to identify the associated `Book` (each book can have many copies, but a copy can only have one `Book`). The key specifies `on_delete=models.RESTRICT` to ensure that the `Book` cannot be deleted while referenced by a `BookInstance`.
- `CharField` to represent the imprint (specific release) of the book.
```python
import uuid # Required for unique book instances
class BookInstance(models.Model):
"""Model representing a specific copy of a book (i.e. that can be borrowed from the library)."""
id = models.UUIDField(primary_key=True, default=uuid.uuid4,
help_text="Unique ID for this particular book across whole library")
book = models.ForeignKey('Book', on_delete=models.RESTRICT, null=True)
imprint = models.CharField(max_length=200)
due_back = models.DateField(null=True, blank=True)
LOAN_STATUS = (
('m', 'Maintenance'),
('o', 'On loan'),
('a', 'Available'),
('r', 'Reserved'),
)
status = models.CharField(
max_length=1,
choices=LOAN_STATUS,
blank=True,
default='m',
help_text='Book availability',
)
class Meta:
ordering = ['due_back']
def __str__(self):
"""String for representing the Model object."""
return f'{self.id} ({self.book.title})'
```
We additionally declare a few new types of field:
- `UUIDField` is used for the `id` field to set it as the `primary_key` for this model.
This type of field allocates a globally unique value for each instance (one for every book you can find in the library).
- `DateField` is used for the `due_back` date (at which the book is expected to become available after being borrowed or in maintenance). This value can be `blank` or `null` (needed for when the book is available). The model metadata (`Class Meta`) uses this field to order records when they are returned in a query.
- `status` is a `CharField` that defines a choice/selection list. As you can see, we define a tuple containing tuples of key-value pairs and pass it to the choices argument. The value in a key/value pair is a display value that a user can select, while the keys are the values that are actually saved if the option is selected. We've also set a default value of 'm' (maintenance) as books will initially be created unavailable before they are stocked on the shelves.
The method `__str__()` represents the `BookInstance` object using a combination of its unique id and the associated `Book`'s title.
> **Note:** A little Python:
>
> - Starting with Python 3.6, you can use the string interpolation syntax (also known as f-strings): `f'{self.id} ({self.book.title})'`.
> - In older versions of this tutorial, we were using a [formatted string](https://peps.python.org/pep-3101/) syntax, which is also a valid way of formatting strings in Python (e.g. `'{0} ({1})'.format(self.id,self.book.title)`).
### Author model
Copy the `Author` model (shown below) underneath the existing code in **models.py**.
```python
class Author(models.Model):
"""Model representing an author."""
first_name = models.CharField(max_length=100)
last_name = models.CharField(max_length=100)
date_of_birth = models.DateField(null=True, blank=True)
date_of_death = models.DateField('Died', null=True, blank=True)
class Meta:
ordering = ['last_name', 'first_name']
def get_absolute_url(self):
"""Returns the URL to access a particular author instance."""
return reverse('author-detail', args=[str(self.id)])
def __str__(self):
"""String for representing the Model object."""
return f'{self.last_name}, {self.first_name}'
```
All of the fields/methods should now be familiar. The model defines an author as having a first name, last name, and dates of birth and death (both optional). It specifies that by default the `__str__()` returns the name in _last name_, _firstname_ order. The `get_absolute_url()` method reverses the `author-detail` URL mapping to get the URL for displaying an individual author.
## Re-run the database migrations
All your models have now been created. Now re-run your database migrations to add them to your database.
```bash
python3 manage.py makemigrations
python3 manage.py migrate
```
## Language model — challenge
Imagine a local benefactor donates a number of new books written in another language (say, Farsi). The challenge is to work out how these would be best represented in our library website, and then to add them to the models.
Some things to consider:
- Should "language" be associated with a `Book`, `BookInstance`, or some other object?
- Should the different languages be represented using model, a free text field, or a hard-coded selection list?
After you've decided, add the field. You can see what we decided on GitHub [here](https://github.com/mdn/django-locallibrary-tutorial/blob/main/catalog/models.py).
Don't forget that after a change to your model, you should again re-run your database migrations to add the changes.
```bash
python3 manage.py makemigrations
python3 manage.py migrate
```
## Summary
In this article we've learned how models are defined, and then used this information to design and implement appropriate models for the _LocalLibrary_ website.
At this point we'll divert briefly from creating the site, and check out the _Django Administration site_. This site will allow us to add some data to the library, which we can then display using our (yet to be created) views and templates.
## See also
- [Writing your first Django app, part 2](https://docs.djangoproject.com/en/4.2/intro/tutorial02/) (Django docs)
- [Making queries](https://docs.djangoproject.com/en/4.2/topics/db/queries/) (Django Docs)
- [QuerySet API Reference](https://docs.djangoproject.com/en/4.2/ref/models/querysets/) (Django Docs)
{{PreviousMenuNext("Learn/Server-side/Django/skeleton_website", "Learn/Server-side/Django/Admin_site", "Learn/Server-side/Django")}}
| 0 |
data/mdn-content/files/en-us/learn/server-side/django | data/mdn-content/files/en-us/learn/server-side/django/models/local_library_model_uml.svg | <svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:lucid="lucid" width="1140" height="724"><g transform="translate(-180 1220)" lucid:page-tab-id="0_0"><path d="M200-1194c0-3.3 2.7-6 6-6h288c3.3 0 6 2.7 6 6v292c0 3.3-2.7 6-6 6H206c-3.3 0-6-2.7-6-6z" stroke="#5e5e5e" stroke-width="3" fill="#fff"/><path d="M200-1157.33h300m-300 197.5h300" stroke="#5e5e5e" stroke-width="3" fill="none"/><use xlink:href="#a" transform="translate(324.691 -1174.056)"/><use xlink:href="#b" transform="translate(212 -1120.556)"/><use xlink:href="#c" transform="translate(231.136 -1120.556)"/><use xlink:href="#b" transform="translate(212 -1093.889)"/><use xlink:href="#d" transform="translate(231.136 -1093.889)"/><use xlink:href="#b" transform="translate(212 -1067.222)"/><use xlink:href="#e" transform="translate(231.136 -1067.222)"/><use xlink:href="#b" transform="translate(212 -1040.556)"/><use xlink:href="#f" transform="translate(231.136 -1040.556)"/><use xlink:href="#b" transform="translate(212 -1013.889)"/><use xlink:href="#g" transform="translate(231.136 -1013.889)"/><use xlink:href="#b" transform="translate(212 -987.222)"/><use xlink:href="#h" transform="translate(231.136 -987.222)"/><use xlink:href="#b" transform="translate(212 -922.889)"/><use xlink:href="#i" transform="translate(231.136 -922.889)"/><path d="M200-814c0-3.3 2.7-6 6-6h288c3.3 0 6 2.7 6 6v292c0 3.3-2.7 6-6 6H206c-3.3 0-6-2.7-6-6z" stroke="#5e5e5e" stroke-width="3" fill="#fff"/><path d="M200-777.33h300m-300 197.5h300" stroke="#5e5e5e" stroke-width="3" fill="none"/><use xlink:href="#j" transform="translate(282.716 -794.056)"/><use xlink:href="#b" transform="translate(212 -740.556)"/><use xlink:href="#k" transform="translate(231.136 -740.556)"/><use xlink:href="#b" transform="translate(212 -713.889)"/><use xlink:href="#l" transform="translate(231.136 -713.889)"/><use xlink:href="#b" transform="translate(212 -687.222)"/><use xlink:href="#m" transform="translate(231.136 -687.222)"/><use xlink:href="#b" transform="translate(212 -660.556)"/><use xlink:href="#n" transform="translate(231.136 -660.556)"/><use xlink:href="#b" transform="translate(212 -633.889)"/><use xlink:href="#o" transform="translate(231.136 -633.889)"/><use xlink:href="#p" transform="translate(309.901 -633.889)"/><use xlink:href="#b" transform="translate(212 -607.222)"/><use xlink:href="#q" transform="translate(231.136 -607.222)"/><use xlink:href="#b" transform="translate(212 -542.889)"/><use xlink:href="#i" transform="translate(231.136 -542.889)"/><path d="M660-1114c0-3.3 2.7-6 6-6h208c3.3 0 6 2.7 6 6v159c0 3.3-2.7 6-6 6H666c-3.3 0-6-2.7-6-6z" stroke="#5e5e5e" stroke-width="3" fill="#fff"/><path d="M660-1077.33h220m-220 64.16h220" stroke="#5e5e5e" stroke-width="3" fill="none"/><use xlink:href="#r" transform="translate(739.167 -1094.056)"/><use xlink:href="#b" transform="translate(672 -1040.389)"/><use xlink:href="#s" transform="translate(691.136 -1040.389)"/><use xlink:href="#b" transform="translate(672 -976.222)"/><use xlink:href="#i" transform="translate(691.136 -976.222)"/><path d="M660-854c0-3.3 2.7-6 6-6h208c3.3 0 6 2.7 6 6v159c0 3.3-2.7 6-6 6H666c-3.3 0-6-2.7-6-6z" stroke="#5e5e5e" stroke-width="3" fill="#fff"/><path d="M660-817.33h220m-220 64.16h220" stroke="#5e5e5e" stroke-width="3" fill="none"/><use xlink:href="#t" transform="translate(720.617 -834.056)"/><use xlink:href="#b" transform="translate(672 -780.389)"/><use xlink:href="#s" transform="translate(691.136 -780.389)"/><use xlink:href="#b" transform="translate(672 -716.222)"/><use xlink:href="#i" transform="translate(691.136 -716.222)"/><path d="M1000-1194c0-3.3 2.7-6 6-6h288c3.3 0 6 2.7 6 6v239c0 3.3-2.7 6-6 6h-288c-3.3 0-6-2.7-6-6z" stroke="#5e5e5e" stroke-width="3" fill="#fff"/><path d="M1000-1157.33h300m-300 144.16h300" stroke="#5e5e5e" stroke-width="3" fill="none"/><use xlink:href="#u" transform="translate(1117.315 -1174.056)"/><use xlink:href="#b" transform="translate(1012 -1120.389)"/><use xlink:href="#v" transform="translate(1031.136 -1120.389)"/><use xlink:href="#b" transform="translate(1012 -1093.722)"/><use xlink:href="#w" transform="translate(1031.136 -1093.722)"/><use xlink:href="#b" transform="translate(1012 -1067.056)"/><use xlink:href="#x" transform="translate(1031.136 -1067.056)"/><use xlink:href="#b" transform="translate(1012 -1040.389)"/><use xlink:href="#y" transform="translate(1031.136 -1040.389)"/><use xlink:href="#b" transform="translate(1012 -976.222)"/><use xlink:href="#i" transform="translate(1031.136 -976.222)"/><path d="M502.5-1176.3h495" stroke="#5e5e5e" stroke-width="2" fill="none"/><path d="M502.53-1175.3h-1.03v-2h1.03zm495.97 0h-1.03v-2h1.03z" fill="#5e5e5e"/><use xlink:href="#z" transform="translate(501 -1157.898)"/><use xlink:href="#A" transform="translate(978.821 -1187.498)"/><path d="M502.5-1079.44h155" stroke="#5e5e5e" stroke-width="2" fill="none"/><path d="M502.53-1078.44h-1.03v-2h1.03zm155.97 0h-1.03v-2h1.03z" fill="#5e5e5e"/><use xlink:href="#B" transform="translate(507.402 -1061.041)"/><use xlink:href="#z" transform="translate(622.175 -1090.641)"/><path d="M502.5-978H574c3.3 0 6 2.7 6 6v145c0 3.32 2.7 6 6 6h71.5" stroke="#5e5e5e" stroke-width="2" fill="none"/><path d="M502.53-977h-1.03v-2h1.03zM658.5-820h-1.03v-2h1.03z" fill="#5e5e5e"/><use xlink:href="#B" transform="translate(505.489 -959.589)"/><use xlink:href="#A" transform="translate(643.553 -832.189)"/><path d="M350-893.5v71" stroke="#5e5e5e" stroke-width="2" fill="none"/><path d="M351-893.47h-2v-1.03h2zm0 71.97h-2v-1.03h2z" fill="#5e5e5e"/><use xlink:href="#A" transform="translate(332 -880.9)"/><use xlink:href="#B" transform="translate(358 -827.9)"/><defs><path fill="#333" d="M160-131c35 5 61 23 61 61C221 17 115-2 30 0v-248c76 3 177-17 177 60 0 33-19 50-47 57zm-97-11c50-1 110 9 110-42 0-47-63-36-110-37v79zm0 115c55-2 124 14 124-45 0-56-70-42-124-44v89" id="C"/><path fill="#333" d="M100-194c62-1 85 37 85 99 1 63-27 99-86 99S16-35 15-95c0-66 28-99 85-99zM99-20c44 1 53-31 53-75 0-43-8-75-51-75s-53 32-53 75 10 74 51 75" id="D"/><path fill="#333" d="M143 0 79-87 56-68V0H24v-261h32v163l83-92h37l-77 82L181 0h-38" id="E"/><path fill="#333" d="M118-107v75H92v-75H18v-26h74v-75h26v75h74v26h-74" id="av"/><path fill="#333" d="M59-47c-2 24 18 29 38 22v24C64 9 27 4 27-40v-127H5v-23h24l9-43h21v43h35v23H59v120" id="F"/><path fill="#333" d="M24-231v-30h32v30H24zM24 0v-190h32V0H24" id="G"/><path fill="#333" d="M24 0v-261h32V0H24" id="H"/><path fill="#333" d="M100-194c63 0 86 42 84 106H49c0 40 14 67 53 68 26 1 43-12 49-29l28 8c-11 28-37 45-77 45C44 4 14-33 15-96c1-61 26-98 85-98zm52 81c6-60-76-77-97-28-3 7-6 17-6 28h103" id="I"/><path fill="#333" d="M33-154v-36h34v36H33zM33 0v-36h34V0H33" id="J"/><path fill="#333" d="M185-189c-5-48-123-54-124 2 14 75 158 14 163 119 3 78-121 87-175 55-17-10-28-26-33-46l33-7c5 56 141 63 141-1 0-78-155-14-162-118-5-82 145-84 179-34 5 7 8 16 11 25" id="K"/><path fill="#333" d="M114-163C36-179 61-72 57 0H25l-1-190h30c1 12-1 29 2 39 6-27 23-49 58-41v29" id="L"/><path fill="#333" d="M117-194c89-4 53 116 60 194h-32v-121c0-31-8-49-39-48C34-167 62-67 57 0H25l-1-190h30c1 10-1 24 2 32 11-22 29-35 61-36" id="M"/><path fill="#333" d="M177-190C167-65 218 103 67 71c-23-6-38-20-44-43l32-5c15 47 100 32 89-28v-30C133-14 115 1 83 1 29 1 15-40 15-95c0-56 16-97 71-98 29-1 48 16 59 35 1-10 0-23 2-32h30zM94-22c36 0 50-32 50-73 0-42-14-75-50-75-39 0-46 34-46 75s6 73 46 73" id="N"/><path fill="#333" d="M141-36C126-15 110 5 73 4 37 3 15-17 15-53c-1-64 63-63 125-63 3-35-9-54-41-54-24 1-41 7-42 31l-33-3c5-37 33-52 76-52 45 0 72 20 72 64v82c-1 20 7 32 28 27v20c-31 9-61-2-59-35zM48-53c0 20 12 33 32 33 41-3 63-29 60-74-43 2-92-5-92 41" id="O"/><path fill="#333" d="M84 4C-5 8 30-112 23-190h32v120c0 31 7 50 39 49 72-2 45-101 50-169h31l1 190h-30c-1-10 1-25-2-33-11 22-28 36-60 37" id="P"/><path fill="#333" d="M106-169C34-169 62-67 57 0H25v-261h32l-1 103c12-21 28-36 61-36 89 0 53 116 60 194h-32v-121c2-32-8-49-39-48" id="Q"/><path fill="#333" d="m205 0-28-72H64L36 0H1l101-248h38L239 0h-34zm-38-99-47-123c-12 45-31 82-46 123h93" id="R"/><path fill="#333" d="M26 75v-336h71v23H56V52h41v23H26" id="S"/><path fill="#333" d="M27 0v-27h64v-190l-56 39v-29l58-41h29v221h61V0H27" id="T"/><path fill="#333" d="M3 75V52h41v-290H3v-23h71V75H3" id="U"/><path fill="#333" d="M135-143c-3-34-86-38-87 0 15 53 115 12 119 90S17 21 10-45l28-5c4 36 97 45 98 0-10-56-113-15-118-90-4-57 82-63 122-42 12 7 21 19 24 35" id="V"/><path fill="#333" d="M210-169c-67 3-38 105-44 169h-31v-121c0-29-5-50-35-48C34-165 62-65 56 0H25l-1-190h30c1 10-1 24 2 32 10-44 99-50 107 0 11-21 27-35 58-36 85-2 47 119 55 194h-31v-121c0-29-5-49-35-48" id="W"/><path fill="#333" d="M179-190 93 31C79 59 56 82 12 73V49c39 6 53-20 64-50L1-190h34L92-34l54-156h33" id="X"/><path fill="#333" d="M33 0v-248h34V0H33" id="Y"/><path fill="#333" d="M190 0 58-211 59 0H30v-248h39L202-35l-2-213h31V0h-41" id="Z"/><path fill="#333" d="M143 4C61 4 22-44 18-125c-5-107 100-154 193-111 17 8 29 25 37 43l-32 9c-13-25-37-40-76-40-61 0-88 39-88 99 0 61 29 100 91 101 35 0 62-11 79-27v-45h-74v-28h105v86C228-13 192 4 143 4" id="aa"/><path fill="#333" d="M33 0v-38h34V0H33" id="ab"/><path fill="#333" d="m80-196 47-18 7 23-49 13 32 44-20 13-27-46-27 45-21-12 33-44-49-13 8-23 47 19-2-53h23" id="ac"/><path fill="#333" d="M30 0v-248h33v221h125V0H30" id="ad"/><path fill="#333" d="M-5 72V49h209v23H-5" id="ae"/><path fill="#333" d="M96-169c-40 0-48 33-48 73s9 75 48 75c24 0 41-14 43-38l32 2c-6 37-31 61-74 61-59 0-76-41-82-99-10-93 101-131 147-64 4 7 5 14 7 22l-32 3c-4-21-16-35-41-35" id="af"/><path fill="#333" d="M145-31C134-9 116 4 85 4 32 4 16-35 15-94c0-59 17-99 70-100 32-1 48 14 60 33 0-11-1-24 2-32h30l-1 268h-32zM93-21c41 0 51-33 51-76s-8-73-50-73c-40 0-46 35-46 75s5 74 45 74" id="ag"/><path fill="#333" d="M85-194c31 0 48 13 60 33l-1-100h32l1 261h-30c-2-10 0-23-3-31C134-8 116 4 85 4 32 4 16-35 15-94c0-66 23-100 70-100zm9 24c-40 0-46 34-46 75 0 40 6 74 45 74 42 0 51-32 51-76 0-42-9-74-50-73" id="ah"/><path fill="#333" d="M115-194c53 0 69 39 70 98 0 66-23 100-70 100C84 3 66-7 56-30L54 0H23l1-261h32v101c10-23 28-34 59-34zm-8 174c40 0 45-34 45-75 0-40-5-75-45-74-42 0-51 32-51 76 0 43 10 73 51 73" id="ai"/><path fill="#333" d="M30-248c118-7 216 8 213 122C240-48 200 0 122 0H30v-248zM63-27c89 8 146-16 146-99s-60-101-146-95v194" id="aj"/><path fill="#333" d="M63-220v92h138v28H63V0H30v-248h175v28H63" id="ak"/><path fill="#333" d="M140-251c81 0 123 46 123 126C263-46 219 4 140 4 59 4 17-45 17-125s42-126 123-126zm0 227c63 0 89-41 89-101s-29-99-89-99c-61 0-89 39-89 99S79-25 140-24" id="al"/><path fill="#333" d="M127-220V0H93v-220H8v-28h204v28h-85" id="am"/><path fill="#333" d="M232-93c-1 65-40 97-104 97C67 4 28-28 28-90v-158h33c8 89-33 224 67 224 102 0 64-133 71-224h33v155" id="an"/><path fill="#333" d="M115-194c55 1 70 41 70 98S169 2 115 4C84 4 66-9 55-30l1 105H24l-1-265h31l2 30c10-21 28-34 59-34zm-8 174c40 0 45-34 45-75s-6-73-45-74c-42 0-51 32-51 76 0 43 10 73 51 73" id="ao"/><path fill="#333" d="M206 0h-36l-40-164L89 0H53L-1-190h32L70-26l43-164h34l41 164 42-164h31" id="ap"/><path fill="#333" d="M101-234c-31-9-42 10-38 44h38v23H63V0H32v-167H5v-23h27c-7-52 17-82 69-68v24" id="aq"/><path d="M27 0v-27h64v-190l-56 39v-29l58-41h29v221h61V0H27" id="ar"/><path d="M33 0v-38h34V0H33" id="as"/><path d="m80-196 47-18 7 23-49 13 32 44-20 13-27-46-27 45-21-12 33-44-49-13 8-23 47 19-2-53h23" id="at"/><path d="M101-251c68 0 85 55 85 127S166 4 100 4C33 4 14-52 14-124c0-73 17-127 87-127zm-1 229c47 0 54-49 54-102s-4-102-53-102c-51 0-55 48-55 102 0 53 5 102 54 102" id="au"/><g id="a"><use transform="rotate(.413) scale(.06173)" xlink:href="#C"/><use transform="translate(14.815) scale(.06173)" xlink:href="#D"/><use transform="translate(27.16) scale(.06173)" xlink:href="#D"/><use transform="translate(39.506) scale(.06173)" xlink:href="#E"/></g><g id="c"><use transform="rotate(.413) scale(.06173)" xlink:href="#F"/><use transform="translate(6.173) scale(.06173)" xlink:href="#G"/><use transform="translate(11.05) scale(.06173)" xlink:href="#F"/><use transform="translate(17.222) scale(.06173)" xlink:href="#H"/><use transform="translate(22.099) scale(.06173)" xlink:href="#I"/><use transform="translate(34.444) scale(.06173)" xlink:href="#J"/><use transform="translate(40.617) scale(.06173)" xlink:href="#K"/><use transform="translate(55.432) scale(.06173)" xlink:href="#F"/><use transform="translate(61.605) scale(.06173)" xlink:href="#L"/><use transform="translate(68.95) scale(.06173)" xlink:href="#G"/><use transform="translate(73.827) scale(.06173)" xlink:href="#M"/><use transform="translate(86.173) scale(.06173)" xlink:href="#N"/></g><g id="d"><use transform="rotate(.413) scale(.06173)" xlink:href="#O"/><use transform="translate(12.346) scale(.06173)" xlink:href="#P"/><use transform="translate(24.691) scale(.06173)" xlink:href="#F"/><use transform="translate(30.864) scale(.06173)" xlink:href="#Q"/><use transform="translate(43.21) scale(.06173)" xlink:href="#D"/><use transform="translate(55.556) scale(.06173)" xlink:href="#L"/><use transform="translate(62.901) scale(.06173)" xlink:href="#J"/><use transform="translate(69.074) scale(.06173)" xlink:href="#R"/><use transform="translate(83.889) scale(.06173)" xlink:href="#P"/><use transform="translate(96.235) scale(.06173)" xlink:href="#F"/><use transform="translate(102.407) scale(.06173)" xlink:href="#Q"/><use transform="translate(114.753) scale(.06173)" xlink:href="#D"/><use transform="translate(127.099) scale(.06173)" xlink:href="#L"/><use transform="translate(134.444) scale(.06173)" xlink:href="#S"/><use transform="translate(140.617) scale(.06173)" xlink:href="#T"/><use transform="translate(152.963) scale(.06173)" xlink:href="#U"/></g><g id="e"><use transform="rotate(.413) scale(.06173)" xlink:href="#V"/><use transform="translate(11.111) scale(.06173)" xlink:href="#P"/><use transform="translate(23.457) scale(.06173)" xlink:href="#W"/><use transform="translate(41.914) scale(.06173)" xlink:href="#W"/><use transform="translate(60.37) scale(.06173)" xlink:href="#O"/><use transform="translate(72.716) scale(.06173)" xlink:href="#L"/><use transform="translate(80.062) scale(.06173)" xlink:href="#X"/><use transform="translate(91.173) scale(.06173)" xlink:href="#J"/><use transform="translate(97.346) scale(.06173)" xlink:href="#K"/><use transform="translate(112.16) scale(.06173)" xlink:href="#F"/><use transform="translate(118.333) scale(.06173)" xlink:href="#L"/><use transform="translate(125.679) scale(.06173)" xlink:href="#G"/><use transform="translate(130.556) scale(.06173)" xlink:href="#M"/><use transform="translate(142.901) scale(.06173)" xlink:href="#N"/></g><g id="f"><use transform="rotate(.413) scale(.06173)" xlink:href="#Y"/><use transform="translate(6.173) scale(.06173)" xlink:href="#K"/><use transform="translate(20.988) scale(.06173)" xlink:href="#C"/><use transform="translate(35.802) scale(.06173)" xlink:href="#Z"/><use transform="translate(51.79) scale(.06173)" xlink:href="#J"/><use transform="translate(57.963) scale(.06173)" xlink:href="#K"/><use transform="translate(72.778) scale(.06173)" xlink:href="#F"/><use transform="translate(78.95) scale(.06173)" xlink:href="#L"/><use transform="translate(86.296) scale(.06173)" xlink:href="#G"/><use transform="translate(91.173) scale(.06173)" xlink:href="#M"/><use transform="translate(103.519) scale(.06173)" xlink:href="#N"/></g><g id="g"><use transform="rotate(.413) scale(.06173)" xlink:href="#N"/><use transform="translate(12.346) scale(.06173)" xlink:href="#I"/><use transform="translate(24.691) scale(.06173)" xlink:href="#M"/><use transform="translate(37.037) scale(.06173)" xlink:href="#L"/><use transform="translate(44.383) scale(.06173)" xlink:href="#I"/><use transform="translate(56.728) scale(.06173)" xlink:href="#J"/><use transform="translate(62.901) scale(.06173)" xlink:href="#aa"/><use transform="translate(80.185) scale(.06173)" xlink:href="#I"/><use transform="translate(92.53) scale(.06173)" xlink:href="#M"/><use transform="translate(104.877) scale(.06173)" xlink:href="#L"/><use transform="translate(112.222) scale(.06173)" xlink:href="#I"/><use transform="translate(124.568) scale(.06173)" xlink:href="#S"/><use transform="translate(130.74) scale(.06173)" xlink:href="#T"/><use transform="translate(143.086) scale(.06173)" xlink:href="#ab"/><use transform="translate(149.26) scale(.06173)" xlink:href="#ab"/><use transform="translate(155.432) scale(.06173)" xlink:href="#ac"/><use transform="translate(164.074) scale(.06173)" xlink:href="#U"/></g><g id="h"><use transform="rotate(.413) scale(.06173)" xlink:href="#H"/><use transform="translate(4.877) scale(.06173)" xlink:href="#O"/><use transform="translate(17.222) scale(.06173)" xlink:href="#M"/><use transform="translate(29.568) scale(.06173)" xlink:href="#N"/><use transform="translate(41.914) scale(.06173)" xlink:href="#P"/><use transform="translate(54.26) scale(.06173)" xlink:href="#O"/><use transform="translate(66.605) scale(.06173)" xlink:href="#N"/><use transform="translate(78.95) scale(.06173)" xlink:href="#I"/><use transform="translate(91.296) scale(.06173)" xlink:href="#J"/><use transform="translate(97.47) scale(.06173)" xlink:href="#ad"/><use transform="translate(109.815) scale(.06173)" xlink:href="#O"/><use transform="translate(122.16) scale(.06173)" xlink:href="#M"/><use transform="translate(134.506) scale(.06173)" xlink:href="#N"/><use transform="translate(146.852) scale(.06173)" xlink:href="#P"/><use transform="translate(159.198) scale(.06173)" xlink:href="#O"/><use transform="translate(171.543) scale(.06173)" xlink:href="#N"/><use transform="translate(183.889) scale(.06173)" xlink:href="#I"/><use transform="translate(196.235) scale(.06173)" xlink:href="#S"/><use transform="translate(202.407) scale(.06173)" xlink:href="#T"/><use transform="translate(214.753) scale(.06173)" xlink:href="#U"/></g><g id="i"><use transform="rotate(.413) scale(.06173)" xlink:href="#ae"/><use transform="translate(12.346) scale(.06173)" xlink:href="#ae"/><use transform="translate(24.691) scale(.06173)" xlink:href="#V"/><use transform="translate(35.802) scale(.06173)" xlink:href="#F"/><use transform="translate(41.975) scale(.06173)" xlink:href="#L"/><use transform="translate(49.321) scale(.06173)" xlink:href="#ae"/><use transform="translate(61.667) scale(.06173)" xlink:href="#ae"/><use transform="translate(74.012) scale(.06173)" xlink:href="#J"/><use transform="translate(80.185) scale(.06173)" xlink:href="#K"/><use transform="translate(95) scale(.06173)" xlink:href="#F"/><use transform="translate(101.173) scale(.06173)" xlink:href="#L"/><use transform="translate(108.519) scale(.06173)" xlink:href="#G"/><use transform="translate(113.395) scale(.06173)" xlink:href="#M"/><use transform="translate(125.74) scale(.06173)" xlink:href="#N"/></g><g id="j"><use transform="rotate(.413) scale(.06173)" xlink:href="#C"/><use transform="translate(14.815) scale(.06173)" xlink:href="#D"/><use transform="translate(27.16) scale(.06173)" xlink:href="#D"/><use transform="translate(39.506) scale(.06173)" xlink:href="#E"/><use transform="translate(50.617) scale(.06173)" xlink:href="#Y"/><use transform="translate(56.79) scale(.06173)" xlink:href="#M"/><use transform="translate(69.136) scale(.06173)" xlink:href="#V"/><use transform="translate(80.247) scale(.06173)" xlink:href="#F"/><use transform="translate(86.42) scale(.06173)" xlink:href="#O"/><use transform="translate(98.765) scale(.06173)" xlink:href="#M"/><use transform="translate(111.111) scale(.06173)" xlink:href="#af"/><use transform="translate(122.222) scale(.06173)" xlink:href="#I"/></g><g id="k"><use transform="rotate(.413) scale(.06173)" xlink:href="#P"/><use transform="translate(12.346) scale(.06173)" xlink:href="#M"/><use transform="translate(24.691) scale(.06173)" xlink:href="#G"/><use transform="translate(29.568) scale(.06173)" xlink:href="#ag"/><use transform="translate(41.914) scale(.06173)" xlink:href="#P"/><use transform="translate(54.26) scale(.06173)" xlink:href="#I"/><use transform="translate(66.605) scale(.06173)" xlink:href="#Y"/><use transform="translate(72.778) scale(.06173)" xlink:href="#ah"/><use transform="translate(85.123) scale(.06173)" xlink:href="#J"/><use transform="translate(91.296) scale(.06173)" xlink:href="#K"/><use transform="translate(106.111) scale(.06173)" xlink:href="#F"/><use transform="translate(112.284) scale(.06173)" xlink:href="#L"/><use transform="translate(119.63) scale(.06173)" xlink:href="#G"/><use transform="translate(124.506) scale(.06173)" xlink:href="#M"/><use transform="translate(136.852) scale(.06173)" xlink:href="#N"/></g><g id="l"><use transform="rotate(.413) scale(.06173)" xlink:href="#ah"/><use transform="translate(12.346) scale(.06173)" xlink:href="#P"/><use transform="translate(24.691) scale(.06173)" xlink:href="#I"/><use transform="translate(37.037) scale(.06173)" xlink:href="#ae"/><use transform="translate(49.383) scale(.06173)" xlink:href="#ai"/><use transform="translate(61.728) scale(.06173)" xlink:href="#O"/><use transform="translate(74.074) scale(.06173)" xlink:href="#af"/><use transform="translate(85.185) scale(.06173)" xlink:href="#E"/><use transform="translate(96.296) scale(.06173)" xlink:href="#J"/><use transform="translate(102.47) scale(.06173)" xlink:href="#aj"/><use transform="translate(118.457) scale(.06173)" xlink:href="#O"/><use transform="translate(130.802) scale(.06173)" xlink:href="#F"/><use transform="translate(136.975) scale(.06173)" xlink:href="#I"/><use transform="translate(149.321) scale(.06173)" xlink:href="#ak"/><use transform="translate(162.84) scale(.06173)" xlink:href="#G"/><use transform="translate(167.716) scale(.06173)" xlink:href="#I"/><use transform="translate(180.062) scale(.06173)" xlink:href="#H"/><use transform="translate(184.938) scale(.06173)" xlink:href="#ah"/></g><g id="m"><use transform="rotate(.413) scale(.06173)" xlink:href="#V"/><use transform="translate(11.111) scale(.06173)" xlink:href="#F"/><use transform="translate(17.284) scale(.06173)" xlink:href="#O"/><use transform="translate(29.63) scale(.06173)" xlink:href="#F"/><use transform="translate(35.802) scale(.06173)" xlink:href="#P"/><use transform="translate(48.148) scale(.06173)" xlink:href="#V"/><use transform="translate(59.26) scale(.06173)" xlink:href="#J"/><use transform="translate(65.432) scale(.06173)" xlink:href="#ad"/><use transform="translate(77.778) scale(.06173)" xlink:href="#al"/><use transform="translate(95.062) scale(.06173)" xlink:href="#R"/><use transform="translate(109.877) scale(.06173)" xlink:href="#Z"/><use transform="translate(125.864) scale(.06173)" xlink:href="#ae"/><use transform="translate(138.21) scale(.06173)" xlink:href="#K"/><use transform="translate(153.025) scale(.06173)" xlink:href="#am"/><use transform="translate(164.877) scale(.06173)" xlink:href="#R"/><use transform="translate(178.025) scale(.06173)" xlink:href="#am"/><use transform="translate(191.543) scale(.06173)" xlink:href="#an"/><use transform="translate(207.53) scale(.06173)" xlink:href="#K"/></g><g id="n"><use transform="rotate(.413) scale(.06173)" xlink:href="#ai"/><use transform="translate(12.346) scale(.06173)" xlink:href="#D"/><use transform="translate(24.691) scale(.06173)" xlink:href="#D"/><use transform="translate(37.037) scale(.06173)" xlink:href="#E"/><use transform="translate(48.148) scale(.06173)" xlink:href="#J"/><use transform="translate(54.321) scale(.06173)" xlink:href="#C"/><use transform="translate(69.136) scale(.06173)" xlink:href="#D"/><use transform="translate(81.481) scale(.06173)" xlink:href="#D"/><use transform="translate(93.827) scale(.06173)" xlink:href="#E"/><use transform="translate(104.938) scale(.06173)" xlink:href="#S"/><use transform="translate(111.111) scale(.06173)" xlink:href="#T"/><use transform="translate(123.457) scale(.06173)" xlink:href="#U"/></g><g id="o"><use transform="rotate(.413) scale(.06173)" xlink:href="#G"/><use transform="translate(4.877) scale(.06173)" xlink:href="#W"/><use transform="translate(23.333) scale(.06173)" xlink:href="#ao"/><use transform="translate(35.679) scale(.06173)" xlink:href="#L"/><use transform="translate(43.025) scale(.06173)" xlink:href="#G"/><use transform="translate(47.901) scale(.06173)" xlink:href="#M"/><use transform="translate(60.247) scale(.06173)" xlink:href="#F"/><use transform="translate(66.42) scale(.06173)" xlink:href="#J"/></g><g id="p"><use transform="rotate(.413) scale(.06173)" xlink:href="#K"/><use transform="translate(14.815) scale(.06173)" xlink:href="#F"/><use transform="translate(20.988) scale(.06173)" xlink:href="#L"/><use transform="translate(28.333) scale(.06173)" xlink:href="#G"/><use transform="translate(33.21) scale(.06173)" xlink:href="#M"/><use transform="translate(45.556) scale(.06173)" xlink:href="#N"/></g><g id="q"><use transform="rotate(.413) scale(.06173)" xlink:href="#ai"/><use transform="translate(12.346) scale(.06173)" xlink:href="#D"/><use transform="translate(24.691) scale(.06173)" xlink:href="#L"/><use transform="translate(32.037) scale(.06173)" xlink:href="#L"/><use transform="translate(39.383) scale(.06173)" xlink:href="#D"/><use transform="translate(51.728) scale(.06173)" xlink:href="#ap"/><use transform="translate(67.716) scale(.06173)" xlink:href="#I"/><use transform="translate(80.062) scale(.06173)" xlink:href="#L"/><use transform="translate(87.407) scale(.06173)" xlink:href="#J"/><use transform="translate(93.58) scale(.06173)" xlink:href="#an"/><use transform="translate(109.568) scale(.06173)" xlink:href="#V"/><use transform="translate(120.679) scale(.06173)" xlink:href="#I"/><use transform="translate(133.025) scale(.06173)" xlink:href="#L"/><use transform="translate(140.37) scale(.06173)" xlink:href="#S"/><use transform="translate(146.543) scale(.06173)" xlink:href="#T"/><use transform="translate(158.889) scale(.06173)" xlink:href="#U"/></g><g id="r"><use transform="rotate(.413) scale(.06173)" xlink:href="#aa"/><use transform="translate(17.284) scale(.06173)" xlink:href="#I"/><use transform="translate(29.63) scale(.06173)" xlink:href="#M"/><use transform="translate(41.975) scale(.06173)" xlink:href="#L"/><use transform="translate(49.321) scale(.06173)" xlink:href="#I"/></g><g id="s"><use transform="rotate(.413) scale(.06173)" xlink:href="#M"/><use transform="translate(12.346) scale(.06173)" xlink:href="#O"/><use transform="translate(24.691) scale(.06173)" xlink:href="#W"/><use transform="translate(43.148) scale(.06173)" xlink:href="#I"/><use transform="translate(55.494) scale(.06173)" xlink:href="#J"/><use transform="translate(61.667) scale(.06173)" xlink:href="#K"/><use transform="translate(76.481) scale(.06173)" xlink:href="#F"/><use transform="translate(82.654) scale(.06173)" xlink:href="#L"/><use transform="translate(90) scale(.06173)" xlink:href="#G"/><use transform="translate(94.877) scale(.06173)" xlink:href="#M"/><use transform="translate(107.222) scale(.06173)" xlink:href="#N"/></g><g id="t"><use transform="rotate(.413) scale(.06173)" xlink:href="#ad"/><use transform="translate(12.346) scale(.06173)" xlink:href="#O"/><use transform="translate(24.691) scale(.06173)" xlink:href="#M"/><use transform="translate(37.037) scale(.06173)" xlink:href="#N"/><use transform="translate(49.383) scale(.06173)" xlink:href="#P"/><use transform="translate(61.728) scale(.06173)" xlink:href="#O"/><use transform="translate(74.074) scale(.06173)" xlink:href="#N"/><use transform="translate(86.42) scale(.06173)" xlink:href="#I"/></g><g id="u"><use transform="rotate(.413) scale(.06173)" xlink:href="#R"/><use transform="translate(14.815) scale(.06173)" xlink:href="#P"/><use transform="translate(27.16) scale(.06173)" xlink:href="#F"/><use transform="translate(33.333) scale(.06173)" xlink:href="#Q"/><use transform="translate(45.679) scale(.06173)" xlink:href="#D"/><use transform="translate(58.025) scale(.06173)" xlink:href="#L"/></g><g id="v"><use transform="rotate(.413) scale(.06173)" xlink:href="#M"/><use transform="translate(12.346) scale(.06173)" xlink:href="#O"/><use transform="translate(24.691) scale(.06173)" xlink:href="#W"/><use transform="translate(43.148) scale(.06173)" xlink:href="#I"/><use transform="translate(55.494) scale(.06173)" xlink:href="#J"/><use transform="translate(61.667) scale(.06173)" xlink:href="#K"/><use transform="translate(76.481) scale(.06173)" xlink:href="#F"/><use transform="translate(82.654) scale(.06173)" xlink:href="#L"/><use transform="translate(90) scale(.06173)" xlink:href="#G"/><use transform="translate(94.877) scale(.06173)" xlink:href="#M"/><use transform="translate(107.222) scale(.06173)" xlink:href="#N"/></g><g id="w"><use transform="rotate(.413) scale(.06173)" xlink:href="#ah"/><use transform="translate(12.346) scale(.06173)" xlink:href="#O"/><use transform="translate(24.691) scale(.06173)" xlink:href="#F"/><use transform="translate(30.864) scale(.06173)" xlink:href="#I"/><use transform="translate(43.21) scale(.06173)" xlink:href="#ae"/><use transform="translate(55.556) scale(.06173)" xlink:href="#D"/><use transform="translate(67.901) scale(.06173)" xlink:href="#aq"/><use transform="translate(74.074) scale(.06173)" xlink:href="#ae"/><use transform="translate(86.42) scale(.06173)" xlink:href="#ai"/><use transform="translate(98.765) scale(.06173)" xlink:href="#G"/><use transform="translate(103.642) scale(.06173)" xlink:href="#L"/><use transform="translate(110.988) scale(.06173)" xlink:href="#F"/><use transform="translate(117.16) scale(.06173)" xlink:href="#Q"/><use transform="translate(129.506) scale(.06173)" xlink:href="#J"/><use transform="translate(135.679) scale(.06173)" xlink:href="#aj"/><use transform="translate(151.667) scale(.06173)" xlink:href="#O"/><use transform="translate(164.012) scale(.06173)" xlink:href="#F"/><use transform="translate(170.185) scale(.06173)" xlink:href="#I"/><use transform="translate(182.53) scale(.06173)" xlink:href="#ak"/><use transform="translate(196.05) scale(.06173)" xlink:href="#G"/><use transform="translate(200.926) scale(.06173)" xlink:href="#I"/><use transform="translate(213.272) scale(.06173)" xlink:href="#H"/><use transform="translate(218.148) scale(.06173)" xlink:href="#ah"/></g><g id="x"><use transform="rotate(.413) scale(.06173)" xlink:href="#ah"/><use transform="translate(12.346) scale(.06173)" xlink:href="#O"/><use transform="translate(24.691) scale(.06173)" xlink:href="#F"/><use transform="translate(30.864) scale(.06173)" xlink:href="#I"/><use transform="translate(43.21) scale(.06173)" xlink:href="#ae"/><use transform="translate(55.556) scale(.06173)" xlink:href="#D"/><use transform="translate(67.901) scale(.06173)" xlink:href="#aq"/><use transform="translate(74.074) scale(.06173)" xlink:href="#ae"/><use transform="translate(86.42) scale(.06173)" xlink:href="#ah"/><use transform="translate(98.765) scale(.06173)" xlink:href="#I"/><use transform="translate(111.111) scale(.06173)" xlink:href="#O"/><use transform="translate(123.457) scale(.06173)" xlink:href="#F"/><use transform="translate(129.63) scale(.06173)" xlink:href="#Q"/><use transform="translate(141.975) scale(.06173)" xlink:href="#J"/><use transform="translate(148.148) scale(.06173)" xlink:href="#ah"/><use transform="translate(160.494) scale(.06173)" xlink:href="#O"/><use transform="translate(172.84) scale(.06173)" xlink:href="#F"/><use transform="translate(179.012) scale(.06173)" xlink:href="#I"/><use transform="translate(191.358) scale(.06173)" xlink:href="#ak"/><use transform="translate(204.877) scale(.06173)" xlink:href="#G"/><use transform="translate(209.753) scale(.06173)" xlink:href="#I"/><use transform="translate(222.099) scale(.06173)" xlink:href="#H"/><use transform="translate(226.975) scale(.06173)" xlink:href="#ah"/></g><g id="y"><use transform="rotate(.413) scale(.06173)" xlink:href="#ai"/><use transform="translate(12.346) scale(.06173)" xlink:href="#D"/><use transform="translate(24.691) scale(.06173)" xlink:href="#D"/><use transform="translate(37.037) scale(.06173)" xlink:href="#E"/><use transform="translate(48.148) scale(.06173)" xlink:href="#V"/><use transform="translate(59.26) scale(.06173)" xlink:href="#J"/><use transform="translate(65.432) scale(.06173)" xlink:href="#C"/><use transform="translate(80.247) scale(.06173)" xlink:href="#D"/><use transform="translate(92.593) scale(.06173)" xlink:href="#D"/><use transform="translate(104.938) scale(.06173)" xlink:href="#E"/><use transform="translate(116.05) scale(.06173)" xlink:href="#S"/><use transform="translate(122.222) scale(.06173)" xlink:href="#T"/><use transform="translate(134.568) scale(.06173)" xlink:href="#ab"/><use transform="translate(140.74) scale(.06173)" xlink:href="#ab"/><use transform="translate(146.914) scale(.06173)" xlink:href="#ac"/><use transform="translate(155.556) scale(.06173)" xlink:href="#U"/></g><g id="z"><use transform="scale(.05)" xlink:href="#ar"/><use transform="translate(10) scale(.05)" xlink:href="#as"/><use transform="translate(15) scale(.05)" xlink:href="#as"/><use transform="translate(20) scale(.05)" xlink:href="#at"/></g><g id="B"><use transform="scale(.05)" xlink:href="#au"/><use transform="translate(10) scale(.05)" xlink:href="#as"/><use transform="translate(15) scale(.05)" xlink:href="#as"/><use transform="translate(20) scale(.05)" xlink:href="#at"/></g><use transform="rotate(.413) scale(.06173)" xlink:href="#av" id="b"/><use transform="scale(.05)" xlink:href="#ar" id="A"/></defs></g></svg> | 0 |
data/mdn-content/files/en-us/learn/server-side/django | data/mdn-content/files/en-us/learn/server-side/django/forms/index.md | ---
title: "Django Tutorial Part 9: Working with forms"
slug: Learn/Server-side/Django/Forms
page-type: learn-module-chapter
---
{{LearnSidebar}}{{PreviousMenuNext("Learn/Server-side/Django/authentication_and_sessions", "Learn/Server-side/Django/Testing", "Learn/Server-side/Django")}}
In this tutorial, we'll show you how to work with HTML Forms in Django, and, in particular, the easiest way to write forms to create, update, and delete model instances. As part of this demonstration, we'll extend the [LocalLibrary](/en-US/docs/Learn/Server-side/Django/Tutorial_local_library_website) website so that librarians can renew books, and create, update, and delete authors using our own forms (rather than using the admin application).
<table>
<tbody>
<tr>
<th scope="row">Prerequisites:</th>
<td>
Complete all previous tutorial topics, including
<a href="/en-US/docs/Learn/Server-side/Django/Authentication">Django Tutorial Part 8: User authentication and permissions</a>.
</td>
</tr>
<tr>
<th scope="row">Objective:</th>
<td>
To understand how to write forms to get information from users and update the database.
To understand how the generic class-based editing views can vastly simplify creating forms for working with a single model.
</td>
</tr>
</tbody>
</table>
## Overview
An [HTML Form](/en-US/docs/Learn/Forms) is a group of one or more fields/widgets on a web page, which can be used to collect information from users for submission to a server. Forms are a flexible mechanism for collecting user input because there are suitable widgets for entering many different types of data, including text boxes, checkboxes, radio buttons, date pickers and so on. Forms are also a relatively secure way of sharing data with the server, as they allow us to send data in `POST` requests with cross-site request forgery protection.
While we haven't created any forms in this tutorial so far, we've already encountered them in the Django Admin site — for example, the screenshot below shows a form for editing one of our [Book](/en-US/docs/Learn/Server-side/Django/Models) models, comprised of a number of selection lists and text editors.
Working with forms can be complicated! Developers need to write HTML for the form, validate and properly sanitize entered data on the server (and possibly also in the browser), repost the form with error messages to inform users of any invalid fields, handle the data when it has successfully been submitted, and finally respond to the user in some way to indicate success. _Django Forms_ take a lot of the work out of all these steps, by providing a framework that lets you define forms and their fields programmatically, and then use these objects to both generate the form HTML code and handle much of the validation and user interaction.
In this tutorial, we're going to show you a few of the ways you can create and work with forms, and in particular, how the generic editing views can significantly reduce the amount of work you need to do to create forms to manipulate your models. Along the way, we'll extend our _LocalLibrary_ application by adding a form to allow librarians to renew library books, and we'll create pages to create, edit and delete books and authors (reproducing a basic version of the form shown above for editing books).
## HTML Forms
First, a brief overview of [HTML Forms](/en-US/docs/Learn/Forms). Consider a simple HTML form, with a single text field for entering the name of some "team", and its associated label:
The form is defined in HTML as a collection of elements inside `<form>…</form>` tags, containing at least one `input` element of `type="submit"`.
```html
<form action="/team_name_url/" method="post">
<label for="team_name">Enter name: </label>
<input
id="team_name"
type="text"
name="name_field"
value="Default name for team." />
<input type="submit" value="OK" />
</form>
```
While here we just have one text field for entering the team name, a form _may_ have any number of other input elements and their associated labels. The field's `type` attribute defines what sort of widget will be displayed. The `name` and `id` of the field are used to identify the field in JavaScript/CSS/HTML, while `value` defines the initial value for the field when it is first displayed. The matching team label is specified using the `label` tag (see "Enter name" above), with a `for` field containing the `id` value of the associated `input`.
The `submit` input will be displayed as a button by default.
This can be pressed to upload the data in all the other input elements in the form to the server (in this case, just the `team_name` field).
The form attributes define the HTTP `method` used to send the data and the destination of the data on the server (`action`):
- `action`: The resource/URL where data is to be sent for processing when the form is submitted. If this is not set (or set to an empty string), then the form will be submitted back to the current page URL.
- `method`: The HTTP method used to send the data: _post_ or _get_.
- The `POST` method should always be used if the data is going to result in a change to the server's database, because it can be made more resistant to cross-site forgery request attacks.
- The `GET` method should only be used for forms that don't change user data (for example, a search form). It is recommended for when you want to be able to bookmark or share the URL.
The role of the server is first to render the initial form state — either containing blank fields or pre-populated with initial values. After the user presses the submit button, the server will receive the form data with values from the web browser and must validate the information. If the form contains invalid data, the server should display the form again, this time with user-entered data in "valid" fields and messages to describe the problem for the invalid fields. Once the server gets a request with all valid form data, it can perform an appropriate action (such as: saving the data, returning the result of a search, uploading a file, etc.) and then notify the user.
As you can imagine, creating the HTML, validating the returned data, re-displaying the entered data with error reports if needed, and performing the desired operation on valid data can all take quite a lot of effort to "get right". Django makes this a lot easier by taking away some of the heavy lifting and repetitive code!
## Django form handling process
Django's form handling uses all of the same techniques that we learned about in previous tutorials (for displaying information about our models): the view gets a request, performs any actions required including reading data from the models, then generates and returns an HTML page (from a template, into which we pass a _context_ containing the data to be displayed). What makes things more complicated is that the server also needs to be able to process data provided by the user, and redisplay the page if there are any errors.
A process flowchart of how Django handles form requests is shown below, starting with a request for a page containing a form (shown in green).
Based on the diagram above, the main things that Django's form handling does are:
1. Display the default form the first time it is requested by the user.
- The form may contain blank fields if you're creating a new record, or it may be pre-populated with initial values (for example, if you are changing a record, or have useful default initial values).
- The form is referred to as _unbound_ at this point, because it isn't associated with any user-entered data (though it may have initial values).
2. Receive data from a submit request and bind it to the form.
- Binding data to the form means that the user-entered data and any errors are available when we need to redisplay the form.
3. Clean and validate the data.
- Cleaning the data performs sanitization of the input fields, such as removing invalid characters that might be used to send malicious content to the server, and converts them into consistent Python types.
- Validation checks that the values are appropriate for the field (for example, that they are in the right date range, aren't too short or too long, etc.)
4. If any data is invalid, re-display the form, this time with any user populated values and error messages for the problem fields.
5. If all data is valid, perform required actions (such as save the data, send an email, return the result of a search, upload a file, and so on).
6. Once all actions are complete, redirect the user to another page.
Django provides a number of tools and approaches to help you with the tasks detailed above. The most fundamental is the `Form` class, which simplifies both generation of form HTML and data cleaning/validation. In the next section, we describe how forms work using the practical example of a page to allow librarians to renew books.
> **Note:** Understanding how `Form` is used will help you when we discuss Django's more "high level" form framework classes.
## Renew-book form using a Form and function view
Next, we're going to add a page to allow librarians to renew borrowed books. To do this we'll create a form that allows users to enter a date value. We'll seed the field with an initial value 3 weeks from the current date (the normal borrowing period), and add some validation to ensure that the librarian can't enter a date in the past or a date too far in the future. When a valid date has been entered, we'll write it to the current record's `BookInstance.due_back` field.
The example will use a function-based view and a `Form` class. The following sections explain how forms work, and the changes you need to make to our ongoing _LocalLibrary_ project.
### Form
The `Form` class is the heart of Django's form handling system. It specifies the fields in the form, their layout, display widgets, labels, initial values, valid values, and (once validated) the error messages associated with invalid fields. The class also provides methods for rendering itself in templates using predefined formats (tables, lists, etc.) or for getting the value of any element (enabling fine-grained manual rendering).
#### Declaring a Form
The declaration syntax for a `Form` is very similar to that for declaring a `Model`, and shares the same field types (and some similar parameters). This makes sense because in both cases we need to ensure that each field handles the right types of data, is constrained to valid data, and has a description for display/documentation.
Form data is stored in an application's forms.py file, inside the application directory. Create and open the file **locallibrary/catalog/forms.py**. To create a `Form`, we import the `forms` library, derive from the `Form` class, and declare the form's fields. A very basic form class for our library book renewal form is shown below — add this to your new file:
```python
from django import forms
class RenewBookForm(forms.Form):
renewal_date = forms.DateField(help_text="Enter a date between now and 4 weeks (default 3).")
```
#### Form fields
In this case, we have a single [`DateField`](https://docs.djangoproject.com/en/4.2/ref/forms/fields/#datefield) for entering the renewal date that will render in HTML with a blank value, the default label "_Renewal date:_", and some helpful usage text: "_Enter a date between now and 4 weeks (default 3 weeks)._" As none of the other optional arguments are specified the field will accept dates using the [input_formats](https://docs.djangoproject.com/en/4.2/ref/forms/fields/#django.forms.DateField.input_formats): YYYY-MM-DD (2016-11-06), MM/DD/YYYY (02/26/2016), MM/DD/YY (10/25/16), and will be rendered using the default [widget](https://docs.djangoproject.com/en/4.2/ref/forms/fields/#widget): [DateInput](https://docs.djangoproject.com/en/4.2/ref/forms/widgets/#django.forms.DateInput).
There are many other types of form fields, which you will largely recognize from their similarity to the equivalent model field classes:
- [`BooleanField`](https://docs.djangoproject.com/en/4.2/ref/forms/fields/#booleanfield)
- [`CharField`](https://docs.djangoproject.com/en/4.2/ref/forms/fields/#charfield)
- [`ChoiceField`](https://docs.djangoproject.com/en/4.2/ref/forms/fields/#choicefield)
- [`TypedChoiceField`](https://docs.djangoproject.com/en/4.2/ref/forms/fields/#typedchoicefield)
- [`DateField`](https://docs.djangoproject.com/en/4.2/ref/forms/fields/#datefield)
- [`DateTimeField`](https://docs.djangoproject.com/en/4.2/ref/forms/fields/#datetimefield)
- [`DecimalField`](https://docs.djangoproject.com/en/4.2/ref/forms/fields/#decimalfield)
- [`DurationField`](https://docs.djangoproject.com/en/4.2/ref/forms/fields/#durationfield)
- [`EmailField`](https://docs.djangoproject.com/en/4.2/ref/forms/fields/#emailfield)
- [`FileField`](https://docs.djangoproject.com/en/4.2/ref/forms/fields/#filefield)
- [`FilePathField`](https://docs.djangoproject.com/en/4.2/ref/forms/fields/#filepathfield)
- [`FloatField`](https://docs.djangoproject.com/en/4.2/ref/forms/fields/#floatfield)
- [`ImageField`](https://docs.djangoproject.com/en/4.2/ref/forms/fields/#imagefield)
- [`IntegerField`](https://docs.djangoproject.com/en/4.2/ref/forms/fields/#integerfield)
- [`GenericIPAddressField`](https://docs.djangoproject.com/en/4.2/ref/forms/fields/#genericipaddressfield)
- [`MultipleChoiceField`](https://docs.djangoproject.com/en/4.2/ref/forms/fields/#multiplechoicefield)
- [`TypedMultipleChoiceField`](https://docs.djangoproject.com/en/4.2/ref/forms/fields/#typedmultiplechoicefield)
- [`NullBooleanField`](https://docs.djangoproject.com/en/4.2/ref/forms/fields/#nullbooleanfield)
- [`RegexField`](https://docs.djangoproject.com/en/4.2/ref/forms/fields/#regexfield)
- [`SlugField`](https://docs.djangoproject.com/en/4.2/ref/forms/fields/#slugfield)
- [`TimeField`](https://docs.djangoproject.com/en/4.2/ref/forms/fields/#timefield)
- [`URLField`](https://docs.djangoproject.com/en/4.2/ref/forms/fields/#urlfield)
- [`UUIDField`](https://docs.djangoproject.com/en/4.2/ref/forms/fields/#uuidfield)
- [`ComboField`](https://docs.djangoproject.com/en/4.2/ref/forms/fields/#combofield)
- [`MultiValueField`](https://docs.djangoproject.com/en/4.2/ref/forms/fields/#multivaluefield)
- [`SplitDateTimeField`](https://docs.djangoproject.com/en/4.2/ref/forms/fields/#splitdatetimefield)
- [`ModelMultipleChoiceField`](https://docs.djangoproject.com/en/4.2/ref/forms/fields/#modelmultiplechoicefield)
- [`ModelChoiceField`](https://docs.djangoproject.com/en/4.2/ref/forms/fields/#modelchoicefield)
The arguments that are common to most fields are listed below (these have sensible default values):
- [`required`](https://docs.djangoproject.com/en/4.2/ref/forms/fields/#required): If `True`, the field may not be left blank or given a `None` value. Fields are required by default, so you would set `required=False` to allow blank values in the form.
- [`label`](https://docs.djangoproject.com/en/4.2/ref/forms/fields/#label): The label to use when rendering the field in HTML. If a [label](https://docs.djangoproject.com/en/4.2/ref/forms/fields/#label) is not specified, Django will create one from the field name by capitalizing the first letter and replacing underscores with spaces (e.g. _Renewal date_).
- [`label_suffix`](https://docs.djangoproject.com/en/4.2/ref/forms/fields/#label-suffix): By default, a colon is displayed after the label (e.g. Renewal date​**:**). This argument allows you to specify a different suffix containing other character(s).
- [`initial`](https://docs.djangoproject.com/en/4.2/ref/forms/fields/#initial): The initial value for the field when the form is displayed.
- [`widget`](https://docs.djangoproject.com/en/4.2/ref/forms/fields/#widget): The display widget to use.
- [`help_text`](https://docs.djangoproject.com/en/4.2/ref/forms/fields/#help-text) (as seen in the example above): Additional text that can be displayed in forms to explain how to use the field.
- [`error_messages`](https://docs.djangoproject.com/en/4.2/ref/forms/fields/#error-messages): A list of error messages for the field. You can override these with your own messages if needed.
- [`validators`](https://docs.djangoproject.com/en/4.2/ref/forms/fields/#validators): A list of functions that will be called on the field when it is validated.
- [`localize`](https://docs.djangoproject.com/en/4.2/ref/forms/fields/#localize): Enables the localization of form data input (see link for more information).
- [`disabled`](https://docs.djangoproject.com/en/4.2/ref/forms/fields/#disabled): The field is displayed but its value cannot be edited if this is `True`. The default is `False`.
#### Validation
Django provides numerous places where you can validate your data. The easiest way to validate a single field is to override the method `clean_<fieldname>()` for the field you want to check. So for example, we can validate that entered `renewal_date` values are between now and 4 weeks by implementing `clean_renewal_date()` as shown below.
Update your forms.py file so it looks like this:
```python
import datetime
from django import forms
from django.core.exceptions import ValidationError
from django.utils.translation import gettext_lazy as _
class RenewBookForm(forms.Form):
renewal_date = forms.DateField(help_text="Enter a date between now and 4 weeks (default 3).")
def clean_renewal_date(self):
data = self.cleaned_data['renewal_date']
# Check if a date is not in the past.
if data < datetime.date.today():
raise ValidationError(_('Invalid date - renewal in past'))
# Check if a date is in the allowed range (+4 weeks from today).
if data > datetime.date.today() + datetime.timedelta(weeks=4):
raise ValidationError(_('Invalid date - renewal more than 4 weeks ahead'))
# Remember to always return the cleaned data.
return data
```
There are two important things to note. The first is that we get our data using `self.cleaned_data['renewal_date']` and that we return this data whether or not we change it at the end of the function.
This step gets us the data "cleaned" and sanitized of potentially unsafe input using the default validators, and converted into the correct standard type for the data (in this case a Python `datetime.datetime` object).
The second point is that if a value falls outside our range we raise a `ValidationError`, specifying the error text that we want to display in the form if an invalid value is entered.
The example above also wraps this text in one of Django's [translation functions](https://docs.djangoproject.com/en/4.2/topics/i18n/translation/), `gettext_lazy()` (imported as `_()`), which is good practice if you want to translate your site later.
> **Note:** There are numerous other methods and examples for validating forms in [Form and field validation](https://docs.djangoproject.com/en/4.2/ref/forms/validation/) (Django docs). For example, in cases where you have multiple fields that depend on each other, you can override the [Form.clean()](https://docs.djangoproject.com/en/4.2/ref/forms/api/#django.forms.Form.clean) function and again raise a `ValidationError`.
That's all we need for the form in this example!
### URL configuration
Before we create our view, let's add a URL configuration for the _renew-books_ page. Copy the following configuration to the bottom of **locallibrary/catalog/urls.py**:
```python
urlpatterns += [
path('book/<uuid:pk>/renew/', views.renew_book_librarian, name='renew-book-librarian'),
]
```
The URL configuration will redirect URLs with the format **/catalog/book/_\<bookinstance_id>_/renew/** to the function named `renew_book_librarian()` in **views.py**, and send the `BookInstance` id as the parameter named `pk`. The pattern only matches if `pk` is a correctly formatted `uuid`.
> **Note:** We can name our captured URL data "`pk`" anything we like, because we have complete control over the view function (we're not using a generic detail view class that expects parameters with a certain name). However, `pk` short for "primary key", is a reasonable convention to use!
### View
As discussed in the [Django form handling process](#django_form_handling_process) above, the view has to render the default form when it is first called and then either re-render it with error messages if the data is invalid, or process the data and redirect to a new page if the data is valid. In order to perform these different actions, the view has to be able to know whether it is being called for the first time to render the default form, or a subsequent time to validate data.
For forms that use a `POST` request to submit information to the server, the most common pattern is for the view to test against the `POST` request type (`if request.method == 'POST':`) to identify form validation requests and `GET` (using an `else` condition) to identify the initial form creation request. If you want to submit your data using a `GET` request, then a typical approach for identifying whether this is the first or subsequent view invocation is to read the form data (e.g. to read a hidden value in the form).
The book renewal process will be writing to our database, so, by convention, we use the `POST` request approach.
The code fragment below shows the (very standard) pattern for this sort of function view.
```python
import datetime
from django.shortcuts import render, get_object_or_404
from django.http import HttpResponseRedirect
from django.urls import reverse
from catalog.forms import RenewBookForm
def renew_book_librarian(request, pk):
book_instance = get_object_or_404(BookInstance, pk=pk)
# If this is a POST request then process the Form data
if request.method == 'POST':
# Create a form instance and populate it with data from the request (binding):
form = RenewBookForm(request.POST)
# Check if the form is valid:
if form.is_valid():
# process the data in form.cleaned_data as required (here we just write it to the model due_back field)
book_instance.due_back = form.cleaned_data['renewal_date']
book_instance.save()
# redirect to a new URL:
return HttpResponseRedirect(reverse('all-borrowed'))
# If this is a GET (or any other method) create the default form.
else:
proposed_renewal_date = datetime.date.today() + datetime.timedelta(weeks=3)
form = RenewBookForm(initial={'renewal_date': proposed_renewal_date})
context = {
'form': form,
'book_instance': book_instance,
}
return render(request, 'catalog/book_renew_librarian.html', context)
```
First, we import our form (`RenewBookForm`) and a number of other useful objects/methods used in the body of the view function:
- [`get_object_or_404()`](https://docs.djangoproject.com/en/4.2/topics/http/shortcuts/#get-object-or-404): Returns a specified object from a model based on its primary key value, and raises an `Http404` exception (not found) if the record does not exist.
- [`HttpResponseRedirect`](https://docs.djangoproject.com/en/4.2/ref/request-response/#django.http.HttpResponseRedirect): This creates a redirect to a specified URL (HTTP status code 302).
- [`reverse()`](https://docs.djangoproject.com/en/4.2/ref/urlresolvers/#django.urls.reverse): This generates a URL from a URL configuration name and a set of arguments. It is the Python equivalent of the `url` tag that we've been using in our templates.
- [`datetime`](https://docs.python.org/3/library/datetime.html): A Python library for manipulating dates and times.
In the view, we first use the `pk` argument in `get_object_or_404()` to get the current `BookInstance` (if this does not exist, the view will immediately exit and the page will display a "not found" error).
If this is _not_ a `POST` request (handled by the `else` clause) then we create the default form passing in an `initial` value for the `renewal_date` field, 3 weeks from the current date.
```python
book_instance = get_object_or_404(BookInstance, pk=pk)
# If this is a GET (or any other method) create the default form
else:
proposed_renewal_date = datetime.date.today() + datetime.timedelta(weeks=3)
form = RenewBookForm(initial={'renewal_date': proposed_renewal_date})
context = {
'form': form,
'book_instance': book_instance,
}
return render(request, 'catalog/book_renew_librarian.html', context)
```
After creating the form, we call `render()` to create the HTML page, specifying the template and a context that contains our form. In this case, the context also contains our `BookInstance`, which we'll use in the template to provide information about the book we're renewing.
However, if this is a `POST` request, then we create our `form` object and populate it with data from the request. This process is called "binding" and allows us to validate the form.
We then check if the form is valid, which runs all the validation code on all of the fields — including both the generic code to check that our date field is actually a valid date and our specific form's `clean_renewal_date()` function to check the date is in the right range.
```python
book_instance = get_object_or_404(BookInstance, pk=pk)
# If this is a POST request then process the Form data
if request.method == 'POST':
# Create a form instance and populate it with data from the request (binding):
form = RenewBookForm(request.POST)
# Check if the form is valid:
if form.is_valid():
# process the data in form.cleaned_data as required (here we just write it to the model due_back field)
book_instance.due_back = form.cleaned_data['renewal_date']
book_instance.save()
# redirect to a new URL:
return HttpResponseRedirect(reverse('all-borrowed'))
context = {
'form': form,
'book_instance': book_instance,
}
return render(request, 'catalog/book_renew_librarian.html', context)
```
If the form is not valid we call `render()` again, but this time the form value passed in the context will include error messages.
If the form is valid, then we can start to use the data, accessing it through the `form.cleaned_data` attribute (e.g. `data = form.cleaned_data['renewal_date']`). Here, we just save the data into the `due_back` value of the associated `BookInstance` object.
> **Warning:** While you can also access the form data directly through the request (for example, `request.POST['renewal_date']` or `request.GET['renewal_date']` if using a GET request), this is NOT recommended. The cleaned data is sanitized, validated, and converted into Python-friendly types.
The final step in the form-handling part of the view is to redirect to another page, usually a "success" page. In this case, we use `HttpResponseRedirect` and `reverse()` to redirect to the view named `'all-borrowed'` (this was created as the "challenge" in [Django Tutorial Part 8: User authentication and permissions](/en-US/docs/Learn/Server-side/Django/Authentication#challenge_yourself)). If you didn't create that page consider redirecting to the home page at URL '`/`').
That's everything needed for the form handling itself, but we still need to restrict access to the view to just logged-in librarians who have permission to renew books. We use `@login_required` to require that the user is logged in, and the `@permission_required` function decorator with our existing `can_mark_returned` permission to allow access (decorators are processed in order). Note that we probably should have created a new permission setting in `BookInstance` ("`can_renew`"), but we will reuse the existing one to keep the example simple.
The final view is therefore as shown below. Please copy this into the bottom of **locallibrary/catalog/views.py**.
```python
import datetime
from django.contrib.auth.decorators import login_required, permission_required
from django.shortcuts import get_object_or_404
from django.http import HttpResponseRedirect
from django.urls import reverse
from catalog.forms import RenewBookForm
@login_required
@permission_required('catalog.can_mark_returned', raise_exception=True)
def renew_book_librarian(request, pk):
"""View function for renewing a specific BookInstance by librarian."""
book_instance = get_object_or_404(BookInstance, pk=pk)
# If this is a POST request then process the Form data
if request.method == 'POST':
# Create a form instance and populate it with data from the request (binding):
form = RenewBookForm(request.POST)
# Check if the form is valid:
if form.is_valid():
# process the data in form.cleaned_data as required (here we just write it to the model due_back field)
book_instance.due_back = form.cleaned_data['renewal_date']
book_instance.save()
# redirect to a new URL:
return HttpResponseRedirect(reverse('all-borrowed'))
# If this is a GET (or any other method) create the default form.
else:
proposed_renewal_date = datetime.date.today() + datetime.timedelta(weeks=3)
form = RenewBookForm(initial={'renewal_date': proposed_renewal_date})
context = {
'form': form,
'book_instance': book_instance,
}
return render(request, 'catalog/book_renew_librarian.html', context)
```
### The template
Create the template referenced in the view (**/catalog/templates/catalog/book_renew_librarian.html**) and copy the code below into it:
```django
{% extends "base_generic.html" %}
{% block content %}
<h1>Renew: \{{ book_instance.book.title }}</h1>
<p>Borrower: \{{ book_instance.borrower }}</p>
<p {% if book_instance.is_overdue %} class="text-danger"{% endif %} >Due date: \{{ book_instance.due_back }}</p>
<form action="" method="post">
{% csrf_token %}
<table>
\{{ form.as_table }}
</table>
<input type="submit" value="Submit">
</form>
{% endblock %}
```
Most of this will be completely familiar from previous tutorials.
We extend the base template and then redefine the content block. We are able to reference `\{{ book_instance }}` (and its variables) because it was passed into the context object in the `render()` function, and we use these to list the book title, borrower, and the original due date.
The form code is relatively simple. First, we declare the `form` tags, specifying where the form is to be submitted (`action`) and the `method` for submitting the data (in this case an "HTTP `POST`") — if you recall the [HTML Forms](#html_forms) overview at the top of the page, an empty `action` as shown, means that the form data will be posted back to the current URL of the page (which is what we want). Inside the tags, we define the `submit` input, which a user can press to submit the data. The `{% csrf_token %}` added just inside the form tags is part of Django's cross-site forgery protection.
> **Note:** Add the `{% csrf_token %}` to every Django template you create that uses `POST` to submit data. This will reduce the chance of forms being hijacked by malicious users.
All that's left is the `\{{ form }}` template variable, which we passed to the template in the context dictionary.
Perhaps unsurprisingly, when used as shown this provides the default rendering of all the form fields, including their labels, widgets, and help text — the rendering is as shown below:
```html
<tr>
<th><label for="id_renewal_date">Renewal date:</label></th>
<td>
<input
id="id_renewal_date"
name="renewal_date"
type="text"
value="2023-11-08"
required />
<br />
<span class="helptext">
Enter date between now and 4 weeks (default 3 weeks).
</span>
</td>
</tr>
```
> **Note:** It is perhaps not obvious because we only have one field, but, by default, every field is defined in its own table row. This same rendering is provided if you reference the template variable `\{{ form.as_table }}`.
If you were to enter an invalid date, you'd additionally get a list of the errors rendered on the page (see `errorlist` below).
```html
<tr>
<th><label for="id_renewal_date">Renewal date:</label></th>
<td>
<ul class="errorlist">
<li>Invalid date - renewal in past</li>
</ul>
<input
id="id_renewal_date"
name="renewal_date"
type="text"
value="2023-11-08"
required />
<br />
<span class="helptext">
Enter date between now and 4 weeks (default 3 weeks).
</span>
</td>
</tr>
```
#### Other ways of using form template variable
Using `\{{ form.as_table }}` as shown above, each field is rendered as a table row. You can also render each field as a list item (using `\{{ form.as_ul }}`) or as a paragraph (using `\{{ form.as_p }}`).
It is also possible to have complete control over the rendering of each part of the form, by indexing its properties using dot notation. So, for example, we can access a number of separate items for our `renewal_date` field:
- `\{{ form.renewal_date }}:` The whole field.
- `\{{ form.renewal_date.errors }}`: The list of errors.
- `\{{ form.renewal_date.id_for_label }}`: The id of the label.
- `\{{ form.renewal_date.help_text }}`: The field help text.
For more examples of how to manually render forms in templates and dynamically loop over template fields, see [Working with forms > Rendering fields manually](https://docs.djangoproject.com/en/4.2/topics/forms/#rendering-fields-manually) (Django docs).
### Testing the page
If you accepted the "challenge" in [Django Tutorial Part 8: User authentication and permissions](/en-US/docs/Learn/Server-side/Django/Authentication#challenge_yourself) you'll have a view showing all books on loan in the library, which is only visible to library staff.
The view might look similar to this:
```django
{% extends "base_generic.html" %}
{% block content %}
<h1>All Borrowed Books</h1>
{% if bookinstance_list %}
<ul>
{% for bookinst in bookinstance_list %}
<li class="{% if bookinst.is_overdue %}text-danger{% endif %}">
<a href="{% url 'book-detail' bookinst.book.pk %}">\{{ bookinst.book.title }}</a> (\{{ bookinst.due_back }}) {% if user.is_staff %}- \{{ bookinst.borrower }}{% endif %}
</li>
{% endfor %}
</ul>
{% else %}
<p>There are no books borrowed.</p>
{% endif %}
{% endblock %}
```
We can add a link to the book renew page next to each item by appending the following template code to the list item text above.
Note that this template code can only run inside the `{% for %}` loop, because that is where the `bookinst` value is defined.
```django
{% if perms.catalog.can_mark_returned %}- <a href="{% url 'renew-book-librarian' bookinst.id %}">Renew</a>{% endif %}
```
> **Note:** Remember that your test login will need to have the permission "`catalog.can_mark_returned`" in order to see the new "Renew" link added above, and to access the linked page (perhaps use your superuser account).
You can alternatively manually construct a test URL like this — `http://127.0.0.1:8000/catalog/book/<bookinstance_id>/renew/` (a valid `bookinstance_id` can be obtained by navigating to a book detail page in your library, and copying the `id` field).
### What does it look like?
If you are successful, the default form will look like this:
The form with an invalid value entered will look like this:
The list of all books with renew links will look like this:
## ModelForms
Creating a `Form` class using the approach described above is very flexible, allowing you to create whatever sort of form page you like and associate it with any model or models.
However, if you just need a form to map the fields of a _single_ model then your model will already define most of the information that you need in your form: fields, labels, help text and so on. Rather than recreating the model definitions in your form, it is easier to use the [ModelForm](https://docs.djangoproject.com/en/4.2/topics/forms/modelforms/) helper class to create the form from your model. This `ModelForm` can then be used within your views in exactly the same way as an ordinary `Form`.
A basic `ModelForm` containing the same field as our original `RenewBookForm` is shown below. All you need to do to create the form is add `class Meta` with the associated `model` (`BookInstance`) and a list of the model `fields` to include in the form.
```python
from django.forms import ModelForm
from catalog.models import BookInstance
class RenewBookModelForm(ModelForm):
class Meta:
model = BookInstance
fields = ['due_back']
```
> **Note:** You can also include all fields in the form using `fields = '__all__'`, or you can use `exclude` (instead of `fields`) to specify the fields _not_ to include from the model).
>
> Neither approach is recommended because new fields added to the model are then automatically included in the form (without the developer necessarily considering possible security implications).
> **Note:** This might not look all that much simpler than just using a `Form` (and it isn't in this case, because we just have one field). However, if you have a lot of fields, it can reduce the amount of code quite significantly!
The rest of the information comes from the model field definitions (e.g. labels, widgets, help text, error messages). If these aren't quite right, then we can override them in our `class Meta`, specifying a dictionary containing the field to change and its new value. For example, in this form, we might want a label for our field of "_Renewal date_" (rather than the default based on the field name: _Due Back_), and we also want our help text to be specific to this use case.
The `Meta` below shows you how to override these fields, and you can similarly set `widgets` and `error_messages` if the defaults aren't sufficient.
```python
class Meta:
model = BookInstance
fields = ['due_back']
labels = {'due_back': _('New renewal date')}
help_texts = {'due_back': _('Enter a date between now and 4 weeks (default 3).')}
```
To add validation you can use the same approach as for a normal `Form` — you define a function named `clean_<field_name>()` and raise `ValidationError` exceptions for invalid values.
The only difference with respect to our original form is that the model field is named `due_back` and not "`renewal_date`".
This change is necessary since the corresponding field in `BookInstance` is called `due_back`.
```python
from django.forms import ModelForm
from catalog.models import BookInstance
class RenewBookModelForm(ModelForm):
def clean_due_back(self):
data = self.cleaned_data['due_back']
# Check if a date is not in the past.
if data < datetime.date.today():
raise ValidationError(_('Invalid date - renewal in past'))
# Check if a date is in the allowed range (+4 weeks from today).
if data > datetime.date.today() + datetime.timedelta(weeks=4):
raise ValidationError(_('Invalid date - renewal more than 4 weeks ahead'))
# Remember to always return the cleaned data.
return data
class Meta:
model = BookInstance
fields = ['due_back']
labels = {'due_back': _('Renewal date')}
help_texts = {'due_back': _('Enter a date between now and 4 weeks (default 3).')}
```
The class `RenewBookModelForm` above is now functionally equivalent to our original `RenewBookForm`. You could import and use it wherever you currently use `RenewBookForm` as long as you also update the corresponding form variable name from `renewal_date` to `due_back` as in the second form declaration: `RenewBookModelForm(initial={'due_back': proposed_renewal_date}`.
## Generic editing views
The form handling algorithm we used in our function view example above represents an extremely common pattern in form editing views. Django abstracts much of this "boilerplate" for you, by creating [generic editing views](https://docs.djangoproject.com/en/4.2/ref/class-based-views/generic-editing/) for creating, editing, and deleting views based on models. Not only do these handle the "view" behavior, but they automatically create the form class (a `ModelForm`) for you from the model.
> **Note:** In addition to the editing views described here, there is also a [FormView](https://docs.djangoproject.com/en/4.2/ref/class-based-views/generic-editing/#formview) class, which lies somewhere between our function view and the other generic views in terms of "flexibility" vs. "coding effort". Using `FormView`, you still need to create your `Form`, but you don't have to implement all of the standard form-handling patterns. Instead, you just have to provide an implementation of the function that will be called once the submission is known to be valid.
In this section, we're going to use generic editing views to create pages to add functionality to create, edit, and delete `Author` records from our library — effectively providing a basic reimplementation of parts of the Admin site (this could be useful if you need to offer admin functionality in a more flexible way than can be provided by the admin site).
### Views
Open the views file (**locallibrary/catalog/views.py**) and append the following code block to the bottom of it:
```python
from django.views.generic.edit import CreateView, UpdateView, DeleteView
from django.urls import reverse_lazy
from .models import Author
class AuthorCreate(PermissionRequiredMixin, CreateView):
model = Author
fields = ['first_name', 'last_name', 'date_of_birth', 'date_of_death']
initial = {'date_of_death': '11/11/2023'}
permission_required = 'catalog.add_author'
class AuthorUpdate(PermissionRequiredMixin, UpdateView):
model = Author
# Not recommended (potential security issue if more fields added)
fields = '__all__'
permission_required = 'catalog.change_author'
class AuthorDelete(PermissionRequiredMixin, DeleteView):
model = Author
success_url = reverse_lazy('authors')
permission_required = 'catalog.delete_author'
def form_valid(self, form):
try:
self.object.delete()
return HttpResponseRedirect(self.success_url)
except Exception as e:
return HttpResponseRedirect(
reverse("author-delete", kwargs={"pk": self.object.pk})
)
```
As you can see, to create, update, or delete the views you need to derive from `CreateView`, `UpdateView`, and `DeleteView` (respectively) and then define the associated model.
We also restrict calling these views to only logged in users with the `add_author`, `change_author`, and `delete_author` permissions, respectively.
For the "create" and "update" cases you also need to specify the fields to display in the form (using the same syntax as for `ModelForm`). In this case, we show how to list them individually and the syntax to list "all" fields. You can also specify initial values for each of the fields using a dictionary of _field_name_/_value_ pairs (here we arbitrarily set the date of death for demonstration purposes — you might want to remove that). By default, these views will redirect on success to a page displaying the newly created/edited model item, which in our case will be the author detail view we created in a previous tutorial. You can specify an alternative redirect location by explicitly declaring parameter `success_url`.
The `AuthorDelete` class doesn't need to display any of the fields, so these don't need to be specified.
We so set a `success_url` (as shown above), because there is no obvious default URL for Django to navigate to after successfully deleting the `Author`. Above we use the [`reverse_lazy()`](https://docs.djangoproject.com/en/4.2/ref/urlresolvers/#reverse-lazy) function to redirect to our author list after an author has been deleted — `reverse_lazy()` is a lazily executed version of `reverse()`, used here because we're providing a URL to a class-based view attribute.
If deletion of authors should always succeed that would be it.
Unfortunately deleting an `Author` will cause an exception if the author has an associated book, because our [`Book` model](/en-US/docs/Learn/Server-side/Django/Models#book_model) specifies `on_delete=models.RESTRICT` for the author `ForeignKey` field.
To handle this case the view overrides the [`form_valid()`](https://docs.djangoproject.com/en/4.2/ref/class-based-views/mixins-editing/#django.views.generic.edit.FormMixin.form_valid) method so that if deleting the `Author` succeeds it redirects to the `success_url`, but if not, it just redirects back to the same form.
We'll update the template below to make clear that you can't delete an `Author` instance that is used in any `Book`.
### URL configurations
Open your URL configuration file (**locallibrary/catalog/urls.py**) and add the following configuration to the bottom of the file:
```python
urlpatterns += [
path('author/create/', views.AuthorCreate.as_view(), name='author-create'),
path('author/<int:pk>/update/', views.AuthorUpdate.as_view(), name='author-update'),
path('author/<int:pk>/delete/', views.AuthorDelete.as_view(), name='author-delete'),
]
```
There is nothing particularly new here! You can see that the views are classes, and must hence be called via `.as_view()`, and you should be able to recognize the URL patterns in each case. We must use `pk` as the name for our captured primary key value, as this is the parameter name expected by the view classes.
### Templates
The "create" and "update" views use the same template by default, which will be named after your model: `model_name_form.html` (you can change the suffix to something other than **\_form** using the `template_name_suffix` field in your view, for example, `template_name_suffix = '_other_suffix'`)
Create the template file `locallibrary/catalog/templates/catalog/author_form.html` and copy the text below.
```django
{% extends "base_generic.html" %}
{% block content %}
<form action="" method="post">
{% csrf_token %}
<table>
\{{ form.as_table }}
</table>
<input type="submit" value="Submit" />
</form>
{% endblock %}
```
This is similar to our previous forms and renders the fields using a table. Note also how again we declare the `{% csrf_token %}` to ensure that our forms are resistant to CSRF attacks.
The "delete" view expects to find a template named with the format \_`model_name_confirm_delete.html` (again, you can change the suffix using `template_name_suffix` in your view).
Create the template file `locallibrary/catalog/templates/catalog/author_confirm_delete.html` and copy the text below.
```django
{% extends "base_generic.html" %}
{% block content %}
<h1>Delete Author: \{{ author }}</h1>
{% if author.book_set.all %}
<p>You can't delete this author until all their books have been deleted:</p>
<ul>
{% for book in author.book_set.all %}
<li><a href="{% url 'book-detail' book.pk %}">\{{book}}</a> (\{{book.bookinstance_set.all.count}})</li>
{% endfor %}
</ul>
{% else %}
<p>Are you sure you want to delete the author?</p>
<form action="" method="POST">
{% csrf_token %}
<input type="submit" action="" value="Yes, delete.">
</form>
{% endif %}
{% endblock %}
```
The template should be familiar.
It first checks if the author is used in any books, and if so displays the list of books that must be deleted before the author record can be deleted.
If not, it displays a form asking the user to confirm they want to delete the author record.
The final step is to hook the pages into the sidebar.
First we'll add a link for creating the author into the _base template_, so that it is visible in all pages for logged in users who are considered "staff" and who have permission to create authors (`catalog.add_author`).
Open **/locallibrary/catalog/templates/base_generic.html** and add the lines that allow users with the permission to create the author (in the same block as the link that shows "All Borrowed" books).
Remember to reference the URL using it's name `'author-create'` as shown below.
```django
{% if user.is_staff %}
<hr>
<ul class="sidebar-nav">
<li>Staff</li>
<li><a href="{% url 'all-borrowed' %}">All borrowed</a></li>
{% if perms.catalog.add_author %}
<li><a href="{% url 'author-create' %}">Create author</a></li>
{% endif %}
</ul>
{% endif %}
```
We'll add the links to update and delete authors to the author detail page.
Open **catalog/templates/catalog/author_detail.html** and append the following code:
```django
{% block sidebar %}
\{{ block.super }}
{% if perms.catalog.change_author or perms.catalog.delete_author %}
<hr>
<ul class="sidebar-nav">
{% if perms.catalog.change_author %}
<li><a href="{% url 'author-update' author.id %}">Update author</a></li>
{% endif %}
{% if not author.book_set.all and perms.catalog.delete_author %}
<li><a href="{% url 'author-delete' author.id %}">Delete author</a></li>
{% endif %}
</ul>
{% endif %}
{% endblock %}
```
This block overrides the `sidebar` block in the base template and then pulls in the original content using `\{{ block.super }}`.
It then appends links to update or delete the author, but when the user has the correct permissions and the author record isn't associated with any books.
The pages are now ready to test!
### Testing the page
First, log in to the site with an account that has author add, change and delete permissions.
Navigate to any page, and select "Create author" in the sidebar (with URL `http://127.0.0.1:8000/catalog/author/create/`).
The page should look like the screenshot below.
Enter values for the fields and then press **Submit** to save the author record.
You should now be taken to a detail view for your new author, with a URL of something like `http://127.0.0.1:8000/catalog/author/10`.
You can test editing the record by selecting the "Update author" link (with URL something like `http://127.0.0.1:8000/catalog/author/10/update/`) — we don't show a screenshot because it looks just like the "create" page!
Finally, we can delete the page by selecting "Delete author" from the sidebar on the detail page.
Django should display the delete page shown below if the author record isn't used in any books.
Press "**Yes, delete.**" to remove the record and be taken to the list of all authors.
## Challenge yourself
Create some forms to create, edit, and delete `Book` records. You can use exactly the same structure as for `Authors` (for the deletion, remember that you can't delete a `Book` until all its associated `BookInstance` records are deleted) and you must use the correct permissions.
If your **book_form.html** template is just a copy-renamed version of the **author_form.html** template, then the new "create book" page will look like the screenshot below:
## Summary
Creating and handling forms can be a complicated process! Django makes it much easier by providing programmatic mechanisms to declare, render, and validate forms. Furthermore, Django provides generic form editing views that can do _almost all_ the work to define pages that can create, edit, and delete records associated with a single model instance.
There is a lot more that can be done with forms (check out our [See also](#see_also) list below), but you should now understand how to add basic forms and form-handling code to your own websites.
## See also
- [Working with forms](https://docs.djangoproject.com/en/4.2/topics/forms/) (Django docs)
- [Writing your first Django app, part 4 > Writing a simple form](https://docs.djangoproject.com/en/4.2/intro/tutorial04/#write-a-simple-form) (Django docs)
- [The Forms API](https://docs.djangoproject.com/en/4.2/ref/forms/api/) (Django docs)
- [Form fields](https://docs.djangoproject.com/en/4.2/ref/forms/fields/) (Django docs)
- [Form and field validation](https://docs.djangoproject.com/en/4.2/ref/forms/validation/) (Django docs)
- [Form handling with class-based views](https://docs.djangoproject.com/en/4.2/topics/class-based-views/generic-editing/) (Django docs)
- [Creating forms from models](https://docs.djangoproject.com/en/4.2/topics/forms/modelforms/) (Django docs)
- [Generic editing views](https://docs.djangoproject.com/en/4.2/ref/class-based-views/generic-editing/) (Django docs)
{{PreviousMenuNext("Learn/Server-side/Django/authentication_and_sessions", "Learn/Server-side/Django/Testing", "Learn/Server-side/Django")}}
| 0 |
data/mdn-content/files/en-us/learn/server-side/django | data/mdn-content/files/en-us/learn/server-side/django/authentication/index.md | ---
title: "Django Tutorial Part 8: User authentication and permissions"
slug: Learn/Server-side/Django/Authentication
page-type: learn-module-chapter
---
{{LearnSidebar}}{{PreviousMenuNext("Learn/Server-side/Django/Sessions", "Learn/Server-side/Django/Forms", "Learn/Server-side/Django")}}
In this tutorial, we'll show you how to allow users to log in to your site with their own accounts, and how to control what they can do and see based on whether or not they are logged in and their _permissions_. As part of this demonstration, we'll extend the [LocalLibrary](/en-US/docs/Learn/Server-side/Django/Tutorial_local_library_website) website, adding login and logout pages, and user- and staff-specific pages for viewing books that have been borrowed.
<table>
<tbody>
<tr>
<th scope="row">Prerequisites:</th>
<td>
Complete all previous tutorial topics, up to and including <a href="/en-US/docs/Learn/Server-side/Django/Sessions">Django Tutorial Part 7: Sessions framework</a>.
</td>
</tr>
<tr>
<th scope="row">Objective:</th>
<td>
To understand how to set up and use user authentication and permissions.
</td>
</tr>
</tbody>
</table>
## Overview
Django provides an authentication and authorization ("permission") system, built on top of the session framework discussed in the [previous tutorial](/en-US/docs/Learn/Server-side/Django/Sessions), that allows you to verify user credentials and define what actions each user is allowed to perform. The framework includes built-in models for `Users` and `Groups` (a generic way of applying permissions to more than one user at a time), permissions/flags that designate whether a user may perform a task, forms and views for logging in users, and view tools for restricting content.
> **Note:** According to Django the authentication system aims to be very generic, and so does not provide some features provided in other web authentication systems. Solutions for some common problems are available as third-party packages. For example, throttling of login attempts and authentication against third parties (e.g. OAuth).
In this tutorial, we'll show you how to enable user authentication in the [LocalLibrary](/en-US/docs/Learn/Server-side/Django/Tutorial_local_library_website) website, create your own login and logout pages, add permissions to your models, and control access to pages. We'll use the authentication/permissions to display lists of books that have been borrowed for both users and librarians.
The authentication system is very flexible, and you can build up your URLs, forms, views, and templates from scratch if you like, just calling the provided API to log in the user. However, in this article, we're going to use Django's "stock" authentication views and forms for our login and logout pages. We'll still need to create some templates, but that's pretty easy.
We'll also show you how to create permissions, and check on login status and permissions in both views and templates.
## Enabling authentication
The authentication was enabled automatically when we [created the skeleton website](/en-US/docs/Learn/Server-side/Django/skeleton_website) (in tutorial 2) so you don't need to do anything more at this point.
> **Note:** The necessary configuration was all done for us when we created the app using the `django-admin startproject` command. The database tables for users and model permissions were created when we first called `python manage.py migrate`.
The configuration is set up in the `INSTALLED_APPS` and `MIDDLEWARE` sections of the project file (**locallibrary/locallibrary/settings.py**), as shown below:
```python
INSTALLED_APPS = [
# …
'django.contrib.auth', # Core authentication framework and its default models.
'django.contrib.contenttypes', # Django content type system (allows permissions to be associated with models).
# …
MIDDLEWARE = [
# …
'django.contrib.sessions.middleware.SessionMiddleware', # Manages sessions across requests
# …
'django.contrib.auth.middleware.AuthenticationMiddleware', # Associates users with requests using sessions.
# …
```
## Creating users and groups
You already created your first user when we looked at the [Django admin site](/en-US/docs/Learn/Server-side/Django/Admin_site) in tutorial 4 (this was a superuser, created with the command `python manage.py createsuperuser`).
Our superuser is already authenticated and has all permissions, so we'll need to create a test user to represent a normal site user. We'll be using the admin site to create our _locallibrary_ groups and website logins, as it is one of the quickest ways to do so.
> **Note:** You can also create users programmatically as shown below.
> You would have to do this, for example, if developing an interface to allow "ordinary" users to create their own logins (you shouldn't give most users access to the admin site).
>
> ```python
> from django.contrib.auth.models import User
>
> # Create user and save to the database
> user = User.objects.create_user('myusername', '[email protected]', 'mypassword')
>
> # Update fields and then save again
> user.first_name = 'Tyrone'
> user.last_name = 'Citizen'
> user.save()
> ```
>
> Note however that it is highly recommended to set up a _custom user model_ when starting a project, as you'll be able to easily customize it in the future if the need arises.
> If using a custom user model the code to create the same user would look like this:
>
> ```python
> # Get current user model from settings
> from django.contrib.auth import get_user_model
> User = get_user_model()
>
> # Create user from model and save to the database
> user = User.objects.create_user('myusername', '[email protected]', 'mypassword')
>
> # Update fields and then save again
> user.first_name = 'Tyrone'
> user.last_name = 'Citizen'
> user.save()
> ```
>
> For more information, see [Using a custom user model when starting a project](https://docs.djangoproject.com/en/4.2/topics/auth/customizing/#using-a-custom-user-model-when-starting-a-project) (Django docs).
Below we'll first create a group and then a user. Even though we don't have any permissions to add for our library members yet, if we need to later, it will be much easier to add them once to the group than individually to each member.
Start the development server and navigate to the admin site in your local web browser (`http://127.0.0.1:8000/admin/`). Login to the site using the credentials for your superuser account. The top level of the Admin site displays all of your models, sorted by "Django application". From the **Authentication and Authorization** section, you can click the **Users** or **Groups** links to see their existing records.
First lets create a new group for our library members.
1. Click the **Add** button (next to Group) to create a new _Group_; enter the **Name** "Library Members" for the group.
2. We don't need any permissions for the group, so just press **SAVE** (you will be taken to a list of groups).
Now let's create a user:
1. Navigate back to the home page of the admin site
2. Click the **Add** button next to _Users_ to open the _Add user_ dialog box.
3. Enter an appropriate **Username** and **Password**/**Password confirmation** for your test user
4. Press **SAVE** to create the user.
The admin site will create the new user and immediately take you to a _Change user_ screen where you can change your **username** and add information for the User model's optional fields. These fields include the first name, last name, email address, and the user's status and permissions (only the **Active** flag should be set). Further down you can specify the user's groups and permissions, and see important dates related to the user (e.g. their join date and last login date).
5. In the _Groups_ section, select **Library Member** group from the list of _Available groups_, and then press the **right-arrow** between the boxes to move it into the _Chosen groups_ box.
6. We don't need to do anything else here, so just select **SAVE** again, to go to the list of users.
That's it! Now you have a "normal library member" account that you will be able to use for testing (once we've implemented the pages to enable them to log in).
> **Note:** You should try creating another library member user. Also, create a group for Librarians, and add a user to that too!
## Setting up your authentication views
Django provides almost everything you need to create authentication pages to handle login, log out, and password management "out of the box". This includes a URL mapper, views and forms, but it does not include the templates — we have to create our own!
In this section, we show how to integrate the default system into the _LocalLibrary_ website and create the templates. We'll put them in the main project URLs.
> **Note:** You don't have to use any of this code, but it is likely that you'll want to because it makes things a lot easier.
> You'll almost certainly need to change the form handling code if you change your user model, but even so, you would still be able to use the stock view functions.
> **Note:** In this case, we could reasonably put the authentication pages, including the URLs and templates, inside our catalog application.
> However, if we had multiple applications it would be better to separate out this shared login behavior and have it available across the whole site, so that is what we've shown here!
### Project URLs
Add the following to the bottom of the project urls.py file (**locallibrary/locallibrary/urls.py**) file:
```python
# Add Django site authentication urls (for login, logout, password management)
urlpatterns += [
path('accounts/', include('django.contrib.auth.urls')),
]
```
Navigate to the `http://127.0.0.1:8000/accounts/` URL (note the trailing forward slash!).
Django will show an error that it could not find this URL, and list all the URLs it tried.
From this you can see the URLs that will work, for example:
> **Note:** Using the above method adds the following URLs with names in square brackets, which can be used to reverse the URL mappings. You don't have to implement anything else — the above URL mapping automatically maps the below mentioned URLs.
>
> ```python
> accounts/ login/ [name='login']
> accounts/ logout/ [name='logout']
> accounts/ password_change/ [name='password_change']
> accounts/ password_change/done/ [name='password_change_done']
> accounts/ password_reset/ [name='password_reset']
> accounts/ password_reset/done/ [name='password_reset_done']
> accounts/ reset/<uidb64>/<token>/ [name='password_reset_confirm']
> accounts/ reset/done/ [name='password_reset_complete']
> ```
Now try to navigate to the login URL (`http://127.0.0.1:8000/accounts/login/`). This will fail again, but with an error that tells you that we're missing the required template (**registration/login.html**) on the template search path.
You'll see the following lines listed in the yellow section at the top:
```python
Exception Type: TemplateDoesNotExist
Exception Value: registration/login.html
```
The next step is to create a registration directory on the search path and then add the **login.html** file.
### Template directory
The URLs (and implicitly, views) that we just added expect to find their associated templates in a directory **/registration/** somewhere in the templates search path.
For this site, we'll put our HTML pages in the **templates/registration/** directory. This directory should be in your project root directory, that is, the same directory as the **catalog** and **locallibrary** folders. Please create these folders now.
> **Note:** Your folder structure should now look like the below:
>
> ```plain
> locallibrary/ # Django project folder
> catalog/
> locallibrary/
> templates/
> registration/
> ```
To make the **templates** directory visible to the template loader we need to add it in the template search path.
Open the project settings (**/locallibrary/locallibrary/settings.py**).
Then import the `os` module (add the following line near the top of the file).
```python
import os # needed by code below
```
Update the `TEMPLATES` section's `'DIRS'` line as shown:
```python
# …
TEMPLATES = [
{
# …
'DIRS': [os.path.join(BASE_DIR, 'templates')],
'APP_DIRS': True,
# …
```
### Login template
> **Warning:** The authentication templates provided in this article are a very basic/slightly modified version of the Django demonstration login templates. You may need to customize them for your own use!
Create a new HTML file called /**locallibrary/templates/registration/login.html** and give it the following contents:
```django
{% extends "base_generic.html" %}
{% block content %}
{% if form.errors %}
<p>Your username and password didn't match. Please try again.</p>
{% endif %}
{% if next %}
{% if user.is_authenticated %}
<p>Your account doesn't have access to this page. To proceed,
please login with an account that has access.</p>
{% else %}
<p>Please login to see this page.</p>
{% endif %}
{% endif %}
<form method="post" action="{% url 'login' %}">
{% csrf_token %}
<table>
<tr>
<td>\{{ form.username.label_tag }}</td>
<td>\{{ form.username }}</td>
</tr>
<tr>
<td>\{{ form.password.label_tag }}</td>
<td>\{{ form.password }}</td>
</tr>
</table>
<input type="submit" value="login">
<input type="hidden" name="next" value="\{{ next }}">
</form>
{# Assumes you set up the password_reset view in your URLconf #}
<p><a href="{% url 'password_reset' %}">Lost password?</a></p>
{% endblock %}
```
This template shares some similarities with the ones we've seen before — it extends our base template and overrides the `content` block. The rest of the code is fairly standard form handling code, which we will discuss in a later tutorial. All you need to know for now is that this will display a form in which you can enter your username and password, and that if you enter invalid values you will be prompted to enter correct values when the page refreshes.
Navigate back to the login page (`http://127.0.0.1:8000/accounts/login/`) once you've saved your template, and you should see something like this:
If you log in using valid credentials, you'll be redirected to another page (by default this will be `http://127.0.0.1:8000/accounts/profile/`). The problem is that, by default, Django expects that upon logging in you will want to be taken to a profile page, which may or may not be the case. As you haven't defined this page yet, you'll get another error!
Open the project settings (**/locallibrary/locallibrary/settings.py**) and add the text below to the bottom. Now when you log in you should be redirected to the site homepage by default.
```python
# Redirect to home URL after login (Default redirects to /accounts/profile/)
LOGIN_REDIRECT_URL = '/'
```
### Logout template
If you navigate to the logout URL (`http://127.0.0.1:8000/accounts/logout/`) then you'll see some odd behavior — your user will be logged out sure enough, but you'll be taken to the **Admin** logout page. That's not what you want, if only because the login link on that page takes you to the Admin login screen (and that is only available to users who have the `is_staff` permission).
Create and open **/locallibrary/templates/registration/logged_out.html**. Copy in the text below:
```django
{% extends "base_generic.html" %}
{% block content %}
<p>Logged out!</p>
<a href="{% url 'login'%}">Click here to login again.</a>
{% endblock %}
```
This template is very simple. It just displays a message informing you that you have been logged out, and provides a link that you can press to go back to the login screen. If you go to the logout URL again you should see this page:
### Password reset templates
The default password reset system uses email to send the user a reset link. You need to create forms to get the user's email address, send the email, allow them to enter a new password, and to note when the whole process is complete.
The following templates can be used as a starting point.
#### Password reset form
This is the form used to get the user's email address (for sending the password reset email). Create **/locallibrary/templates/registration/password_reset_form.html**, and give it the following contents:
```django
{% extends "base_generic.html" %}
{% block content %}
<form action="" method="post">
{% csrf_token %}
{% if form.email.errors %}
\{{ form.email.errors }}
{% endif %}
<p>\{{ form.email }}</p>
<input type="submit" class="btn btn-default btn-lg" value="Reset password">
</form>
{% endblock %}
```
#### Password reset done
This form is displayed after your email address has been collected. Create **/locallibrary/templates/registration/password_reset_done.html**, and give it the following contents:
```django
{% extends "base_generic.html" %}
{% block content %}
<p>We've emailed you instructions for setting your password. If they haven't arrived in a few minutes, check your spam folder.</p>
{% endblock %}
```
#### Password reset email
This template provides the text of the HTML email containing the reset link that we will send to users. Create **/locallibrary/templates/registration/password_reset_email.html**, and give it the following contents:
```django
Someone asked for password reset for email \{{ email }}. Follow the link below:
\{{ protocol }}://\{{ domain }}{% url 'password_reset_confirm' uidb64=uid token=token %}
```
#### Password reset confirm
This page is where you enter your new password after clicking the link in the password reset email. Create **/locallibrary/templates/registration/password_reset_confirm.html**, and give it the following contents:
```django
{% extends "base_generic.html" %}
{% block content %}
{% if validlink %}
<p>Please enter (and confirm) your new password.</p>
<form action="" method="post">
{% csrf_token %}
<table>
<tr>
<td>\{{ form.new_password1.errors }}
<label for="id_new_password1">New password:</label></td>
<td>\{{ form.new_password1 }}</td>
</tr>
<tr>
<td>\{{ form.new_password2.errors }}
<label for="id_new_password2">Confirm password:</label></td>
<td>\{{ form.new_password2 }}</td>
</tr>
<tr>
<td></td>
<td><input type="submit" value="Change my password"></td>
</tr>
</table>
</form>
{% else %}
<h1>Password reset failed</h1>
<p>The password reset link was invalid, possibly because it has already been used. Please request a new password reset.</p>
{% endif %}
{% endblock %}
```
#### Password reset complete
This is the last password-reset template, which is displayed to notify you when the password reset has succeeded. Create **/locallibrary/templates/registration/password_reset_complete.html**, and give it the following contents:
```django
{% extends "base_generic.html" %}
{% block content %}
<h1>The password has been changed!</h1>
<p><a href="{% url 'login' %}">log in again?</a></p>
{% endblock %}
```
### Testing the new authentication pages
Now that you've added the URL configuration and created all these templates, the authentication pages should now just work!
You can test the new authentication pages by attempting to log in to and then log out of your superuser account using these URLs:
- `http://127.0.0.1:8000/accounts/login/`
- `http://127.0.0.1:8000/accounts/logout/`
You'll be able to test the password reset functionality from the link in the login page. **Be aware that Django will only send reset emails to addresses (users) that are already stored in its database!**
> **Note:** The password reset system requires that your website supports email, which is beyond the scope of this article, so this part **won't work yet**. To allow testing, put the following line at the end of your settings.py file. This logs any emails sent to the console (so you can copy the password reset link from the console).
>
> ```python
> EMAIL_BACKEND = 'django.core.mail.backends.console.EmailBackend'
> ```
>
> For more information, see [Sending email](https://docs.djangoproject.com/en/4.2/topics/email/) (Django docs).
## Testing against authenticated users
This section looks at what we can do to selectively control content the user sees based on whether they are logged in or not.
### Testing in templates
You can get information about the currently logged in user in templates with the `\{{ user }}` template variable (this is added to the template context by default when you set up the project as we did in our skeleton).
Typically you will first test against the `\{{ user.is_authenticated }}` template variable to determine whether the user is eligible to see specific content. To demonstrate this, next we'll update our sidebar to display a "Login" link if the user is logged out, and a "Logout" link if they are logged in.
Open the base template (**/locallibrary/catalog/templates/base_generic.html**) and copy the following text into the `sidebar` block, immediately before the `endblock` template tag.
```django
<ul class="sidebar-nav">
…
{% if user.is_authenticated %}
<li>User: \{{ user.get_username }}</li>
<li><a href="{% url 'logout' %}?next=\{{ request.path }}">Logout</a></li>
{% else %}
<li><a href="{% url 'login' %}?next=\{{ request.path }}">Login</a></li>
{% endif %}
</ul>
```
As you can see, we use `if` / `else` / `endif` template tags to conditionally display text based on whether `\{{ user.is_authenticated }}` is true. If the user is authenticated then we know that we have a valid user, so we call `\{{ user.get_username }}` to display their name.
We create the login and logout link URLs using the `url` template tag and the names of the respective URL configurations. Note also how we have appended `?next=\{{ request.path }}` to the end of the URLs. What this does is add a URL parameter `next` containing the address (URL) of the _current_ page, to the end of the linked URL. After the user has successfully logged in/out, the views will use this "`next`" value to redirect the user back to the page where they first clicked the login/logout link.
> **Note:** Try it out! If you're on the home page and you click Login/Logout in the sidebar, then after the operation completes you should end up back on the same page.
### Testing in views
If you're using function-based views, the easiest way to restrict access to your functions is to apply the `login_required` decorator to your view function, as shown below. If the user is logged in then your view code will execute as normal. If the user is not logged in, this will redirect to the login URL defined in the project settings (`settings.LOGIN_URL`), passing the current absolute path as the `next` URL parameter. If the user succeeds in logging in then they will be returned back to this page, but this time authenticated.
```python
from django.contrib.auth.decorators import login_required
@login_required
def my_view(request):
# …
```
> **Note:** You can do the same sort of thing manually by testing on `request.user.is_authenticated`, but the decorator is much more convenient!
Similarly, the easiest way to restrict access to logged-in users in your class-based views is to derive from `LoginRequiredMixin`. You need to declare this mixin first in the superclass list, before the main view class.
```python
from django.contrib.auth.mixins import LoginRequiredMixin
class MyView(LoginRequiredMixin, View):
# …
```
This has exactly the same redirect behavior as the `login_required` decorator. You can also specify an alternative location to redirect the user to if they are not authenticated (`login_url`), and a URL parameter name instead of "`next`" to insert the current absolute path (`redirect_field_name`).
```python
class MyView(LoginRequiredMixin, View):
login_url = '/login/'
redirect_field_name = 'redirect_to'
```
For additional detail, check out the [Django docs here](https://docs.djangoproject.com/en/4.2/topics/auth/default/#limiting-access-to-logged-in-users).
## Example — listing the current user's books
Now that we know how to restrict a page to a particular user, let's create a view of the books that the current user has borrowed.
Unfortunately, we don't yet have any way for users to borrow books! So before we can create the book list we'll first extend the `BookInstance` model to support the concept of borrowing and use the Django Admin application to loan a number of books to our test user.
### Models
First, we're going to have to make it possible for users to have a `BookInstance` on loan (we already have a `status` and a `due_back` date, but we don't yet have any association between this model and a particular user. We'll create one using a `ForeignKey` (one-to-many) field. We also need an easy mechanism to test whether a loaned book is overdue.
Open **catalog/models.py**, and import the `settings` from `django.conf` (add this just below the previous import line at the top of the file, so the settings are available to subsequent code that makes use of them):
```python
from django.conf import settings
```
Next, add the `borrower` field to the `BookInstance` model, setting the user model for the key as the value of the setting `AUTH_USER_MODEL`.
Since we have not overridden the setting with a [custom user model](https://docs.djangoproject.com/en/4.2/topics/auth/customizing/) this maps to the default `User` model from `django.contrib.auth.models`.
```python
borrower = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.SET_NULL, null=True, blank=True)
```
> **Note:** Importing the model in this way reduces the work required if you later discover that you need a custom user model.
> This tutorial uses the default model, so you could instead import the `User` model directly with the following lines:
>
> ```python
> from django.contrib.auth.models import User
> ```
>
> ```python
> borrower = models.ForeignKey(User, on_delete=models.SET_NULL, null=True, blank=True)
> ```
While we're here, let's add a property that we can call from our templates to tell if a particular book instance is overdue.
While we could calculate this in the template itself, using a [property](https://docs.python.org/3/library/functions.html#property) as shown below will be much more efficient.
Add this somewhere near the top of the file:
```python
from datetime import date
```
Now add the following property definition to the `BookInstance` class:
> **Note:** The following code uses Python's `bool()` function, which evaluates an object or the resulting object of an expression, and returns `True` unless the result is "falsy", in which case it returns `False`.
> In Python an object is _falsy_ (evaluates as `False`) if it is: empty (like `[]`, `()`, `{}`), `0`, `None` or if it is `False`.
```python
@property
def is_overdue(self):
"""Determines if the book is overdue based on due date and current date."""
return bool(self.due_back and date.today() > self.due_back)
```
> **Note:** We first verify whether `due_back` is empty before making a comparison. An empty `due_back` field would cause Django to throw an error instead of showing the page: empty values are not comparable. This is not something we would want our users to experience!
Now that we've updated our models, we'll need to make fresh migrations on the project and then apply those migrations:
```bash
python3 manage.py makemigrations
python3 manage.py migrate
```
### Admin
Now open **catalog/admin.py**, and add the `borrower` field to the `BookInstanceAdmin` class in both the `list_display` and the `fieldsets` as shown below.
This will make the field visible in the Admin section, allowing us to assign a `User` to a `BookInstance` when needed.
```python
@admin.register(BookInstance)
class BookInstanceAdmin(admin.ModelAdmin):
list_display = ('book', 'status', 'borrower', 'due_back', 'id')
list_filter = ('status', 'due_back')
fieldsets = (
(None, {
'fields': ('book', 'imprint', 'id')
}),
('Availability', {
'fields': ('status', 'due_back', 'borrower')
}),
)
```
### Loan a few books
Now that it's possible to loan books to a specific user, go and loan out a number of `BookInstance` records. Set their `borrowed` field to your test user, make the `status` "On loan", and set due dates both in the future and the past.
> **Note:** We won't spell the process out, as you already know how to use the Admin site!
### On loan view
Now we'll add a view for getting the list of all books that have been loaned to the current user. We'll use the same generic class-based list view we're familiar with, but this time we'll also import and derive from `LoginRequiredMixin`, so that only a logged in user can call this view. We will also choose to declare a `template_name`, rather than using the default, because we may end up having a few different lists of BookInstance records, with different views and templates.
Add the following to catalog/views.py:
```python
from django.contrib.auth.mixins import LoginRequiredMixin
class LoanedBooksByUserListView(LoginRequiredMixin,generic.ListView):
"""Generic class-based view listing books on loan to current user."""
model = BookInstance
template_name = 'catalog/bookinstance_list_borrowed_user.html'
paginate_by = 10
def get_queryset(self):
return (
BookInstance.objects.filter(borrower=self.request.user)
.filter(status__exact='o')
.order_by('due_back')
)
```
In order to restrict our query to just the `BookInstance` objects for the current user, we re-implement `get_queryset()` as shown above. Note that "o" is the stored code for "on loan" and we order by the `due_back` date so that the oldest items are displayed first.
### URL conf for on loan books
Now open **/catalog/urls.py** and add a `path()` pointing to the above view (you can just copy the text below to the end of the file).
```python
urlpatterns += [
path('mybooks/', views.LoanedBooksByUserListView.as_view(), name='my-borrowed'),
]
```
### Template for on-loan books
Now, all we need to do for this page is add a template. First, create the template file **/catalog/templates/catalog/bookinstance_list_borrowed_user.html** and give it the following contents:
```django
{% extends "base_generic.html" %}
{% block content %}
<h1>Borrowed books</h1>
{% if bookinstance_list %}
<ul>
{% for bookinst in bookinstance_list %}
<li class="{% if bookinst.is_overdue %}text-danger{% endif %}">
<a href="{% url 'book-detail' bookinst.book.pk %}">\{{ bookinst.book.title }}</a> (\{{ bookinst.due_back }})
</li>
{% endfor %}
</ul>
{% else %}
<p>There are no books borrowed.</p>
{% endif %}
{% endblock %}
```
This template is very similar to those we've created previously for the `Book` and `Author` objects.
The only "new" thing here is that we check the method we added in the model `(bookinst.is_overdue`) and use it to change the color of overdue items.
When the development server is running, you should now be able to view the list for a logged in user in your browser at `http://127.0.0.1:8000/catalog/mybooks/`. Try this out with your user logged in and logged out (in the second case, you should be redirected to the login page).
### Add the list to the sidebar
The very last step is to add a link for this new page into the sidebar. We'll put this in the same section where we display other information for the logged in user.
Open the base template (**/locallibrary/catalog/templates/base_generic.html**) and add the "My Borrowed" line to the sidebar in the position shown below.
```django
<ul class="sidebar-nav">
{% if user.is_authenticated %}
<li>User: \{{ user.get_username }}</li>
<li><a href="{% url 'my-borrowed' %}">My Borrowed</a></li>
<li><a href="{% url 'logout' %}?next=\{{ request.path }}">Logout</a></li>
{% else %}
<li><a href="{% url 'login' %}?next=\{{ request.path }}">Login</a></li>
{% endif %}
</ul>
```
### What does it look like?
When any user is logged in, they'll see the _My Borrowed_ link in the sidebar, and the list of books displayed as below (the first book has no due date, which is a bug we hope to fix in a later tutorial!).
## Permissions
Permissions are associated with models and define the operations that can be performed on a model instance by a user who has the permission. By default, Django automatically gives _add_, _change_, and _delete_ permissions to all models, which allow users with the permissions to perform the associated actions via the admin site. You can define your own permissions to models and grant them to specific users. You can also change the permissions associated with different instances of the same model.
Testing on permissions in views and templates is then very similar to testing on the authentication status (and in fact, testing for a permission also tests for authentication).
### Models
Defining permissions is done on the model "`class Meta`" section, using the `permissions` field.
You can specify as many permissions as you need in a tuple, each permission itself being defined in a nested tuple containing the permission name and permission display value.
For example, we might define a permission to allow a user to mark that a book has been returned as shown:
```python
class BookInstance(models.Model):
# …
class Meta:
# …
permissions = (("can_mark_returned", "Set book as returned"),)
```
We could then assign the permission to a "Librarian" group in the Admin site.
Open the **catalog/models.py**, and add the permission as shown above. You will need to re-run your migrations (call `python3 manage.py makemigrations` and `python3 manage.py migrate`) to update the database appropriately.
### Templates
The current user's permissions are stored in a template variable called `\{{ perms }}`. You can check whether the current user has a particular permission using the specific variable name within the associated Django "app" — e.g. `\{{ perms.catalog.can_mark_returned }}` will be `True` if the user has this permission, and `False` otherwise. We typically test for the permission using the template `{% if %}` tag as shown:
```django
{% if perms.catalog.can_mark_returned %}
<!-- We can mark a BookInstance as returned. -->
<!-- Perhaps add code to link to a "book return" view here. -->
{% endif %}
```
### Views
Permissions can be tested in function view using the `permission_required` decorator or in a class-based view using the `PermissionRequiredMixin`. The pattern are the same as for login authentication, though of course, you might reasonably have to add multiple permissions.
Function view decorator:
```python
from django.contrib.auth.decorators import permission_required
@permission_required('catalog.can_mark_returned')
@permission_required('catalog.can_edit')
def my_view(request):
# …
```
A permission-required mixin for class-based views.
```python
from django.contrib.auth.mixins import PermissionRequiredMixin
class MyView(PermissionRequiredMixin, View):
permission_required = 'catalog.can_mark_returned'
# Or multiple permissions
permission_required = ('catalog.can_mark_returned', 'catalog.change_book')
# Note that 'catalog.change_book' is permission
# Is created automatically for the book model, along with add_book, and delete_book
```
> **Note:** There is a small default difference in the behavior above. By **default** for a logged-in user with a permission violation:
>
> - `@permission_required` redirects to login screen (HTTP Status 302).
> - `PermissionRequiredMixin` returns 403 (HTTP Status Forbidden).
>
> Normally you will want the `PermissionRequiredMixin` behavior: return 403 if a user is logged in but does not have the correct permission. To do this for a function view use `@login_required` and `@permission_required` with `raise_exception=True` as shown:
>
> ```python
> from django.contrib.auth.decorators import login_required, permission_required
>
> @login_required
> @permission_required('catalog.can_mark_returned', raise_exception=True)
> def my_view(request):
> # …
> ```
### Example
We won't update the _LocalLibrary_ here; perhaps in the next tutorial!
## Challenge yourself
Earlier in this article, we showed you how to create a page for the current user, listing the books that they have borrowed.
The challenge now is to create a similar page that is only visible for librarians, that displays _all_ books that have been borrowed, and which includes the name of each borrower.
You should be able to follow the same pattern as for the other view. The main difference is that you'll need to restrict the view to only librarians. You could do this based on whether the user is a staff member (function decorator: `staff_member_required`, template variable: `user.is_staff`) but we recommend that you instead use the `can_mark_returned` permission and `PermissionRequiredMixin`, as described in the previous section.
> **Warning:** Remember not to use your superuser for permissions based testing (permission checks always return true for superusers, even if a permission has not yet been defined!). Instead, create a librarian user, and add the required capability.
When you are finished, your page should look something like the screenshot below.
## Summary
Excellent work — you've now created a website where library members can log in and view their own content, and where librarians (with the correct permission) can view all loaned books and their borrowers. At the moment we're still just viewing content, but the same principles and techniques are used when you want to start modifying and adding data.
In our next article, we'll look at how you can use Django forms to collect user input, and then start modifying some of our stored data.
## See also
- [User authentication in Django](https://docs.djangoproject.com/en/4.2/topics/auth/) (Django docs)
- [Using the (default) Django authentication system](https://docs.djangoproject.com/en/4.2/topics/auth/default/) (Django docs)
- [Introduction to class-based views > Decorating class-based views](https://docs.djangoproject.com/en/4.2/topics/class-based-views/intro/#decorating-class-based-views) (Django docs)
{{PreviousMenuNext("Learn/Server-side/Django/Sessions", "Learn/Server-side/Django/Forms", "Learn/Server-side/Django")}}
| 0 |
data/mdn-content/files/en-us/learn/server-side/django | data/mdn-content/files/en-us/learn/server-side/django/introduction/index.md | ---
title: Django introduction
slug: Learn/Server-side/Django/Introduction
page-type: learn-module-chapter
---
{{LearnSidebar}}{{NextMenu("Learn/Server-side/Django/development_environment", "Learn/Server-side/Django")}}
In this first Django article, we answer the question "What is Django?" and give you an overview of what makes this web framework special.
We'll outline the main features, including some of the advanced functionality that we won't have time to cover in detail in this module. We'll also show you some of the main building blocks of a Django application (although at this point you won't yet have a development environment in which to test it).
<table>
<tbody>
<tr>
<th scope="row">Prerequisites:</th>
<td>
A general understanding of <a href="/en-US/docs/Learn/Server-side/First_steps">server-side website programming</a>, and in particular the mechanics of <a href="/en-US/docs/Learn/Server-side/First_steps/Client-Server_overview">client-server interactions in websites</a>.
</td>
</tr>
<tr>
<th scope="row">Objective:</th>
<td>
To gain familiarity with what Django is, what functionality it provides, and the main building blocks of a Django application.
</td>
</tr>
</tbody>
</table>
## What is Django?
Django is a high-level Python web framework that enables rapid development of secure and maintainable websites. Built by experienced developers, Django takes care of much of the hassle of web development, so you can focus on writing your app without needing to reinvent the wheel. It is free and open source, has a thriving and active community, great documentation, and many options for free and paid-for support.
Django helps you write software that is:
- Complete
- : Django follows the "Batteries included" philosophy and provides almost everything developers might want to do "out of the box". Because everything you need is part of the one "product", it all works seamlessly together, follows consistent design principles, and has extensive and [up-to-date documentation](https://docs.djangoproject.com/en/stable/).
- Versatile
- : Django can be (and has been) used to build almost any type of website — from content management systems and wikis, through to social networks and news sites. It can work with any client-side framework, and can deliver content in almost any format (including HTML, RSS feeds, JSON, and XML).
Internally, while it provides choices for almost any functionality you might want (e.g. several popular databases, templating engines, etc.), it can also be extended to use other components if needed.
- Secure
- : Django helps developers avoid many common security mistakes by providing a framework that has been engineered to "do the right things" to protect the website automatically. For example, Django provides a secure way to manage user accounts and passwords, avoiding common mistakes like putting session information in cookies where it is vulnerable (instead cookies just contain a key, and the actual data is stored in the database) or directly storing passwords rather than a password hash.
_A password hash is a fixed-length value created by sending the password through a [cryptographic hash function](https://en.wikipedia.org/wiki/Cryptographic_hash_function). Django can check if an entered password is correct by running it through the hash function and comparing the output to the stored hash value. However due to the "one-way" nature of the function, even if a stored hash value is compromised it is hard for an attacker to work out the original password._
Django enables protection against many vulnerabilities by default, including SQL injection, cross-site scripting, cross-site request forgery and [clickjacking](/en-US/docs/Glossary/Clickjacking) (see [Website security](/en-US/docs/Learn/Server-side/First_steps/Website_security) for more details of such attacks).
- Scalable
- : Django uses a component-based "[shared-nothing](https://en.wikipedia.org/wiki/Shared_nothing_architecture)" architecture (each part of the architecture is independent of the others, and can hence be replaced or changed if needed). Having a clear separation between the different parts means that it can scale for increased traffic by adding hardware at any level: caching servers, database servers, or application servers. Some of the busiest sites have successfully scaled Django to meet their demands (e.g. Instagram and Disqus, to name just two).
- Maintainable
- : Django code is written using design principles and patterns that encourage the creation of maintainable and reusable code. In particular, it makes use of the Don't Repeat Yourself (DRY) principle so there is no unnecessary duplication, reducing the amount of code. Django also promotes the grouping of related functionality into reusable "applications" and, at a lower level, groups related code into modules (along the lines of the [Model View Controller (MVC)](/en-US/docs/Glossary/MVC) pattern).
- Portable
- : Django is written in Python, which runs on many platforms. That means that you are not tied to any particular server platform, and can run your applications on many flavors of Linux, Windows, and macOS. Furthermore, Django is well-supported by many web hosting providers, who often provide specific infrastructure and documentation for hosting Django sites.
## Where did it come from?
Django was initially developed between 2003 and 2005 by a web team who were responsible for creating and maintaining newspaper websites. After creating a number of sites, the team began to factor out and reuse lots of common code and design patterns. This common code evolved into a generic web development framework, which was open-sourced as the "Django" project in July 2005.
Django has continued to grow and improve, from its first milestone release (1.0) in September 2008 through to the version 4.0 in 2022. Each release has added new functionality and bug fixes, ranging from support for new types of databases, template engines, and caching, through to the addition of "generic" view functions and classes (which reduce the amount of code that developers have to write for a number of programming tasks).
> **Note:** Check out the [release notes](https://docs.djangoproject.com/en/stable/releases/) on the Django website to see what has changed in recent versions, and how much work is going into making Django better.
Django is now a thriving, collaborative open source project, with many thousands of users and contributors. While it does still have some features that reflect its origin, Django has evolved into a versatile framework that is capable of developing any type of website.
## How popular is Django?
There isn't any readily-available and definitive measurement of popularity of server-side frameworks (although you can estimate popularity using mechanisms like counting the number of GitHub projects and StackOverflow questions for each platform). A better question is whether Django is "popular enough" to avoid the problems of unpopular platforms. Is it continuing to evolve? Can you get help if you need it? Is there an opportunity for you to get paid work if you learn Django?
Based on the number of high profile sites that use Django, the number of people contributing to the codebase, and the number of people providing both free and paid for support, then yes, Django is a popular framework!
High-profile sites that use Django include: Disqus, Instagram, Knight Foundation, MacArthur Foundation, Mozilla, National Geographic, Open Knowledge Foundation, Pinterest, and Open Stack (source: [Django overview page](https://www.djangoproject.com/start/overview/)).
## Is Django opinionated?
Web frameworks often refer to themselves as "opinionated" or "unopinionated".
Opinionated frameworks are those with opinions about the "right way" to handle any particular task. They often support rapid development _in a particular domain_ (solving problems of a particular type) because the right way to do anything is usually well-understood and well-documented. However they can be less flexible at solving problems outside their main domain, and tend to offer fewer choices for what components and approaches they can use.
Unopinionated frameworks, by contrast, have far fewer restrictions on the best way to glue components together to achieve a goal, or even what components should be used. They make it easier for developers to use the most suitable tools to complete a particular task, albeit at the cost that you need to find those components yourself.
Django is "somewhat opinionated", and hence delivers the "best of both worlds". It provides a set of components to handle most web development tasks and one (or two) preferred ways to use them. However, Django's decoupled architecture means that you can usually pick and choose from a number of different options, or add support for completely new ones if desired.
## What does Django code look like?
In a traditional data-driven website, a web application waits for HTTP requests from the web browser (or other client). When a request is received the application works out what is needed based on the URL and possibly information in `POST` data or `GET` data. Depending on what is required it may then read or write information from a database or perform other tasks required to satisfy the request. The application will then return a response to the web browser, often dynamically creating an HTML page for the browser to display by inserting the retrieved data into placeholders in an HTML template.
Django web applications typically group the code that handles each of these steps into separate files:
- **URLs:** While it is possible to process requests from every single URL via a single function, it is much more maintainable to write a separate view function to handle each resource. A URL mapper is used to redirect HTTP requests to the appropriate view based on the request URL. The URL mapper can also match particular patterns of strings or digits that appear in a URL and pass these to a view function as data.
- **View:** A view is a request handler function, which receives HTTP requests and returns HTTP responses. Views access the data needed to satisfy requests via _models_, and delegate the formatting of the response to _templates_.
- **Models:** Models are Python objects that define the structure of an application's data, and provide mechanisms to manage (add, modify, delete) and query records in the database.
- **Templates:** A template is a text file defining the structure or layout of a file (such as an HTML page), with placeholders used to represent actual content. A _view_ can dynamically create an HTML page using an HTML template, populating it with data from a _model_. A template can be used to define the structure of any type of file; it doesn't have to be HTML!
> **Note:** Django refers to this organization as the "Model View Template (MVT)" architecture. It has many similarities to the more familiar [Model View Controller](/en-US/docs/Glossary/MVC) architecture.
The sections below will give you an idea of what these main parts of a Django app look like (we'll go into more detail later on in the course, once we've set up a development environment).
### Sending the request to the right view (urls.py)
A URL mapper is typically stored in a file named **urls.py**.
In the example below, the mapper (`urlpatterns`) defines a list of mappings between _routes_ (specific URL _patterns)_ and corresponding view functions.
If an HTTP Request is received that has a URL matching a specified pattern, then the associated view function will be called and passed the request.
```python
urlpatterns = [
path('admin/', admin.site.urls),
path('book/<int:id>/', views.book_detail, name='book_detail'),
path('catalog/', include('catalog.urls')),
re_path(r'^([0-9]+)/$', views.best),
]
```
The `urlpatterns` object is a list of `path()` and/or `re_path()` functions (Python lists are defined using square brackets, where items are separated by commas and may have an [optional trailing comma](https://docs.python.org/3/faq/design.html#why-does-python-allow-commas-at-the-end-of-lists-and-tuples). For example: `[item1, item2, item3,]`).
The first argument to both methods is a route (pattern) that will be matched. The `path()` method uses angle brackets to define parts of a URL that will be captured and passed through to the view function as named arguments. The `re_path()` function uses a flexible pattern matching approach known as a regular expression. We'll talk about these in a later article!
The second argument is another function that will be called when the pattern is matched. The notation `views.book_detail` indicates that the function is called `book_detail()` and can be found in a module called `views` (i.e. inside a file named `views.py`)
### Handling the request (views.py)
Views are the heart of the web application, receiving HTTP requests from web clients and returning HTTP responses. In between, they marshal the other resources of the framework to access databases, render templates, etc.
The example below shows a minimal view function `index()`, which could have been called by our URL mapper in the previous section. Like all view functions it receives an `HttpRequest` object as a parameter (`request`) and returns an `HttpResponse` object. In this case we don't do anything with the request, and our response returns a hard-coded string. We'll show you a request that does something more interesting in a later section.
```python
# filename: views.py (Django view functions)
from django.http import HttpResponse
def index(request):
# Get an HttpRequest - the request parameter
# perform operations using information from the request.
# Return HttpResponse
return HttpResponse('Hello from Django!')
```
> **Note:** A little bit of Python:
>
> - [Python modules](https://docs.python.org/3/tutorial/modules.html) are "libraries" of functions, stored in separate files, that we might want to use in our code. Here we import just the `HttpResponse` object from the `django.http` module so that we can use it in our view: `from django.http import HttpResponse`. There are other ways of importing some or all objects from a module.
> - Functions are declared using the `def` keyword as shown above, with named parameters listed in parentheses after the name of the function; the whole line ends in a colon. Note how the next lines are all **indented**. The indentation is important, as it specifies that the lines of code are inside that particular block (mandatory indentation is a key feature of Python, and is one reason that Python code is so easy to read).
Views are usually stored in a file called **views.py**.
### Defining data models (models.py)
Django web applications manage and query data through Python objects referred to as models. Models define the structure of stored data, including the field _types_ and possibly also their maximum size, default values, selection list options, help text for documentation, label text for forms, etc. The definition of the model is independent of the underlying database — you can choose one of several as part of your project settings. Once you've chosen what database you want to use, you don't need to talk to it directly at all — you just write your model structure and other code, and Django handles all the "dirty work" of communicating with the database for you.
The code snippet below shows a very simple Django model for a `Team` object. The `Team` class is derived from the Django class `models.Model`. It defines the team name and team level as character fields and specifies a maximum number of characters to be stored for each record. The `team_level` can be one of several values, so we define it as a choice field and provide a mapping between choices to be displayed and data to be stored, along with a default value.
```python
# filename: models.py
from django.db import models
class Team(models.Model):
team_name = models.CharField(max_length=40)
TEAM_LEVELS = (
('U09', 'Under 09s'),
('U10', 'Under 10s'),
('U11', 'Under 11s'),
# …
# list other team levels
)
team_level = models.CharField(max_length=3, choices=TEAM_LEVELS, default='U11')
```
> **Note:** A little bit of Python:
>
> Python supports "object-oriented programming", a style of programming where we organize our code into objects, which include related data and functions for operating on that data. Objects can also inherit/extend/derive from other objects, allowing common behavior between related objects to be shared. In Python we use the keyword `class` to define the "blueprint" for an object. We can create multiple specific _instances_ of the type of object based on the model in the class.
>
> So for example, here we have a `Team` class, which derives from the `Model` class. This means it is a model, and will contain all the methods of a model, but we can also give it specialized features of its own too. In our model we define the fields our database will need to store our data, giving them specific names. Django uses these definitions, including the field names, to create the underlying database.
### Querying data (views.py)
The Django model provides a simple query API for searching the associated database. This can match against a number of fields at a time using different criteria (e.g. exact, case-insensitive, greater than, etc.), and can support complex statements (for example, you can specify a search on U11 teams that have a team name that starts with "Fr" or ends with "al").
The code snippet shows a view function (resource handler) for displaying all of our U09 teams. The `list_teams = Team.objects.filter(team_level__exact="U09")` line shows how we can use the model query API to filter for all records where the `team_level` field has exactly the text '`U09`' (note how this criteria is passed to the `filter()` function as an argument, with the field name and match type separated by a double underscore: **`team_level__exact`**).
```python
## filename: views.py
from django.shortcuts import render
from .models import Team
def index(request):
list_teams = Team.objects.filter(team_level__exact="U09")
context = {'youngest_teams': list_teams}
return render(request, '/best/index.html', context)
```
This function uses the `render()` function to create the `HttpResponse` that is sent back to the browser. This function is a _shortcut_; it creates an HTML file by combining a specified HTML template and some data to insert in the template (provided in the variable named "`context`"). In the next section we show how the template has the data inserted in it to create the HTML.
### Rendering data (HTML templates)
Template systems allow you to specify the structure of an output document, using placeholders for data that will be filled in when a page is generated. Templates are often used to create HTML, but can also create other types of document. Django supports both its native templating system and another popular Python library called Jinja2 out of the box (it can also be made to support other systems if needed).
The code snippet shows what the HTML template called by the `render()` function in the previous section might look like. This template has been written under the assumption that it will have access to a list variable called `youngest_teams` when it is rendered (this is contained in the `context` variable inside the `render()` function above). Inside the HTML skeleton we have an expression that first checks if the `youngest_teams` variable exists, and then iterates it in a `for` loop. On each iteration the template displays each team's `team_name` value in an `{{htmlelement("li")}}` element.
```python
## filename: best/templates/best/index.html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Home page</title>
</head>
<body>
{% if youngest_teams %}
<ul>
{% for team in youngest_teams %}
<li>\{\{ team.team_name \}\}</li>
{% endfor %}
</ul>
{% else %}
<p>No teams are available.</p>
{% endif %}
</body>
</html>
```
## What else can you do?
The preceding sections show the main features that you'll use in almost every web application: URL mapping, views, models and templates. Just a few of the other things provided by Django include:
- **Forms**: HTML Forms are used to collect user data for processing on the server. Django simplifies form creation, validation, and processing.
- **User authentication and permissions**: Django includes a robust user authentication and permission system that has been built with security in mind.
- **Caching**: Creating content dynamically is much more computationally intensive (and slow) than serving static content. Django provides flexible caching so that you can store all or part of a rendered page so that it doesn't get re-rendered except when necessary.
- **Administration site**: The Django administration site is included by default when you create an app using the basic skeleton. It makes it trivially easy to provide an admin page for site administrators to create, edit, and view any data models in your site.
- **Serializing data**: Django makes it easy to serialize and serve your data as XML or JSON. This can be useful when creating a web service (a website that purely serves data to be consumed by other applications or sites, and doesn't display anything itself), or when creating a website in which the client-side code handles all the rendering of data.
## Summary
Congratulations, you've completed the first step in your Django journey! You should now understand Django's main benefits, a little about its history, and roughly what each of the main parts of a Django app might look like. You should have also learned a few things about the Python programming language, including the syntax for lists, functions, and classes.
You've already seen some real Django code above, but unlike with client-side code, you need to set up a development environment to run it. That's our next step.
{{NextMenu("Learn/Server-side/Django/development_environment", "Learn/Server-side/Django")}}
| 0 |
data/mdn-content/files/en-us/learn/server-side | data/mdn-content/files/en-us/learn/server-side/configuring_server_mime_types/index.md | ---
title: Properly configuring server MIME types
slug: Learn/Server-side/Configuring_server_MIME_types
page-type: guide
---
{{LearnSidebar}}
MIME types describe the media type of content, either in email, or served by web servers or web applications. They are intended to help provide a hint as to how the content should be processed and displayed.
Examples of MIME types:
- `text/html` for HTML documents.
- `text/plain` for plain text.
- `text/css` for Cascading Style Sheets.
- `text/javascript` for JavaScript files.
- `text/markdown` for Markdown files.
- `application/octet-stream` for binary files where user action is expected.
Server default configurations vary wildly and set different _default_ MIME-type values for files with no defined content type.
Versions of the Apache Web Server **before 2.2.7** were configured to report a MIME type of `text/plain` or `application/octet-stream` for unknown content types. Modern versions of Apache report `none` for files with unknown content types.
[Nginx](https://nginx.org/) will report `text/plain` if you don't define a default content type.
As new content types are invented or added to web servers, web administrators may fail to add the new MIME types to their web server's configuration. This is a major source of problems for users of browsers that respect the MIME types reported by web servers and applications.
## Why are correct MIME types important?
If a web server or application reports an incorrect MIME type for content (including a "default type" for unknown content), a web browser has no way of knowing the author's intentions. This may cause unexpected behavior.
Some web browsers may try to _guess_ the correct MIME type. This allows misconfigured web servers and applications to continue working for those browsers (but not other browsers that correctly implement the standard). Apart from violating the HTTP spec, this is a bad idea for a couple of other significant reasons:
- Loss of control
- : If the browser ignores the reported MIME type, web administrators and authors no longer have control over how their content is to be processed.
For example, a website oriented for web developers might wish to send certain example HTML documents as either `text/html` or `text/plain` in order to have the documents either processed and displayed as HTML or as source code. If the browser guesses the MIME type, this option is no longer available to the author.
- Security
- : Some content types, such as executable programs, are inherently unsafe. For this reason, these MIME types are usually restricted in terms of what actions a web browser will take when given that type of content. An executable program should not be executed on the user's computer and should at least cause a dialog to appear **asking the user** if they wish to download the file.
MIME type guessing has led to security exploits in Internet Explorer that were based upon a malicious author incorrectly reporting a MIME type of a dangerous file as a safe type. This bypassed the normal download dialog, resulting in Internet Explorer guessing that the content was an executable program and then running it on the user's computer.
## JavaScript legacy MIME types
When looking for information about JavaScript MIME types, you may see several MIME types that reference JavaScript. Some of these MIME types include:
- `application/javascript`
- `application/ecmascript`
- `application/x-ecmascript`
- `application/x-javascript`
- `text/ecmascript`
- `text/javascript1.0`
- `text/javascript1.1`
- `text/javascript1.2`
- `text/javascript1.3`
- `text/javascript1.4`
- `text/javascript1.5`
- `text/x-ecmascript`
- `text/x-javascript`
While browsers may support any, some, or all of these alternative MIME types, you should **only** use `text/javascript` to indicate the MIME type of JavaScript files.
> **Note:** See [MIME types (IANA media types)](/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types) for more information.
## How to determine the MIME type to set
There are several ways to determine the correct MIME type value to be used to serve your content.
- If your content was created using commercial software, read the vendor's documentation to see what MIME types should be reported for the application.
- Look in IANA's [MIME Media Types registry](https://www.iana.org/assignments/media-types/media-types.xhtml), which contains information on all registered MIME types.
- Search for the file extension in [FILExt](https://filext.com/) or the [File extensions reference](https://www.file-extensions.org/) to see what MIME types are associated with that extension. Pay close attention as the application may have multiple MIME types that differ by only one letter.
## How to check the MIME type of received content
- In Firefox
- Load the file and go to **Tools > Page Info** to get the content type for the page you accessed.
- You can also go to **Tools > Web Developer > Network** and reload the page. The request tab gives you a list of all the resources the page loaded. Clicking on any resource will list all the information available, including the page's [`Content-Type`](/en-US/docs/Web/HTTP/Headers/Content-Type) header.
- In Chrome
- Load the file and go to **View > Developer > Developer Tools** and choose the _Network_ tab. Reload the page and select the resource you want to inspect. Under headers look for `Content-Type` and it will report the content type of the resource.
- Look for a `<meta>` element in the page source that gives the MIME type, for example `<meta http-equiv="Content-Type" content="text/html">`.
- According to the standards, the `<meta>` element that specifies the MIME type should be ignored if there's a Content-Type header available.
[IANA](https://www.iana.org/) keeps a list of registered [MIME Media Types](https://www.iana.org/assignments/media-types/media-types.xhtml). The [HTTP specification](https://www.w3.org/Protocols/rfc2616/rfc2616.html) defines a superset of MIME types, which is used to describe the media types used on the web.
## How to set up your server to send the correct MIME types
The goal is to configure your server to send the correct {{HTTPHeader("Content-Type")}} header for each document.
- If you're using the Apache web server, check the **_Media Types and Character Encodings_** section of [Apache Configuration: .htaccess](/en-US/docs/Learn/Server-side/Apache_Configuration_htaccess) for examples of different document types and their corresponding MIME types.
- If you're using Nginx, note that Nginx does not have a `.htaccess` equivalent tool, so all changes will go into the main configuration file.
- If you're using a server-side script or framework to generate content, the way to indicate the content type will depend on the tool you're using. Check the framework or library's documentation.
Regardless of what server system you use, the effect you need to achieve is to set a response header with the name {{httpheader("Content-Type")}}, followed by a colon and space, followed by a MIME type. High-level environments often allow such headers to be set when generating the page. For example, in a PHP environment, you could set the response header for PDF resources like this:
```php
header('Content-Type: application/pdf')
```
Trying to instead set it with just `header('application/pdf')` won't work.
## Related Links
- [IANA | MIME Media Types](https://www.iana.org/assignments/media-types/media-types.xhtml)
- [Hypertext Transfer Protocol — HTTP/1.1](https://www.w3.org/Protocols/rfc2616/rfc2616.html)
- [MIME types (IANA media types)](/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types)
- [Apache vs Nginx: Practical Considerations](https://www.digitalocean.com/community/tutorials/apache-vs-nginx-practical-considerations)
- [Migrate Apache .htaccess to Nginx server block](https://barryvanveen.nl/articles/56-migrate-apache-htaccess-to-nginx-server-block)
| 0 |
data/mdn-content/files/en-us/learn/server-side | data/mdn-content/files/en-us/learn/server-side/first_steps/index.md | ---
title: Server-side website programming first steps
slug: Learn/Server-side/First_steps
page-type: learn-module
---
{{LearnSidebar}}
In this module, we answer a few fundamental questions about server-side programming such as "What is it?", "How does it differ from client-side programming?", and "Why is it so useful?". We also provide an overview of some of the most popular server-side web frameworks, along with guidance on how to select the most suitable framework for creating your first project. Finally, we provide a high-level introductory article about web server security.
## Prerequisites
Before starting this module, you don't need to have any knowledge of server-side website programming or any other type of programming.
However, you should understand something about the workings of websites and web servers. For that purpose, this is our recommended reading:
- [What is a web server?](/en-US/docs/Learn/Common_questions/Web_mechanics/What_is_a_web_server)
- [What software do I need to build a website?](/en-US/docs/Learn/Common_questions/Tools_and_setup/What_software_do_I_need)
- [How do you upload files to a web server?](/en-US/docs/Learn/Common_questions/Tools_and_setup/Upload_files_to_a_web_server)
With the basic understanding that you gain from this preparation, you'll be ready to work your way through the modules in this section.
## Guides
- [Introduction to the server-side](/en-US/docs/Learn/Server-side/First_steps/Introduction)
- : Welcome to the MDN beginner's server-side programming course! The first article examines server-side programming from a high level, answering questions such as "What is it?", "How does it differ from client-side programming?", and "Why it is so useful?". After reading this, you will understand the additional capabilities available to websites through server-side coding.
- [Client-Server overview](/en-US/docs/Learn/Server-side/First_steps/Client-Server_overview)
- : Now that you know the purpose and potential benefits of server-side programming, we're going to examine what happens when a server receives a "dynamic request" from a browser. As most websites' server-side code handles requests and responses in a similar way, this will help you understand what you need to do when writing your own code.
- [Server-side web frameworks](/en-US/docs/Learn/Server-side/First_steps/Web_frameworks)
- : The previous article explained what a server-side web application needs to do to respond to web browser requests. This article explains how web frameworks can simplify these tasks, and helps you choose the right framework for your first server-side web application.
- [Website security](/en-US/docs/Learn/Server-side/First_steps/Website_security)
- : Website security requires vigilance in all aspects of building and operating a site. This introductory article helps you understand the first important steps you can take to protect your web application against the most common threats.
> **Note:** This topic deals with server-side frameworks, and how to use them to create websites. If you are looking for information on client-side JavaScript frameworks, see [Understanding client-side JavaScript frameworks](/en-US/docs/Learn/Tools_and_testing/Client-side_JavaScript_frameworks).
## Assessments
This "first steps" module doesn't have any assessment because we haven't yet shown you any code. At this point, you should have a general understanding of the functionality you can deliver with server-side programming, and you have made a decision about what server-side web framework you will use to create your first server-side application.
| 0 |
data/mdn-content/files/en-us/learn/server-side/first_steps | data/mdn-content/files/en-us/learn/server-side/first_steps/web_frameworks/index.md | ---
title: Server-side web frameworks
slug: Learn/Server-side/First_steps/Web_frameworks
page-type: learn-module-chapter
---
{{LearnSidebar}}{{PreviousMenuNext("Learn/Server-side/First_steps/Client-Server_overview", "Learn/Server-side/First_steps/Website_security", "Learn/Server-side/First_steps")}}
The previous article showed you what the communication between web clients and servers looks like, the nature of HTTP requests and responses, and what a server-side web application needs to do in order to respond to requests from a web browser. With this knowledge under our belt, it's time to explore how web frameworks can simplify these tasks, and give you an idea of how you'd choose a framework for your first server-side web application.
<table>
<tbody>
<tr>
<th scope="row">Prerequisites:</th>
<td>
Basic understanding of how server-side code
handles and responds to HTTP requests (see <a
href="/en-US/docs/Learn/Server-side/First_steps/Client-Server_overview"
>Client-Server overview</a
>).
</td>
</tr>
<tr>
<th scope="row">Objective:</th>
<td>
To understand how web frameworks can simplify development/maintenance of
server-side code and to get readers thinking about selecting a framework
for their own development.
</td>
</tr>
</tbody>
</table>
The following sections illustrate some points using code fragments taken from real web frameworks. Don't be concerned if it doesn't **all** make sense now; we'll be working you through the code in our framework-specific modules.
## Overview
Server-side web frameworks (a.k.a. "web application frameworks") are software frameworks that make it easier to write, maintain and scale web applications. They provide tools and libraries that simplify common web development tasks, including routing URLs to appropriate handlers, interacting with databases, supporting sessions and user authorization, formatting output (e.g. HTML, JSON, XML), and improving security against web attacks.
The next section provides a bit more detail about how web frameworks can ease web application development. We then explain some of the criteria you can use for choosing a web framework, and then list some of your options.
## What can a web framework do for you?
Web frameworks provide tools and libraries to simplify common web development operations. You don't _have_ to use a server-side web framework, but it is strongly advised — it will make your life a lot easier.
This section discusses some of the functionality that is often provided by web frameworks (not every framework will necessarily provide all of these features!).
### Work directly with HTTP requests and responses
As we saw in the last article, web servers and browsers communicate via the HTTP protocol — servers wait for HTTP requests from the browser and then return information in HTTP responses. Web frameworks allow you to write simplified syntax that will generate server-side code to work with these requests and responses. This means that you will have an easier job, interacting with easier, higher-level code rather than lower level networking primitives.
The example below shows how this works in the Django (Python) web framework. Every "view" function (a request handler) receives an `HttpRequest` object containing request information, and is required to return an `HttpResponse` object with the formatted output (in this case a string).
```python
# Django view function
from django.http import HttpResponse
def index(request):
# Get an HttpRequest (request)
# perform operations using information from the request.
# Return HttpResponse
return HttpResponse('Output string to return')
```
### Route requests to the appropriate handler
Most sites will provide a number of different resources, accessible through distinct URLs. Handling these all in one function would be hard to maintain, so web frameworks provide simple mechanisms to map URL patterns to specific handler functions. This approach also has benefits in terms of maintenance, because you can change the URL used to deliver a particular feature without having to change the underlying code.
Different frameworks use different mechanisms for the mapping. For example, the Flask (Python) web framework adds routes to view functions using a decorator.
```python
@app.route("/")
def hello():
return "Hello World!"
```
While Django expects developers to define a list of URL mappings between a URL pattern and a view function.
```python
urlpatterns = [
url(r'^$', views.index),
# example: /best/myteamname/5/
url(r'^best/(?P<team_name>\w.+?)/(?P<team_number>[0-9]+)/$', views.best),
]
```
### Make it easy to access data in the request
Data can be encoded in an HTTP request in a number of ways. An HTTP `GET` request to get files or data from the server may encode what data is required in URL parameters or within the URL structure. An HTTP `POST` request to update a resource on the server will instead include the update information as "POST data" within the body of the request. The HTTP request may also include information about the current session or user in a client-side cookie.
Web frameworks provide programming-language-appropriate mechanisms to access this information. For example, the `HttpRequest` object that Django passes to every view function contains methods and properties for accessing the target URL, the type of request (e.g. an HTTP `GET`), `GET` or `POST` parameters, cookie and session data, etc. Django can also pass information encoded in the structure of the URL by defining "capture patterns" in the URL mapper (see the last code fragment in the section above).
### Abstract and simplify database access
Websites use databases to store information both to be shared with users, and about users. Web frameworks often provide a database layer that abstracts database read, write, query, and delete operations. This abstraction layer is referred to as an Object-Relational Mapper (ORM).
Using an ORM has two benefits:
- You can replace the underlying database without necessarily needing to change the code that uses it. This allows developers to optimize for the characteristics of different databases based on their usage.
- Basic validation of data can be implemented within the framework. This makes it easier and safer to check that data is stored in the correct type of database field, has the correct format (e.g. an email address), and isn't malicious in any way (hackers can use certain patterns of code to do bad things such as deleting database records).
For example, the Django web framework provides an ORM, and refers to the object used to define the structure of a record as the _model_. The model specifies the field _types_ to be stored, which may provide field-level validation on what information can be stored (e.g. an email field would only allow valid email addresses). The field definitions may also specify their maximum size, default values, selection list options, help text for documentation, label text for forms etc. The model doesn't state any information about the underlying database as that is a configuration setting that may be changed separately of our code.
The first code snippet below shows a very simple Django model for a `Team` object. This stores the team name and team level as character fields and specifies a maximum number of characters to be stored for each record. The `team_level` is a choice field, so we also provide a mapping between choices to be displayed and data to be stored, along with a default value.
```python
#best/models.py
from django.db import models
class Team(models.Model):
team_name = models.CharField(max_length=40)
TEAM_LEVELS = (
('U09', 'Under 09s'),
('U10', 'Under 10s'),
('U11', 'Under 11s'),
# List our other teams
)
team_level = models.CharField(max_length=3,choices=TEAM_LEVELS,default='U11')
```
The Django model provides a simple query API for searching the database. This can match against a number of fields at a time using different criteria (e.g. exact, case-insensitive, greater than, etc.), and can support complex statements (for example, you can specify a search on U11 teams that have a team name that starts with "Fr" or ends with "al").
The second code snippet shows a view function (resource handler) for displaying all of our U09 teams. In this case we specify that we want to filter for all records where the `team_level` field has exactly the text 'U09' (note below how this criteria is passed to the `filter()` function as an argument with field name and match type separated by double underscores: **team_level\_\_exact**).
```python
#best/views.py
from django.shortcuts import render
from .models import Team
def youngest(request):
list_teams = Team.objects.filter(team_level__exact="U09")
context = {'youngest_teams': list_teams}
return render(request, 'best/index.html', context)
```
### Rendering data
Web frameworks often provide templating systems. These allow you to specify the structure of an output document, using placeholders for data that will be added when a page is generated. Templates are often used to create HTML, but can also create other types of documents.
Web frameworks often provide a mechanism to make it easy to generate other formats from stored data, including {{glossary("JSON")}} and {{glossary("XML")}}.
For example, the Django template system allows you to specify variables using a "double-handlebars" syntax (e.g. `\{{ variable_name }}`), which will be replaced by values passed in from the view function when a page is rendered. The template system also provides support for expressions (with syntax: `{% expression %}`), which allow templates to perform simple operations like iterating list values passed into the template.
> **Note:** Many other templating systems use a similar syntax, e.g.: Jinja2 (Python), handlebars (JavaScript), moustache (JavaScript), etc.
The code snippet below shows how this works. Continuing the "youngest team" example from the previous section, the HTML template is passed a list variable called `youngest_teams` by the view. Inside the HTML skeleton we have an expression that first checks if the `youngest_teams` variable exists, and then iterates it in a `for` loop. On each iteration the template displays the team's `team_name` value in a list item.
```django
#best/templates/best/index.html
<!DOCTYPE html>
<html lang="en">
<body>
{% if youngest_teams %}
<ul>
{% for team in youngest_teams %}
<li>\{\{ team.team_name \}\}</li>
{% endfor %}
</ul>
{% else %}
<p>No teams are available.</p>
{% endif %}
</body>
</html>
```
## How to select a web framework
Numerous web frameworks exist for almost every programming language you might want to use (we list a few of the more popular frameworks in the following section). With so many choices, it can become difficult to work out what framework provides the best starting point for your new web application.
Some of the factors that may affect your decision are:
- **Effort to learn:** The effort to learn a web framework depends on how familiar you are with the underlying programming language, the consistency of its API, the quality of its documentation, and the size and activity of its community. If you're starting from absolutely no programming experience then consider Django (it is one of the easiest to learn based on the above criteria). If you are part of a development team that already has significant experience with a particular web framework or programming language, then it makes sense to stick with that.
- **Productivity:** Productivity is a measure of how quickly you can create new features once you are familiar with the framework, and includes both the effort to write and maintain code (since you can't write new features while old ones are broken). Many of the factors affecting productivity are similar to those for "Effort to learn" — e.g. documentation, community, programming experience, etc. — other factors include:
- _Framework purpose/origin_: Some web frameworks were initially created to solve certain types of problems, and remain _better_ at creating web apps with similar constraints. For example, Django was created to support development of a newspaper website, so it's good for blogs and other sites that involve publishing things. By contrast, Flask is a much lighter-weight framework and is great for creating web apps running on embedded devices.
- _Opinionated vs. unopinionated_: An opinionated framework is one in which there are recommended "best" ways to solve a particular problem. Opinionated frameworks tend to be more productive when you're trying to solve common problems, because they lead you in the right direction, however they are sometimes less flexible.
- _Batteries included vs. get it yourself_: Some web frameworks include tools/libraries that address every problem their developers can think "by default", while more lightweight frameworks expect web developers to pick and choose solution to problems from separate libraries (Django is an example of the former, while Flask is an example of a very light-weight framework). Frameworks that include everything are often easier to get started with because you already have everything you need, and the chances are that it is well integrated and well documented. However if a smaller framework has everything you (will ever) need then it can run in more constrained environments and will have a smaller and easier subset of things to learn.
- _Whether or not the framework encourages good development practices_: For example, a framework that encourages a [Model-View-Controller](/en-US/docs/Glossary/MVC) architecture to separate code into logical functions will result in more maintainable code than one that has no expectations on developers. Similarly, framework design can have a large impact on how easy it is to test and re-use code.
- **Performance of the framework/programming language:** Usually "speed" is not the biggest factor in selection because even relatively slow runtimes like Python are more than "good enough" for mid-sized sites running on moderate hardware. The perceived speed benefits of another language, e.g. C++ or JavaScript, may well be offset by the costs of learning and maintenance.
- **Caching support:** As your website becomes more successful then you may find that it can no longer cope with the number of requests it is receiving as users access it. At this point you may consider adding support for caching. Caching is an optimization where you store all or part of a web response so that it does not have to be recalculated on subsequent requests. Returning a cached response is much faster than calculating one in the first place. Caching can be implemented in your code or in the server (see [reverse proxy](https://en.wikipedia.org/wiki/Reverse_proxy)). Web frameworks will have different levels of support for defining what content can be cached.
- **Scalability:** Once your website is fantastically successful you will exhaust the benefits of caching and even reach the limits of _vertical scaling_ (running your web application on more powerful hardware). At this point you may need to _scale horizontally_ (share the load by distributing your site across a number of web servers and databases) or scale "geographically" because some of your customers are based a long way away from your server. The web framework you choose can make a big difference on how easy it is to scale your site.
- **Web security:** Some web frameworks provide better support for handling common web attacks. Django for example sanitizes all user input from HTML templates so that user-entered JavaScript cannot be run. Other frameworks provide similar protection, but it is not always enabled by default.
There are many other possible factors, including licensing, whether or not the framework is under active development, etc.
If you're an absolute beginner at programming then you'll probably choose your framework based on "ease of learning". In addition to "ease of use" of the language itself, high quality documentation/tutorials and an active community helping new users are your most valuable resources. We've chosen [Django](https://www.djangoproject.com/) (Python) and [Express](https://expressjs.com/) (Node/JavaScript) to write our examples later on in the course, mainly because they are easy to learn and have good support.
> **Note:** Let's go to the main websites for [Django](https://www.djangoproject.com/) (Python) and [Express](https://expressjs.com/) (Node/JavaScript) and check out their documentation and community.
>
> 1. Navigate to the main sites (linked above)
>
> - Click on the Documentation menu links (named things like "Documentation, Guide, API Reference, Getting Started", etc.).
> - Can you see topics showing how to set up URL routing, templates, and databases/models?
> - Are the documents clear?
>
> 2. Navigate to mailing lists for each site (accessible from Community links).
>
> - How many questions have been posted in the last few days
> - How many have responses?
> - Do they have an active community?
## A few good web frameworks?
Let's now move on, and discuss a few specific server-side web frameworks.
The server-side frameworks below represent _a few_ of the most popular available at the time of writing. All of them have everything you need to be productive — they are open source, are under active development, have enthusiastic communities creating documentation and helping users on discussion boards, and are used in large numbers of high-profile websites. There are many other great server-side frameworks that you can discover using a basic internet search.
> **Note:** Descriptions come (partially) from the framework websites!
### Django (Python)
[Django](https://www.djangoproject.com/) is a high-level Python Web framework that encourages rapid development and clean, pragmatic design. Built by experienced developers, it takes care of much of the hassle of web development, so you can focus on writing your app without needing to reinvent the wheel. It's free and open source.
Django follows the "Batteries included" philosophy and provides almost everything most developers might want to do "out of the box". Because everything is included, it all works together, follows consistent design principles, and has extensive and up-to-date documentation. It is also fast, secure, and very scalable. Being based on Python, Django code is easy to read and to maintain.
Popular sites using Django (from Django home page) include: Disqus, Instagram, Knight Foundation, MacArthur Foundation, Mozilla, National Geographic, Open Knowledge Foundation, Pinterest, Open Stack.
### Flask (Python)
[Flask](https://flask.palletsprojects.com) is a microframework for Python.
While minimalist, Flask can create serious websites out of the box. It contains a development server and debugger, and includes support for [Jinja2](https://github.com/pallets/jinja) templating, secure cookies, [unit testing](https://en.wikipedia.org/wiki/Unit_testing), and [RESTful](https://www.restapitutorial.com/lessons/restfulresourcenaming.html) request dispatching. It has good documentation and an active community.
Flask has become extremely popular, particularly for developers who need to provide web services on small, resource-constrained systems (e.g. running a web server on a [Raspberry Pi](https://www.raspberrypi.org/), [Drone controllers](https://www.techuseful.com/drone-definitions-learning-the-drone-lingo/), etc.)
### Express (Node.js/JavaScript)
[Express](https://expressjs.com/) is a fast, unopinionated, flexible and minimalist web framework for [Node.js](https://nodejs.org/en/) (node is a browserless environment for running JavaScript). It provides a robust set of features for web and mobile applications and delivers useful HTTP utility methods and [middleware](/en-US/docs/Glossary/Middleware).
Express is extremely popular, partially because it eases the migration of client-side JavaScript web programmers into server-side development, and partially because it is resource-efficient (the underlying node environment uses lightweight multitasking within a thread rather than spawning separate processes for every new web request).
Because Express is a minimalist web framework it does not incorporate every component that you might want to use (for example, database access and support for users and sessions are provided through independent libraries). There are many excellent independent components, but sometimes it can be hard to work out which is the best for a particular purpose!
Many popular server-side and full stack frameworks (comprising both server and client-side frameworks) are based on Express, including [Feathers](https://feathersjs.com/), [ItemsAPI](https://itemsapi.com/), [KeystoneJS](https://keystonejs.com/), [Kraken](https://krakenjs.com/), [LoopBack](https://loopback.io/), [MEAN](https://github.com/linnovate/mean), and [Sails](https://sailsjs.com/).
A lot of high profile companies use Express, including: Uber, Accenture, IBM, etc. (a list is provided [here](https://expressjs.com/en/resources/companies-using-express.html)).
### Deno (JavaScript)
[Deno](https://deno.land/) is a simple, modern, and secure [JavaScript](/en-US/docs/Web/JavaScript)/TypeScript runtime and framework built on top of Chrome V8 and [Rust](https://www.rust-lang.org/).
Deno is powered by [Tokio](https://tokio.rs/) — a Rust-based asynchronous runtime which lets it serve web pages faster. It also has internal support for [WebAssembly](/en-US/docs/WebAssembly), which enables the compilation of binary code for use on the client-side. Deno aims to fill in some of the loop-holes in [Node.js](/en-US/docs/Learn/Server-side/Node_server_without_framework) by providing a mechanism that naturally maintains better security.
Deno's features include:
- Security by default. [Deno modules restrict permissions](https://lyty.dev/deno/deno-permission.html) to **file**, **network**, or **environment** access unless explicitly allowed.
- TypeScript support **out-of-the-box**.
- First-class await mechanism.
- Built-in testing facility and code formatter (`deno fmt`)
- (JavaScript) Browser compatibility: Deno programs that are written completely in JavaScript excluding the `Deno` namespace (or feature test for it), should work directly in any modern browser.
- Script bundling into a single JavaScript file.
Deno provides an easy yet powerful way to use JavaScript for both client- and server-side programming.
### Ruby on Rails (Ruby)
[Rails](https://rubyonrails.org/) (usually referred to as "Ruby on Rails") is a web framework written for the Ruby programming language.
Rails follows a very similar design philosophy to Django. Like Django it provides standard mechanisms for routing URLs, accessing data from a database, generating HTML from templates and formatting data as {{glossary("JSON")}} or {{glossary("XML")}}. It similarly encourages the use of design patterns like DRY ("don't repeat yourself" — write code only once if at all possible), MVC (model-view-controller) and a number of others.
There are of course many differences due to specific design decisions and the nature of the languages.
Rails has been used for high profile sites, including: [Basecamp](https://basecamp.com/), [GitHub](https://github.com/), [Shopify](https://www.shopify.com/), [Airbnb](https://www.airbnb.com/), [Twitch](https://www.twitch.tv/), [SoundCloud](https://soundcloud.com/), [Hulu](https://www.hulu.com/welcome), [Zendesk](https://www.zendesk.com/), [Square](https://square.com/), [Highrise](https://highrisehq.com/).
### Laravel (PHP)
[Laravel](https://laravel.com/) is a web application framework with expressive, elegant syntax. Laravel attempts to take the pain out of development by easing common tasks used in the majority of web projects, such as:
- [Simple, fast routing engine](https://laravel.com/docs/routing).
- [Powerful dependency injection container](https://laravel.com/docs/container).
- Multiple back-ends for [session](https://laravel.com/docs/session) and [cache](https://laravel.com/docs/cache) storage.
- Expressive, intuitive [database ORM](https://laravel.com/docs/eloquent).
- Database agnostic [schema migrations](https://laravel.com/docs/migrations).
- [Robust background job processing](https://laravel.com/docs/queues).
- [Real-time event broadcasting](https://laravel.com/docs/broadcasting).
Laravel is accessible, yet powerful, providing tools needed for large, robust applications.
### ASP.NET
[ASP.NET](https://dotnet.microsoft.com/en-us/apps/aspnet) is an open source web framework developed by Microsoft for building modern web applications and services. With ASP.NET you can quickly create websites based on HTML, CSS, and JavaScript, scale them for use by millions of users and easily add more complex capabilities like Web APIs, forms over data, or real time communications.
One of the differentiators for ASP.NET is that it is built on the [Common Language Runtime](https://en.wikipedia.org/wiki/Common_Language_Runtime) (CLR), allowing programmers to write ASP.NET code using any supported .NET language (C#, Visual Basic, etc.). Like many Microsoft products it benefits from excellent tools (often free), an active developer community, and well-written documentation.
ASP.NET is used by Microsoft, Xbox.com, Stack Overflow, and many others.
### Mojolicious (Perl)
[Mojolicious](https://mojolicious.org/) is a next-generation web framework for the Perl programming language.
Back in the early days of the web, many people learned Perl because of a wonderful Perl library called [CGI](https://metacpan.org/pod/CGI). It was simple enough to get started without knowing much about the language and powerful enough to keep you going. Mojolicious implements this idea using bleeding edge technologies.
Some of the features provided by Mojolicious are:
- A real-time web framework, to easily grow single-file prototypes into well-structured MVC web applications.
- RESTful routes, plugins, commands, Perl-ish templates, content negotiation, session management, form validation, testing framework, static file server, CGI/[PSGI](https://plackperl.org) detection, and first-class Unicode support.
- A full-stack HTTP and WebSocket client/server implementation with IPv6, TLS, SNI, IDNA, HTTP/SOCKS5 proxy, UNIX domain socket, Comet (long polling), keep-alive, connection pooling, timeout, cookie, multipart, and gzip compression support.
- JSON and HTML/XML parsers and generators with CSS selector support.
- Very clean, portable and object-oriented pure-Perl API with no hidden magic.
- Fresh code based upon years of experience, free and open-source.
### Spring Boot (Java)
[Spring Boot](https://spring.io/projects/spring-boot) is one of a number of projects provided by [Spring](https://spring.io/). It is a good starting point for doing server-side web development using [Java](https://www.java.com).
Although definitely not the only framework based on [Java](https://www.java.com) it is easy to use to create stand-alone, production-grade Spring-based Applications that you can "just run". It is an opinionated view of the Spring platform and third-party libraries but allows to start with minimum fuss and configuration.
It can be used for small problems but its strength is building larger scale applications that use a cloud approach. Usually multiple applications run in parallel talking to each other, with some providing user interaction and others doing back end work (e.g. accessing databases or other services). Load balancers help to ensure redundancy and reliability or allow geolocated handling of user requests to ensure responsiveness.
## Summary
This article has shown that web frameworks can make it easier to develop and maintain server-side code. It has also provided a high level overview of a few popular frameworks, and discussed criteria for choosing a web application framework. You should now have at least an idea of how to choose a web framework for your own server-side development. If not, then don't worry — later on in the course we'll give you detailed tutorials on Django and Express to give you some experience of actually working with a web framework.
For the next article in this module we'll change direction slightly and consider web security.
{{PreviousMenuNext("Learn/Server-side/First_steps/Client-Server_overview", "Learn/Server-side/First_steps/Website_security", "Learn/Server-side/First_steps")}}
| 0 |
data/mdn-content/files/en-us/learn/server-side/first_steps | data/mdn-content/files/en-us/learn/server-side/first_steps/website_security/index.md | ---
title: Website security
slug: Learn/Server-side/First_steps/Website_security
page-type: learn-module-chapter
---
{{LearnSidebar}}{{PreviousMenu("Learn/Server-side/First_steps/Web_frameworks", "Learn/Server-side/First_steps")}}
Website security requires vigilance in all aspects of website design and usage. This introductory article won't make you a website security guru, but it will help you understand where threats come from, and what you can do to harden your web application against the most common attacks.
<table>
<tbody>
<tr>
<th scope="row">Prerequisites:</th>
<td>Basic computer literacy.</td>
</tr>
<tr>
<th scope="row">Objective:</th>
<td>
To understand the most common threats to web application security and
what you can do to reduce the risk of your site being hacked.
</td>
</tr>
</tbody>
</table>
## What is website security?
The Internet is a dangerous place! With great regularity, we hear about websites becoming unavailable due to denial of service attacks, or displaying modified (and often damaging) information on their homepages. In other high-profile cases, millions of passwords, email addresses, and credit card details have been leaked into the public domain, exposing website users to both personal embarrassment and financial risk.
The purpose of website security is to prevent these (or any) sorts of attacks. The more formal definition of website security _is the act/practice of protecting websites from unauthorized access, use, modification, destruction, or disruption_.
Effective website security requires design effort across the whole of the website: in your web application, the configuration of the web server, your policies for creating and renewing passwords, and the client-side code. While all that sounds very ominous, the good news is that if you're using a server-side web framework, it will almost certainly enable "by default" robust and well-thought-out defense mechanisms against a number of the more common attacks. Other attacks can be mitigated through your web server configuration, for example by enabling HTTPS. Finally, there are publicly available vulnerability scanner tools that can help you find out if you've made any obvious mistakes.
The rest of this article gives you more details about a few common threats and some of the simple steps you can take to protect your site.
> **Note:** This is an introductory topic, designed to help you start thinking about website security, but it is not exhaustive.
## Website security threats
This section lists just a few of the most common website threats and how they are mitigated. As you read, note how threats are most successful when the web application either trusts, or is _not paranoid enough_ about the data coming from the browser.
### Cross-Site Scripting (XSS)
XSS is a term used to describe a class of attacks that allow an attacker to inject client-side scripts _through_ the website into the browsers of other users. Because the injected code comes to the browser from the site, the code is _trusted_ and can do things like send the user's site authorization cookie to the attacker. When the attacker has the cookie, they can log into a site as though they were the user and do anything the user can, such as access their credit card details, see contact details, or change passwords.
> **Note:** XSS vulnerabilities have been historically more common than any other type of security threat.
The XSS vulnerabilities are divided into _reflected_ and _persistent_, based on how the site returns the injected scripts to a browser.
- A _reflected_ XSS vulnerability occurs when user content that is passed to the server is returned _immediately_ and _unmodified_ for display in the browser. Any scripts in the original user content will be run when the new page is loaded.
For example, consider a site search function where the search terms are encoded as URL parameters, and these terms are displayed along with the results. An attacker can construct a search link that contains a malicious script as a parameter (e.g., `http://developer.mozilla.org?q=beer<script%20src="http://example.com/tricky.js"></script>`) and email it to another user. If the target user clicks this "interesting link", the script will be executed when the search results are displayed. As discussed earlier, this gives the attacker all the information they need to enter the site as the target user, potentially making purchases as the user or sharing their contact information.
- A _persistent_ XSS vulnerability occurs when the malicious script is _stored_ on the website and then later redisplayed unmodified for other users to execute unwittingly.
For example, a discussion board that accepts comments that contain unmodified HTML could store a malicious script from an attacker. When the comments are displayed, the script is executed and can send to the attacker the information required to access the user's account. This sort of attack is extremely popular and powerful, because the attacker might not even have any direct engagement with the victims.
While the data from `POST` or `GET` requests is the most common source of XSS vulnerabilities, any data from the browser is potentially vulnerable, such as cookie data rendered by the browser, or user files that are uploaded and displayed.
The best defense against XSS vulnerabilities is to remove or disable any markup that can potentially contain instructions to run the code. For HTML this includes elements, such as `<script>`, `<object>`, `<embed>`, and `<link>`.
The process of modifying user data so that it can't be used to run scripts or otherwise affect the execution of server code is known as input sanitization. Many web frameworks automatically sanitize user input from HTML forms by default.
### SQL injection
SQL injection vulnerabilities enable malicious users to execute arbitrary SQL code on a database, allowing data to be accessed, modified, or deleted irrespective of the user's permissions. A successful injection attack might spoof identities, create new identities with administration rights, access all data on the server, or destroy/modify the data to make it unusable.
SQL injection types include Error-based SQL injection, SQL injection based on boolean errors, and Time-based SQL injection.
This vulnerability is present if user input that is passed to an underlying SQL statement can change the meaning of the statement. For example, the following code is intended to list all users with a particular name (`userName`) that has been supplied from an HTML form:
```sql
statement = "SELECT * FROM users WHERE name = '" + userName + "';"
```
If the user specifies a real name, the statement will work as intended. However, a malicious user could completely change the behavior of this SQL statement to the new statement in the following example, by specifying `a';DROP TABLE users; SELECT * FROM userinfo WHERE 't' = 't` for the `userName`.
```sql
SELECT * FROM users WHERE name = 'a';DROP TABLE users; SELECT * FROM userinfo WHERE 't' = 't';
```
The modified statement creates a valid SQL statement that deletes the `users` table and selects all data from the `userinfo` table (which reveals the information of every user). This works because the first part of the injected text (`a';`) completes the original statement.
To avoid this sort of attack, you must ensure that any user data that is passed to an SQL query cannot change the nature of the query. One way to do this is to [escape](https://en.wikipedia.org/wiki/Escape_character) all the characters in the user input that have a special meaning in SQL.
> **Note:** The SQL statement treats the **'** character as the beginning and end of a string literal. By putting a backslash in front of this character (**\\'**), we escape the symbol, and tell SQL to instead treat it as a character (just a part of the string).
In the following statement, we escape the **'** character. The SQL will now interpret the name as the whole string in bold (which is a very odd name indeed, but not harmful).
```sql
SELECT * FROM users WHERE name = 'a\';DROP TABLE users; SELECT * FROM userinfo WHERE \'t\' = \'t';
```
Web frameworks will often take care of the character escaping for you. Django, for example, ensures that any user-data passed to querysets (model queries) is escaped.
> **Note:** This section draws heavily on the information in [Wikipedia here](https://en.wikipedia.org/wiki/SQL_injection).
### Cross-Site Request Forgery (CSRF)
CSRF attacks allow a malicious user to execute actions using the credentials of another user without that user's knowledge or consent.
This type of attack is best explained by example. Josh is a malicious user who knows that a particular site allows logged-in users to send money to a specified account using an HTTP `POST` request that includes the account name and an amount of money. Josh constructs a form that includes his bank details and an amount of money as hidden fields, and emails it to other site users (with the _Submit_ button disguised as a link to a "get rich quick" site).
If a user clicks the submit button, an HTTP `POST` request will be sent to the server containing the transaction details and any client-side cookies that the browser associated with the site (adding associated site cookies to requests is normal browser behavior). The server will check the cookies, and use them to determine whether or not the user is logged in and has permission to make the transaction.
The result is that any user who clicks the _Submit_ button while they are logged in to the trading site will make the transaction. Josh gets rich.
> **Note:** The trick here is that Josh doesn't need to have access to the user's cookies (or access credentials). The browser of the user stores this information and automatically includes it in all requests to the associated server.
One way to prevent this type of attack is for the server to require that `POST` requests include a user-specific site-generated secret. The secret would be supplied by the server when sending the web form used to make transfers. This approach prevents Josh from creating his own form, because he would have to know the secret that the server is providing for the user. Even if he found out the secret and created a form for a particular user, he would no longer be able to use that same form to attack every user.
Web frameworks often include such CSRF prevention mechanisms.
### Other threats
Other common attacks/vulnerabilities include:
- [Clickjacking](/en-US/docs/Glossary/Clickjacking). In this attack, a malicious user hijacks clicks meant for a visible top-level site and routes them to a hidden page beneath. This technique might be used, for example, to display a legitimate bank site but capture the login credentials into an invisible {{htmlelement("iframe")}} controlled by the attacker. Clickjacking could also be used to get the user to click a button on a visible site, but in doing so actually unwittingly click a completely different button. As a defense, your site can prevent itself from being embedded in an iframe in another site by setting the appropriate HTTP headers.
- [Denial of Service](/en-US/docs/Glossary/Distributed_Denial_of_Service) (DoS). DoS is usually achieved by flooding a target site with fake requests so that access to a site is disrupted for legitimate users. The requests may be numerous, or they may individually consume large amounts of resource (e.g., slow reads or uploading of large files). DoS defenses usually work by identifying and blocking "bad" traffic while allowing legitimate messages through. These defenses are typically located before or in the web server (they are not part of the web application itself).
- [Directory Traversal](https://en.wikipedia.org/wiki/Directory_traversal_attack) (File and disclosure). In this attack, a malicious user attempts to access parts of the web server file system that they should not be able to access. This vulnerability occurs when the user is able to pass filenames that include file system navigation characters (for example, `../../`). The solution is to sanitize input before using it.
- [File Inclusion](https://en.wikipedia.org/wiki/File_inclusion_vulnerability). In this attack, a user is able to specify an "unintended" file for display or execution in data passed to the server. When loaded, this file might be executed on the web server or the client-side (leading to an XSS attack). The solution is to sanitize input before using it.
- [Command Injection](https://owasp.org/www-community/attacks/Command_Injection). Command injection attacks allow a malicious user to execute arbitrary system commands on the host operating system. The solution is to sanitize user input before it might be used in system calls.
For a comprehensive listing of website security threats see [Category: Web security exploits](https://en.wikipedia.org/wiki/Category:Web_security_exploits) (Wikipedia) and [Category: Attack](https://owasp.org/www-community/attacks/) (Open Web Application Security Project).
## A few key messages
Almost all of the security exploits in the previous sections are successful when the web application trusts data from the browser. Whatever else you do to improve the security of your website, you should sanitize all user-originating data before it is displayed in the browser, used in SQL queries, or passed to an operating system or file system call.
> **Warning:** The single most important lesson you can learn about website security is to **never trust data from the browser**. This includes, but is not limited to data in URL parameters of `GET` requests, `POST` requests, HTTP headers and cookies, and user-uploaded files. Always check and sanitize all incoming data. Always assume the worst.
A number of other concrete steps you can take are:
- Use more effective password management. Encourage strong passwords. Consider two-factor authentication for your site, so that in addition to a password the user must enter another authentication code (usually one that is delivered via some physical hardware that only the user will have, such as a code in an SMS sent to their phone).
- Configure your web server to use [HTTPS](/en-US/docs/Glossary/HTTPS) and [HTTP Strict Transport Security](/en-US/docs/Web/HTTP/Headers/Strict-Transport-Security) (HSTS). HTTPS encrypts data sent between your client and server. This ensures that login credentials, cookies, `POST` requests data and header information are not easily available to attackers.
- Keep track of the most popular threats (the [current OWASP list is here](https://owasp.org/www-project-top-ten/)) and address the most common vulnerabilities first.
- Use [vulnerability scanning tools](https://owasp.org/www-community/Vulnerability_Scanning_Tools) to perform automated security testing on your site. Later on, your very successful website may also find bugs by offering a bug bounty [like Mozilla does here](https://www.mozilla.org/en-US/security/bug-bounty/faq-webapp/).
- Only store and display data that you need. For example, if your users must store sensitive information like credit card details, only display enough of the card number that it can be identified by the user, and not enough that it can be copied by an attacker and used on another site. The most common pattern at this time is to only display the last 4 digits of a credit card number.
Web frameworks can help mitigate many of the more common vulnerabilities.
## Summary
This article has explained the concept of web security and some of the more common threats against which your website should attempt to protect. Most importantly, you should understand that a web application cannot trust any data from the web browser. All user data should be sanitized before it is displayed, or used in SQL queries and file system calls.
With this article, you've come to the end of [this module](/en-US/docs/Learn/Server-side/First_steps), covering your first steps in server-side website programming. We hope you've enjoyed learning these fundamental concepts, and you're now ready to select a Web Framework and start programming.
{{PreviousMenu("Learn/Server-side/First_steps/Web_frameworks", "Learn/Server-side/First_steps")}}
| 0 |
data/mdn-content/files/en-us/learn/server-side/first_steps | data/mdn-content/files/en-us/learn/server-side/first_steps/client-server_overview/index.md | ---
title: Client-Server Overview
slug: Learn/Server-side/First_steps/Client-Server_overview
page-type: learn-module-chapter
---
{{LearnSidebar}}{{PreviousMenuNext("Learn/Server-side/First_steps/Introduction", "Learn/Server-side/First_steps/Web_frameworks", "Learn/Server-side/First_steps")}}
Now that you know the purpose and potential benefits of server-side programming, we're going to examine in detail what happens when a server receives a "dynamic request" from a browser. As most website server-side code handles requests and responses in similar ways, this will help you understand what you need to do when writing most of your own code.
<table>
<tbody>
<tr>
<th scope="row">Prerequisites:</th>
<td>
A basic understanding of what a web server is.
</td>
</tr>
<tr>
<th scope="row">Objective:</th>
<td>
To understand client-server interactions in a dynamic website, and in
particular what operations need to be performed by server-side code.
</td>
</tr>
</tbody>
</table>
There is no real code in the discussion because we haven't yet chosen a web framework to use to write our code! This discussion is however still very relevant, because the described behavior must be implemented by your server-side code, irrespective of which programming language or web framework you select.
## Web servers and HTTP (a primer)
Web browsers communicate with [web servers](/en-US/docs/Learn/Common_questions/Web_mechanics/What_is_a_web_server) using the **H**yper**T**ext **T**ransfer **P**rotocol ([HTTP](/en-US/docs/Web/HTTP)). When you click a link on a web page, submit a form, or run a search, the browser sends an _HTTP Request_ to the server.
This request includes:
- A URL identifying the target server and resource (e.g. an HTML file, a particular data point on the server, or a tool to run).
- A method that defines the required action (for example, to get a file or to save or update some data). The different methods/verbs and their associated actions are listed below:
- `GET`: Get a specific resource (e.g. an HTML file containing information about a product, or a list of products).
- `POST`: Create a new resource (e.g. add a new article to a wiki, add a new contact to a database).
- `HEAD`: Get the metadata information about a specific resource without getting the body like `GET` would. You might for example use a `HEAD` request to find out the last time a resource was updated, and then only use the (more "expensive") `GET` request to download the resource if it has changed.
- `PUT`: Update an existing resource (or create a new one if it doesn't exist).
- `DELETE`: Delete the specified resource.
- `TRACE`, `OPTIONS`, `CONNECT`, `PATCH`: These verbs are for less common/advanced tasks, so we won't cover them here.
- Additional information can be encoded with the request (for example, HTML form data). Information can be encoded as:
- URL parameters: `GET` requests encode data in the URL sent to the server by adding name/value pairs onto the end of it — for example `http://example.com?name=Fred&age=11`. You always have a question mark (`?`) separating the rest of the URL from the URL parameters, an equals sign (`=`) separating each name from its associated value, and an ampersand (`&`) separating each pair. URL parameters are inherently "insecure" as they can be changed by users and then resubmitted. As a result URL parameters/`GET` requests are not used for requests that update data on the server.
- `POST` data. `POST` requests add new resources, the data for which is encoded within the request body.
- Client-side cookies. Cookies contain session data about the client, including keys that the server can use to determine their login status and permissions/accesses to resources.
Web servers wait for client request messages, process them when they arrive, and reply to the web browser with an HTTP Response message. The response contains an [HTTP Response status code](/en-US/docs/Web/HTTP/Status) indicating whether or not the request succeeded (e.g. "`200 OK`" for success, "`404 Not Found`" if the resource cannot be found, "`403 Forbidden`" if the user isn't authorized to see the resource, etc.). The body of a successful response to a `GET` request would contain the requested resource.
When an HTML page is returned it is rendered by the web browser. As part of processing, the browser may discover links to other resources (e.g. an HTML page usually references JavaScript and CSS files), and will send separate HTTP Requests to download these files.
Both static and dynamic websites (discussed in the following sections) use exactly the same communication protocol/patterns.
### GET request/response example
You can make a simple `GET` request by clicking on a link or searching on a site (like a search engine homepage). For example, the HTTP request that is sent when you perform a search on MDN for the term "client-server overview" will look a lot like the text shown below (it will not be identical because parts of the message depend on your browser/setup).
> **Note:** The format of HTTP messages is defined in a "web standard" ([RFC9110](https://httpwg.org/specs/rfc9110.html#messages)). You don't need to know this level of detail, but at least now you know where this all came from!
#### The request
Each line of the request contains information about it. The first part is called the **header**, and contains useful information about the request, in the same way that an [HTML head](/en-US/docs/Learn/HTML/Introduction_to_HTML/The_head_metadata_in_HTML) contains useful information about an HTML document (but not the actual content itself, which is in the body):
```http
GET /en-US/search?q=client+server+overview&topic=apps&topic=html&topic=css&topic=js&topic=api&topic=webdev HTTP/1.1
Host: developer.mozilla.org
Connection: keep-alive
Pragma: no-cache
Cache-Control: no-cache
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/52.0.2743.116 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8
Referer: https://developer.mozilla.org/en-US/
Accept-Encoding: gzip, deflate, sdch, br
Accept-Charset: ISO-8859-1,UTF-8;q=0.7,*;q=0.7
Accept-Language: en-US,en;q=0.8,es;q=0.6
Cookie: sessionid=6ynxs23n521lu21b1t136rhbv7ezngie; csrftoken=zIPUJsAZv6pcgCBJSCj1zU6pQZbfMUAT; dwf_section_edit=False; dwf_sg_task_completion=False; _gat=1; _ga=GA1.2.1688886003.1471911953; ffo=true
```
The first and second lines contain most of the information we talked about above:
- The type of request (`GET`).
- The target resource URL (`/en-US/search`).
- The URL parameters (`q=client%2Bserver%2Boverview&topic=apps&topic=html&topic=css&topic=js&topic=api&topic=webdev`).
- The target/host website (developer.mozilla.org).
- The end of the first line also includes a short string identifying the specific protocol version (`HTTP/1.1`).
The final line contains information about the client-side cookies — you can see in this case the cookie includes an id for managing sessions (`Cookie: sessionid=6ynxs23n521lu21b1t136rhbv7ezngie; …`).
The remaining lines contain information about the browser used and the sort of responses it can handle.
For example, you can see here that:
- My browser (`User-Agent`) is Mozilla Firefox (`Mozilla/5.0`).
- It can accept gzip compressed information (`Accept-Encoding: gzip`).
- It can accept the specified set of characters (`Accept-Charset: ISO-8859-1,UTF-8;q=0.7,*;q=0.7`) and languages (`Accept-Language: en-US,en;q=0.8,es;q=0.6`).
- The `Referer` line indicates the address of the web page that contained the link to this resource (i.e. the origin of the request, `https://developer.mozilla.org/en-US/`).
HTTP requests can also have a body, but it is empty in this case.
#### The response
The first part of the response for this request is shown below. The header contains information like the following:
- The first line includes the response code `200 OK`, which tells us that the request succeeded.
- We can see that the response is `text/html` formatted (`Content-Type`).
- We can also see that it uses the UTF-8 character set (`Content-Type: text/html; charset=utf-8`).
- The head also tells us how big it is (`Content-Length: 41823`).
At the end of the message we see the **body** content — which contains the actual HTML returned by the request.
```http
HTTP/1.1 200 OK
Server: Apache
X-Backend-Server: developer1.webapp.scl3.mozilla.com
Vary: Accept, Cookie, Accept-Encoding
Content-Type: text/html; charset=utf-8
Date: Wed, 07 Sep 2016 00:11:31 GMT
Keep-Alive: timeout=5, max=999
Connection: Keep-Alive
X-Frame-Options: DENY
Allow: GET
X-Cache-Info: caching
Content-Length: 41823
<!DOCTYPE html>
<html lang="en-US" dir="ltr" class="redesign no-js" data-ffo-opensanslight=false data-ffo-opensans=false >
<head prefix="og: http://ogp.me/ns#">
<meta charset="utf-8">
<meta http-equiv="X-UA-Compatible" content="IE=Edge">
<script>(function(d) { d.className = d.className.replace(/\bno-js/, ''); })(document.documentElement);</script>
…
```
The remainder of the response header includes information about the response (e.g. when it was generated), the server, and how it expects the browser to handle the page (e.g. the `X-Frame-Options: DENY` line tells the browser not to allow this page to be embedded in an {{htmlelement("iframe")}} in another site).
### POST request/response example
An HTTP `POST` is made when you submit a form containing information to be saved on the server.
#### The request
The text below shows the HTTP request made when a user submits new profile details on this site. The format of the request is almost the same as the `GET` request example shown previously, though the first line identifies this request as a `POST`.
```http
POST /en-US/profiles/hamishwillee/edit HTTP/1.1
Host: developer.mozilla.org
Connection: keep-alive
Content-Length: 432
Pragma: no-cache
Cache-Control: no-cache
Origin: https://developer.mozilla.org
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/52.0.2743.116 Safari/537.36
Content-Type: application/x-www-form-urlencoded
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8
Referer: https://developer.mozilla.org/en-US/profiles/hamishwillee/edit
Accept-Encoding: gzip, deflate, br
Accept-Language: en-US,en;q=0.8,es;q=0.6
Cookie: sessionid=6ynxs23n521lu21b1t136rhbv7ezngie; _gat=1; csrftoken=zIPUJsAZv6pcgCBJSCj1zU6pQZbfMUAT; dwf_section_edit=False; dwf_sg_task_completion=False; _ga=GA1.2.1688886003.1471911953; ffo=true
csrfmiddlewaretoken=zIPUJsAZv6pcgCBJSCj1zU6pQZbfMUAT&user-username=hamishwillee&user-fullname=Hamish+Willee&user-title=&user-organization=&user-location=Australia&user-locale=en-US&user-timezone=Australia%2FMelbourne&user-irc_nickname=&user-interests=&user-expertise=&user-twitter_url=&user-stackoverflow_url=&user-linkedin_url=&user-mozillians_url=&user-facebook_url=
```
The main difference is that the URL doesn't have any parameters. As you can see, the information from the form is encoded in the body of the request (for example, the new user fullname is set using: `&user-fullname=Hamish+Willee`).
#### The response
The response from the request is shown below. The status code of "`302 Found`" tells the browser that the post succeeded, and that it must issue a second HTTP request to load the page specified in the `Location` field. The information is otherwise similar to that for the response to a `GET` request.
```http
HTTP/1.1 302 FOUND
Server: Apache
X-Backend-Server: developer3.webapp.scl3.mozilla.com
Vary: Cookie
Vary: Accept-Encoding
Content-Type: text/html; charset=utf-8
Date: Wed, 07 Sep 2016 00:38:13 GMT
Location: https://developer.mozilla.org/en-US/profiles/hamishwillee
Keep-Alive: timeout=5, max=1000
Connection: Keep-Alive
X-Frame-Options: DENY
X-Cache-Info: not cacheable; request wasn't a GET or HEAD
Content-Length: 0
```
> **Note:** The HTTP responses and requests shown in these examples were captured using the [Fiddler](https://www.telerik.com/download/fiddler) application, but you can get similar information using web sniffers (e.g. [Websniffer](https://websniffer.cc/)) or packet analyzers like [Wireshark](https://www.wireshark.org/). You can try this yourself. Use any of the linked tools, and then navigate through a site and edit profile information to see the different requests and responses. Most modern browsers also have tools that monitor network requests (for example, the [Network Monitor](https://firefox-source-docs.mozilla.org/devtools-user/network_monitor/index.html) tool in Firefox).
## Static sites
A _static site_ is one that returns the same hard coded content from the server whenever a particular resource is requested. So for example if you have a page about a product at `/static/myproduct1.html`, this same page will be returned to every user. If you add another similar product to your site you will need to add another page (e.g. `myproduct2.html`) and so on. This can start to get really inefficient — what happens when you get to thousands of product pages? You would repeat a lot of code across each page (the basic page template, structure, etc.), and if you wanted to change anything about the page structure — like add a new "related products" section for example — then you'd have to change every page individually.
> **Note:** Static sites are excellent when you have a small number of pages and you want to send the same content to every user. However they can have a significant cost to maintain as the number of pages becomes larger.
Let's recap on how this works, by looking again at the static site architecture diagram we looked at in the last article.
When a user wants to navigate to a page, the browser sends an HTTP `GET` request specifying the URL of its HTML page. The server retrieves the requested document from its file system and returns an HTTP response containing the document and an [HTTP Response status code](/en-US/docs/Web/HTTP/Status) of "`200 OK`" (indicating success). The server might return a different status code, for example "`404 Not Found`" if the file is not present on the server, or "`301 Moved Permanently`" if the file exists but has been redirected to a different location.
The server for a static site will only ever need to process GET requests, because the server doesn't store any modifiable data. It also doesn't change its responses based on HTTP Request data (e.g. URL parameters or cookies).
Understanding how static sites work is nevertheless useful when learning server-side programming, because dynamic sites handle requests for static files (CSS, JavaScript, static images, etc.) in exactly the same way.
## Dynamic sites
A _dynamic site_ is one that can generate and return content based on the specific request URL and data (rather than always returning the same hard-coded file for a particular URL). Using the example of a product site, the server would store product "data" in a database rather than individual HTML files. When receiving an HTTP `GET` Request for a product, the server determines the product ID, fetches the data from the database, and then constructs the HTML page for the response by inserting the data into an HTML template. This has major advantages over a static site:
Using a database allows the product information to be stored efficiently in an easily extensible, modifiable, and searchable way.
Using HTML templates makes it very easy to change the HTML structure, because this only needs to be done in one place, in a single template, and not across potentially thousands of static pages.
### Anatomy of a dynamic request
This section provides a step-by-step overview of the "dynamic" HTTP request and response cycle, building on what we looked at in the last article with much more detail. In order to "keep things real" we'll use the context of a sports-team manager website where a coach can select their team name and team size in an HTML form and get back a suggested "best lineup" for their next game.
The diagram below shows the main elements of the "team coach" website, along with numbered labels for the sequence of operations when the coach accesses their "best team" list. The parts of the site that make it dynamic are the _Web Application_ (this is how we will refer to the server-side code that processes HTTP requests and returns HTTP responses), the _Database_, which contains information about players, teams, coaches and their relationships, and the _HTML Templates_.
After the coach submits the form with the team name and number of players, the sequence of operations is:
1. The web browser creates an HTTP `GET` request to the server using the base URL for the resource (`/best`) and encoding the team and player number either as URL parameters (e.g. `/best?team=my_team_name&show=11`) or as part of the URL pattern (e.g. `/best/my_team_name/11/`). A `GET` request is used because the request is only fetching data (not modifying data).
2. The _Web Server_ detects that the request is "dynamic" and forwards it to the _Web Application_ for processing (the web server determines how to handle different URLs based on pattern matching rules defined in its configuration).
3. The _Web Application_ identifies that the _intention_ of the request is to get the "best team list" based on the URL (`/best/`) and finds out the required team name and number of players from the URL. The _Web Application_ then gets the required information from the database (using additional "internal" parameters to define which players are "best", and possibly also getting the identity of the logged in coach from a client-side cookie).
4. The _Web Application_ dynamically creates an HTML page by putting the data (from the _Database_) into placeholders inside an HTML template.
5. The _Web Application_ returns the generated HTML to the web browser (via the _Web Server_), along with an HTTP status code of 200 ("success"). If anything prevents the HTML from being returned then the _Web Application_ will return another code — for example "404" to indicate that the team does not exist.
6. The Web Browser will then start to process the returned HTML, sending separate requests to get any other CSS or JavaScript files that it references (see step 7).
7. The Web Server loads static files from the file system and returns them to the browser directly (again, correct file handling is based on configuration rules and URL pattern matching).
An operation to update a record in the database would be handled similarly, except that like any database update, the HTTP request from the browser should be encoded as a `POST` request.
### Doing other work
A _Web Application's_ job is to receive HTTP requests and return HTTP responses. While interacting with a database to get or update information are very common tasks, the code may do other things at the same time, or not interact with a database at all.
A good example of an additional task that a _Web Application_ might perform would be sending an email to users to confirm their registration with the site. The site might also perform logging or other operations.
### Returning something other than HTML
Server-side website code does not have to return HTML snippets/files in the response. It can instead dynamically create and return other types of files (text, PDF, CSV, etc.) or even data (JSON, XML, etc.).
This is especially relevant for websites that work by fetching content from the server using JavaScript and updating the page dynamically, rather than always loading a new page when new content is to be shown. See [Fetching data from the server](/en-US/docs/Learn/JavaScript/Client-side_web_APIs/Fetching_data) for more on the motivation for this approach, and what this model looks like from the client's point of view.
## Web frameworks simplify server-side web programming
Server-side web frameworks make writing code to handle the operations described above much easier.
One of the most important operations they perform is providing simple mechanisms to map URLs for different resources/pages to specific handler functions. This makes it easier to keep the code associated with each type of resource separate. It also has benefits in terms of maintenance, because you can change the URL used to deliver a particular feature in one place, without having to change the handler function.
For example, consider the following Django (Python) code that maps two URL patterns to two view functions. The first pattern ensures that an HTTP request with a resource URL of `/best` will be passed to a function named `index()` in the `views` module. A request that has the pattern "`/best/junior`", will instead be passed to the `junior()` view function.
```python
# file: best/urls.py
#
from django.conf.urls import url
from . import views
urlpatterns = [
# example: /best/
url(r'^$', views.index),
# example: /best/junior/
url(r'^junior/$', views.junior),
]
```
> **Note:** The first parameters in the `url()` functions may look a bit odd (e.g. `r'^junior/$'`) because they use a pattern matching technique called "regular expressions" (RegEx, or RE). You don't need to know how regular expressions work at this point, other than that they allow us to match patterns in the URL (rather than the hard coded values above) and use them as parameters in our view functions. As an example, a really simple RegEx might say "match a single uppercase letter, followed by between 4 and 7 lower case letters."
The web framework also makes it easy for a view function to fetch information from the database. The structure of our data is defined in models, which are Python classes that define the fields to be stored in the underlying database. If we have a model named _Team_ with a field of "_team_type_" then we can use a simple query syntax to get back all teams that have a particular type.
The example below gets a list of all teams that have the exact (case sensitive) `team_type` of "junior" — note the format: field name (`team_type`) followed by double underscore, and then the type of match to use (in this case `exact`). There are many other types of matches and we can daisy chain them. We can also control the order and the number of results returned.
```python
#best/views.py
from django.shortcuts import render
from .models import Team
def junior(request):
list_teams = Team.objects.filter(team_type__exact="junior")
context = {'list': list_teams}
return render(request, 'best/index.html', context)
```
After the `junior()` function gets the list of junior teams, it calls the `render()` function, passing the original `HttpRequest`, an HTML template, and a "context" object defining the information to be included in the template. The `render()` function is a convenience function that generates HTML using a context and an HTML template, and returns it in an `HttpResponse` object.
Obviously web frameworks can help you with a lot of other tasks. We discuss a lot more benefits and some popular web framework choices in the next article.
## Summary
At this point you should have a good overview of the operations that server-side code has to perform, and know some of the ways in which a server-side web framework can make this easier.
In a following module we'll help you choose the best Web Framework for your first site.
{{PreviousMenuNext("Learn/Server-side/First_steps/Introduction", "Learn/Server-side/First_steps/Web_frameworks", "Learn/Server-side/First_steps")}}
| 0 |
data/mdn-content/files/en-us/learn/server-side/first_steps | data/mdn-content/files/en-us/learn/server-side/first_steps/introduction/index.md | ---
title: Introduction to the server side
slug: Learn/Server-side/First_steps/Introduction
page-type: learn-module-chapter
---
{{LearnSidebar}}{{NextMenu("Learn/Server-side/First_steps/Client-Server_overview", "Learn/Server-side/First_steps")}}
Welcome to the MDN beginner's server-side programming course! In this first article, we look at server-side programming from a high level, answering questions such as "what is it?", "how does it differ from client-side programming?", and "why it is so useful?". After reading this article you'll understand the additional power available to websites through server-side coding.
<table>
<tbody>
<tr>
<th scope="row">Prerequisites:</th>
<td>
A basic understanding of what a web server is.
</td>
</tr>
<tr>
<th scope="row">Objective:</th>
<td>
To gain familiarity with what server-side programming is, what it can
do, and how it differs from client-side programming.
</td>
</tr>
</tbody>
</table>
Most large-scale websites use server-side code to dynamically display different data when needed, generally pulled out of a database stored on a server and sent to the client to be displayed via some code (e.g. HTML and JavaScript).
Perhaps the most significant benefit of server-side code is that it allows you to tailor website content for individual users. Dynamic sites can highlight content that is more relevant based on user preferences and habits. It can also make sites easier to use by storing personal preferences and information — for example reusing stored credit card details to streamline subsequent payments.
It can even allow interaction with users of the site, sending notifications and updates via email or through other channels. All of these capabilities enable much deeper engagement with users.
In the modern world of web development, learning about server-side development is highly recommended.
## What is server-side website programming?
Web browsers communicate with [web servers](/en-US/docs/Learn/Common_questions/Web_mechanics/What_is_a_web_server) using the **H**yper**T**ext **T**ransfer **P**rotocol ({{glossary("HTTP")}}). When you click a link on a web page, submit a form, or run a search, an **HTTP request** is sent from your browser to the target server.
The request includes a URL identifying the affected resource, a method that defines the required action (for example to get, delete, or post the resource), and may include additional information encoded in URL parameters (the field-value pairs sent via a [query string](https://en.wikipedia.org/wiki/Query_string)), as POST data (data sent by the [HTTP POST method](/en-US/docs/Web/HTTP/Methods/POST)), or in associated {{glossary("Cookie", "cookies")}}.
Web servers wait for client request messages, process them when they arrive, and reply to the web browser with an **HTTP response** message. The response contains a status line indicating whether or not the request succeeded (e.g. "HTTP/1.1 200 OK" for success).
The body of a successful response to a request would contain the requested resource (e.g. a new HTML page, or an image), which could then be displayed by the web browser.
### Static sites
The diagram below shows a basic web server architecture for a _static site_ (a static site is one that returns the same hard-coded content from the server whenever a particular resource is requested). When a user wants to navigate to a page, the browser sends an HTTP "GET" request specifying its URL.
The server retrieves the requested document from its file system and returns an HTTP response containing the document and a [success status](/en-US/docs/Web/HTTP/Status#successful_responses) (usually 200 OK). If the file cannot be retrieved for some reason, an error status is returned (see [client error responses](/en-US/docs/Web/HTTP/Status#client_error_responses) and [server error responses](/en-US/docs/Web/HTTP/Status#server_error_responses)).
### Dynamic sites
A dynamic website is one where some of the response content is generated _dynamically_, only when needed. On a dynamic website HTML pages are normally created by inserting data from a database into placeholders in HTML templates (this is a much more efficient way of storing large amounts of content than using static websites).
A dynamic site can return different data for a URL based on information provided by the user or stored preferences and can perform other operations as part of returning a response (e.g. sending notifications).
Most of the code to support a dynamic website must run on the server. Creating this code is known as "**server-side programming**" (or sometimes "**back-end scripting**").
The diagram below shows a simple architecture for a _dynamic website_. As in the previous diagram, browsers send HTTP requests to the server, then the server processes the requests and returns appropriate HTTP responses.
Requests for _static_ resources are handled in the same way as for static sites (static resources are any files that don't change — typically: CSS, JavaScript, Images, pre-created PDF files, etc.).
Requests for dynamic resources are instead forwarded (2) to server-side code (shown in the diagram as a _Web Application_). For "dynamic requests" the server interprets the request, reads required information from the database (3), combines the retrieved data with HTML templates (4), and sends back a response containing the generated HTML (5,6).
## Are server-side and client-side programming the same?
Let's now turn our attention to the code involved in server-side and client-side programming. In each case, the code is significantly different:
- They have different purposes and concerns.
- They generally don't use the same programming languages (the exception being JavaScript, which can be used on the server- and client-side).
- They run inside different operating system environments.
Code running in the browser is known as **client-side code** and is primarily concerned with improving the appearance and behavior of a rendered web page. This includes selecting and styling UI components, creating layouts, navigation, form validation, etc. By contrast, server-side website programming mostly involves choosing _which content_ is returned to the browser in response to requests. The server-side code handles tasks like validating submitted data and requests, using databases to store and retrieve data and sending the correct data to the client as required.
Client-side code is written using [HTML](/en-US/docs/Learn/HTML), [CSS](/en-US/docs/Learn/CSS), and [JavaScript](/en-US/docs/Learn/JavaScript) — it is run inside a web browser and has little or no access to the underlying operating system (including limited access to the file system).
Web developers can't control what browser every user might be using to view a website — browsers provide inconsistent levels of compatibility with client-side code features, and part of the challenge of client-side programming is handling differences in browser support gracefully.
Server-side code can be written in any number of programming languages — examples of popular server-side web languages include PHP, Python, Ruby, C#, and JavaScript (NodeJS). The server-side code has full access to the server operating system and the developer can choose what programming language (and specific version) they wish to use.
Developers typically write their code using **web frameworks**. Web frameworks are collections of functions, objects, rules and other code constructs designed to solve common problems, speed up development, and simplify the different types of tasks faced in a particular domain.
Again, while both client and server-side code use frameworks, the domains are very different, and hence so are the frameworks. Client-side web frameworks simplify layout and presentation tasks while server-side web frameworks provide a lot of "common" web server functionality that you might otherwise have to implement yourself (e.g. support for sessions, support for users and authentication, easy database access, templating libraries, etc.).
> **Note:** Client-side frameworks are often used to help speed up development of client-side code, but you can also choose to write all the code by hand; in fact, writing your code by hand can be quicker and more efficient if you only need a small, simple website UI.
>
> In contrast, you would almost never consider writing the server-side component of a web app without a framework — implementing a vital feature like an HTTP server is really hard to do from scratch in say Python, but Python web frameworks like Django provide one out of the box, along with other very useful tools.
## What can you do on the server-side?
Server-side programming is very useful because it allows us to _efficiently_ deliver information tailored for individual users and thereby create a much better user experience.
Companies like Amazon use server-side programming to construct search results for products, make targeted product suggestions based on client preferences and previous buying habits, simplify purchases, etc.
Banks use server-side programming to store account information and allow only authorized users to view and make transactions. Other services like Facebook, Twitter, Instagram, and Wikipedia use server-side programming to highlight, share, and control access to interesting content.
Some of the common uses and benefits of server-side programming are listed below. You'll note that there is some overlap!
### Efficient storage and delivery of information
Imagine how many products are available on Amazon, and imagine how many posts have been written on Facebook? Creating a separate static page for each product or post would be completely impractical.
Server-side programming allows us to instead store the information in a database and dynamically construct and return HTML and other types of files (e.g. PDFs, images, etc.). It is also possible to return data ({{glossary("JSON")}}, {{glossary("XML")}}, etc.) for rendering by appropriate client-side web frameworks (this reduces the processing burden on the server and the amount of data that needs to be sent).
The server is not limited to sending information from databases, and might alternatively return the result of software tools, or data from communications services. The content can even be targeted for the type of client device that is receiving it.
Because the information is in a database, it can also more easily be shared and updated with other business systems (for example, when products are sold either online or in a shop, the shop might update its database of inventory).
> **Note:** Your imagination doesn't have to work hard to see the benefit of server-side code for efficient storage and delivery of information:
>
> 1. Go to [Amazon](https://www.amazon.com) or some other e-commerce site.
> 2. Search for a number of keywords and note how the page structure doesn't change, even though the results do.
> 3. Open two or three different products. Note again how they have a common structure and layout, but the content for different products has been pulled from the database.
>
> For a common search term ("fish", say) you can see literally millions of returned values. Using a database allows these to be stored and shared efficiently, and it allows the presentation of the information to be controlled in just one place.
### Customized user experience
Servers can store and use information about clients to provide a convenient and tailored user experience. For example, many sites store credit cards so that details don't have to be entered again. Sites like Google Maps can use saved or current locations for providing routing information, and search or travel history to highlight local businesses in search results.
A deeper analysis of user habits can be used to anticipate their interests and further customize responses and notifications, for example providing a list of previously visited or popular locations you may want to look at on a map.
> **Note:** [Google Maps](https://www.google.com/maps) saves your search and visit history. Frequently visited or frequently searched locations are highlighted more than others.
>
> Google search results are optimized based on previous searches.
>
> 1. Go to [Google search](https://www.google.com/).
> 2. Search for "football".
> 3. Now try typing "favorite" in the search box and observe the autocomplete search predictions.
>
> Coincidence? Nada!
### Controlled access to content
Server-side programming allows sites to restrict access to authorized users and serve only the information that a user is permitted to see.
Real-world examples include social-networking sites which allow users to determine who can see the content they post to the site, and whose content appears in their feed.
> **Note:** Consider other real examples where access to content is controlled. For example, what can you see if you go to the online site for your bank? Log in to your account — what additional information can you see and modify? What information can you see that only the bank can change?
### Store session/state information
Server-side programming allows developers to make use of **sessions** — basically, a mechanism that allows a server to store information associated with the current user of a site and send different responses based on that information.
This allows, for example, a site to know that a user has previously logged in and display links to their emails or order history, or perhaps save the state of a simple game so that the user can go to a site again and carry on where they left it.
> **Note:** Visit a newspaper site that has a subscription model and open a bunch of tabs (e.g. [The Age](https://www.theage.com.au/)). Continue to visit the site over a few hours/days. Eventually, you will start to be redirected to pages explaining how to subscribe, and you will be unable to access articles. This information is an example of session information stored in cookies.
### Notifications and communication
Servers can send general or user-specific notifications through the website itself or via email, SMS, instant messaging, video conversations, or other communications services.
A few examples include:
- Facebook and Twitter send emails and SMS messages to notify you of new communications.
- Amazon regularly sends product emails that suggest products similar to those already bought or viewed that you might be interested in.
- A web server might send warning messages to site administrators alerting them to low memory on the server, or suspicious user activity.
> **Note:** The most common type of notification is a "confirmation of registration". Pick almost any large site that you are interested in (Google, Amazon, Instagram, etc.) and create a new account using your email address. You will shortly receive an email confirming your registration, or requiring acknowledgment to activate your account.
### Data analysis
A website may collect a lot of data about users: what they search for, what they buy, what they recommend, how long they stay on each page. Server-side programming can be used to refine responses based on analysis of this data.
For example, Amazon and Google both advertise products based on previous searches (and purchases).
> **Note:** If you're a Facebook user, go to your main feed and look at the stream of posts. Note how some of the posts are out of numerical order - in particular, posts with more "likes" are often higher on the list than more recent posts.
>
> Also look at what kind of ads you are being shown — you might see ads for things you looked at on other sites. Facebook's algorithm for highlighting content and advertising can be a bit of a mystery, but it is clear that it does depend on your likes and viewing habits!
## Summary
Congratulations, you've reached the end of the first article about server-side programming.
You've now learned that server-side code is run on a web server and that its main role is to control _what_ information is sent to the user (while client-side code mainly handles the structure and presentation of that data to the user).
You should also understand that it is useful because it allows us to create websites that _efficiently_ deliver information tailored for individual users and have a good idea of some of the things you might be able to do when you're a server-side programmer.
Lastly, you should understand that server-side code can be written in a number of programming languages and that you should use a web framework to make the whole process easier.
In a future article we'll help you choose the best web framework for your first site. Here we'll take you through the main client-server interactions in just a little more detail.
{{NextMenu("Learn/Server-side/First_steps/Client-Server_overview", "Learn/Server-side/First_steps")}}
| 0 |
data/mdn-content/files/en-us/learn/server-side | data/mdn-content/files/en-us/learn/server-side/express_nodejs/index.md | ---
title: Express web framework (Node.js/JavaScript)
slug: Learn/Server-side/Express_Nodejs
page-type: learn-module
---
{{LearnSidebar}}
Express is a popular unopinionated web framework, written in JavaScript and hosted within the Node.js runtime environment. This module explains some of the key benefits of the framework, how to set up your development environment and how to perform common web development and deployment tasks.
## Prerequisites
Before starting this module you will need to understand what server-side web programming and web frameworks are, ideally by reading the topics in our [Server-side website programming first steps](/en-US/docs/Learn/Server-side/First_steps) module. A general knowledge of programming concepts and [JavaScript](/en-US/docs/Web/JavaScript) is highly recommended, but not essential to understanding the core concepts.
> **Note:** This website has many useful resources for learning JavaScript _in the context of client-side development_: [JavaScript](/en-US/docs/Web/JavaScript), [JavaScript Guide](/en-US/docs/Web/JavaScript/Guide), [JavaScript Basics](/en-US/docs/Learn/Getting_started_with_the_web/JavaScript_basics), [JavaScript](/en-US/docs/Learn/JavaScript) (learning). The core JavaScript language and concepts are the same for server-side development on Node.js and this material will be relevant. Node.js offers [additional APIs](https://nodejs.org/dist/latest-v10.x/docs/api/) for supporting functionality that is useful in browserless environments (e.g., to create HTTP servers and access the file system), but does not support JavaScript APIs for working with the browser and DOM.
>
> This guide will provide some information about working with Node.js and Express, and there are numerous other excellent resources on the Internet and in books — some of these linked from [How do I get started with Node.js](https://stackoverflow.com/questions/2353818/how-do-i-get-started-with-node-js/5511507) (StackOverflow) and [What are the best resources for learning Node.js?](https://www.quora.com/What-is-the-greatest-resource-for-learning-Node-js-for-a-newbie) (Quora).
## Guides
- [Express/Node introduction](/en-US/docs/Learn/Server-side/Express_Nodejs/Introduction)
- : In this first Express article we answer the questions "What is Node?" and "What is Express?" and give you an overview of what makes the Express web framework special. We'll outline the main features and show you some of the main building blocks of an Express application (although at this point you won't yet have a development environment in which to test it).
- [Setting up a Node (Express) development environment](/en-US/docs/Learn/Server-side/Express_Nodejs/development_environment)
- : Now that you know what Express is for, we'll show you how to set up and test a Node/Express development environment on Windows, Linux (Ubuntu), and macOS. Whatever common operating system you are using, this article should give you what you need to be able to start developing Express apps.
- [Express Tutorial: The Local Library website](/en-US/docs/Learn/Server-side/Express_Nodejs/Tutorial_local_library_website)
- : The first article in our practical tutorial series explains what you'll learn and provides an overview of the "local library" example website we'll be working through and evolving in subsequent articles.
- [Express Tutorial Part 2: Creating a skeleton website](/en-US/docs/Learn/Server-side/Express_Nodejs/skeleton_website)
- : This article shows how you can create a "skeleton" website project, which you can then go on to populate with site-specific routes, templates/views, and databases.
- [Express Tutorial Part 3: Using a Database (with Mongoose)](/en-US/docs/Learn/Server-side/Express_Nodejs/mongoose)
- : This article briefly introduces databases for Node/Express. It then goes on to show how we can use [Mongoose](https://mongoosejs.com/) to provide database access for the _LocalLibrary_ website. It explains how object schema and models are declared, the main field types, and basic validation. It also briefly shows a few of the main ways you can access model data.
- [Express Tutorial Part 4: Routes and controllers](/en-US/docs/Learn/Server-side/Express_Nodejs/routes)
- : In this tutorial we'll set up routes (URL handling code) with "dummy" handler functions for all the resource endpoints that we'll eventually need in the _LocalLibrary_ website. On completion, we'll have a modular structure for our route handling code, that we can extend with real handler functions in the following articles. We'll also have a really good understanding of how to create modular routes using Express.
- [Express Tutorial Part 5: Displaying library data](/en-US/docs/Learn/Server-side/Express_Nodejs/Displaying_data)
- : We're now ready to add the pages that display the _LocalLibrary_ website books and other data. The pages will include a home page that shows how many records we have of each model type and list and detail pages for all of our models. Along the way, we'll gain practical experience in getting records from the database and using templates.
- [Express Tutorial Part 6: Working with forms](/en-US/docs/Learn/Server-side/Express_Nodejs/forms)
- : In this tutorial we'll show you how to work with [HTML Forms](/en-US/docs/Learn/Forms) in Express, using Pug, and in particular how to write forms to create, update, and delete documents from the database.
- [Express Tutorial Part 7: Deploying to production](/en-US/docs/Learn/Server-side/Express_Nodejs/deployment)
- : Now you've created an awesome _LocalLibrary_ website, you're going to want to install it on a public web server so that it can be accessed by library staff and members over the Internet. This article provides an overview of how you might go about finding a host to deploy your website, and what you need to do in order to get your site ready for production.
## Adding more tutorials
All existing tutorials are listed above, but if you would like to extend this module, some other interesting topics to cover include:
- Using sessions.
- User authentication.
- User authorization and permissions.
- Testing an Express web application.
- Web security for Express web applications.
An assessment for the module would also make a wonderful addition!
| 0 |
data/mdn-content/files/en-us/learn/server-side/express_nodejs | data/mdn-content/files/en-us/learn/server-side/express_nodejs/deployment/index.md | ---
title: "Express Tutorial Part 7: Deploying to production"
slug: Learn/Server-side/Express_Nodejs/deployment
page-type: learn-module-chapter
---
{{LearnSidebar}}{{PreviousMenu("Learn/Server-side/Express_Nodejs/forms", "Learn/Server-side/Express_Nodejs")}}
Now you've created (and tested) an awesome [LocalLibrary](/en-US/docs/Learn/Server-side/Express_Nodejs/Tutorial_local_library_website) website, you're going to want to install it on a public web server so that it can be accessed by library staff and members over the Internet. This article provides an overview of how you might go about finding a host to deploy your website, and what you need to do in order to get your site ready for production.
<table>
<tbody>
<tr>
<th scope="row">Prerequisites:</th>
<td>
Complete all previous tutorial topics, including <a href="/en-US/docs/Learn/Server-side/Express_Nodejs/forms">Express Tutorial Part 6: Working with forms</a>.
</td>
</tr>
<tr>
<th scope="row">Objective:</th>
<td>
To learn where and how you can deploy an Express app to production.
</td>
</tr>
</tbody>
</table>
## Overview
Once your site is finished (or finished "enough" to start public testing) you're going to need to host it somewhere more public and accessible than your personal development computer.
Up to now, you've been working in a [development environment](/en-US/docs/Learn/Server-side/Express_Nodejs/development_environment), using Express/Node as a web server to share your site to the local browser/network, and running your website with (insecure) development settings that expose debugging and other private information. Before you can host a website externally you're first going to have to:
- Choose an environment for hosting the Express app.
- Make a few changes to your project settings.
- Set up a production-level infrastructure for serving your website.
This tutorial provides some guidance on your options for choosing a hosting site, a brief overview of what you need to do in order to get your Express app ready for production, and a working example of how to install the LocalLibrary website onto the [Railway](https://railway.app/) cloud hosting service.
## What is a production environment?
The production environment is the environment provided by the server computer where you will run your website for external consumption. The environment includes:
- Computer hardware on which the website runs.
- Operating system (e.g. Linux or Windows).
- Programming language runtime and framework libraries on top of which your website is written.
- Web server infrastructure, possibly including a web server, reverse proxy, load balancer, etc.
- Databases on which your website is dependent.
The server computer could be located on your premises and connected to the Internet by a fast link, but it is far more common to use a computer that is hosted "in the cloud". What this actually means is that your code is run on some remote computer (or possibly a "virtual" computer) in your hosting company's data center(s). The remote server will usually offer some guaranteed level of computing resources (e.g. CPU, RAM, storage memory, etc.) and Internet connectivity for a certain price.
This sort of remotely accessible computing/networking hardware is referred to as _Infrastructure as a Service (IaaS)_. Many IaaS vendors provide options to preinstall a particular operating system, onto which you must install the other components of your production environment. Other vendors allow you to select more fully-featured environments, perhaps including a complete Node setup.
> **Note:** Pre-built environments can make setting up your website very easy because they reduce the configuration, but the available options may limit you to an unfamiliar server (or other components) and may be based on an older version of the OS. Often it is better to install components yourself so that you get the ones that you want, and when you need to upgrade parts of the system, you have some idea of where to start!
Other hosting providers support Express as part of a _Platform as a Service_ (_PaaS_) offering. When using this sort of hosting you don't need to worry about most of your production environment (servers, load balancers, etc.) as the host platform takes care of those for you. That makes deployment quite easy because you just need to concentrate on your web application and not any other server infrastructure.
Some developers will choose the increased flexibility provided by IaaS over PaaS, while others will appreciate the reduced maintenance overhead and easier scaling of PaaS. When you're getting started, setting up your website on a PaaS system is much easier, so that is what we'll do in this tutorial.
> **Note:** If you choose a Node/Express-friendly hosting provider they should provide instructions on how to set up an Express website using different configurations of web server, application server, reverse proxy, etc. For example, there are many step-by-step guides for various configurations in the [Digital Ocean Node community docs](https://www.digitalocean.com/community/tutorials?q=node).
## Choosing a hosting provider
There are numerous hosting providers that are known to either actively support or work well with _Node_ (and _Express_). These vendors provide different types of environments (IaaS, PaaS), and different levels of computing and network resources at different prices.
> **Note:** There are a lot of hosting solutions, and their services and pricing can change over time. While we introduce a few options below, it is worth checking both these and other options before selecting a hosting provider.
Some of the things to consider when choosing a host:
- How busy your site is likely to be and the cost of data and computing resources required to meet that demand.
- Level of support for scaling horizontally (adding more machines) and vertically (upgrading to more powerful machines) and the costs of doing so.
- The locations where the supplier has data centers, and hence where access is likely to be fastest.
- The host's historical uptime and downtime performance.
- Tools provided for managing the site — are they easy to use and are they secure (e.g. SFTP vs. FTP).
- Inbuilt frameworks for monitoring your server.
- Known limitations. Some hosts will deliberately block certain services (e.g. email). Others offer only a certain number of hours of "live time" in some price tiers, or only offer a small amount of storage.
- Additional benefits. Some providers will offer free domain names and support for TLS certificates that you would otherwise have to pay for.
- Whether the "free" tier you're relying on expires over time, and whether the cost of migrating to a more expensive tier means you would have been better off using some other service in the first place!
The good news when you're starting out is that there are quite a few sites that provide "free" computing environments that are intended for evaluation and testing.
These are usually fairly resource constrained/limited environments, and you do need to be aware that they may expire after some introductory period or have other constraints.
They are however great for testing low-traffic sites in a hosted environment, and can provide an easy migration to paying for more resources when your site gets busier.
Popular choices in this category include [Glitch](https://glitch.com/), [Python Anywhere](https://www.pythonanywhere.com/), [Amazon Web Services](https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/billing-free-tier.html), [Microsoft Azure](https://azure.microsoft.com/pricing/details/app-service/), etc.
Most providers also offer a "basic" or "hobby" tier that is intended for small production sites, and which provide more useful levels of computing power and fewer limitations.
[Railway](https://railway.app/), [Heroku](https://www.heroku.com/), [Digital Ocean](https://www.digitalocean.com/) and [Python Anywhere](https://www.pythonanywhere.com/) are examples of popular hosting providers that have a relatively inexpensive basic computing tier (in the $5 to $10 USD per month range).
> **Note:** Remember that price is not the only selection criterion.
> If your website is successful, it may turn out that scalability is the most important consideration.
## Getting your website ready to publish
The main things to think about when publishing your website are web security and performance.
At the bare minimum, you will want to modify the database configuration so that you can use a different database for production and secure its credentials, remove the stack traces that are included on error pages during development, tidy up your logging, and set the appropriate headers to avoid many common security threats.
In the following subsections, we outline the most important changes that you should make to your app.
> **Note:** There are other useful tips in the Express docs — see [Production best practices: performance and reliability](https://expressjs.com/en/advanced/best-practice-performance.html) and [Production Best Practices: Security](https://expressjs.com/en/advanced/best-practice-security.html).
### Database configuration
So far in this tutorial, we've used a single development database, for which the address and credentials are hard-coded into **app.js**.
Since the development database doesn't contain any information that we mind being exposed or corrupted, there is no particular risk in leaking these details.
However if you're working with real data, in particular personal user information, then protecting your database credentials is very important.
For this reason we want to use a different database for production than we use for development, and also keep the production database credentials separate from the source code so that they can be properly protected.
If your hosting provider supports setting environment variables through a web interface (as many do), one way to do this is to have the server get the database URL from an environment variable.
Below we modify the LocalLibrary website to get the database URI from an OS environment variable, if it has been defined, and otherwise use the development database URL.
Open **app.js** and find the line that sets the MongoDB connection variable.
It will look something like this:
```js
const mongoDB =
"mongodb+srv://your_user_name:[email protected]/local_library?retryWrites=true&w=majority";
```
Replace the line with the following code that uses `process.env.MONGODB_URI` to get the connection string from an environment variable named `MONGODB_URI` if has been set (use your own database URL instead of the placeholder below).
```js
// Set up mongoose connection
const mongoose = require("mongoose");
mongoose.set("strictQuery", false);
const dev_db_url =
"mongodb+srv://your_user_name:[email protected]/local_library?retryWrites=true&w=majority";
const mongoDB = process.env.MONGODB_URI || dev_db_url;
main().catch((err) => console.log(err));
async function main() {
await mongoose.connect(mongoDB);
}
```
> **Note:** Another common way to keep production database credentials separate from source code is to read them from an `.env` file that is separately deployed to the file system (for example, they might be read using the npm [dotenv](https://www.npmjs.com/package/dotenv) module).
### Set NODE_ENV to 'production'
We can remove stack traces in error pages by setting the `NODE_ENV` environment variable to _production_ (it is set to '_development_' by default). In addition to generating less-verbose error messages, setting the variable to _production_ caches view templates and CSS files generated from CSS extensions. Tests indicate that setting `NODE_ENV` to _production_ can improve app performance by a factor of three!
This change can be made either by using `export`, an environment file, or the OS initialization system.
> **Note:** This is actually a change you make in your environment setup rather than your app, but important enough to note here! We'll show how this is set for our hosting example below.
### Log appropriately
Logging calls can have an impact on a high-traffic website. In a production environment, you may need to log website activity (e.g. tracking traffic or logging API calls) but you should attempt to minimize the amount of logging added for debugging purposes.
One way to minimize "debug" logging in production is to use a module like [debug](https://www.npmjs.com/package/debug) that allows you to control what logging is performed by setting an environment variable.
For example, the code fragment below shows how you might set up "author" logging.
The debug variable is declared with the name 'author', and the prefix "author" will be automatically displayed for all logs from this object.
```js
const debug = require("debug")("author");
// Display Author update form on GET.
exports.author_update_get = asyncHandler(async (req, res, next) => {
const author = await Author.findById(req.params.id).exec();
if (author === null) {
// No results.
debug(`id not found on update: ${req.params.id}`);
const err = new Error("Author not found");
err.status = 404;
return next(err);
}
res.render("author_form", { title: "Update Author", author: author });
});
```
You can then enable a particular set of logs by specifying them as a comma-separated list in the `DEBUG` environment variable.
You can set the variables for displaying author and book logs as shown (wildcards are also supported).
```bash
#Windows
set DEBUG=author,book
#Linux
export DEBUG="author,book"
```
> **Note:** Calls to `debug` can replace logging you might previously have done using `console.log()` or `console.error()`. Replace any `console.log()` calls in your code with logging via the [debug](https://www.npmjs.com/package/debug) module. Turn the logging on and off in your development environment by setting the DEBUG variable and observe the impact this has on logging.
If you need to log website activity you can use a logging library like _Winston_ or _Bunyan_. For more information on this topic see: [Production best practices: performance and reliability](https://expressjs.com/en/advanced/best-practice-performance.html).
### Use gzip/deflate compression for responses
Web servers can often compress the HTTP response sent back to a client, significantly reducing the time required for the client to get and load the page. The compression method used will depend on the decompression methods the client says it supports in the request (the response will be sent uncompressed if no compression methods are supported).
Add this to your site using [compression](https://www.npmjs.com/package/compression) middleware. Install this at the root of your project by running the following command:
```bash
npm install compression
```
Open **./app.js** and require the compression library as shown. Add the compression library to the middleware chain with the `use()` method (this should appear before any routes you want compressed — in this case, all of them!)
```js
const catalogRouter = require("./routes/catalog"); // Import routes for "catalog" area of site
const compression = require("compression");
// Create the Express application object
const app = express();
// …
app.use(compression()); // Compress all routes
app.use(express.static(path.join(__dirname, "public")));
app.use("/", indexRouter);
app.use("/users", usersRouter);
app.use("/catalog", catalogRouter); // Add catalog routes to middleware chain.
// …
```
> **Note:** For a high-traffic website in production you wouldn't use this middleware. Instead, you would use a reverse proxy like [Nginx](https://nginx.org/).
### Use Helmet to protect against well known vulnerabilities
[Helmet](https://www.npmjs.com/package/helmet) is a middleware package. It can set appropriate HTTP headers that help protect your app from well-known web vulnerabilities (see the [docs](https://helmetjs.github.io/) for more information on what headers it sets and vulnerabilities it protects against).
Install this at the root of your project by running the following command:
```bash
npm install helmet
```
Open **./app.js** and require the _helmet_ library as shown.
Then add the module to the middleware chain with the `use()` method.
```js
const compression = require("compression");
const helmet = require("helmet");
// Create the Express application object
const app = express();
// Add helmet to the middleware chain.
// Set CSP headers to allow our Bootstrap and Jquery to be served
app.use(
helmet.contentSecurityPolicy({
directives: {
"script-src": ["'self'", "code.jquery.com", "cdn.jsdelivr.net"],
},
}),
);
// …
```
We normally might have just inserted `app.use(helmet());` to add the _subset_ of the security-related headers that make sense for most sites.
However in the [LocalLibrary base template](/en-US/docs/Learn/Server-side/Express_Nodejs/Displaying_data/LocalLibrary_base_template) we include some bootstrap and jQuery scripts.
These violate the helmet's _default_ [Content Security Policy (CSP)](/en-US/docs/Web/HTTP/CSP), which does not allow loading of cross-site scripts.
To allow these scripts to be loaded we modify the helmet configuration so that it sets CSP directives to allow script loading from the indicated domains.
For your own server you can add/disable specific headers as needed by following the [instructions for using helmet here](https://www.npmjs.com/package/helmet).
### Add rate limiting to the API routes
[Express-rate-limit](https://www.npmjs.com/package/express-rate-limit) is a middleware package that can be used to limit repeated requests to APIs and endpoints.
There are many reasons why excessive requests might be made to your site, such as denial of service attacks, brute force attacks, or even just a client or script that is not behaving as expected.
Aside from performance issues that can arise from too many requests causing your server to slow down, you may also be charged for the additional traffic.
This package can be used to limit the number of requests that can be made to a particular route or set of routes.
Install this at the root of your project by running the following command:
```bash
npm install express-rate-limit
```
Open **./app.js** and require the _express-rate-limit_ library as shown.
Then add the module to the middleware chain with the `use()` method.
```js
const compression = require("compression");
const helmet = require("helmet");
const app = express();
// Set up rate limiter: maximum of twenty requests per minute
const RateLimit = require("express-rate-limit");
const limiter = RateLimit({
windowMs: 1 * 60 * 1000, // 1 minute
max: 20,
});
// Apply rate limiter to all requests
app.use(limiter);
// …
```
The command above limits all requests to 20 per minute (you can change this as needed).
> **Note:** Third-party services like [Cloudflare](https://www.cloudflare.com/) can also be used if you need more advanced protection against denial of service or other types of attacks.
#### Set node version
For node applications, including Express, the **package.json** file contains everything a hosting provider should need to work out the application dependencies and entry point file.
The only important information missing from our current **package.json** is the version of node required by the library.
You can find the version of node that was used for development by entering the command:
```bash
>node --version
v16.17.1
```
Open **package.json**, and add this information as an **engines > node** section as shown (using the version number for your system).
```json
{
"name": "express-locallibrary-tutorial",
"version": "0.0.0",
"engines": {
"node": ">=16.17.1"
},
"private": true,
// …
```
The hosting service might not support the specific indicated version of node, but this change should ensure that it attempts to use a version with the same major version number, or a more recent version.
Note that there may be other ways to specify the node version on different hosting services, but the **package.json** approach is widely supported.
#### Get dependencies and re-test
Before we proceed, let's test the site again and make sure it wasn't affected by any of our changes.
First, we will need to fetch our dependencies. You can do this by running the following command in your terminal at the root of the project:
```bash
npm install
```
Now run the site (see [Testing the routes](/en-US/docs/Learn/Server-side/Express_Nodejs/routes#testing_the_routes) for the relevant commands) and check that the site still behaves as you expect.
### Creating an application repository in GitHub
Many hosting services allow you to import and/or synchronize projects from a local repository or from cloud-based source version control platforms.
This can make deployment and iterative development much easier.
For this tutorial we'll set up a [GitHub](https://github.com/) account and repository for the library, and use the **git** tool to upload our source code.
> **Note:** You can skip this step if you're already using GitHub to manage your source code!
>
> Note that using source code management tools is good software development practice, as it allows you to try out changes, and switch between your experiments and "known good code" when you need to!
The steps are:
1. Visit <https://github.com/> and create an account.
2. Once you are logged in, click the **+** link in the top toolbar and select **New repository**.
3. Fill in all the fields on this form. While these are not compulsory, they are strongly recommended.
- Enter a new repository name (e.g. _express-locallibrary-tutorial_), and description (e.g. "Local Library website written in Express (Node)".
- Choose **Node** in the _Add .gitignore_ selection list.
- Choose your preferred license in the _Add license_ selection list.
- Check **Initialize this repository with a README**.
> **Warning:** The default "Public" access will make _all_ source code — including your database username and password — visible to anyone on the internet! Make sure the source code reads credentials _only_ from environment variables and does not have any credentials hard-coded.
>
> Otherwise, select the "Private" option to allow only selected people to see the source code.
4. Press **Create repository**.
5. Click the green **Clone or download** button on your new repo page.
6. Copy the URL value from the text field inside the dialog box that appears.
If you used the repository name "express-locallibrary-tutorial", the URL should be something like: `https://github.com/<your_git_user_id>/express-locallibrary-tutorial.git`.
Now that the repository ("repo") is created on GitHub we are going to want to clone (copy) it to our local computer:
1. Install _git_ for your local computer (you can find versions for different platforms [here](https://git-scm.com/downloads)).
2. Open a command prompt/terminal and clone your repo using the URL you copied above:
```bash
git clone https://github.com/<your_git_user_id>/express-locallibrary-tutorial.git
```
This will create the repository inside the current directory.
3. Navigate into the repo folder.
```bash
cd express-locallibrary-tutorial
```
Then copy your application source files into the repo folder, make them part of the repo using _git_, and upload them to GitHub:
1. Copy your Express application into this folder (excluding **/node_modules**, which contains dependency files that you should fetch from npm as needed).
2. Open a command prompt/terminal and use the `add` command to add all files to git.
```bash
git add -A
```
3. Use the `status` command to check that all files you are about to `commit` are correct (you want to include source files, not binaries, temporary files etc.).
It should look a bit like the listing below.
```bash
git status
```
```plain
On branch main
Your branch is up-to-date with 'origin/main'.
Changes to be committed:
(use "git reset HEAD <file>..." to unstage)
new file: ...
```
4. When you're satisfied, `commit` the files to your local repo.
This is equivalent to signing off on the changes and making them an official part of the local repo.
```bash
git commit -m "First version of application moved into GitHub"
```
5. At this point, the remote repo has not been changed.
The last step is to synchronize (`push`) your local repo up to the remote GitHub repo using the following command:
```bash
git push origin main
```
When this operation completes, you should be able to go back to the page on GitHub where you created your repo, refresh the page, and see that your whole application has now been uploaded. You can continue to update your repo as files change using this add/commit/push cycle.
This is a good point to make a backup of your "vanilla" project — while some of the changes we're going to be making in the following sections might be useful for deployment on any hosting service (or for development) others might not.
You can do this using `git` on the command line:
```bash
# Create branch vanilla_deployment from the current branch (main)
git checkout -b vanilla_deployment
# Push the new branch to GitHub
git push origin vanilla_deployment
# Switch back to main
git checkout main
# Make any further changes in a new branch
git pull upstream main # Merge the latest changes from GitHub
git checkout -b my_changes # Create a new branch
```
> **Note:** Git is incredibly powerful!
> To learn more, see [Learning Git](https://docs.github.com/en/get-started/quickstart/git-and-github-learning-resources).
## Example: Hosting on Glitch
This section provides a practical demonstration of how to host _LocalLibrary_ on [Glitch](https://glitch.com/).
### Why Glitch?
We are choosing to use Glitch for several reasons:
- Glitch has a [free starter plan](https://glitch.com/pricing) that is _really_ free, albeit with some limitations.
The fact that it is affordable for all developers is really important to MDN!
- Glitch takes care of the infrastructure so you don't have to.
Not having to worry about servers, load balancers, reverse proxies, and so on, makes it much easier to get started.
- The skills and concepts you will learn when using Glitch are transferrable.
- The service and plan limitations do not really impact us using Glitch for the tutorial.
For example:
- The starter plan only offers 1000 "project hours" per month, which is reset monthly.
This is used when you're actively editing the site or if someone is accessing it.
If no one is accessing or editing the site it will sleep.
- The starter plan environment has a limited amount of container RAM and storage space.
There is more than enough for the tutorial, in particular because our database is hosted elsewhere.
- Custom domains are not well supported (at time of writing).
- Other limitations can be found in the [Glitch technical restrictions page](https://help.glitch.com/hc/en-us/articles/16287495313293-Technical-Restrictions).
While Glitch is appropriate for hosting this demonstration, you should take the time to determine if it is [suitable for your own website](#choosing_a_hosting_provider).
### How does Glitch work?
Glitch provides a web-based interface in which you can create projects from starter templates, or import them from GitHub, and then add and edit the project files.
As you make changes, the project is built and run in its own isolated and independent virtualized container.
How this all works "under the hood" is a mystery — Glitch doesn't say.
What is clear is that as long as you create a fairly standard nodejs web application (for example, using `package.json` for your dependencies), and don't consume more resources than listed in the [technical restrictions](https://help.glitch.com/hc/en-us/articles/16287495313293-Technical-Restrictions), your application should "just work".
Once the application is running, it can be configured for production using [private data](https://help.glitch.com/hc/en-us/articles/16287550167437-Adding-Private-Data) supplied in a `.env` file.
The values in the secret data are read by the application as environment variables, which, as you will recall from a previous section, is how we configured our application to get its database URL.
Note that the variables are _secret_: the `.env` should not be included in your GitHub repository.
The Glitch editing view also provides _terminal_ access to the web app environment, which you can use to work with the web app as though it was running on your local machine.
That's all the overview you need to get started.
Next, we will set up a Glitch account, upload the Library project from Github, and connect it to a database.
### Get a Glitch account
To start using Glitch you will first need to create an account:
- Go to [glitch.com](https://glitch.com) and click the **Sign up** button in the top toolbar.
- Select GitHub in the popup to sign up using your GitHub credentials.
- You'll then be logged in to the Glitch dashboard: <https://glitch.com/dashboard>.
### Deploy on Glitch from GitHub
Next we'll import the Library project from GitHub.
First choose the **Dashboard** option from the site top menu, then select the **New project** button.
Glitch will display a list of options for the new project; select **Import from GitHub**.
A popup will appear.
Enter the URL of your GitHub library repository into the popup and press **OK**.
Below, we have entered the repo for the worked project.
Glitch will then import the project, displaying notifications of progress.
Upon completion, it will display the editing view for the new project, as shown below.
You can get the live site URL by selecting the **Share** button.
Open a new browser tab and copy the link for the live site into the address bar.
The local library site should open and display data from the development database.
> **Note:** This process was a one-off import from GitHub.
> You can also use GitHub actions such as [glitch-project-sync](https://github.com/marketplace/actions/glitch-project-sync) to keep Glitch and > your project synchronized.
### Use a production MongoDB database
You should set up a different database for production than development.
While Glitch only hosts SQLite databases (and we are set up to use MongoDB), many other sites provide MongoDB databases as a service.
One option is to follow the [Setting up the MongoDB database](/en-US/docs/Learn/Server-side/Express_Nodejs/mongoose#setting_up_the_mongodb_database) instructions from earlier in the tutorial to set up a new production database.
To make the production database accessible to the library application, open the `.env` file in the editor view for the project.
Enter the database URL variable `MONGODB_URI` and the URL of your production database.
The site updates as you enter values into the editor.
> **Note:** We didn't create this file.
> It is intended for [private data](https://help.glitch.com/hc/en-us/articles/16287550167437-Adding-Private-Data) and was created automatically on import to Glitch.
> It is never exported or copied.
### Other configuration variables
You will recall from a preceding section that we need to [set NODE_ENV to 'production'](#node_env) in order to improve our performance and generate less-verbose error messages. We do this in the same file as we set the `MONGODB_URI` variable.
Open `.env` and add a `NODE_ENV` variable with value `production` (see the screenshot in the previous section).
The local library application is now set up and configured for production use.
You can add data through the website interface, and it should work as it did during development (though with less debug information exposed for invalid pages).
> **Note:** If you only want to add some data for testing, you might use the `populatedb` script (with your MongoDB production database URL) as discussed in the section [Express Tutorial Part 3: Using a Database (with Mongoose) Testing — create some items](/en-US/docs/Learn/Server-side/Express_Nodejs/mongoose#testing_%E2%80%94_create_some_items).
### Debugging Express apps on Glitch
Glitch allows effective debugging.
Some of the things you can do are:
- Select the logs button at the bottom of the editor view to see log information from your server, such as console log output.
- Select the terminal button at the bottom of the editor view to open a terminal in the hosting environment.
You can use this to run commands and tools in the environment.
For example, you might use `node -v` to check the node version.
- Interactive debugging in VSCode using the _GLITCH extension for VSCode_.
## Example: Hosting on Railway
This section provides a practical demonstration of how to install _LocalLibrary_ on [Railway](https://railway.app/).
### Why Railway?
> **Warning:** Railway no longer has a completely free starter tier.
> We've kept these instructions because Railway has some great features, and will be a better option for some users.
Railway is an attractive hosting option for several reasons:
- Railway takes care of most of the infrastructure so you don't have to.
Not having to worry about servers, load balancers, reverse proxies, and so on, makes it much easier to get started.
- Railway has a [focus on developer experience for development and deployment](https://docs.railway.app/reference/compare-to-heroku), which leads to a faster and softer learning curve than many other alternatives.
- The skills and concepts you will learn when using Railway are transferrable.
While Railway has some excellent new features, other popular hosting services use many of the same ideas and approaches.
- [Railway documentation](https://docs.railway.app/) is clear and complete.
- The service appears to be very reliable, and if you end up loving it, the pricing is predictable, and scaling your app is very easy.
You should take the time to determine if Railway is [suitable for your own website](#choosing_a_hosting_provider).
### How does Railway work?
Web applications are each run in their own isolated and independent virtualized container.
To execute your application, Railway needs to be able to set up the appropriate environment and dependencies, and also understand how it is launched.
Railway makes this easy, as it can automatically recognize and install many different web application frameworks and environments based on their use of "common conventions".
For example, Railway recognizes node applications because they have a **package.json** file, and can determine the package manager used for building from the "lock" file.
For example, if the application includes the file **package-lock.json** Railway knows to use _npm_ to install the packages, whereas if it finds **yarn.lock** it knows to use _yarn_.
Having installed all the dependencies, Railway will look for scripts named "build" and "start" in the package file, and use these to build and run the code.
> **Note:** Railway uses [Nixpacks](https://nixpacks.com/docs/) to recognize various web application frameworks written in different programming languages.
> You don't need to know anything else for this tutorial, but you can find out more about options for deploying node applications in [Nixpacks Node](https://nixpacks.com/docs/providers/node).
Once the application is running it can configure itself using information provided in [environment variables](https://docs.railway.app/develop/variables).
For example, an application that uses a database must get the address using a variable.
The database service itself may be hosted by Railway or some other provider.
Developers interact with Railway through the Railway site, and using a special [Command Line Interface (CLI)](https://docs.railway.app/develop/cli) tool.
The CLI allows you to associate a local GitHub repository with a railway project, upload the repository from the local branch to the live site, inspect the logs of the running process, set and get configuration variables and much more.
One of the most useful features is that you can use the CLI to run your local project with the same environment variables as the live project.
That's all the overview you need to deploy the app to Railway.
Next we will set up a Railway account, install our website and a database, and try out the Railway client.
### Get a Railway account
To start using Railway you will first need to create an account:
- Go to [railway.app](https://railway.app/) and click the **Login** link in the top toolbar.
- Select GitHub in the popup to login using your GitHub credentials
- You may then need to go to your email and verify your account.
- You'll then be logged in to the Railway.app dashboard: <https://railway.app/dashboard>.
### Deploy on Railway from GitHub
Next we'll setup Railway to deploy our library from GitHub.
First choose the **Dashboard** option from the site top menu, then select the **New Project** button:
Railway will display a list of options for the new project, including the option to deploy a project from a template that is first created in your GitHub account, and a number of databases.
Select **Deploy from GitHub repo**.
All projects in the GitHub repos you shared with Railway during setup are displayed.
Select your GitHub repository for the local library: `<user-name>/express-locallibrary-tutorial`.
Confirm your deployment by selecting **Deploy Now**.
Railway will then load and deploy your project, displaying progress on the deployments tab.
When deployment successfully completes, you'll see a screen like the one below.
Now select the _Settings_ tab, then scroll down to the Domains section, and press the **Generate Domain** button.
This will publish the site and put the domain in place of the button, as shown below.
Select the domain URL to open your library application.
Note that because we haven't specified a production database, the local library will open using your development data.
### Provision and connect a MongoDB database
Instead of using our development data, next let's create a production MongoDB database to use instead.
We will create the database as part of the Railway application project, although there is nothing to stop you creating in its own separate project, or indeed to use a _MongoDB Atlas_ database for production data, just as you have for the development database.
On Railway, choose the **Dashboard** option from the site top menu and then select your application project.
At this stage it just contains a single service for your application (this can be selected to set variables and other details of the service).
Select the **New** button, which is used to add services to the current project.
Select **Database** when prompted about the type of service to add:
Then select **Add MongoDB** to start adding the database
Railway will then provision a service containing an empty database in the same project.
On completion you will now see both the application and database services in the project view.
Select the MongoDB service to display information about the database.
Open the _Connect_ tab and copy the "Mongo Connection URL" (this is the address of the database).
To make this accessible to the library application we need to add it to the application process using an environment variable.
First open the application service.
Then select the _Variables_ tab and press the **New Variable** button.
Enter the variable name `MONGODB_URI` and the connection URL you copied for the database (`MONGODB_URI` is the name of the environment variable from which [we configured the application](#database_configuration) to read the database address).
This will look something like the screen shown below.
Select **Add** to add the variable.
Railway restarts your app when it updates variables. If you check the home page now it should show zero values for your object counts, as the changes above mean that we're now using a new (empty) database.
### Other configuration variables
You will recall from a preceding section that we need to [set NODE_ENV to 'production'](#node_env) in order to improve our performance and generate less-verbose error messages. We can do this in the same screen as we set the `MONGODB_URI` variable.
Open the application service.
Then select the _Variables_ tab, where you will see that `MONGODB_URI` is already defined, and press the **New Variable** button.
Enter `NODE_ENV` as the name of the new variable and `production` as the name of the environment.
Then press the **Add** button.
The local library application is now setup and configured for production use.
You can add data through the website interface and it should work in the same way that it did during development (though with less debug information exposed for invalid pages).
> **Note:** If you just want to add some data for testing you might use the `populatedb` script (with your MongoDB production database URL) as discussed in the section [Express Tutorial Part 3: Using a Database (with Mongoose) Testing — create some items](/en-US/docs/Learn/Server-side/Express_Nodejs/mongoose#testing_%E2%80%94_create_some_items).
### Install the client
Download and install the Railway client for your local operating system by following the [instructions here](https://docs.railway.app/develop/cli).
After the client is installed you will be able run commands.
Some of the more important operations include deploying the current directory of your computer to an associated Railway project (without having to upload to GitHub), and running your project locally using the same settings as you have on the production server.
You can get a list of all the possible commands by entering the following in a terminal.
```bash
railway help
```
### Debugging
The Railway client provides the logs command to show the tail of logs (a more full log is available on the site for each project):
```bash
railway logs
```
## Summary
That's the end of this tutorial on setting up Express apps in production, and also the series of tutorials on working with Express. We hope you've found them useful. You can check out a fully worked-through version of the [source code on GitHub here](https://github.com/mdn/express-locallibrary-tutorial).
## See also
- [Production best practices: performance and reliability](https://expressjs.com/en/advanced/best-practice-performance.html) (Express docs)
- [Production Best Practices: Security](https://expressjs.com/en/advanced/best-practice-security.html) (Express docs)
- Railway Docs
- [CLI](https://docs.railway.app/develop/cli)
- Digital Ocean
- [Express](https://www.digitalocean.com/community/tutorials?q=express) tutorials
- [Node.js](https://www.digitalocean.com/community/tutorials?q=node.js) tutorials
- Heroku
- [Getting Started on Heroku with Node.js](https://devcenter.heroku.com/articles/getting-started-with-nodejs) (Heroku docs)
- [Deploying Node.js Applications on Heroku](https://devcenter.heroku.com/articles/deploying-nodejs) (Heroku docs)
- [Heroku Node.js Support](https://devcenter.heroku.com/articles/nodejs-support) (Heroku docs)
- [Optimizing Node.js Application Concurrency](https://devcenter.heroku.com/articles/node-concurrency) (Heroku docs)
- [How Heroku works](https://devcenter.heroku.com/articles/how-heroku-works) (Heroku docs)
- [Dynos and the Dyno Manager](https://devcenter.heroku.com/articles/dynos) (Heroku docs)
- [Configuration and Config Vars](https://devcenter.heroku.com/articles/config-vars) (Heroku docs)
- [Limits](https://devcenter.heroku.com/articles/limits) (Heroku docs)
{{PreviousMenu("Learn/Server-side/Express_Nodejs/forms", "Learn/Server-side/Express_Nodejs")}}
| 0 |
data/mdn-content/files/en-us/learn/server-side/express_nodejs | data/mdn-content/files/en-us/learn/server-side/express_nodejs/displaying_data/index.md | ---
title: "Express Tutorial Part 5: Displaying library data"
slug: Learn/Server-side/Express_Nodejs/Displaying_data
page-type: learn-module-chapter
---
{{LearnSidebar}}{{PreviousMenuNext("Learn/Server-side/Express_Nodejs/routes", "Learn/Server-side/Express_Nodejs/forms", "Learn/Server-side/Express_Nodejs")}}
We're now ready to add the pages that display the [LocalLibrary](/en-US/docs/Learn/Server-side/Express_Nodejs/Tutorial_local_library_website) website books and other data. The pages will include a home page that shows how many records we have of each model type and list and detail pages for all of our models. Along the way, we'll gain practical experience in getting records from the database, and using templates.
<table>
<tbody>
<tr>
<th scope="row">Prerequisites:</th>
<td>
Complete previous tutorial topics (including <a href="/en-US/docs/Learn/Server-side/Express_Nodejs/routes">Express Tutorial Part 4: Routes and controllers</a>).
</td>
</tr>
<tr>
<th scope="row">Objective:</th>
<td>
To understand how to perform asynchronous database operations using <code>async</code>/<code>await</code>, how to use the Pug template language, and how to get data from the URL in our controller functions.
</td>
</tr>
</tbody>
</table>
## Overview
In our previous tutorial articles, we defined [Mongoose models](/en-US/docs/Learn/Server-side/Express_Nodejs/mongoose) that we can use to interact with a database and created some initial library records. We then [created all the routes](/en-US/docs/Learn/Server-side/Express_Nodejs/routes) needed for the LocalLibrary website, but with "dummy controller" functions (these are skeleton controller functions that just return a "not implemented" message when a page is accessed).
The next step is to provide proper implementations for the pages that _display_ our library information (we'll look at implementing pages featuring forms to create, update, or delete information in later articles). This includes updating the controller functions to fetch records using our models and defining templates to display this information to users.
We will start by providing overview/primer topics explaining how to manage asynchronous operations in controller functions and how to write templates using Pug. Then we'll provide implementations for each of our main "read-only" pages with a brief explanation of any special or new features that they use.
At the end of this article, you should have a good end-to-end understanding of how routes, asynchronous functions, views, and models work in practice.
## Displaying library data tutorial subarticles
The following subarticles go through the process of adding the different features required for us to display the required website pages.
You need to read and work through each one of these in turn, before moving on to the next one.
1. [Template primer](/en-US/docs/Learn/Server-side/Express_Nodejs/Displaying_data/Template_primer)
2. [The LocalLibrary base template](/en-US/docs/Learn/Server-side/Express_Nodejs/Displaying_data/LocalLibrary_base_template)
3. [Home page](/en-US/docs/Learn/Server-side/Express_Nodejs/Displaying_data/Home_page)
4. [Book list page](/en-US/docs/Learn/Server-side/Express_Nodejs/Displaying_data/Book_list_page)
5. [BookInstance list page](/en-US/docs/Learn/Server-side/Express_Nodejs/Displaying_data/BookInstance_list_page)
6. [Date formatting using luxon](/en-US/docs/Learn/Server-side/Express_Nodejs/Displaying_data/Date_formatting_using_moment)
7. [Author list page and Genre list page challenge](/en-US/docs/Learn/Server-side/Express_Nodejs/Displaying_data/Author_list_page)
8. [Genre detail page](/en-US/docs/Learn/Server-side/Express_Nodejs/Displaying_data/Genre_detail_page)
9. [Book detail page](/en-US/docs/Learn/Server-side/Express_Nodejs/Displaying_data/Book_detail_page)
10. [Author detail page](/en-US/docs/Learn/Server-side/Express_Nodejs/Displaying_data/Author_detail_page)
11. [BookInstance detail page and challenge](/en-US/docs/Learn/Server-side/Express_Nodejs/Displaying_data/BookInstance_detail_page_and_challenge)
## Summary
We've now created all the "read-only" pages for our site: a home page that displays counts of instances of each of our models, and list and detail pages for our books, book instances, authors, and genres. Along the way, we've gained a lot of fundamental knowledge about controllers, managing flow control when using asynchronous operations, creating views using _Pug_, querying the site's database using models, passing information to a view, and creating and extending templates. The challenges will also have taught readers a little about date handling using _Luxon_.
In our next article, we'll build on our knowledge, creating HTML forms and form handling code to start modifying the data stored by the site.
## See also
- [Using Template engines with Express](https://expressjs.com/en/guide/using-template-engines.html) (Express docs)
- [Pug](https://pugjs.org/api/getting-started.html) (Pug docs)
- [Luxon](https://moment.github.io/luxon/#/) (Luxon docs)
{{PreviousMenuNext("Learn/Server-side/Express_Nodejs/routes", "Learn/Server-side/Express_Nodejs/forms", "Learn/Server-side/Express_Nodejs")}}
| 0 |
data/mdn-content/files/en-us/learn/server-side/express_nodejs/displaying_data | data/mdn-content/files/en-us/learn/server-side/express_nodejs/displaying_data/author_list_page/index.md | ---
title: Author list page and Genre list page challenge
slug: Learn/Server-side/Express_Nodejs/Displaying_data/Author_list_page
page-type: learn-module-chapter
---
The author list page needs to display a list of all authors in the database, with each author name linked to its associated author detail page. The date of birth and date of death should be listed after the name on the same line.
## Controller
The author list controller function needs to get a list of all `Author` instances, and then pass these to the template for rendering.
Open **/controllers/authorController.js**. Find the exported `author_list()` controller method near the top of the file and replace it with the following code.
```js
// Display list of all Authors.
exports.author_list = asyncHandler(async (req, res, next) => {
const allAuthors = await Author.find().sort({ family_name: 1 }).exec();
res.render("author_list", {
title: "Author List",
author_list: allAuthors,
});
});
```
The route controller function follows the same pattern as for the other list pages.
It defines a query on the `Author` model, using the `find()` function to get all authors, and the `sort()` method to sort them by `family_name` in alphabetic order.
`exec()` is daisy-chained on the end in order to execute the query and return a promise that the function can `await`.
Once the promise is fulfilled the route handler renders the **author_list**(.pug) template, passing the page `title` and the list of authors (`allAuthors`) using template keys.
## View
Create **/views/author_list.pug** and replace its content with the text below.
```pug
extends layout
block content
h1= title
if author_list.length
ul
each author in author_list
li
a(href=author.url) #{author.name}
| (#{author.date_of_birth} - #{author.date_of_death})
else
p There are no authors.
```
Run the application and open your browser to `http://localhost:3000/`. Then select the _All authors_ link. If everything is set up correctly, the page should look something like the following screenshot.
> **Note:** The appearance of the author _lifespan_ dates is ugly! You can improve this using the [same approach](/en-US/docs/Learn/Server-side/Express_Nodejs/Displaying_data/Date_formatting_using_moment) as we used for the `BookInstance` list (adding the virtual property for the lifespan to the `Author` model).
>
> However, as the author may not be dead or may have missing birth/death data, in this case we need to ignore missing dates or references to nonexistent properties. One way to deal with this is to return either a formatted date, or a blank string, depending on whether the property is defined. For example:
>
> `return this.date_of_birth ? DateTime.fromJSDate(this.date_of_birth).toLocaleString(DateTime.DATE_MED) : '';`
## Genre list page—challenge!
In this section you should implement your own genre list page. The page should display a list of all genres in the database, with each genre linked to its associated detail page. A screenshot of the expected result is shown below.
The genre list controller function needs to get a list of all `Genre` instances, and then pass these to the template for rendering.
1. You will need to edit `genre_list()` in **/controllers/genreController.js**.
2. The implementation is almost exactly the same as the `author_list()` controller.
- Sort the results by name, in ascending order.
3. The template to be rendered should be named **genre_list.pug**.
4. The template to be rendered should be passed the variables `title` ('Genre List') and `genre_list` (the list of genres returned from your `Genre.find()` callback).
5. The view should match the screenshot/requirements above (this should have a very similar structure/format to the Author list view, except for the fact that genres do not have dates).
## Next steps
Return to [Express Tutorial Part 5: Displaying library data](/en-US/docs/Learn/Server-side/Express_Nodejs/Displaying_data).
Proceed to the next subarticle of part 5: [Genre detail page](/en-US/docs/Learn/Server-side/Express_Nodejs/Displaying_data/Genre_detail_page).
| 0 |
data/mdn-content/files/en-us/learn/server-side/express_nodejs/displaying_data | data/mdn-content/files/en-us/learn/server-side/express_nodejs/displaying_data/bookinstance_detail_page_and_challenge/index.md | ---
title: BookInstance detail page and challenge
slug: Learn/Server-side/Express_Nodejs/Displaying_data/BookInstance_detail_page_and_challenge
page-type: learn-module-chapter
---
## BookInstance detail page
The `BookInstance` detail page needs to display the information for each `BookInstance`, identified using its (automatically generated) `_id` field value. This will include the `Book` name (as a link to the _Book detail page_) along with other information in the record.
### Controller
Open **/controllers/bookinstanceController.js**.
Find the exported `bookinstance_detail()` controller method and replace it with the following code.
```js
// Display detail page for a specific BookInstance.
exports.bookinstance_detail = asyncHandler(async (req, res, next) => {
const bookInstance = await BookInstance.findById(req.params.id)
.populate("book")
.exec();
if (bookInstance === null) {
// No results.
const err = new Error("Book copy not found");
err.status = 404;
return next(err);
}
res.render("bookinstance_detail", {
title: "Book:",
bookinstance: bookInstance,
});
});
```
The implementation is very similar to that used for the other model detail pages.
The route controller function calls `BookInstance.findById()` with the ID of a specific book instance extracted from the URL (using the route), and accessed within the controller via the request parameters: `req.params.id`.
It then calls `populate()` to get the details of the associated `Book`.
If a matching `BookInstance` is not found an error is sent to the Express middleware.
Otherwise the returned data is rendered using the **bookinstance_detail.pug** view.
### View
Create **/views/bookinstance_detail.pug** and copy in the content below.
```pug
extends layout
block content
h1 ID: #{bookinstance._id}
p #[strong Title: ]
a(href=bookinstance.book.url) #{bookinstance.book.title}
p #[strong Imprint:] #{bookinstance.imprint}
p #[strong Status: ]
if bookinstance.status=='Available'
span.text-success #{bookinstance.status}
else if bookinstance.status=='Maintenance'
span.text-danger #{bookinstance.status}
else
span.text-warning #{bookinstance.status}
if bookinstance.status!='Available'
p #[strong Due back:] #{bookinstance.due_back}
```
Everything in this template has been demonstrated in previous sections.
### What does it look like?
Run the application and open your browser to `http://localhost:3000/`. Select the _All book-instances_ link, then select one of the items. If everything is set up correctly, your site should look something like the following screenshot.
## Challenge
Currently most _dates_ displayed on the site use the default JavaScript format (e.g. _Tue Oct 06 2020 15:49:58 GMT+1100 (AUS Eastern Daylight Time))_. The challenge for this article is to improve the appearance of the date display for `Author` lifespan information (date of death/birth) and for _BookInstance detail_ pages to use the format: Oct 6th, 2016.
> **Note:** You can use the same approach as we used for the _Book Instance List_ (adding the virtual property for the lifespan to the `Author` model and use [luxon](https://www.npmjs.com/package/luxon) to format the date strings).
To complete this challenge, you must:
1. Replace the variable `due_back` with `due_back_formatted` in the _BookInstance detail_ page.
2. Update the `Author` model to add a lifespan virtual property. The lifespan should look like: _date_of_birth - date_of_death_, where both values have the same date format as `BookInstance.due_back_formatted`.
3. Use `Author.lifespan` in all views where you currently explicitly use `date_of_birth` and `date_of_death`.
## Next steps
- Return to [Express Tutorial Part 5: Displaying library data](/en-US/docs/Learn/Server-side/Express_Nodejs/Displaying_data#displaying_library_data_tutorial_subarticles).
| 0 |
data/mdn-content/files/en-us/learn/server-side/express_nodejs/displaying_data | data/mdn-content/files/en-us/learn/server-side/express_nodejs/displaying_data/bookinstance_list_page/index.md | ---
title: BookInstance list page
slug: Learn/Server-side/Express_Nodejs/Displaying_data/BookInstance_list_page
page-type: learn-module-chapter
---
Next we'll implement our list of all book copies (`BookInstance`) in the library. This page needs to include the title of the `Book` associated with each `BookInstance` (linked to its detail page) along with other information in the `BookInstance` model, including the status, imprint, and unique id of each copy. The unique id text should be linked to the `BookInstance` detail page.
## Controller
The `BookInstance` list controller function needs to get a list of all book instances, populate the associated book information, and then pass the list to the template for rendering.
Open `/controllers/bookinstanceController.js`.
Find the exported `bookinstance_list()` controller method and replace it with the following code.
```js
// Display list of all BookInstances.
exports.bookinstance_list = asyncHandler(async (req, res, next) => {
const allBookInstances = await BookInstance.find().populate("book").exec();
res.render("bookinstance_list", {
title: "Book Instance List",
bookinstance_list: allBookInstances,
});
});
```
The route handler calls the `find()` function on the `BookInstance` model, and then daisy-chains a call to `populate()` with the `book` field—this will replace the book id stored for each `BookInstance` with a full `Book` document.
`exec()` is then daisy-chained on the end in order to execute the query and return a promise.
The route handler uses `await` to wait on the promise, pausing execution until it is settled.
If the promise is fulfilled, the results of the query are saved to the `allBookInstances` variable, and the route handler continues execution.
The last part of the code calls `render()`, specifying the **bookinstance_list** (.pug) template and passing values for the `title` and `bookinstance_list` into the template.
## View
Create **/views/bookinstance_list.pug** and copy in the text below.
```pug
extends layout
block content
h1= title
if bookinstance_list.length
ul
each val in bookinstance_list
li
a(href=val.url) #{val.book.title} : #{val.imprint} -
if val.status=='Available'
span.text-success #{val.status}
else if val.status=='Maintenance'
span.text-danger #{val.status}
else
span.text-warning #{val.status}
if val.status!='Available'
span (Due: #{val.due_back} )
else
p There are no book copies in this library.
```
This view is much the same as all the others. It extends the layout, replacing the _content_ block, displays the `title` passed in from the controller, and iterates through all the book copies in `bookinstance_list`. For each copy we display its status (color coded) and if the book is not available, its expected return date. One new feature is introduced—we can use dot notation after a tag to assign a class. So `span.text-success` will be compiled to `<span class="text-success">` (and might also be written in Pug as `span(class="text-success")`.
## What does it look like?
Run the application, open your browser to `http://localhost:3000/`, then select the _All book-instances_ link. If everything is set up correctly, your site should look something like the following screenshot.
## Next steps
- Return to [Express Tutorial Part 5: Displaying library data](/en-US/docs/Learn/Server-side/Express_Nodejs/Displaying_data).
- Proceed to the next subarticle of part 5: [Date formatting using luxon](/en-US/docs/Learn/Server-side/Express_Nodejs/Displaying_data/Date_formatting_using_moment).
| 0 |
data/mdn-content/files/en-us/learn/server-side/express_nodejs/displaying_data | data/mdn-content/files/en-us/learn/server-side/express_nodejs/displaying_data/home_page/index.md | ---
title: Home page
slug: Learn/Server-side/Express_Nodejs/Displaying_data/Home_page
page-type: learn-module-chapter
---
The first page we'll create will be the website home page, which is accessible from either the site (`/`) or catalog (`catalog/`) root. This will display some static text describing the site, along with dynamically calculated "counts" of different record types in the database.
We've already created a route for the home page. In order to complete the page we need to update our controller function to fetch "counts" of records from the database, and create a view (template) that we can use to render the page.
> **Note:** We'll be using Mongoose for getting database information.
> Before continuing you may wish to re-read the [Mongoose primer](/en-US/docs/Learn/Server-side/Express_Nodejs/mongoose#mongoose_primer) section on [searching for records](/en-US/docs/Learn/Server-side/Express_Nodejs/mongoose#searching_for_records).
## Route
We created our index page routes in a [previous tutorial](/en-US/docs/Learn/Server-side/Express_Nodejs/routes).
As a reminder, all the route functions are defined in **/routes/catalog.js**:
```js
// GET catalog home page.
router.get("/", book_controller.index); //This actually maps to /catalog/ because we import the route with a /catalog prefix
```
The book controller index function passed as a parameter (`book_controller.index`) has a "placeholder" implementation defined in **/controllers/bookController.js**:
```js
exports.index = asyncHandler(async (req, res, next) => {
res.send("NOT IMPLEMENTED: Site Home Page");
});
```
It is this controller function that we extend to get information from our models and then render it using a template (view).
## Controller
The index controller function needs to fetch information about how many `Book`, `BookInstance` (all), `BookInstance` (available), `Author`, and `Genre` records we have in the database, render this data in a template to create an HTML page, and then return it in an HTTP response.
Open **/controllers/bookController.js**. Near the top of the file you should see the exported `index()` function.
```js
const Book = require("../models/book");
const asyncHandler = require("express-async-handler");
exports.index = asyncHandler(async (req, res, next) => {
res.send("NOT IMPLEMENTED: Site Home Page");
});
```
Replace all the code above with the following code fragment.
The first thing this does is import (`require()`) all the models.
We need to do this because we'll be using them to get our counts of documents.
The code also requires "express-async-handler", which provides a wrapper to [catch exceptions thrown in route handler functions](/en-US/docs/Learn/Server-side/Express_Nodejs/routes#handling_exceptions_in_route_functions).
```js
const Book = require("../models/book");
const Author = require("../models/author");
const Genre = require("../models/genre");
const BookInstance = require("../models/bookinstance");
const asyncHandler = require("express-async-handler");
exports.index = asyncHandler(async (req, res, next) => {
// Get details of books, book instances, authors and genre counts (in parallel)
const [
numBooks,
numBookInstances,
numAvailableBookInstances,
numAuthors,
numGenres,
] = await Promise.all([
Book.countDocuments({}).exec(),
BookInstance.countDocuments({}).exec(),
BookInstance.countDocuments({ status: "Available" }).exec(),
Author.countDocuments({}).exec(),
Genre.countDocuments({}).exec(),
]);
res.render("index", {
title: "Local Library Home",
book_count: numBooks,
book_instance_count: numBookInstances,
book_instance_available_count: numAvailableBookInstances,
author_count: numAuthors,
genre_count: numGenres,
});
});
```
We use the [`countDocuments()`](<https://mongoosejs.com/docs/api/model.html#Model.countDocuments()>) method to get the number of instances of each model.
This method is called on a model, with an optional set of conditions to match against, and returns a `Query` object.
The query can be executed by calling [`exec()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.exec), which returns a `Promise` that is either fulfilled with a result, or rejected if there is a database error.
Because the queries for document counts are independent of each other we use [`Promise.all()`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/all) to run them in parallel.
The method returns a new promise that we [`await`](/en-US/docs/Web/JavaScript/Reference/Operators/await) for completion (execution pauses within _this function_ at `await`).
When all the queries complete, the promise returned by `all()` fulfills, continuing execution of the route handler function, and populating the array with the results of the database queries.
We then call [`res.render()`](https://expressjs.com/en/4x/api.html#res.render), specifying a view (template) named '**index**' and objects mapping the results of the database queries to the view template.
The data is supplied as key-value pairs, and can be accessed in the template using the key.
Note that the code is very simple because we can assume that the database queries succeed.
If any of the database operations fail, the exception that is thrown will be caught by `asyncHandler()` and passed to the `next` middleware handler in the chain.
## View
Open **/views/index.pug** and replace its content with the text below.
```pug
extends layout
block content
h1= title
p Welcome to #[em LocalLibrary], a very basic Express website developed as a tutorial example on the Mozilla Developer Network.
h1 Dynamic content
p The library has the following record counts:
ul
li #[strong Books:] !{book_count}
li #[strong Copies:] !{book_instance_count}
li #[strong Copies available:] !{book_instance_available_count}
li #[strong Authors:] !{author_count}
li #[strong Genres:] !{genre_count}
```
The view is straightforward. We extend the **layout.pug** base template, overriding the `block` named '**content**'. The first `h1` heading will be the escaped text for the `title` variable that was passed into the `render()` function—note the use of the '`h1=`' so that the following text is treated as a JavaScript expression. We then include a paragraph introducing the LocalLibrary.
Under the _Dynamic content_ heading we list the number of copies of each model.
Note that the template values for the data are the keys that were specified when `render()` was called in the route handler function.
> **Note:** We didn't escape the count values (i.e. we used the `!{}` syntax) because the count values are calculated. If the information was supplied by end-users then we'd escape the variable for display.
## What does it look like?
At this point we should have created everything needed to display the index page. Run the application and open your browser to `http://localhost:3000/`. If everything is set up correctly, your site should look something like the following screenshot.
> **Note:** You won't be able to _use_ the sidebar links yet because the URLs, views, and templates for those pages haven't been defined. If you try you'll get errors like "NOT IMPLEMENTED: Book list" for example, depending on the link you click on. These string literals (which will be replaced with proper data) were specified in the different controllers that live inside your "controllers" file.
## Next steps
- Return to [Express Tutorial Part 5: Displaying library data](/en-US/docs/Learn/Server-side/Express_Nodejs/Displaying_data).
- Proceed to the next subarticle of part 5: [Book list page](/en-US/docs/Learn/Server-side/Express_Nodejs/Displaying_data/Book_list_page).
| 0 |
data/mdn-content/files/en-us/learn/server-side/express_nodejs/displaying_data | data/mdn-content/files/en-us/learn/server-side/express_nodejs/displaying_data/date_formatting_using_moment/index.md | ---
title: Date formatting using luxon
slug: Learn/Server-side/Express_Nodejs/Displaying_data/Date_formatting_using_moment
page-type: learn-module-chapter
---
The default rendering of dates from our models is very ugly: _Mon Apr 10 2020 15:49:58 GMT+1100 (AUS Eastern Daylight Time)_. In this section we'll show how you can update the _BookInstance List_ page from the previous section to present the `due_date` field in a more friendly format: Apr 10th, 2023.
The approach we will use is to create a virtual property in our `BookInstance` model that returns the formatted date. We'll do the actual formatting using [luxon](https://www.npmjs.com/package/luxon), a powerful, modern, and friendly library for parsing, validating, manipulating, formatting and localising dates.
> **Note:** It is possible to use _luxon_ to format the strings directly in our Pug templates, or we could format the string in a number of other places. Using a virtual property allows us to get the formatted date in exactly the same way as we get the `due_date` currently.
## Install luxon
Enter the following command in the root of the project:
```bash
npm install luxon
```
## Create the virtual property
1. Open **./models/bookinstance.js**.
2. At the top of the page, import _luxon_.
```js
const { DateTime } = require("luxon");
```
Add the virtual property `due_back_formatted` just after the URL property.
```js
BookInstanceSchema.virtual("due_back_formatted").get(function () {
return DateTime.fromJSDate(this.due_back).toLocaleString(DateTime.DATE_MED);
});
```
> **Note:** Luxon can import strings in many formats and export to both predefined and free-form formats. In this case we use `fromJSDate()` to import a JavaScript date string and `toLocaleString()` to output the date in `DATE_MED` format in English: Apr 10th, 2023.
> For information about other formats and date string internationalization see the Luxon documentation on [formatting](https://github.com/moment/luxon/blob/master/docs/formatting.md#formatting).
## Update the view
Open **/views/bookinstance_list.pug** and replace `due_back` with `due_back_formatted`.
```pug
if val.status != 'Available'
//span (Due: #{val.due_back} )
span (Due: #{val.due_back_formatted} )
```
That's it. If you go to _All book-instances_ in the sidebar, you should now see all the due dates are far more attractive!
## Next steps
- Return to [Express Tutorial Part 5: Displaying library data](/en-US/docs/Learn/Server-side/Express_Nodejs/Displaying_data).
- Proceed to the next subarticle of part 5: [Author list page and Genre list page challenge](/en-US/docs/Learn/Server-side/Express_Nodejs/Displaying_data/Author_list_page).
| 0 |
data/mdn-content/files/en-us/learn/server-side/express_nodejs/displaying_data | data/mdn-content/files/en-us/learn/server-side/express_nodejs/displaying_data/author_detail_page/index.md | ---
title: Author detail page
slug: Learn/Server-side/Express_Nodejs/Displaying_data/Author_detail_page
page-type: learn-module-chapter
---
The author detail page needs to display the information about the specified `Author`, identified using their (automatically generated) `_id` field value, along with a list of all the `Book` objects associated with that `Author`.
## Controller
Open **/controllers/authorController.js**.
Add the following lines to the top of the file to `require()` the `Book` module needed by the author detail page (other modules such as "express-async-handler" should already be present).
```js
const Book = require("../models/book");
```
Find the exported `author_detail()` controller method and replace it with the following code.
```js
// Display detail page for a specific Author.
exports.author_detail = asyncHandler(async (req, res, next) => {
// Get details of author and all their books (in parallel)
const [author, allBooksByAuthor] = await Promise.all([
Author.findById(req.params.id).exec(),
Book.find({ author: req.params.id }, "title summary").exec(),
]);
if (author === null) {
// No results.
const err = new Error("Author not found");
err.status = 404;
return next(err);
}
res.render("author_detail", {
title: "Author Detail",
author: author,
author_books: allBooksByAuthor,
});
});
```
The approach is exactly the same as described for the [Genre detail page](/en-US/docs/Learn/Server-side/Express_Nodejs/Displaying_data/Genre_detail_page).
The route controller function uses `Promise.all()` to query the specified `Author` and their associated `Book` instances in parallel.
If no matching author is found an Error object is sent to the Express error handling middleware.
If the author is found then the retrieved database information is rendered using the "author_detail" template.
## View
Create **/views/author_detail.pug** and copy in the following text.
```pug
extends layout
block content
h1 Author: #{author.name}
p #{author.date_of_birth} - #{author.date_of_death}
div(style='margin-left:20px;margin-top:20px')
h4 Books
if author_books.length
dl
each book in author_books
dt
a(href=book.url) #{book.title}
dd #{book.summary}
else
p This author has no books.
```
Everything in this template has been demonstrated in previous sections.
## What does it look like?
Run the application and open your browser to `http://localhost:3000/`. Select the _All Authors_ link, then select one of the authors. If everything is set up correctly, your site should look something like the following screenshot.
> **Note:** The appearance of the author _lifespan_ dates is ugly! We'll address that in the final challenge in this article.
## Next steps
- Return to [Express Tutorial Part 5: Displaying library data](/en-US/docs/Learn/Server-side/Express_Nodejs/Displaying_data).
- Proceed to final subarticle of part 5 : [BookInstance detail page and challenge](/en-US/docs/Learn/Server-side/Express_Nodejs/Displaying_data/BookInstance_detail_page_and_challenge).
| 0 |
data/mdn-content/files/en-us/learn/server-side/express_nodejs/displaying_data | data/mdn-content/files/en-us/learn/server-side/express_nodejs/displaying_data/template_primer/index.md | ---
title: Template primer
slug: Learn/Server-side/Express_Nodejs/Displaying_data/Template_primer
page-type: learn-module-chapter
---
A template is a text file defining the _structure_ or layout of an output file, with placeholders used to represent where data will be inserted when the template is rendered (in _Express_, templates are referred to as _views_).
## Express template choices
Express can be used with many different [template rendering engines](https://expressjs.com/en/guide/using-template-engines.html). In this tutorial we use [Pug](https://pugjs.org/api/getting-started.html) (formerly known as _Jade_) for our templates. This is the most popular Node template language, and describes itself as a "clean, whitespace-sensitive syntax for writing HTML, heavily influenced by [Haml](https://haml.info/)".
Different template languages use different approaches for defining layout and marking placeholders for data—some use HTML to define the layout while others use different markup formats that can be transpiled to HTML. Pug is of the second type; it uses a _representation_ of HTML where the first word in any line usually represents an HTML element, and indentation on subsequent lines is used to represent nesting. The result is a page definition that translates directly to HTML, but is more concise and arguably easier to read.
> **Note:** The downside of using _Pug_ is that it is sensitive to indentation and whitespace (if you add an extra space in the wrong place you may get an unhelpful error code). Once you have your templates in place, however, they are very easy to read and maintain.
## Template configuration
The _LocalLibrary_ was configured to use [Pug](https://pugjs.org/api/getting-started.html) when we [created the skeleton website](/en-US/docs/Learn/Server-side/Express_Nodejs/skeleton_website). You should see the pug module included as a dependency in the website's **package.json** file, and the following configuration settings in the **app.js** file. The settings tell us that we're using pug as the view engine, and that _Express_ should search for templates in the **/views** subdirectory.
```js
// View engine setup
app.set("views", path.join(__dirname, "views"));
app.set("view engine", "pug");
```
If you look in the views directory you will see the .pug files for the project's default views.
These include the view for the home page (**index.pug**) and base template (**layout.pug**) that we will need to replace with our own content.
```plain
/express-locallibrary-tutorial //the project root
/views
error.pug
index.pug
layout.pug
```
## Template syntax
The example template file below shows off many of Pug's most useful features.
The first thing to notice is that the file maps the structure of a typical HTML file, with the first word in (almost) every line being an HTML element, and indentation being used to indicate nested elements. So for example, the `body` element is inside an `html` element, and paragraph elements (`p`) are within the `body` element, etc. Non-nested elements (e.g. individual paragraphs) are on separate lines.
```pug
doctype html
html(lang="en")
head
title= title
script(type='text/javascript').
body
h1= title
p This is a line with #[em some emphasis] and #[strong strong text] markup.
p This line has un-escaped data: !{'<em> is emphasized</em>'} and escaped data: #{'<em> is not emphasized</em>'}.
| This line follows on.
p= 'Evaluated and <em>escaped expression</em>:' + title
<!-- You can add HTML comments directly -->
// You can add single line JavaScript comments and they are generated to HTML comments
//- Introducing a single line JavaScript comment with "//-" ensures the comment isn't rendered to HTML
p A line with a link
a(href='/catalog/authors') Some link text
| and some extra text.
#container.col
if title
p A variable named "title" exists.
else
p A variable named "title" does not exist.
p.
Pug is a terse and simple template language with a
strong focus on performance and powerful features.
h2 Generate a list
ul
each val in [1, 2, 3, 4, 5]
li= val
```
Element attributes are defined in parentheses after their associated element. Inside the parentheses, the attributes are defined in comma- or whitespace- separated lists of the pairs of attribute names and attribute values, for example:
- `script(type='text/javascript')`, `link(rel='stylesheet', href='/stylesheets/style.css')`
- `meta(name='viewport' content='width=device-width initial-scale=1')`
The values of all attributes are _escaped_ (e.g. characters like `>` are converted to their HTML code equivalents like `>`) to prevent JavaScript injection or cross-site scripting attacks.
If a tag is followed by the equals sign, the following text is treated as a JavaScript _expression_. So for example, in the first line below, the content of the `h1` tag will be _variable_ `title` (either defined in the file or passed into the template from Express). In the second line the paragraph content is a text string concatenated with the `title` variable. In both cases the default behavior is to _escape_ the line.
```pug
h1= title
p= 'Evaluated and <em>escaped expression</em>:' + title
```
If there is no equals symbol after the tag then the content is treated as plain text. Within the plain text you can insert escaped and unescaped data using the `#{}` and `!{}` syntax respectively, as shown below. You can also add raw HTML within the plain text.
```pug
p This is a line with #[em some emphasis] and #[strong strong text] markup.
p This line has an un-escaped string: !{'<em> is emphasized</em>'}, an escaped string: #{'<em> is not emphasized</em>'}, and escaped variables: #{title}.
```
> **Note:** You will almost always want to escape data from users (via the **`#{}`** syntax). Data that can be trusted (e.g. generated counts of records, etc.) may be displayed without escaping the values.
You can use the pipe ('**|**') character at the beginning of a line to indicate "[plain text](https://pugjs.org/language/plain-text.html)". For example, the additional text shown below will be displayed on the same line as the preceding anchor, but will not be linked.
```pug
a(href='http://someurl/') Link text
| Plain text
```
Pug allows you to perform conditional operations using `if`, `else`, `else if` and `unless` — for example:
```pug
if title
p A variable named "title" exists
else
p A variable named "title" does not exist
```
You can also perform loop/iteration operations using `each-in` or `while` syntax. In the code fragment below we've looped through an array to display a list of variables (note the use of the 'li=' to evaluate the "val" as a variable below. The value you iterate across can also be passed into the template as a variable!
```pug
ul
each val in [1, 2, 3, 4, 5]
li= val
```
The syntax also supports comments (that can be rendered in the output—or not—as you choose), mixins to create reusable blocks of code, case statements, and many other features. For more detailed information see [The Pug docs](https://pugjs.org/api/getting-started.html).
## Extending templates
Across a site, it is usual for all pages to have a common structure, including standard HTML markup for the head, footer, navigation, etc. Rather than forcing developers to duplicate this "boilerplate" in every page, _Pug_ allows you to declare a base template and then extend it, replacing just the bits that are different for each specific page.
For example, the base template **layout.pug** created in our [skeleton project](/en-US/docs/Learn/Server-side/Express_Nodejs/skeleton_website) looks like this:
```pug
doctype html
html
head
title= title
link(rel='stylesheet', href='/stylesheets/style.css')
body
block content
```
The `block` tag is used to mark up sections of content that may be replaced in a derived template (if the block is not redefined then its implementation in the base class is used).
The default **index.pug** (created for our skeleton project) shows how we override the base template. The `extends` tag identifies the base template to use, and then we use `block section_name` to indicate the new content of the section that we will override.
```pug
extends layout
block content
h1= title
p Welcome to #{title}
```
## Next steps
- Return to [Express Tutorial Part 5: Displaying library data](/en-US/docs/Learn/Server-side/Express_Nodejs/Displaying_data).
- Proceed to the next subarticle of part 5: [The LocalLibrary base template](/en-US/docs/Learn/Server-side/Express_Nodejs/Displaying_data/LocalLibrary_base_template).
| 0 |
data/mdn-content/files/en-us/learn/server-side/express_nodejs/displaying_data | data/mdn-content/files/en-us/learn/server-side/express_nodejs/displaying_data/book_detail_page/index.md | ---
title: Book detail page
slug: Learn/Server-side/Express_Nodejs/Displaying_data/Book_detail_page
page-type: learn-module-chapter
---
The _Book detail page_ needs to display the information for a specific `Book` (identified using its automatically generated `_id` field value), along with information about each associated copy in the library (`BookInstance`). Wherever we display an author, genre, or book instance, these should be linked to the associated detail page for that item.
## Controller
Open **/controllers/bookController.js**. Find the exported `book_detail()` controller method and replace it with the following code.
```js
// Display detail page for a specific book.
exports.book_detail = asyncHandler(async (req, res, next) => {
// Get details of books, book instances for specific book
const [book, bookInstances] = await Promise.all([
Book.findById(req.params.id).populate("author").populate("genre").exec(),
BookInstance.find({ book: req.params.id }).exec(),
]);
if (book === null) {
// No results.
const err = new Error("Book not found");
err.status = 404;
return next(err);
}
res.render("book_detail", {
title: book.title,
book: book,
book_instances: bookInstances,
});
});
```
> **Note:** We don't need to require any additional modules in this step, as we already imported the dependencies when we implemented the home page controller.
The approach is exactly the same as described for the [Genre detail page](/en-US/docs/Learn/Server-side/Express_Nodejs/Displaying_data/Genre_detail_page).
The route controller function uses `Promise.all()` to query the specified `Book` and its associated copies (`BookInstance`) in parallel.
If no matching book is found an Error object is returned with a "404: Not Found" error.
If the book is found, then the retrieved database information is rendered using the "book_detail" template.
Since the key 'title' is used to give name to the webpage (as defined in the header in 'layout.pug'), this time we are passing `results.book.title` while rendering the webpage.
## View
Create **/views/book_detail.pug** and add the text below.
```pug
extends layout
block content
h1 Title: #{book.title}
p #[strong Author: ]
a(href=book.author.url) #{book.author.name}
p #[strong Summary:] #{book.summary}
p #[strong ISBN:] #{book.isbn}
p #[strong Genre: ]
each val, index in book.genre
a(href=val.url) #{val.name}
if index < book.genre.length - 1
|,
div(style='margin-left:20px;margin-top:20px')
h4 Copies
each val in book_instances
hr
if val.status=='Available'
p.text-success #{val.status}
else if val.status=='Maintenance'
p.text-danger #{val.status}
else
p.text-warning #{val.status}
p #[strong Imprint:] #{val.imprint}
if val.status!='Available'
p #[strong Due back:] #{val.due_back}
p #[strong Id: ]
a(href=val.url) #{val._id}
else
p There are no copies of this book in the library.
```
Almost everything in this template has been demonstrated in previous sections.
> **Note:** The list of genres associated with the book is implemented in the template as below. This adds a comma and a non breaking space after every genre associated with the book except for the last one.
>
> ```pug
> p #[strong Genre: ]
> each val, index in book.genre
> a(href=val.url) #{val.name}
> if index < book.genre.length - 1
> |,
> ```
## What does it look like?
Run the application and open your browser to `http://localhost:3000/`. Select the _All books_ link, then select one of the books. If everything is set up correctly, your page should look something like the following screenshot.
## Next steps
- Return to [Express Tutorial Part 5: Displaying library data](/en-US/docs/Learn/Server-side/Express_Nodejs/Displaying_data).
- Proceed to the next subarticle of part 5: [Author detail page](/en-US/docs/Learn/Server-side/Express_Nodejs/Displaying_data/Author_detail_page).
| 0 |
data/mdn-content/files/en-us/learn/server-side/express_nodejs/displaying_data | data/mdn-content/files/en-us/learn/server-side/express_nodejs/displaying_data/locallibrary_base_template/index.md | ---
title: LocalLibrary base template
slug: Learn/Server-side/Express_Nodejs/Displaying_data/LocalLibrary_base_template
page-type: learn-module-chapter
---
Now that we understand how to extend templates using Pug, let's start by creating a base template for the project. This will have a sidebar with links for the pages we hope to create across the tutorial articles (e.g. to display and create books, genres, authors, etc.) and a main content area that we'll override in each of our individual pages.
Open **/views/layout.pug** and replace the content with the code below.
```pug
doctype html
html(lang='en')
head
title= title
meta(charset='utf-8')
meta(name='viewport', content='width=device-width, initial-scale=1')
link(rel="stylesheet", href="https://cdn.jsdelivr.net/npm/[email protected]/dist/css/bootstrap.min.css", integrity="sha384-xOolHFLEh07PJGoPkLv1IbcEPTNtaed2xpHsD9ESMhqIYd0nLMwNLD69Npy4HI+N", crossorigin="anonymous")
script(src="https://code.jquery.com/jquery-3.5.1.slim.min.js", integrity="sha384-DfXdz2htPH0lsSSs5nCTpuj/zy4C+OGpamoFVy38MVBnE+IbbVYUew+OrCXaRkfj", crossorigin="anonymous")
script(src="https://cdn.jsdelivr.net/npm/[email protected]/dist/js/bootstrap.min.js", integrity="sha384-+sLIOodYLS7CIrQpBjl+C7nPvqq+FbNUBDunl/OZv93DB7Ln/533i8e/mZXLi/P+", crossorigin="anonymous")
link(rel='stylesheet', href='/stylesheets/style.css')
body
div(class='container-fluid')
div(class='row')
div(class='col-sm-2')
block sidebar
ul(class='sidebar-nav')
li
a(href='/catalog') Home
li
a(href='/catalog/books') All books
li
a(href='/catalog/authors') All authors
li
a(href='/catalog/genres') All genres
li
a(href='/catalog/bookinstances') All book-instances
li
hr
li
a(href='/catalog/author/create') Create new author
li
a(href='/catalog/genre/create') Create new genre
li
a(href='/catalog/book/create') Create new book
li
a(href='/catalog/bookinstance/create') Create new book instance (copy)
div(class='col-sm-10')
block content
```
The template uses (and includes) JavaScript and CSS from [Bootstrap](https://getbootstrap.com/) to improve the layout and presentation of the HTML page. Using Bootstrap or another client-side web framework is a quick way to create an attractive page that can scale well on different browser sizes, and it also allows us to deal with the page presentation without having to get into any of the details—we just want to focus on the server-side code here!
> **Note:** The scripts are loaded cross-origin, so later in the tutorial, when we add security middleware, we will need to explicitly allow these files to be loaded.
> For more information see [Deployment > Use Helmet to protect against well known vulnerabilities](/en-US/docs/Learn/Server-side/Express_Nodejs/deployment#use_helmet_to_protect_against_well_known_vulnerabilities).
The layout should be fairly obvious if you've read our above [Template primer](/en-US/docs/Learn/Server-side/Express_Nodejs/Displaying_data#template_primer). Note the use of `block content` as a placeholder for where the content for our individual pages will be placed.
The base template also references a local CSS file (**style.css**) that provides a little additional styling. Open **/public/stylesheets/style.css** and replace its content with the following CSS code:
```css
.sidebar-nav {
margin-top: 20px;
padding: 0;
list-style: none;
}
```
Now we have a base template for creating pages with a sidebar. In the next sections we will use it to define the individual pages.
## Next steps
- Return to [Express Tutorial Part 5: Displaying library data](/en-US/docs/Learn/Server-side/Express_Nodejs/Displaying_data).
- Proceed to the next subarticle of part 5: [Home page](/en-US/docs/Learn/Server-side/Express_Nodejs/Displaying_data/Home_page).
| 0 |
data/mdn-content/files/en-us/learn/server-side/express_nodejs/displaying_data | data/mdn-content/files/en-us/learn/server-side/express_nodejs/displaying_data/genre_detail_page/index.md | ---
title: Genre detail page
slug: Learn/Server-side/Express_Nodejs/Displaying_data/Genre_detail_page
page-type: learn-module-chapter
---
The genre _detail_ page needs to display the information for a particular genre instance, using its automatically generated `_id` field value as the identifier.
The ID of the required genre record is encoded at the end of the URL and extracted automatically based on the route definition (**/genre/:id**).
It is then accessed within the controller via the request parameters: `req.params.id`.
The page should display the genre name and a list of all books in the genre with links to each book's details page.
## Controller
Open **/controllers/genreController.js** and require the `Book` module at the top of the file (the file should already `require()` the `Genre` module and "express-async-handler").
```js
const Book = require("../models/book");
```
Find the exported `genre_detail()` controller method and replace it with the following code.
```js
// Display detail page for a specific Genre.
exports.genre_detail = asyncHandler(async (req, res, next) => {
// Get details of genre and all associated books (in parallel)
const [genre, booksInGenre] = await Promise.all([
Genre.findById(req.params.id).exec(),
Book.find({ genre: req.params.id }, "title summary").exec(),
]);
if (genre === null) {
// No results.
const err = new Error("Genre not found");
err.status = 404;
return next(err);
}
res.render("genre_detail", {
title: "Genre Detail",
genre: genre,
genre_books: booksInGenre,
});
});
```
We first use `Genre.findById()` to get Genre information for a specific ID, and `Book.find()` to get all books records that have that same associated genre ID.
Because the two requests do not depend on each other, we use `Promise.all()` to run the database queries in parallel (this same approach for running queries in parallel was demonstrated in the [home page](/en-US/docs/Learn/Server-side/Express_Nodejs/Displaying_data/Home_page#controller)).
We `await` on the returned promise, and once it settles we check the results.
If the genre does not exist in the database (i.e. it may have been deleted) then `findById()` will return successfully with no results.
In this case we want to display a "not found" page, so we create an `Error` object and pass it to the `next` middleware function in the chain.
> **Note:** Errors passed to the `next` middleware function propagate through to our error handling code (this was set up when we [generated the app skeleton](/en-US/docs/Learn/Server-side/Express_Nodejs/skeleton_website#app.js) - for more information see [Handling Errors](/en-US/docs/Learn/Server-side/Express_Nodejs/Introduction#handling_errors)).
If the `genre` is found, then we call `render()` to display the view.
The view template is **genre_detail** (.pug).
The values for the title, `genre` and `booksInGenre` are passed into the template using the corresponding keys (`title`, `genre` and `genre_books`).
## View
Create **/views/genre_detail.pug** and fill it with the text below:
```pug
extends layout
block content
h1 Genre: #{genre.name}
div(style='margin-left:20px;margin-top:20px')
h4 Books
if genre_books.length
dl
each book in genre_books
dt
a(href=book.url) #{book.title}
dd #{book.summary}
else
p This genre has no books.
```
The view is very similar to all our other templates. The main difference is that we don't use the `title` passed in for the first heading (though it is used in the underlying **layout.pug** template to set the page title).
## What does it look like?
Run the application and open your browser to `http://localhost:3000/`. Select the _All genres_ link, then select one of the genres (e.g. "Fantasy"). If everything is set up correctly, your page should look something like the following screenshot.
> **Note:** You might get an error similar to the one below if `req.params.id` (or any other ID) cannot be cast to a [`mongoose.Types.ObjectId()`](https://mongoosejs.com/docs/api/mongoose.html#Mongoose.prototype.Types).
>
> ```bash
> Cast to ObjectId failed for value " 59347139895ea23f9430ecbb" at path "_id" for model "Genre"
> ```
>
> The most likely cause is that the ID being passed into the mongoose methods is not actually an ID.
> [`Mongoose.prototype.isValidObjectId()`](<https://mongoosejs.com/docs/api/mongoose.html#Mongoose.prototype.isValidObjectId()>) can be used to check whether a particular ID is valid.
## Next steps
- Return to [Express Tutorial Part 5: Displaying library data](/en-US/docs/Learn/Server-side/Express_Nodejs/Displaying_data).
- Proceed to the next subarticle of part 5: [Book detail page](/en-US/docs/Learn/Server-side/Express_Nodejs/Displaying_data/Book_detail_page).
| 0 |
data/mdn-content/files/en-us/learn/server-side/express_nodejs/displaying_data | data/mdn-content/files/en-us/learn/server-side/express_nodejs/displaying_data/book_list_page/index.md | ---
title: Book list page
slug: Learn/Server-side/Express_Nodejs/Displaying_data/Book_list_page
page-type: learn-module-chapter
---
Next we'll implement our book list page. This page needs to display a list of all books in the database along with their author, with each book title being a hyperlink to its associated book detail page.
## Controller
The book list controller function needs to get a list of all `Book` objects in the database, sort them, and then pass these to the template for rendering.
Open **/controllers/bookController.js**. Find the exported `book_list()` controller method and replace it with the following code.
```js
// Display list of all books.
exports.book_list = asyncHandler(async (req, res, next) => {
const allBooks = await Book.find({}, "title author")
.sort({ title: 1 })
.populate("author")
.exec();
res.render("book_list", { title: "Book List", book_list: allBooks });
});
```
The route handler calls the `find()` function on the `Book` model, selecting to return only the `title` and `author` as we don't need the other fields (it will also return the `_id` and virtual fields), and sorting the results by the title alphabetically using the `sort()` method.
We also call `populate()` on `Book`, specifying the `author` field—this will replace the stored book author id with the full author details.
`exec()` is then daisy-chained on the end in order to execute the query and return a promise.
The route handler uses `await` to wait on the promise, pausing execution until it is settled.
If the promise is fulfilled, the results of the query are saved to the `allBooks` variable and the handler continues execution.
The final part of the route handler calls `render()`, specifying the **book_list** (.pug) template and passing values for the `title` and `book_list` into the template.
## View
Create **/views/book_list.pug** and copy in the text below.
```pug
extends layout
block content
h1= title
if book_list.length
ul
each book in book_list
li
a(href=book.url) #{book.title}
| (#{book.author.name})
else
p There are no books.
```
The view extends the **layout.pug** base template and overrides the `block` named '**content**'. It displays the `title` we passed in from the controller (via the `render()` method) and iterates through the `book_list` variable using the `each`-`in` syntax. A list item is created for each book displaying the book title as a link to the book's detail page followed by the author name.
If there are no books in the `book_list` then the `else` clause is executed, and displays the text 'There are no books'.
> **Note:** We use `book.url` to provide the link to the detail record for each book (we've implemented this route, but not the page yet). This is a virtual property of the `Book` model which uses the model instance's `_id` field to produce a unique URL path.
Of interest here is that each book is defined as two lines, using the pipe for the second line. This approach is needed because if the author name were on the previous line then it would be part of the hyperlink.
## What does it look like?
Run the application (see [Testing the routes](/en-US/docs/Learn/Server-side/Express_Nodejs/routes#testing_the_routes) for the relevant commands) and open your browser to `http://localhost:3000/`. Then select the _All books_ link. If everything is set up correctly, your site should look something like the following screenshot.
## Next steps
- Return to [Express Tutorial Part 5: Displaying library data](/en-US/docs/Learn/Server-side/Express_Nodejs/Displaying_data).
- Proceed to the next subarticle of part 5: [BookInstance list page](/en-US/docs/Learn/Server-side/Express_Nodejs/Displaying_data/BookInstance_list_page).
| 0 |
data/mdn-content/files/en-us/learn/server-side/express_nodejs | data/mdn-content/files/en-us/learn/server-side/express_nodejs/mongoose/index.md | ---
title: "Express Tutorial Part 3: Using a Database (with Mongoose)"
slug: Learn/Server-side/Express_Nodejs/mongoose
page-type: learn-module-chapter
---
{{LearnSidebar}}{{PreviousMenuNext("Learn/Server-side/Express_Nodejs/skeleton_website", "Learn/Server-side/Express_Nodejs/routes", "Learn/Server-side/Express_Nodejs")}}
This article briefly introduces databases, and how to use them with Node/Express apps. It then goes on to show how we can use [Mongoose](https://mongoosejs.com/) to provide database access for the [LocalLibrary](/en-US/docs/Learn/Server-side/Express_Nodejs/Tutorial_local_library_website) website. It explains how object schema and models are declared, the main field types, and basic validation. It also briefly shows a few of the main ways in which you can access model data.
<table>
<tbody>
<tr>
<th scope="row">Prerequisites:</th>
<td>
<a href="/en-US/docs/Learn/Server-side/Express_Nodejs/skeleton_website">Express Tutorial Part 2: Creating a skeleton website</a>
</td>
</tr>
<tr>
<th scope="row">Objective:</th>
<td>To be able to design and create your own models using Mongoose.</td>
</tr>
</tbody>
</table>
## Overview
Library staff will use the Local Library website to store information about books and borrowers, while library members will use it to browse and search for books, find out whether there are any copies available, and then reserve or borrow them. In order to store and retrieve information efficiently, we will store it in a _database_.
Express apps can use many different databases, and there are several approaches you can use for performing **C**reate, **R**ead, **U**pdate and **D**elete (CRUD) operations. This tutorial provides a brief overview of some of the available options and then goes on to show in detail the particular mechanisms selected.
### What databases can I use?
_Express_ apps can use any database supported by _Node_ (_Express_ itself doesn't define any specific additional behavior/requirements for database management). There are [many popular options](https://expressjs.com/en/guide/database-integration.html), including PostgreSQL, MySQL, Redis, SQLite, and MongoDB.
When choosing a database, you should consider things like time-to-productivity/learning curve, performance, ease of replication/backup, cost, community support, etc. While there is no single "best" database, almost any of the popular solutions should be more than acceptable for a small-to-medium-sized site like our Local Library.
For more information on the options see [Database integration](https://expressjs.com/en/guide/database-integration.html) (Express docs).
### What is the best way to interact with a database?
There are two common approaches for interacting with a database:
- Using the databases' native query language, such as SQL.
- Using an Object Relational Mapper ("ORM"). An ORM represents the website's data as JavaScript objects, which are then mapped to the underlying database. Some ORMs are tied to a specific database, while others provide a database-agnostic backend.
The very best _performance_ can be gained by using SQL, or whatever query language is supported by the database. ODM's are often slower because they use translation code to map between objects and the database format, which may not use the most efficient database queries (this is particularly true if the ODM supports different database backends, and must make greater compromises in terms of what database features are supported).
The benefit of using an ORM is that programmers can continue to think in terms of JavaScript objects rather than database semantics — this is particularly true if you need to work with different databases (on either the same or different websites). They also provide an obvious place to perform data validation.
> **Note:** Using ODM/ORMs often results in lower costs for development and maintenance! Unless you're very familiar with the native query language or performance is paramount, you should strongly consider using an ODM.
### What ORM/ODM should I use?
There are many ODM/ORM solutions available on the npm package manager site (check out the [odm](https://www.npmjs.com/search?q=keywords:odm) and [orm](https://www.npmjs.com/search?q=keywords:orm) tags for a subset!).
A few solutions that were popular at the time of writing are:
- [Mongoose](https://www.npmjs.com/package/mongoose): Mongoose is a [MongoDB](https://www.mongodb.com/) object modeling tool designed to work in an asynchronous environment.
- [Waterline](https://www.npmjs.com/package/waterline): An ORM extracted from the Express-based [Sails](https://sailsjs.com/) web framework. It provides a uniform API for accessing numerous different databases, including Redis, MySQL, LDAP, MongoDB, and Postgres.
- [Bookshelf](https://www.npmjs.com/package/bookshelf): Features both promise-based and traditional callback interfaces, providing transaction support, eager/nested-eager relation loading, polymorphic associations, and support for one-to-one, one-to-many, and many-to-many relations. Works with PostgreSQL, MySQL, and SQLite3.
- [Objection](https://www.npmjs.com/package/objection): Makes it as easy as possible to use the full power of SQL and the underlying database engine (supports SQLite3, Postgres, and MySQL).
- [Sequelize](https://www.npmjs.com/package/sequelize) is a promise-based ORM for Node.js and io.js. It supports the dialects PostgreSQL, MySQL, MariaDB, SQLite, and MSSQL and features solid transaction support, relations, read replication and more.
- [Node ORM2](https://node-orm.readthedocs.io/en/latest/) is an Object Relationship Manager for NodeJS. It supports MySQL, SQLite, and Progress, helping to work with the database using an object-oriented approach.
- [GraphQL](https://graphql.org/): Primarily a query language for restful APIs, GraphQL is very popular, and has features available for reading data from databases.
As a general rule, you should consider both the features provided and the "community activity" (downloads, contributions, bug reports, quality of documentation, etc.) when selecting a solution. At the time of writing Mongoose is by far the most popular ODM, and is a reasonable choice if you're using MongoDB for your database.
### Using Mongoose and MongoDB for the LocalLibrary
For the _Local Library_ example (and the rest of this topic) we're going to use the [Mongoose ODM](https://www.npmjs.com/package/mongoose) to access our library data. Mongoose acts as a front end to [MongoDB](https://www.mongodb.com/what-is-mongodb), an open source [NoSQL](https://en.wikipedia.org/wiki/NoSQL) database that uses a document-oriented data model. A "collection" of "documents" in a MongoDB database [is analogous to](https://www.mongodb.com/docs/manual/core/databases-and-collections/) a "table" of "rows" in a relational database.
This ODM and database combination is extremely popular in the Node community, partially because the document storage and query system looks very much like JSON, and is hence familiar to JavaScript developers.
> **Note:** You don't need to know MongoDB in order to use Mongoose, although parts of the [Mongoose documentation](https://mongoosejs.com/docs/guide.html) _are_ easier to use and understand if you are already familiar with MongoDB.
The rest of this tutorial shows how to define and access the Mongoose schema and models for the [LocalLibrary website](/en-US/docs/Learn/Server-side/Express_Nodejs/Tutorial_local_library_website) example.
## Designing the LocalLibrary models
Before you jump in and start coding the models, it's worth taking a few minutes to think about what data we need to store and the relationships between the different objects.
We know that we need to store information about books (title, summary, author, genre, ISBN) and that we might have multiple copies available (with globally unique ids, availability statuses, etc.). We might need to store more information about the author than just their name, and there might be multiple authors with the same or similar names. We want to be able to sort information based on the book title, author, genre, and category.
When designing your models it makes sense to have separate models for every "object" (a group of related information). In this case some obvious candidates for these models are books, book instances, and authors.
You might also want to use models to represent selection-list options (e.g. like a drop-down list of choices), rather than hard-coding the choices into the website itself — this is recommended when all the options aren't known up front or may change. A good example is a genre (e.g. fantasy, science fiction, etc.).
Once we've decided on our models and fields, we need to think about the relationships between them.
With that in mind, the UML association diagram below shows the models we'll define in this case (as boxes). As discussed above, we've created models for the book (the generic details of the book), book instance (status of specific physical copies of the book available in the system), and author. We have also decided to have a model for the genre so that values can be created dynamically. We've decided not to have a model for the `BookInstance:status` — we will hard code the acceptable values because we don't expect these to change. Within each of the boxes, you can see the model name, the field names and types, and also the methods and their return types.
The diagram also shows the relationships between the models, including their _multiplicities_. The multiplicities are the numbers on the diagram showing the numbers (maximum and minimum) of each model that may be present in the relationship. For example, the connecting line between the boxes shows that `Book` and a `Genre` are related. The numbers close to the `Book` model show that a `Genre` must have zero or more `Book`s (as many as you like), while the numbers on the other end of the line next to the `Genre` show that a book can have zero or more associated `Genre`s.
> **Note:** As discussed in our [Mongoose primer](#mongoose_primer) below it is often better to have the field that defines the relationship between the documents/models in just _one_ model (you can still find the reverse relationship by searching for the associated `_id` in the other model). Below we have chosen to define the relationship between `Book`/`Genre` and `Book`/`Author` in the Book schema, and the relationship between the `Book`/`BookInstance` in the `BookInstance` Schema. This choice was somewhat arbitrary — we could equally well have had the field in the other schema.
> **Note:** The next section provides a basic primer explaining how models are defined and used. As you read it, consider how we will construct each of the models in the diagram above.
### Database APIs are asynchronous
Database methods to create, find, update, or delete records are asynchronous.
What this means is that the methods return immediately, and the code to handle the success or failure of the method runs at a later time when the operation completes.
Other code can execute while the server is waiting for the database operation to complete, so the server can remain responsive to other requests.
JavaScript has a number of mechanisms for supporting asynchronous behavior.
Historically JavaScript relied heavily on passing [callback functions](/en-US/docs/Learn/JavaScript/Asynchronous/Introducing) to asynchronous methods to handle the success and error cases.
In modern JavaScript callbacks have largely been replaced by [Promises](/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise).
Promises are objects that are (immediately) returned by an asynchronous method that represent it's future state.
When the operation completes, the promise object is "settled", and resolves an object that represents the result of the operation or an error.
There are two main ways you can use promises to run code when a promise is settled, and we highly recommend that you read [How to use promises](/en-US/docs/Learn/JavaScript/Asynchronous/Promises) for a high level overview of both approaches.
In this tutorial, we'll primarily be using [`await`](/en-US/docs/Web/JavaScript/Reference/Operators/await) to wait on promise completion within an [`async function`](/en-US/docs/Web/JavaScript/Reference/Statements/async_function), because this leads to more readable and understandable asynchronous code.
The way this approach works is that you use the `async function` keyword to mark a function as asynchronous, and then inside that function apply `await` to any method that returns a promise.
When the asynchronous function is executed its operation is paused at the first `await` method until the promise settles.
From the perspective of the surrounding code the asynchronous function then returns and the code after it is able to run.
Later when the promise settles, the `await` method inside the asynchronous function returns with the result, or an error is thrown if the promise was rejected.
The code in the asynchronous function then executes until either another `await` is encountered, at which point it will pause again, or until all the code in the function has been run.
You can see how this works in the example below.
`myFunction()` is an asynchronous function that is called within a [`try...catch`](/en-US/docs/Web/JavaScript/Reference/Statements/try...catch) block.
When `myFunction()` is run, code execution is paused at `methodThatReturnsPromise()` until the promise resolves, at which point the code continues to `aFunctionThatReturnsPromise()` and waits again.
The code in the `catch` block runs if an error is thrown in the asynchronous function, and this will happen if the promise returned by either of the methods is rejected.
```js
async function myFunction {
// ...
await someObject.methodThatReturnsPromise();
// ...
await aFunctionThatReturnsPromise();
// ...
}
try {
// ...
myFunction();
// ...
} catch (e) {
// error handling code
}
```
The asynchronous methods above are run in sequence.
If the methods don't depend on each other then you can run them in parallel and finish the whole operation more quickly.
This is done using the [`Promise.all()`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/all) method, which takes an iterable of promises as input and returns a single `Promise`.
This returned promise fulfills when all of the input's promises fulfill, with an array of the fulfillment values.
It rejects when any of the input's promises rejects, with this first rejection reason.
The code below shows how this works.
First, we have two functions that return promises.
We `await` on both of them to complete using the promise returned by `Promise.all()`.
Once they both complete `await` returns and the results array is populated,
the function then continues to the next `await`, and waits until the promise returned by `anotherFunctionThatReturnsPromise()` is settled.
You would call the `myFunction()` in a `try...catch` block to catch any errors.
```js
async function myFunction {
// ...
const [resultFunction1, resultFunction2] = await Promise.all([
functionThatReturnsPromise1(),
functionThatReturnsPromise2()
]);
// ...
await anotherFunctionThatReturnsPromise(resultFunction1);
}
```
Promises with `await`/`async` allow both flexible and "comprehensible" control over asynchronous execution!
## Mongoose primer
This section provides an overview of how to connect Mongoose to a MongoDB database, how to define a schema and a model, and how to make basic queries.
> **Note:** This primer is heavily influenced by the [Mongoose quick start](https://www.npmjs.com/package/mongoose) on _npm_ and the [official documentation](https://mongoosejs.com/docs/guide.html).
### Installing Mongoose and MongoDB
Mongoose is installed in your project (**package.json**) like any other dependency — using npm.
To install it, use the following command inside your project folder:
```bash
npm install mongoose
```
Installing _Mongoose_ adds all its dependencies, including the MongoDB database driver, but it does not install MongoDB itself. If you want to install a MongoDB server then you can [download installers from here](https://www.mongodb.com/try/download/community) for various operating systems and install it locally. You can also use cloud-based MongoDB instances.
> **Note:** For this tutorial, we'll be using the [MongoDB Atlas](https://www.mongodb.com/) cloud-based _database as a service_ free tier to provide the database. This is suitable for development and makes sense for the tutorial because it makes "installation" operating system independent (database-as-a-service is also one approach you might use for your production database).
### Connecting to MongoDB
_Mongoose_ requires a connection to a MongoDB database.
You can `require()` and connect to a locally hosted database with `mongoose.connect()` as shown below (for the tutorial we'll instead connect to an internet-hosted database).
```js
// Import the mongoose module
const mongoose = require("mongoose");
// Set `strictQuery: false` to globally opt into filtering by properties that aren't in the schema
// Included because it removes preparatory warnings for Mongoose 7.
// See: https://mongoosejs.com/docs/migrating_to_6.html#strictquery-is-removed-and-replaced-by-strict
mongoose.set("strictQuery", false);
// Define the database URL to connect to.
const mongoDB = "mongodb://127.0.0.1/my_database";
// Wait for database to connect, logging an error if there is a problem
main().catch((err) => console.log(err));
async function main() {
await mongoose.connect(mongoDB);
}
```
> **Note:** As discussed in the [Database APIs are asynchronous](#database_apis_are_asynchronous) section, here we `await` on the promise returned by the `connect()` method within an `async` function.
> We use the promise `catch()` handler to handle any errors when trying to connect, but we might also have called `main()` within a `try...catch` block.
You can get the default `Connection` object with `mongoose.connection`.
If you need to create additional connections you can use `mongoose.createConnection()`.
This takes the same form of database URI (with host, database, port, options, etc.) as `connect()` and returns a `Connection` object).
Note that `createConnection()` returns immediately; if you need to wait on the connection to be established you can call it with `asPromise()` to return a promise (`mongoose.createConnection(mongoDB).asPromise()`).
### Defining and creating models
Models are _defined_ using the `Schema` interface. The Schema allows you to define the fields stored in each document along with their validation requirements and default values. In addition, you can define static and instance helper methods to make it easier to work with your data types, and also virtual properties that you can use like any other field, but which aren't actually stored in the database (we'll discuss a bit further below).
Schemas are then "compiled" into models using the `mongoose.model()` method. Once you have a model you can use it to find, create, update, and delete objects of the given type.
> **Note:** Each model maps to a _collection_ of _documents_ in the MongoDB database. The documents will contain the fields/schema types defined in the model `Schema`.
#### Defining schemas
The code fragment below shows how you might define a simple schema. First you `require()` mongoose, then use the Schema constructor to create a new schema instance, defining the various fields inside it in the constructor's object parameter.
```js
// Require Mongoose
const mongoose = require("mongoose");
// Define a schema
const Schema = mongoose.Schema;
const SomeModelSchema = new Schema({
a_string: String,
a_date: Date,
});
```
In the case above we just have two fields, a string and a date. In the next sections, we will show some of the other field types, validation, and other methods.
#### Creating a model
Models are created from schemas using the `mongoose.model()` method:
```js
// Define schema
const Schema = mongoose.Schema;
const SomeModelSchema = new Schema({
a_string: String,
a_date: Date,
});
// Compile model from schema
const SomeModel = mongoose.model("SomeModel", SomeModelSchema);
```
The first argument is the singular name of the collection that will be created for your model (Mongoose will create the database collection for the above model _SomeModel_ above), and the second argument is the schema you want to use in creating the model.
> **Note:** Once you've defined your model classes you can use them to create, update, or delete records, and run queries to get all records or particular subsets of records. We'll show you how to do this in the [Using models](#using_models) section, and when we create our views.
#### Schema types (fields)
A schema can have an arbitrary number of fields — each one represents a field in the documents stored in _MongoDB_.
An example schema showing many of the common field types and how they are declared is shown below.
```js
const schema = new Schema({
name: String,
binary: Buffer,
living: Boolean,
updated: { type: Date, default: Date.now() },
age: { type: Number, min: 18, max: 65, required: true },
mixed: Schema.Types.Mixed,
_someId: Schema.Types.ObjectId,
array: [],
ofString: [String], // You can also have an array of each of the other types too.
nested: { stuff: { type: String, lowercase: true, trim: true } },
});
```
Most of the [SchemaTypes](https://mongoosejs.com/docs/schematypes.html) (the descriptors after "type:" or after field names) are self-explanatory. The exceptions are:
- `ObjectId`: Represents specific instances of a model in the database. For example, a book might use this to represent its author object. This will actually contain the unique ID (`_id`) for the specified object. We can use the `populate()` method to pull in the associated information when needed.
- [`Mixed`](https://mongoosejs.com/docs/schematypes.html#mixed): An arbitrary schema type.
- `[]`: An array of items. You can perform JavaScript array operations on these models (push, pop, unshift, etc.). The examples above show an array of objects without a specified type and an array of `String` objects, but you can have an array of any type of object.
The code also shows both ways of declaring a field:
- Field _name_ and _type_ as a key-value pair (i.e. as done with fields `name`, `binary` and `living`).
- Field _name_ followed by an object defining the `type`, and any other _options_ for the field. Options include things like:
- default values.
- built-in validators (e.g. max/min values) and custom validation functions.
- Whether the field is required
- Whether `String` fields should automatically be set to lowercase, uppercase, or trimmed (e.g. `{ type: String, lowercase: true, trim: true }`)
For more information about options see [SchemaTypes](https://mongoosejs.com/docs/schematypes.html) (Mongoose docs).
#### Validation
Mongoose provides built-in and custom validators, and synchronous and asynchronous validators. It allows you to specify both the acceptable range of values and the error message for validation failure in all cases.
The built-in validators include:
- All [SchemaTypes](https://mongoosejs.com/docs/schematypes.html) have the built-in [required](https://mongoosejs.com/docs/api.html#schematype_SchemaType-required) validator. This is used to specify whether the field must be supplied in order to save a document.
- [Numbers](https://mongoosejs.com/docs/api/schemanumber.html) have [min](<https://mongoosejs.com/docs/api/schemanumber.html#SchemaNumber.prototype.min()>) and [max](<https://mongoosejs.com/docs/api/schemanumber.html#SchemaNumber.prototype.max()>) validators.
- [Strings](https://mongoosejs.com/docs/api/schemastring.html) have:
- [enum](<https://mongoosejs.com/docs/api/schemastring.html#SchemaString.prototype.enum()>): specifies the set of allowed values for the field.
- [match](<https://mongoosejs.com/docs/api/schemastring.html#SchemaString.prototype.match()>): specifies a regular expression that the string must match.
- [maxLength](<https://mongoosejs.com/docs/api/schemastring.html#SchemaString.prototype.maxlength()>) and [minLength](<https://mongoosejs.com/docs/api/schemastring.html#SchemaString.prototype.minlength()>) for the string.
The example below (slightly modified from the Mongoose documents) shows how you can specify some of the validator types and error messages:
```js
const breakfastSchema = new Schema({
eggs: {
type: Number,
min: [6, "Too few eggs"],
max: 12,
required: [true, "Why no eggs?"],
},
drink: {
type: String,
enum: ["Coffee", "Tea", "Water"],
},
});
```
For complete information on field validation see [Validation](https://mongoosejs.com/docs/validation.html) (Mongoose docs).
#### Virtual properties
Virtual properties are document properties that you can get and set but that do not get persisted to MongoDB. The getters are useful for formatting or combining fields, while setters are useful for de-composing a single value into multiple values for storage. The example in the documentation constructs (and deconstructs) a full name virtual property from a first and last name field, which is easier and cleaner than constructing a full name every time one is used in a template.
> **Note:** We will use a virtual property in the library to define a unique URL for each model record using a path and the record's `_id` value.
For more information see [Virtuals](https://mongoosejs.com/docs/guide.html#virtuals) (Mongoose documentation).
#### Methods and query helpers
A schema can also have [instance methods](https://mongoosejs.com/docs/guide.html#methods), [static methods](https://mongoosejs.com/docs/guide.html#statics), and [query helpers](https://mongoosejs.com/docs/guide.html#query-helpers). The instance and static methods are similar, but with the obvious difference that an instance method is associated with a particular record and has access to the current object. Query helpers allow you to extend mongoose's [chainable query builder API](https://mongoosejs.com/docs/queries.html) (for example, allowing you to add a query "byName" in addition to the `find()`, `findOne()` and `findById()` methods).
### Using models
Once you've created a schema you can use it to create models. The model represents a collection of documents in the database that you can search, while the model's instances represent individual documents that you can save and retrieve.
We provide a brief overview below. For more information see: [Models](https://mongoosejs.com/docs/models.html) (Mongoose docs).
> **Note:** Creation, update, deletion and querying of records are asynchronous operations that return a [promise](/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise).
> The examples below show just the use of the relevant methods and `await` (i.e. the essential code for using the methods).
> The surrounding `async function` and `try...catch` block to catch errors are omitted for clarity.
> For more information on using `await/async` see [Database APIs are asynchronous](#database_apis_are_asynchronous) above.
#### Creating and modifying documents
To create a record you can define an instance of the model and then call [`save()`](https://mongoosejs.com/docs/api/model.html#Model.prototype.save) on it.
The examples below assume `SomeModel` is a model (with a single field `name`) that we have created from our schema.
```js
// Create an instance of model SomeModel
const awesome_instance = new SomeModel({ name: "awesome" });
// Save the new model instance asynchronously
await awesome_instance.save();
```
You can also use [`create()`](https://mongoosejs.com/docs/api/model.html#Model.create) to define the model instance at the same time as you save it.
Below we create just one, but you can create multiple instances by passing in an array of objects.
```js
await SomeModel.create({ name: "also_awesome" });
```
Every model has an associated connection (this will be the default connection when you use `mongoose.model()`). You create a new connection and call `.model()` on it to create the documents on a different database.
You can access the fields in this new record using the dot syntax, and change the values. You have to call `save()` or `update()` to store modified values back to the database.
```js
// Access model field values using dot notation
console.log(awesome_instance.name); //should log 'also_awesome'
// Change record by modifying the fields, then calling save().
awesome_instance.name = "New cool name";
await awesome_instance.save();
```
#### Searching for records
You can search for records using query methods, specifying the query conditions as a JSON document. The code fragment below shows how you might find all athletes in a database that play tennis, returning just the fields for athlete _name_ and _age_. Here we just specify one matching field (sport) but you can add more criteria, specify regular expression criteria, or remove the conditions altogether to return all athletes.
```js
const Athlete = mongoose.model("Athlete", yourSchema);
// find all athletes who play tennis, returning the 'name' and 'age' fields
const tennisPlayers = await Athlete.find(
{ sport: "Tennis" },
"name age",
).exec();
```
> **Note:** It is important to remember that not finding any results is **not an error** for a search — but it may be a fail-case in the context of your application.
> If your application expects a search to find a value you can check the number of entries returned in the result.
Query APIs, such as [`find()`](<https://mongoosejs.com/docs/api/model.html#Model.find()>), return a variable of type [Query](https://mongoosejs.com/docs/api/query.html).
You can use a query object to build up a query in parts before executing it with the [`exec()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.exec) method.
`exec()` executes the query and returns a promise that you can `await` on for the result.
```js
// find all athletes that play tennis
const query = Athlete.find({ sport: "Tennis" });
// selecting the 'name' and 'age' fields
query.select("name age");
// limit our results to 5 items
query.limit(5);
// sort by age
query.sort({ age: -1 });
// execute the query at a later time
query.exec();
```
Above we've defined the query conditions in the [`find()`](<https://mongoosejs.com/docs/api/model.html#Model.find()>) method. We can also do this using a [`where()`](<https://mongoosejs.com/docs/api/model.html#Model.where()>) function, and we can chain all the parts of our query together using the dot operator (.) rather than adding them separately.
The code fragment below is the same as our query above, with an additional condition for the age.
```js
Athlete.find()
.where("sport")
.equals("Tennis")
.where("age")
.gt(17)
.lt(50) // Additional where query
.limit(5)
.sort({ age: -1 })
.select("name age")
.exec();
```
The [`find()`](<https://mongoosejs.com/docs/api/model.html#Model.find()>) method gets all matching records, but often you just want to get one match. The following methods query for a single record:
- [`findById()`](<https://mongoosejs.com/docs/api/model.html#Model.findById()>): Finds the document with the specified `id` (every document has a unique `id`).
- [`findOne()`](<https://mongoosejs.com/docs/api/model.html#Model.findOne()>): Finds a single document that matches the specified criteria.
- [`findByIdAndDelete()`](<https://mongoosejs.com/docs/api/model.html#Model.findByIdAndDelete()>), [`findByIdAndUpdate()`](<https://mongoosejs.com/docs/api/model.html#Model.findByIdAndUpdate()>), [`findOneAndRemove()`](<https://mongoosejs.com/docs/api/model.html#Model.findOneAndRemove()>), [`findOneAndUpdate()`](<https://mongoosejs.com/docs/api/model.html#Model.findOneAndUpdate()>): Finds a single document by `id` or criteria and either updates or removes it. These are useful convenience functions for updating and removing records.
> **Note:** There is also a [`countDocuments()`](<https://mongoosejs.com/docs/api/model.html#Model.countDocuments()>) method that you can use to get the number of items that match conditions. This is useful if you want to perform a count without actually fetching the records.
There is a lot more you can do with queries. For more information see: [Queries](https://mongoosejs.com/docs/queries.html) (Mongoose docs).
#### Working with related documents — population
You can create references from one document/model instance to another using the `ObjectId` schema field, or from one document to many using an array of `ObjectIds`. The field stores the id of the related model. If you need the actual content of the associated document, you can use the [`populate()`](https://mongoosejs.com/docs/populate.html) method in a query to replace the id with the actual data.
For example, the following schema defines authors and stories.
Each author can have multiple stories, which we represent as an array of `ObjectId`.
Each story can have a single author.
The `ref` property tells the schema which model can be assigned to this field.
```js
const mongoose = require("mongoose");
const Schema = mongoose.Schema;
const authorSchema = new Schema({
name: String,
stories: [{ type: Schema.Types.ObjectId, ref: "Story" }],
});
const storySchema = new Schema({
author: { type: Schema.Types.ObjectId, ref: "Author" },
title: String,
});
const Story = mongoose.model("Story", storySchema);
const Author = mongoose.model("Author", authorSchema);
```
We can save our references to the related document by assigning the `_id` value.
Below we create an author, then a story, and assign the author id to our story's author field.
```js
const bob = new Author({ name: "Bob Smith" });
await bob.save();
// Bob now exists, so lets create a story
const story = new Story({
title: "Bob goes sledding",
author: bob._id, // assign the _id from our author Bob. This ID is created by default!
});
await story.save();
```
> **Note:** One great benefit of this style of programming is that we don't have to complicate the main path of our code with error checking.
> If any of the `save()` operations fail, the promise will reject and an error will be thrown.
> Our error handling code deals with that separately (usually in a `catch()` block), so the intent of our code is very clear.
Our story document now has an author referenced by the author document's ID. In order to get the author information in the story results we use [`populate()`](https://mongoosejs.com/docs/api/model.html#Model.populate), as shown below.
```js
Story.findOne({ title: "Bob goes sledding" })
.populate("author") // Replace the author id with actual author information in results
.exec();
```
> **Note:** Astute readers will have noted that we added an author to our story, but we didn't do anything to add our story to our author's `stories` array. How then can we get all stories by a particular author? One way would be to add our story to the stories array, but this would result in us having two places where the information relating authors and stories needs to be maintained.
>
> A better way is to get the `_id` of our _author_, then use `find()` to search for this in the author field across all stories.
>
> ```js
> Story.find({ author: bob._id }).exec();
> ```
This is almost everything you need to know about working with related items _for this tutorial_. For more detailed information see [Population](https://mongoosejs.com/docs/populate.html) (Mongoose docs).
### One schema/model per file
While you can create schemas and models using any file structure you like, we highly recommend defining each model schema in its own module (file), then exporting the method to create the model.
This is shown below:
```js
// File: ./models/somemodel.js
// Require Mongoose
const mongoose = require("mongoose");
// Define a schema
const Schema = mongoose.Schema;
const SomeModelSchema = new Schema({
a_string: String,
a_date: Date,
});
// Export function to create "SomeModel" model class
module.exports = mongoose.model("SomeModel", SomeModelSchema);
```
You can then require and use the model immediately in other files. Below we show how you might use it to get all instances of the model.
```js
// Create a SomeModel model just by requiring the module
const SomeModel = require("../models/somemodel");
// Use the SomeModel object (model) to find all SomeModel records
const modelInstances = await SomeModel.find().exec();
```
## Setting up the MongoDB database
Now that we understand something of what Mongoose can do and how we want to design our models, it's time to start work on the _LocalLibrary_ website. The very first thing we want to do is set up a MongoDB database that we can use to store our library data.
For this tutorial, we're going to use the [MongoDB Atlas](https://www.mongodb.com/atlas/database) cloud-hosted sandbox database. This database tier is not considered suitable for production websites because it has no redundancy, but it is great for development and prototyping. We're using it here because it is free and easy to set up, and because MongoDB Atlas is a popular _database as a service_ vendor that you might reasonably choose for your production database (other popular choices at the time of writing include [Compose](https://www.compose.com/), [ScaleGrid](https://scalegrid.io/) and [ObjectRocket](https://www.objectrocket.com/)).
> **Note:** If you prefer, you can set up a MongoDB database locally by downloading and installing the [appropriate binaries for your system](https://www.mongodb.com/download-center/community/releases). The rest of the instructions in this article would be similar, except for the database URL you would specify when connecting.
> In the [Express Tutorial Part 7: Deploying to Production](/en-US/docs/Learn/Server-side/Express_Nodejs/deployment) tutorial we host both the application and database on [Railway](https://railway.app/), but we could equally well have used a database on [MongoDB Atlas](https://www.mongodb.com/atlas/database).
You will first need to [create an account](https://www.mongodb.com/cloud/atlas/register) with MongoDB Atlas (this is free, and just requires that you enter basic contact details and acknowledge their terms of service).
After logging in, you'll be taken to the [home](https://cloud.mongodb.com/v2) screen:
1. Click the **+ Create** button in the _Overview_ section.
2. This will open the _Deploy your database_ screen. Click on the **M0 FREE** option template.
3. Scroll down the page to see the different options you can choose.
- Select any provider and region from the _Provider_ and _Region_ sections. Different regions offer different providers.
- You can change the name of your Cluster under _Cluster Name_. We are naming it `Cluster0` for this tutorial.
- Tags are optional. We will not use them here.
- Click the **Create** button (creation of the cluster will take some minutes).
4. This will open the _Security Quickstart_ section.
- Enter a username and password. Remember to copy and store the credentials safely as we will need them later on. Click the **Create User** button.
> **Note:** Avoid using special characters in your MongoDB user password as mongoose may not parse the connection string properly.
- Enter `0.0.0.0/0` in the IP Address field. This tells MongoDB that we want to allow access from anywhere. Click the **Add Entry** button.
> **Note:** It is a best practice to limit the IP addresses that can connect to your database and other resources. Here we allow a connection from anywhere because we don't know where the request will come from after deployment.
- Click the **Finish and Close** button.
5. This will open the following screen. Click on the **Go to Overview** button.
6. You will return to the _Overview_ screen. Click on the _Database_ section under the _Deployment_ menu on the left. Click the **Browse Collections** button.
7. This will open the _Collections_ section. Click the **Add My Own Data** button.
8. This will open the _Create Database_ screen.
- Enter the name for the new database as `local_library`.
- Enter the name of the collection as `Collection0`.
- Click the **Create** button to create the database.
9. You will return to the _Collections_ screen with your database created.
- Click the _Overview_ tab to return to the cluster overview.
10. From the Cluster0 _Overview_ screen click the **Connect** button.
11. This will open the _Connect to Cluster_ screen.
Click the **Drivers** option under the _Connect to your application_ section.
12. You will now be shown the _Connect_ screen.
- Select the Node driver and version as shown.
- **DO NOT** follow the step 2.
- Click the **Copy** icon to copy the connection string.
- Paste this in your local text editor.
- Update the username and password with your user's password.
- Insert the database name "local_library" in the path before the options (`...mongodb.net/local_library?retryWrites...`)
- Save the file containing this string somewhere safe.
You have now created the database, and have a URL (with username and password) that can be used to access it.
This will look something like: `mongodb+srv://your_user_name:[email protected]/local_library?retryWrites=true&w=majority`
## Install Mongoose
Open a command prompt and navigate to the directory where you created your [skeleton Local Library website](/en-US/docs/Learn/Server-side/Express_Nodejs/skeleton_website).
Enter the following command to install Mongoose (and its dependencies) and add it to your **package.json** file, unless you have already done so when reading the [Mongoose Primer](#installing_mongoose_and_mongodb) above.
```bash
npm install mongoose
```
## Connect to MongoDB
Open **/app.js** (in the root of your project) and copy the following text below where you declare the _Express application object_ (after the line `const app = express();`).
Replace the database URL string ('_insert_your_database_url_here_') with the location URL representing your own database (i.e. using the information from _MongoDB Atlas_).
```js
// Set up mongoose connection
const mongoose = require("mongoose");
mongoose.set("strictQuery", false);
const mongoDB = "insert_your_database_url_here";
main().catch((err) => console.log(err));
async function main() {
await mongoose.connect(mongoDB);
}
```
As discussed in the [Mongoose primer](#connecting_to_mongodb) above, this code creates the default connection to the database and reports any errors to the console.
Note that hard-coding database credentials in source code as shown above is not recommended.
We do it here because it shows the core connection code, and because during development there is no significant risk that leaking these details will expose or corrupt sensitive information.
We'll show you how to do this more safely when [deploying to production](/en-US/docs/Learn/Server-side/Express_Nodejs/deployment#database_configuration)!
## Defining the LocalLibrary Schema
We will define a separate module for each model, as [discussed above](#one_schemamodel_per_file).
Start by creating a folder for our models in the project root (**/models**) and then create separate files for each of the models:
```plain
/express-locallibrary-tutorial // the project root
/models
author.js
book.js
bookinstance.js
genre.js
```
### Author model
Copy the `Author` schema code shown below and paste it into your **./models/author.js** file.
The schema defines an author as having `String` SchemaTypes for the first and family names (required, with a maximum of 100 characters), and `Date` fields for the dates of birth and death.
```js
const mongoose = require("mongoose");
const Schema = mongoose.Schema;
const AuthorSchema = new Schema({
first_name: { type: String, required: true, maxLength: 100 },
family_name: { type: String, required: true, maxLength: 100 },
date_of_birth: { type: Date },
date_of_death: { type: Date },
});
// Virtual for author's full name
AuthorSchema.virtual("name").get(function () {
// To avoid errors in cases where an author does not have either a family name or first name
// We want to make sure we handle the exception by returning an empty string for that case
let fullname = "";
if (this.first_name && this.family_name) {
fullname = `${this.family_name}, ${this.first_name}`;
}
return fullname;
});
// Virtual for author's URL
AuthorSchema.virtual("url").get(function () {
// We don't use an arrow function as we'll need the this object
return `/catalog/author/${this._id}`;
});
// Export model
module.exports = mongoose.model("Author", AuthorSchema);
```
We've also declared a [virtual](#virtual_properties) for the AuthorSchema named "url" that returns the absolute URL required to get a particular instance of the model — we'll use the property in our templates whenever we need to get a link to a particular author.
> **Note:** Declaring our URLs as a virtual in the schema is a good idea because then the URL for an item only ever needs to be changed in one place.
> At this point, a link using this URL wouldn't work, because we haven't got any routes handling code for individual model instances.
> We'll set those up in a later article!
At the end of the module, we export the model.
### Book model
Copy the `Book` schema code shown below and paste it into your **./models/book.js** file.
Most of this is similar to the author model — we've declared a schema with a number of string fields and a virtual for getting the URL of specific book records, and we've exported the model.
```js
const mongoose = require("mongoose");
const Schema = mongoose.Schema;
const BookSchema = new Schema({
title: { type: String, required: true },
author: { type: Schema.Types.ObjectId, ref: "Author", required: true },
summary: { type: String, required: true },
isbn: { type: String, required: true },
genre: [{ type: Schema.Types.ObjectId, ref: "Genre" }],
});
// Virtual for book's URL
BookSchema.virtual("url").get(function () {
// We don't use an arrow function as we'll need the this object
return `/catalog/book/${this._id}`;
});
// Export model
module.exports = mongoose.model("Book", BookSchema);
```
The main difference here is that we've created two references to other models:
- author is a reference to a single `Author` model object, and is required.
- genre is a reference to an array of `Genre` model objects. We haven't declared this object yet!
### BookInstance model
Finally, copy the `BookInstance` schema code shown below and paste it into your **./models/bookinstance.js** file.
The `BookInstance` represents a specific copy of a book that someone might borrow and includes information about whether the copy is available, on what date it is expected back, and "imprint" (or version) details.
```js
const mongoose = require("mongoose");
const Schema = mongoose.Schema;
const BookInstanceSchema = new Schema({
book: { type: Schema.Types.ObjectId, ref: "Book", required: true }, // reference to the associated book
imprint: { type: String, required: true },
status: {
type: String,
required: true,
enum: ["Available", "Maintenance", "Loaned", "Reserved"],
default: "Maintenance",
},
due_back: { type: Date, default: Date.now },
});
// Virtual for bookinstance's URL
BookInstanceSchema.virtual("url").get(function () {
// We don't use an arrow function as we'll need the this object
return `/catalog/bookinstance/${this._id}`;
});
// Export model
module.exports = mongoose.model("BookInstance", BookInstanceSchema);
```
The new things we show here are the field options:
- `enum`: This allows us to set the allowed values of a string. In this case, we use it to specify the availability status of our books (using an enum means that we can prevent mis-spellings and arbitrary values for our status).
- `default`: We use default to set the default status for newly created book instances to "Maintenance" and the default `due_back` date to `now` (note how you can call the Date function when setting the date!).
Everything else should be familiar from our previous schema.
### Genre model - challenge!
Open your **./models/genre.js** file and create a schema for storing genres (the category of book, e.g. whether it is fiction or non-fiction, romance or military history, etc.).
The definition will be very similar to the other models:
- The model should have a `String` SchemaType called `name` to describe the genre.
- This name should be required and have between 3 and 100 characters.
- Declare a [virtual](#virtual_properties) for the genre's URL, named `url`.
- Export the model.
## Testing — create some items
That's it. We now have all models for the site set up!
In order to test the models (and to create some example books and other items that we can use in our next articles) we'll now run an _independent_ script to create items of each type:
1. Download (or otherwise create) the file [populatedb.js](https://raw.githubusercontent.com/mdn/express-locallibrary-tutorial/main/populatedb.js) inside your _express-locallibrary-tutorial_ directory (in the same level as `package.json`).
> **Note:** The code in `populatedb.js` may be useful in learning JavaScript, but understanding it is not necessary for this tutorial.
2. Run the script using node in your command prompt, passing in the URL of your _MongoDB_ database (the same one you replaced the _insert_your_database_url_here_ placeholder with, inside `app.js` earlier):
```bash
node populatedb <your MongoDB url>
```
> **Note:** On Windows you need to wrap the database URL inside double (").
> On other operating systems you may need single (') quotation marks.
3. The script should run through to completion, displaying items as it creates them in the terminal.
> **Note:** Go to your database on MongoDB Atlas (in the _Collections_ tab).
> You should now be able to drill down into individual collections of Books, Authors, Genres and BookInstances, and check out individual documents.
## Summary
In this article, we've learned a bit about databases and ORMs on Node/Express, and a lot about how Mongoose schema and models are defined. We then used this information to design and implement `Book`, `BookInstance`, `Author` and `Genre` models for the _LocalLibrary_ website.
Last of all, we tested our models by creating a number of instances (using a standalone script). In the next article we'll look at creating some pages to display these objects.
## See also
- [Database integration](https://expressjs.com/en/guide/database-integration.html) (Express docs)
- [Mongoose website](https://mongoosejs.com/) (Mongoose docs)
- [Mongoose Guide](https://mongoosejs.com/docs/guide.html) (Mongoose docs)
- [Validation](https://mongoosejs.com/docs/validation.html) (Mongoose docs)
- [Schema Types](https://mongoosejs.com/docs/schematypes.html) (Mongoose docs)
- [Models](https://mongoosejs.com/docs/models.html) (Mongoose docs)
- [Queries](https://mongoosejs.com/docs/queries.html) (Mongoose docs)
- [Population](https://mongoosejs.com/docs/populate.html) (Mongoose docs)
{{PreviousMenuNext("Learn/Server-side/Express_Nodejs/skeleton_website", "Learn/Server-side/Express_Nodejs/routes", "Learn/Server-side/Express_Nodejs")}}
| 0 |
data/mdn-content/files/en-us/learn/server-side/express_nodejs | data/mdn-content/files/en-us/learn/server-side/express_nodejs/development_environment/index.md | ---
title: Setting up a Node development environment
slug: Learn/Server-side/Express_Nodejs/development_environment
page-type: learn-module-chapter
---
{{LearnSidebar}}{{PreviousMenuNext("Learn/Server-side/Express_Nodejs/Introduction", "Learn/Server-side/Express_Nodejs/Tutorial_local_library_website", "Learn/Server-side/Express_Nodejs")}}
Now that you know what [Express](/en-US/docs/Learn/Server-side/Express_Nodejs/Introduction#introducing_express) is for, we'll show you how to set up and test a Node/Express development environment on Windows, or Linux (Ubuntu), or macOS. For any of those operating systems, this article provides what you need to start developing Express apps.
<table>
<tbody>
<tr>
<th scope="row">Prerequisites:</th>
<td>
Know how to open a terminal / command line. Know how to install software packages on your development computer's operating system.
</td>
</tr>
<tr>
<th scope="row">Objective:</th>
<td>To set up a development environment for Express on your computer.</td>
</tr>
</tbody>
</table>
## Express development environment overview
_Node_ and _Express_ make it very easy to set up your computer in order to start developing web applications. This section provides an overview of what tools are needed, explains some of the simplest methods for installing Node (and Express) on Ubuntu, macOS, and Windows, and shows how you can test your installation.
### What is the Express development environment?
The _Express_ development environment includes an installation of _Nodejs_, the _npm package manager_, and (optionally) the _Express Application Generator_ on your local computer.
_Node_ and the _npm_ package manager are installed together from prepared binary packages, installers, operating system package managers or from source (as shown in the following sections). _Express_ is then installed by npm as a dependency of your individual _Express_ web applications (along with other libraries like template engines, database drivers, authentication middleware, middleware to serve static files, etc.).
_npm_ can also be used to (globally) install the _Express Application Generator_, a handy tool for creating skeleton _Express_ web apps that follow the [MVC pattern](/en-US/docs/Glossary/MVC). The application generator is optional because you don't _need_ to use this tool to create apps that use Express, or construct Express apps that have the same architectural layout or dependencies. We'll be using it though, because it makes getting started a lot easier, and promotes a modular application structure.
> **Note:** Unlike some other web frameworks, the development environment does not include a separate development web server. In _Node_/_Express_ a web application creates and runs its own web server!
There are other peripheral tools that are part of a typical development environment, including [text editors](/en-US/docs/Learn/Common_questions/Tools_and_setup/Available_text_editors) or IDEs for editing code, and source control management tools like [Git](https://git-scm.com/) for safely managing different versions of your code. We are assuming that you've already got these sorts of tools installed (in particular a text editor).
### What operating systems are supported?
_Node_ can be run on Windows, macOS, many flavors of Linux, Docker, etc. There is a full list on the Node.js [Downloads](https://nodejs.org/en/download/) page. Almost any personal computer should have the necessary performance to run Node during development. _Express_ is run in a _Node_ environment, and hence can run on any platform that runs _Node_.
In this article we provide setup instructions for Windows, macOS, and Ubuntu Linux.
### What version of Node/Express should you use?
There are many [releases of Node](https://nodejs.org/en/blog/release/) — newer releases contain bug fixes, support for more recent versions of ECMAScript (JavaScript) standards, and improvements to the Node APIs.
Generally you should use the most recent _LTS (long-term supported)_ release as this will be more stable than the "current" release while still having relatively recent features (and is still being actively maintained). You should use the _Current_ release if you need a feature that is not present in the LTS version.
For _Express_ you should always use the latest version.
### What about databases and other dependencies?
Other dependencies, such as database drivers, template engines, authentication engines, etc. are part of the application, and are imported into the application environment using the npm package manager. We'll discuss them in later app-specific articles.
## Installing Node
In order to use _Express_ you will have to install _Nodejs_ and the [Node Package Manager (npm)](https://docs.npmjs.com/) on your operating system.
To make this easier we'll first install a node version manager, and then we'll use it to install the latest Long Term Supported (LTS) versions of node and npm.
> **Note:** You can also install nodejs and npm with installers provide on <https://nodejs.org/en/> (select the button to download the LTS build that is "Recommended for most users"), or you can [install using the package manager for your OS](https://nodejs.org/en/download/package-manager/) (nodejs.org).
> We highly recommend using a node version manager as these make it easier to install, upgrade, and switch between any particular version of node and npm.
### Windows
There are a number of node version managers for Windows.
Here we use [nvm-windows](https://github.com/coreybutler/nvm-windows), which is highly respected among node developers.
Install the latest version using your installer of choice from the [nvm-windows/releases](https://github.com/coreybutler/nvm-windows/releases) page.
After `nvm-windows` has installed, open a command prompt (or PowerShell) and enter the following command to download the most recent LTS version of nodejs and npm:
```bash
nvm install lts
```
At time of writing the LTS version of nodejs is 20.11.0.
You can set this as the _current version_ to use with the command below:
```bash
nvm use 20.11.0
```
> **Note:** If you get "Access Denied" warnings, you will need to run this command in a prompt with administration permissions.
Use the command `nvm --help` to find out other command line options, such as listing all available node versions, and all downloaded NVM versions.
### Ubuntu and macOS
There are a number of node version managers for Ubuntu and macOS.
[nvm](https://github.com/nvm-sh/nvm) is one of the more popular, and is the original version on which `nvm-windows` is based.
See [nvm > Install & Update Script](https://github.com/nvm-sh/nvm#install--update-script) for the terminal instructions to install the latest version of nvm.
After `nvm` has installed, open a terminal enter the following command to download the most recent LTS version of nodejs and npm:
```bash
nvm install --lts
```
At the time of writing, the LTS version of nodejs is 20.11.0.
The command `nvm list` shows the downloaded set of version and the current version.
You can set a particular version as the _current version_ with the command below (the same as for `nvm-windows`)
```bash
nvm use 20.11.0
```
Use the command `nvm --help` to find out other command line options.
These are often similar to, or the same as, those offered by `nvm-windows`.
### Testing your Nodejs and npm installation
Once you have set `nvm` to use a particular node version, you can test the installation.
A good way to do this is to use the "version" command in your terminal/command prompt and check that the expected version string is returned:
```bash
> node -v
v20.11.0
```
The _Nodejs_ package manager _npm_ should also have been installed, and can be tested in the same way:
```bash
> npm -v
10.2.4
```
As a slightly more exciting test let's create a very basic "pure node" server that prints out "Hello World" in the browser when you visit the correct URL in your browser:
1. Copy the following text into a file named **hellonode.js**. This uses pure Node features (nothing from Express):
```js
//Load HTTP module
const http = require("http");
const hostname = "127.0.0.1";
const port = 3000;
//Create HTTP server and listen on port 3000 for requests
const server = http.createServer((req, res) => {
//Set the response HTTP header with HTTP status and Content type
res.statusCode = 200;
res.setHeader("Content-Type", "text/plain");
res.end("Hello World\n");
});
//listen for request on port 3000, and as a callback function have the port listened on logged
server.listen(port, hostname, () => {
console.log(`Server running at http://${hostname}:${port}/`);
});
```
The code imports the "http" module and uses it to create a server (`createServer()`) that listens for HTTP requests on port 3000. The script then prints a message to the console about what browser URL you can use to test the server. The `createServer()` function takes as an argument a callback function that will be invoked when an HTTP request is received — this returns a response with an HTTP status code of 200 ("OK") and the plain text "Hello World".
> **Note:** Don't worry if you don't understand exactly what this code is doing yet! We'll explain our code in greater detail once we start using Express!
2. Start the server by navigating into the same directory as your `hellonode.js` file in your command prompt, and calling `node` along with the script name, like so:
```bash
node hellonode.js
```
Once the server starts, you will see console output indicating the IP address the server is running on:
```plain
Server running at http://127.0.0.1:3000/
```
3. Navigate to the URL `http://127.0.0.1:3000`. If everything is working, the browser should display the string "Hello World".
## Using npm
Next to _Node_ itself, [npm](https://docs.npmjs.com/) is the most important tool for working with _Node_ applications.
`npm` is used to fetch any packages (JavaScript libraries) that an application needs for development, testing, and/or production, and may also be used to run tests and tools used in the development process.
> **Note:** From Node's perspective, _Express_ is just another package that you need to install using npm and then require in your own code.
You can manually use npm to separately fetch each needed package. Typically we instead manage dependencies using a plain-text definition file named [package.json](https://docs.npmjs.com/files/package.json/). This file lists all the dependencies for a specific JavaScript "package", including the package's name, version, description, initial file to execute, production dependencies, development dependencies, versions of _Node_ it can work with, etc. The **package.json** file should contain everything npm needs to fetch and run your application (if you were writing a reusable library you could use this definition to upload your package to the npm repository and make it available for other users).
### Adding dependencies
The following steps show how you can use npm to download a package, save it into the project dependencies, and then require it in a Node application.
> **Note:** Here we show the instructions to fetch and install the _Express_ package. Later on we'll show how this package, and others, are already specified for us using the _Express Application Generator_. This section is provided because it is useful to understand how npm works and what is being created by the application generator.
1. First create a directory for your new application and navigate into it:
```bash
mkdir myapp
cd myapp
```
2. Use the npm `init` command to create a **package.json** file for your application. This command prompts you for a number of things, including the name and version of your application and the name of the initial entry point file (by default this is **index.js**). For now, just accept the defaults:
```bash
npm init
```
If you display the **package.json** file (`cat package.json`), you will see the defaults that you accepted, ending with the license.
```json
{
"name": "myapp",
"version": "1.0.0",
"description": "",
"main": "index.js",
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1"
},
"author": "",
"license": "ISC"
}
```
3. Now install Express in the `myapp` directory and save it in the dependencies list of your **package.json** file:
```bash
npm install express
```
The dependencies section of your **package.json** will now appear at the end of the **package.json** file and will include _Express_.
```json
{
"name": "myapp",
"version": "1.0.0",
"description": "",
"main": "index.js",
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1"
},
"author": "",
"license": "ISC",
"dependencies": {
"express": "^4.17.1"
}
}
```
4. To use the Express library you call the `require()` function in your **index.js** file to include it in your application.
Create this file now, in the root of the "myapp" application directory, and give it the following contents:
```js
const express = require("express");
const app = express();
const port = 3000;
app.get("/", (req, res) => {
res.send("Hello World!");
});
app.listen(port, () => {
console.log(`Example app listening on port ${port}!`);
});
```
This code shows a minimal "HelloWorld" Express web application.
This imports the "express" module using `require()` and uses it to create a server (`app`) that listens for HTTP requests on port 3000 and prints a message to the console explaining what browser URL you can use to test the server.
The `app.get()` function only responds to HTTP `GET` requests with the specified URL path ('/'), in this case by calling a function to send our _Hello World!_ message.
> **Note:** The backticks in the `` `Example app listening on port ${port}!` `` let us interpolate the value of `$port` into the string.
5. You can start the server by calling node with the script in your command prompt:
```bash
node index.js
```
You will see the following console output:
```plain
Example app listening on port 3000
```
6. Navigate to the URL `http://localhost:3000/`.
If everything is working, the browser should display the string "Hello World!".
### Development dependencies
If a dependency is only used during development, you should instead save it as a "development dependency" (so that your package users don't have to install it in production). For example, to use the popular JavaScript Linting tool [ESLint](https://eslint.org/) you would call npm as shown:
```bash
npm install eslint --save-dev
```
The following entry would then be added to your application's **package.json**:
```json
"devDependencies": {
"eslint": "^7.10.0"
}
```
> **Note:** "[Linters](<https://en.wikipedia.org/wiki/Lint_(software)>)" are tools that perform static analysis on software in order to recognize and report adherence/non-adherence to some set of coding best practice.
### Running tasks
In addition to defining and fetching dependencies you can also define _named_ scripts in your **package.json** files and call npm to execute them with the [run-script](https://docs.npmjs.com/cli/run-script/) command. This approach is commonly used to automate running tests and parts of the development or build toolchain (e.g., running tools to minify JavaScript, shrink images, LINT/analyze your code, etc.).
> **Note:** Task runners like [Gulp](https://gulpjs.com/) and [Grunt](https://gruntjs.com/) can also be used to run tests and other external tools.
For example, to define a script to run the _eslint_ development dependency that we specified in the previous section we might add the following script block to our **package.json** file (assuming that our application source is in a folder /src/js):
```json
"scripts": {
// …
"lint": "eslint src/js"
// …
}
```
To explain a little further, `eslint src/js` is a command that we could enter in our terminal/command line to run `eslint` on JavaScript files contained in the `src/js` directory inside our app directory. Including the above inside our app's package.json file provides a shortcut for this command — `lint`.
We would then be able to run _eslint_ using npm by calling:
```bash
npm run-script lint
# OR (using the alias)
npm run lint
```
This example may not look any shorter than the original command, but you can include much bigger commands inside your npm scripts, including chains of multiple commands. You could identify a single npm script that runs all your tests at once.
## Installing the Express Application Generator
The [Express Application Generator](https://expressjs.com/en/starter/generator.html) tool generates an Express application "skeleton". Install the generator using npm as shown:
```bash
npm install express-generator -g
```
> **Note:** You may need to prefix this line with `sudo` on Ubuntu or macOS. The `-g` flag installs the tool globally so that you can call it from anywhere.
To create an _Express_ app named "helloworld" with the default settings, navigate to where you want to create it and run the app as shown:
```bash
express helloworld
```
> **Note:** Unless you're using an old nodejs version (< 8.2.0), you could alternatively skip the installation and run express-generator with [npx](https://github.com/npm/npx#readme).
> This has the same effect as installing and then running `express-generator` but does not install the package on your system:
>
> ```bash
> npx express-generator helloworld
> ```
You can also specify the template library to use and a number of other settings.
Use the `help` command to see all the options:
```bash
express --help
```
The generator will create the new Express app in a sub folder of your current location, displaying build progress on the console.
On completion, the tool will display the commands you need to enter to install the Node dependencies and start the app.
The new app will have a **package.json** file in its root directory.
You can open this to see what dependencies are installed, including Express and the template library Jade:
```json
{
"name": "helloworld",
"version": "0.0.0",
"private": true,
"scripts": {
"start": "node ./bin/www"
},
"dependencies": {
"cookie-parser": "~1.4.4",
"debug": "~2.6.9",
"express": "~4.16.1",
"http-errors": "~1.6.3",
"jade": "~1.11.0",
"morgan": "~1.9.1"
}
}
```
Install all the dependencies for the helloworld app using npm as shown:
```bash
cd helloworld
npm install
```
Then run the app (the commands are slightly different for Windows and Linux/macOS), as shown below:
```bash
# Run helloworld on Windows with Command Prompt
SET DEBUG=helloworld:* & npm start
# Run helloworld on Windows with PowerShell
SET DEBUG=helloworld:* | npm start
# Run helloworld on Linux/macOS
DEBUG=helloworld:* npm start
```
The DEBUG command creates useful logging, resulting in an output like the following:
```bash
>SET DEBUG=helloworld:* & npm start
> [email protected] start D:\GitHub\expresstests\helloworld
> node ./bin/www
helloworld:server Listening on port 3000 +0ms
```
Open a browser and navigate to `http://localhost:3000/` to see the default Express welcome page.
We'll talk more about the generated app when we get to the article on generating a skeleton application.
## Summary
You now have a Node development environment up and running on your computer that can be used for creating Express web applications. You've also seen how npm can be used to import Express into an application, and also how you can create applications using the Express Application Generator tool and then run them.
In the next article we start working through a tutorial to build a complete web application using this environment and associated tools.
## See also
- [Downloads](https://nodejs.org/en/download/) page (nodejs.org)
- [Installing Node.js via package manager](https://nodejs.org/en/download/package-manager/) (nodejs.org)
- [Installing Express](https://expressjs.com/en/starter/installing.html) (expressjs.com)
- [Express Application Generator](https://expressjs.com/en/starter/generator.html) (expressjs.com)
- [Using Node.js with Windows subsystem for Linux](https://docs.microsoft.com/windows/dev-environment/javascript/) (docs.microsoft.com)
{{PreviousMenuNext("Learn/Server-side/Express_Nodejs/Introduction", "Learn/Server-side/Express_Nodejs/Tutorial_local_library_website", "Learn/Server-side/Express_Nodejs")}}
| 0 |
data/mdn-content/files/en-us/learn/server-side/express_nodejs | data/mdn-content/files/en-us/learn/server-side/express_nodejs/routes/index.md | ---
title: "Express Tutorial Part 4: Routes and controllers"
slug: Learn/Server-side/Express_Nodejs/routes
page-type: learn-module-chapter
---
{{LearnSidebar}}{{PreviousMenuNext("Learn/Server-side/Express_Nodejs/mongoose", "Learn/Server-side/Express_Nodejs/Displaying_data", "Learn/Server-side/Express_Nodejs")}}
In this tutorial we'll set up routes (URL handling code) with "dummy" handler functions for all the resource endpoints that we'll eventually need in the [LocalLibrary](/en-US/docs/Learn/Server-side/Express_Nodejs/Tutorial_local_library_website) website. On completion we'll have a modular structure for our route handling code, which we can extend with real handler functions in the following articles. We'll also have a really good understanding of how to create modular routes using Express!
<table>
<tbody>
<tr>
<th scope="row">Prerequisites:</th>
<td>
Read the <a href="/en-US/docs/Learn/Server-side/Express_Nodejs/Introduction">Express/Node introduction</a>.
Complete previous tutorial topics (including <a href="/en-US/docs/Learn/Server-side/Express_Nodejs/mongoose">Express Tutorial Part 3: Using a Database (with Mongoose)</a>).
</td>
</tr>
<tr>
<th scope="row">Objective:</th>
<td>
To understand how to create simple routes.
To set up all our URL endpoints.
</td>
</tr>
</tbody>
</table>
## Overview
In the [last tutorial article](/en-US/docs/Learn/Server-side/Express_Nodejs/mongoose) we defined _Mongoose_ models to interact with the database, and used a (standalone) script to create some initial library records. We can now write the code to present that information to users. The first thing we need to do is determine what information we want to be able to display in our pages, and then define appropriate URLs for returning those resources. Then we're going to need to create the routes (URL handlers) and views (templates) to display those pages.
The diagram below is provided as a reminder of the main flow of data and things that need to be implemented when handling an HTTP request/response. In addition to the views and routes the diagram shows "controllers" — functions that separate out the code to route requests from the code that actually processes requests.
As we've already created the models, the main things we'll need to create are:
- "Routes" to forward the supported requests (and any information encoded in request URLs) to the appropriate controller functions.
- Controller functions to get the requested data from the models, create an HTML page displaying the data, and return it to the user to view in the browser.
- Views (templates) used by the controllers to render the data.
Ultimately we might have pages to show lists and detail information for books, genres, authors and bookinstances, along with pages to create, update, and delete records. That's a lot to document in one article. Therefore most of this article will concentrate on setting up our routes and controllers to return "dummy" content. We'll extend the controller methods in our subsequent articles to work with model data.
The first section below provides a brief "primer" on how to use the Express [Router](https://expressjs.com/en/4x/api.html#router) middleware. We'll then use that knowledge in the following sections when we set up the LocalLibrary routes.
## Routes primer
A route is a section of Express code that associates an HTTP verb (`GET`, `POST`, `PUT`, `DELETE`, etc.), a URL path/pattern, and a function that is called to handle that pattern.
There are several ways to create routes. For this tutorial we're going to use the [`express.Router`](https://expressjs.com/en/guide/routing.html#express-router) middleware as it allows us to group the route handlers for a particular part of a site together and access them using a common route-prefix. We'll keep all our library-related routes in a "catalog" module, and, if we add routes for handling user accounts or other functions, we can keep them grouped separately.
> **Note:** We discussed Express application routes briefly in our [Express Introduction > Creating route handlers](/en-US/docs/Learn/Server-side/Express_Nodejs/Introduction#creating_route_handlers). Other than providing better support for modularization (as discussed in the first subsection below), using _Router_ is very similar to defining routes directly on the _Express application object_.
The rest of this section provides an overview of how the `Router` can be used to define the routes.
### Defining and using separate route modules
The code below provides a concrete example of how we can create a route module and then use it in an _Express_ application.
First we create routes for a wiki in a module named **wiki.js**. The code first imports the Express application object, uses it to get a `Router` object and then adds a couple of routes to it using the `get()` method. Last of all the module exports the `Router` object.
```js
// wiki.js - Wiki route module.
const express = require("express");
const router = express.Router();
// Home page route.
router.get("/", function (req, res) {
res.send("Wiki home page");
});
// About page route.
router.get("/about", function (req, res) {
res.send("About this wiki");
});
module.exports = router;
```
> **Note:** Above we are defining our route handler callbacks directly in the router functions. In the LocalLibrary we'll define these callbacks in a separate controller module.
To use the router module in our main app file we first `require()` the route module (**wiki.js**). We then call `use()` on the _Express_ application to add the Router to the middleware handling path, specifying a URL path of 'wiki'.
```js
const wiki = require("./wiki.js");
// …
app.use("/wiki", wiki);
```
The two routes defined in our wiki route module are then accessible from `/wiki/` and `/wiki/about/`.
### Route functions
Our module above defines a couple of typical route functions. The "about" route (reproduced below) is defined using the `Router.get()` method, which responds only to HTTP GET requests. The first argument to this method is the URL path while the second is a callback function that will be invoked if an HTTP GET request with the path is received.
```js
router.get("/about", function (req, res) {
res.send("About this wiki");
});
```
The callback takes three arguments (usually named as shown: `req`, `res`, `next`), that will contain the HTTP Request object, HTTP response, and the _next_ function in the middleware chain.
> **Note:** Router functions are [Express middleware](/en-US/docs/Learn/Server-side/Express_Nodejs/Introduction#using_middleware), which means that they must either complete (respond to) the request or call the `next` function in the chain. In the case above we complete the request using `send()`, so the `next` argument is not used (and we choose not to specify it).
>
> The router function above takes a single callback, but you can specify as many callback arguments as you want, or an array of callback functions. Each function is part of the middleware chain, and will be called in the order it is added to the chain (unless a preceding function completes the request).
The callback function here calls [`send()`](https://expressjs.com/en/4x/api.html#res.send) on the response to return the string "About this wiki" when we receive a GET request with the path ('`/about'`). There are a [number of other response methods](https://expressjs.com/en/guide/routing.html#response-methods) for ending the request/response cycle. For example, you could call [`res.json()`](https://expressjs.com/en/4x/api.html#res.json) to send a JSON response or [`res.sendFile()`](https://expressjs.com/en/4x/api.html#res.sendFile) to send a file. The response method that we'll be using most often as we build up the library is [render()](https://expressjs.com/en/4x/api.html#res.render), which creates and returns HTML files using templates and data—we'll talk a lot more about that in a later article!
### HTTP verbs
The example routes above use the `Router.get()` method to respond to HTTP GET requests with a certain path.
The `Router` also provides route methods for all the other HTTP verbs, that are mostly used in exactly the same way: `post()`, `put()`, `delete()`, `options()`, `trace()`, `copy()`, `lock()`, `mkcol()`, `move()`, `purge()`, `propfind()`, `proppatch()`, `unlock()`, `report()`, `mkactivity()`, `checkout()`, `merge()`, `m-search()`, `notify()`, `subscribe()`, `unsubscribe()`, `patch()`, `search()`, and `connect()`.
For example, the code below behaves just like the previous `/about` route, but only responds to HTTP POST requests.
```js
router.post("/about", (req, res) => {
res.send("About this wiki");
});
```
### Route paths
The route paths define the endpoints at which requests can be made. The examples we've seen so far have just been strings, and are used exactly as written: '/', '/about', '/book', '/any-random.path'.
Route paths can also be string patterns. String patterns use a form of regular expression syntax to define _patterns_ of endpoints that will be matched. The syntax is listed below (note that the hyphen (`-`) and the dot (`.`) are interpreted literally by string-based paths):
- `?` : The endpoint must have 0 or 1 of the preceding character (or group), e.g. a route path of `'/ab?cd'` will match endpoints `acd` or `abcd`.
- `+` : The endpoint must have 1 or more of the preceding character (or group), e.g. a route path of `'/ab+cd'` will match endpoints `abcd`, `abbcd`, `abbbcd`, and so on.
- `*` : The endpoint may have an arbitrary string where the `*` character is placed. E.g. a route path of `'/ab*cd'` will match endpoints `abcd`, `abXcd`, `abSOMErandomTEXTcd`, and so on.
- `()` : Grouping match on a set of characters to perform another operation on, e.g. `'/ab(cd)?e'` will perform a `?`-match on the group `(cd)` — it will match `abe` and `abcde`.
The route paths can also be JavaScript [regular expressions](/en-US/docs/Web/JavaScript/Guide/Regular_expressions). For example, the route path below will match `catfish` and `dogfish`, but not `catflap`, `catfishhead`, and so on. Note that the path for a regular expression uses regular expression syntax (it is not a quoted string as in the previous cases).
```js
app.get(/.*fish$/, function (req, res) {
// …
});
```
> **Note:** Most of our routes for the LocalLibrary will use strings and not regular expressions. We'll also use route parameters as discussed in the next section.
### Route parameters
Route parameters are _named URL segments_ used to capture values at specific positions in the URL. The named segments are prefixed with a colon and then the name (E.g., `/:your_parameter_name/`). The captured values are stored in the `req.params` object using the parameter names as keys (E.g., `req.params.your_parameter_name`).
So for example, consider a URL encoded to contain information about users and books: `http://localhost:3000/users/34/books/8989`. We can extract this information as shown below, with the `userId` and `bookId` path parameters:
```js
app.get("/users/:userId/books/:bookId", (req, res) => {
// Access userId via: req.params.userId
// Access bookId via: req.params.bookId
res.send(req.params);
});
```
The names of route parameters must be made up of "word characters" (A-Z, a-z, 0-9, and \_).
> **Note:** The URL _/book/create_ will be matched by a route like `/book/:bookId` (because `:bookId` is a placeholder for _any_ string, therefore `create` matches). The first route that matches an incoming URL will be used, so if you want to process `/book/create` URLs specifically, their route handler must be defined before your `/book/:bookId` route.
That's all you need to get started with routes - if needed you can find more information in the Express docs: [Basic routing](https://expressjs.com/en/starter/basic-routing.html) and [Routing guide](https://expressjs.com/en/guide/routing.html). The following sections show how we'll set up our routes and controllers for the LocalLibrary.
### Handling errors in the route functions
The route functions shown earlier all have arguments `req` and `res`, which represent the request and response, respectively.
Route functions are also called with a third argument `next`, which can be used to pass errors to the Express middleware chain.
The code below shows how this works, using the example of a database query that takes a callback function, and returns either an error `err` or some results.
If `err` is returned, `next` is called with `err` as the value in its first parameter (eventually the error propagates to our global error handling code).
On success the desired data is returned and then used in the response.
```js
router.get("/about", (req, res, next) => {
About.find({}).exec((err, queryResults) => {
if (err) {
return next(err);
}
//Successful, so render
res.render("about_view", { title: "About", list: queryResults });
});
});
```
### Handling exceptions in route functions
The previous section shows how Express expects route functions to return errors.
The framework is designed for use with asynchronous functions that take a callback function (with an error and result argument), which is called when the operation completes.
That's a problem because later on we will be making Mongoose database queries that use [Promise](/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise)-based APIs, and which may throw exceptions in our route functions (rather than returning errors in a callback).
In order for the framework to properly handle exceptions, they must be caught, and then forwarded as errors as shown in the previous section.
> **Note:** Express 5, which is currently in beta, is expected to handle JavaScript exceptions natively.
Re-imagining the simple example from the previous section with `About.find().exec()` as a database query that returns a promise, we might write the route function inside a [`try...catch`](/en-US/docs/Web/JavaScript/Reference/Statements/try...catch) block like this:
```js
exports.get("/about", async function (req, res, next) {
try {
const successfulResult = await About.find({}).exec();
res.render("about_view", { title: "About", list: successfulResult });
} catch (error) {
return next(error);
}
});
```
That's quite a lot of boilerplate code to add to every function.
Instead, for this tutorial we'll use the [express-async-handler](https://www.npmjs.com/package/express-async-handler) module.
This defines a wrapper function that hides the `try...catch` block and the code to forward the error.
The same example is now very simple, because we only need to write code for the case where we assume success:
```js
// Import the module
const asyncHandler = require("express-async-handler");
exports.get(
"/about",
asyncHandler(async (req, res, next) => {
const successfulResult = await About.find({}).exec();
res.render("about_view", { title: "About", list: successfulResult });
}),
);
```
## Routes needed for the LocalLibrary
The URLs that we're ultimately going to need for our pages are listed below, where _object_ is replaced by the name of each of our models (book, bookinstance, genre, author), _objects_ is the plural of object, and _id_ is the unique instance field (`_id`) that is given to each Mongoose model instance by default.
- `catalog/` — The home/index page.
- `catalog/<objects>/` — The list of all books, bookinstances, genres, or authors (e.g. /`catalog/books/`, /`catalog/genres/`, etc.)
- `catalog/<object>/<id>` — The detail page for a specific book, bookinstance, genre, or author with the given `_id` field value (e.g. `/catalog/book/584493c1f4887f06c0e67d37)`.
- `catalog/<object>/create` — The form to create a new book, bookinstance, genre, or author (e.g. `/catalog/book/create)`.
- `catalog/<object>/<id>/update` — The form to update a specific book, bookinstance, genre, or author with the given `_id` field value (e.g. `/catalog/book/584493c1f4887f06c0e67d37/update)`.
- `catalog/<object>/<id>/delete` — The form to delete a specific book, bookinstance, genre, author with the given `_id` field value (e.g. `/catalog/book/584493c1f4887f06c0e67d37/delete)`.
The first home page and list pages don't encode any additional information. While the results returned will depend on the model type and the content in the database, the queries run to get the information will always be the same (similarly the code run for object creation will always be similar).
By contrast the other URLs are used to act on a specific document/model instance—these encode the identity of the item in the URL (shown as `<id>` above). We'll use path parameters to extract the encoded information and pass it to the route handler (and in a later article we'll use this to dynamically determine what information to get from the database). By encoding the information in our URL we only need one route for every resource of a particular type (e.g. one route to handle the display of every single book item).
> **Note:** Express allows you to construct your URLs any way you like — you can encode information in the body of the URL as shown above or use URL `GET` parameters (e.g. `/book/?id=6`). Whichever approach you use, the URLs should be kept clean, logical and readable ([check out the W3C advice here](https://www.w3.org/Provider/Style/URI)).
Next we create our route handler callback functions and route code for all the above URLs.
## Create the route-handler callback functions
Before we define our routes, we'll first create all the dummy/skeleton callback functions that they will invoke. The callbacks will be stored in separate "controller" modules for `Book`, `BookInstance`, `Genre`, and `Author` (you can use any file/module structure, but this seems an appropriate granularity for this project).
Start by creating a folder for our controllers in the project root (**/controllers**) and then create separate controller files/modules for handling each of the models:
```plain
/express-locallibrary-tutorial //the project root
/controllers
authorController.js
bookController.js
bookinstanceController.js
genreController.js
```
The controllers will use the `express-async-handler` module, so before we proceed, install it into the library using `npm`:
```bash
npm install express-async-handler
```
### Author controller
Open the **/controllers/authorController.js** file and type in the following code:
```js
const Author = require("../models/author");
const asyncHandler = require("express-async-handler");
// Display list of all Authors.
exports.author_list = asyncHandler(async (req, res, next) => {
res.send("NOT IMPLEMENTED: Author list");
});
// Display detail page for a specific Author.
exports.author_detail = asyncHandler(async (req, res, next) => {
res.send(`NOT IMPLEMENTED: Author detail: ${req.params.id}`);
});
// Display Author create form on GET.
exports.author_create_get = asyncHandler(async (req, res, next) => {
res.send("NOT IMPLEMENTED: Author create GET");
});
// Handle Author create on POST.
exports.author_create_post = asyncHandler(async (req, res, next) => {
res.send("NOT IMPLEMENTED: Author create POST");
});
// Display Author delete form on GET.
exports.author_delete_get = asyncHandler(async (req, res, next) => {
res.send("NOT IMPLEMENTED: Author delete GET");
});
// Handle Author delete on POST.
exports.author_delete_post = asyncHandler(async (req, res, next) => {
res.send("NOT IMPLEMENTED: Author delete POST");
});
// Display Author update form on GET.
exports.author_update_get = asyncHandler(async (req, res, next) => {
res.send("NOT IMPLEMENTED: Author update GET");
});
// Handle Author update on POST.
exports.author_update_post = asyncHandler(async (req, res, next) => {
res.send("NOT IMPLEMENTED: Author update POST");
});
```
The module first requires the `Author` model that we'll later be using to access and update our data, and the `asyncHandler` wrapper we'll use to catch any exceptions thrown in our route handler functions.
It then exports functions for each of the URLs we wish to handle.
Note that the create, update and delete operations use forms, and hence also have additional methods for handling form post requests — we'll discuss those methods in the "forms article" later on.
The functions all use the wrapper function described above in [Handling exceptions in route functions](#handling_exceptions_in_route_functions), with arguments for the request, response, and next.
The functions respond with a string indicating that the associated page has not yet been created.
If a controller function is expected to receive path parameters, these are output in the message string (see `req.params.id` above).
Note that once implemented, some route functions might not contain any code that can throw exceptions.
We can change those back to "normal" route handler functions when we get to them.
#### BookInstance controller
Open the **/controllers/bookinstanceController.js** file and copy in the following code (this follows an identical pattern to the `Author` controller module):
```js
const BookInstance = require("../models/bookinstance");
const asyncHandler = require("express-async-handler");
// Display list of all BookInstances.
exports.bookinstance_list = asyncHandler(async (req, res, next) => {
res.send("NOT IMPLEMENTED: BookInstance list");
});
// Display detail page for a specific BookInstance.
exports.bookinstance_detail = asyncHandler(async (req, res, next) => {
res.send(`NOT IMPLEMENTED: BookInstance detail: ${req.params.id}`);
});
// Display BookInstance create form on GET.
exports.bookinstance_create_get = asyncHandler(async (req, res, next) => {
res.send("NOT IMPLEMENTED: BookInstance create GET");
});
// Handle BookInstance create on POST.
exports.bookinstance_create_post = asyncHandler(async (req, res, next) => {
res.send("NOT IMPLEMENTED: BookInstance create POST");
});
// Display BookInstance delete form on GET.
exports.bookinstance_delete_get = asyncHandler(async (req, res, next) => {
res.send("NOT IMPLEMENTED: BookInstance delete GET");
});
// Handle BookInstance delete on POST.
exports.bookinstance_delete_post = asyncHandler(async (req, res, next) => {
res.send("NOT IMPLEMENTED: BookInstance delete POST");
});
// Display BookInstance update form on GET.
exports.bookinstance_update_get = asyncHandler(async (req, res, next) => {
res.send("NOT IMPLEMENTED: BookInstance update GET");
});
// Handle bookinstance update on POST.
exports.bookinstance_update_post = asyncHandler(async (req, res, next) => {
res.send("NOT IMPLEMENTED: BookInstance update POST");
});
```
#### Genre controller
Open the **/controllers/genreController.js** file and copy in the following text (this follows an identical pattern to the `Author` and `BookInstance` files):
```js
const Genre = require("../models/genre");
const asyncHandler = require("express-async-handler");
// Display list of all Genre.
exports.genre_list = asyncHandler(async (req, res, next) => {
res.send("NOT IMPLEMENTED: Genre list");
});
// Display detail page for a specific Genre.
exports.genre_detail = asyncHandler(async (req, res, next) => {
res.send(`NOT IMPLEMENTED: Genre detail: ${req.params.id}`);
});
// Display Genre create form on GET.
exports.genre_create_get = asyncHandler(async (req, res, next) => {
res.send("NOT IMPLEMENTED: Genre create GET");
});
// Handle Genre create on POST.
exports.genre_create_post = asyncHandler(async (req, res, next) => {
res.send("NOT IMPLEMENTED: Genre create POST");
});
// Display Genre delete form on GET.
exports.genre_delete_get = asyncHandler(async (req, res, next) => {
res.send("NOT IMPLEMENTED: Genre delete GET");
});
// Handle Genre delete on POST.
exports.genre_delete_post = asyncHandler(async (req, res, next) => {
res.send("NOT IMPLEMENTED: Genre delete POST");
});
// Display Genre update form on GET.
exports.genre_update_get = asyncHandler(async (req, res, next) => {
res.send("NOT IMPLEMENTED: Genre update GET");
});
// Handle Genre update on POST.
exports.genre_update_post = asyncHandler(async (req, res, next) => {
res.send("NOT IMPLEMENTED: Genre update POST");
});
```
#### Book controller
Open the **/controllers/bookController.js** file and copy in the following code.
This follows the same pattern as the other controller modules, but additionally has an `index()` function for displaying the site welcome page:
```js
const Book = require("../models/book");
const asyncHandler = require("express-async-handler");
exports.index = asyncHandler(async (req, res, next) => {
res.send("NOT IMPLEMENTED: Site Home Page");
});
// Display list of all books.
exports.book_list = asyncHandler(async (req, res, next) => {
res.send("NOT IMPLEMENTED: Book list");
});
// Display detail page for a specific book.
exports.book_detail = asyncHandler(async (req, res, next) => {
res.send(`NOT IMPLEMENTED: Book detail: ${req.params.id}`);
});
// Display book create form on GET.
exports.book_create_get = asyncHandler(async (req, res, next) => {
res.send("NOT IMPLEMENTED: Book create GET");
});
// Handle book create on POST.
exports.book_create_post = asyncHandler(async (req, res, next) => {
res.send("NOT IMPLEMENTED: Book create POST");
});
// Display book delete form on GET.
exports.book_delete_get = asyncHandler(async (req, res, next) => {
res.send("NOT IMPLEMENTED: Book delete GET");
});
// Handle book delete on POST.
exports.book_delete_post = asyncHandler(async (req, res, next) => {
res.send("NOT IMPLEMENTED: Book delete POST");
});
// Display book update form on GET.
exports.book_update_get = asyncHandler(async (req, res, next) => {
res.send("NOT IMPLEMENTED: Book update GET");
});
// Handle book update on POST.
exports.book_update_post = asyncHandler(async (req, res, next) => {
res.send("NOT IMPLEMENTED: Book update POST");
});
```
## Create the catalog route module
Next we create _routes_ for all the URLs [needed by the LocalLibrary website](#routes_needed_for_the_locallibrary), which will call the controller functions we defined in the previous sections.
The skeleton already has a **./routes** folder containing routes for the _index_ and _users_.
Create another route file — **catalog.js** — inside this folder, as shown.
```plain
/express-locallibrary-tutorial //the project root
/routes
index.js
users.js
catalog.js
```
Open **/routes/catalog.js** and copy in the code below:
```js
const express = require("express");
const router = express.Router();
// Require controller modules.
const book_controller = require("../controllers/bookController");
const author_controller = require("../controllers/authorController");
const genre_controller = require("../controllers/genreController");
const book_instance_controller = require("../controllers/bookinstanceController");
/// BOOK ROUTES ///
// GET catalog home page.
router.get("/", book_controller.index);
// GET request for creating a Book. NOTE This must come before routes that display Book (uses id).
router.get("/book/create", book_controller.book_create_get);
// POST request for creating Book.
router.post("/book/create", book_controller.book_create_post);
// GET request to delete Book.
router.get("/book/:id/delete", book_controller.book_delete_get);
// POST request to delete Book.
router.post("/book/:id/delete", book_controller.book_delete_post);
// GET request to update Book.
router.get("/book/:id/update", book_controller.book_update_get);
// POST request to update Book.
router.post("/book/:id/update", book_controller.book_update_post);
// GET request for one Book.
router.get("/book/:id", book_controller.book_detail);
// GET request for list of all Book items.
router.get("/books", book_controller.book_list);
/// AUTHOR ROUTES ///
// GET request for creating Author. NOTE This must come before route for id (i.e. display author).
router.get("/author/create", author_controller.author_create_get);
// POST request for creating Author.
router.post("/author/create", author_controller.author_create_post);
// GET request to delete Author.
router.get("/author/:id/delete", author_controller.author_delete_get);
// POST request to delete Author.
router.post("/author/:id/delete", author_controller.author_delete_post);
// GET request to update Author.
router.get("/author/:id/update", author_controller.author_update_get);
// POST request to update Author.
router.post("/author/:id/update", author_controller.author_update_post);
// GET request for one Author.
router.get("/author/:id", author_controller.author_detail);
// GET request for list of all Authors.
router.get("/authors", author_controller.author_list);
/// GENRE ROUTES ///
// GET request for creating a Genre. NOTE This must come before route that displays Genre (uses id).
router.get("/genre/create", genre_controller.genre_create_get);
//POST request for creating Genre.
router.post("/genre/create", genre_controller.genre_create_post);
// GET request to delete Genre.
router.get("/genre/:id/delete", genre_controller.genre_delete_get);
// POST request to delete Genre.
router.post("/genre/:id/delete", genre_controller.genre_delete_post);
// GET request to update Genre.
router.get("/genre/:id/update", genre_controller.genre_update_get);
// POST request to update Genre.
router.post("/genre/:id/update", genre_controller.genre_update_post);
// GET request for one Genre.
router.get("/genre/:id", genre_controller.genre_detail);
// GET request for list of all Genre.
router.get("/genres", genre_controller.genre_list);
/// BOOKINSTANCE ROUTES ///
// GET request for creating a BookInstance. NOTE This must come before route that displays BookInstance (uses id).
router.get(
"/bookinstance/create",
book_instance_controller.bookinstance_create_get,
);
// POST request for creating BookInstance.
router.post(
"/bookinstance/create",
book_instance_controller.bookinstance_create_post,
);
// GET request to delete BookInstance.
router.get(
"/bookinstance/:id/delete",
book_instance_controller.bookinstance_delete_get,
);
// POST request to delete BookInstance.
router.post(
"/bookinstance/:id/delete",
book_instance_controller.bookinstance_delete_post,
);
// GET request to update BookInstance.
router.get(
"/bookinstance/:id/update",
book_instance_controller.bookinstance_update_get,
);
// POST request to update BookInstance.
router.post(
"/bookinstance/:id/update",
book_instance_controller.bookinstance_update_post,
);
// GET request for one BookInstance.
router.get("/bookinstance/:id", book_instance_controller.bookinstance_detail);
// GET request for list of all BookInstance.
router.get("/bookinstances", book_instance_controller.bookinstance_list);
module.exports = router;
```
The module requires Express and then uses it to create a `Router` object. The routes are all set up on the router, which is then exported.
The routes are defined either using `.get()` or `.post()` methods on the router object. All the paths are defined using strings (we don't use string patterns or regular expressions).
Routes that act on some specific resource (e.g. book) use path parameters to get the object id from the URL.
The handler functions are all imported from the controller modules we created in the previous section.
### Update the index route module
We've set up all our new routes, but we still have a route to the original page. Let's instead redirect this to the new index page that we've created at the path '/catalog'.
Open **/routes/index.js** and replace the existing route with the function below.
```js
// GET home page.
router.get("/", function (req, res) {
res.redirect("/catalog");
});
```
> **Note:** This is our first use of the [redirect()](https://expressjs.com/en/4x/api.html#res.redirect) response method. This redirects to the specified page, by default sending HTTP status code "302 Found". You can change the status code returned if needed, and supply either absolute or relative paths.
### Update app.js
The last step is to add the routes to the middleware chain.
We do this in `app.js`.
Open **app.js** and require the catalog route below the other routes (add the third line shown below, underneath the other two that should be already present in the file):
```js
var indexRouter = require("./routes/index");
var usersRouter = require("./routes/users");
const catalogRouter = require("./routes/catalog"); //Import routes for "catalog" area of site
```
Next, add the catalog route to the middleware stack below the other routes (add the third line shown below, underneath the other two that should be already present in the file):
```js
app.use("/", indexRouter);
app.use("/users", usersRouter);
app.use("/catalog", catalogRouter); // Add catalog routes to middleware chain.
```
> **Note:** We have added our catalog module at a path `'/catalog'`. This is prepended to all of the paths defined in the catalog module. So for example, to access a list of books, the URL will be: `/catalog/books/`.
That's it. We should now have routes and skeleton functions enabled for all the URLs that we will eventually support on the LocalLibrary website.
### Testing the routes
To test the routes, first start the website using your usual approach
- The default method
```bash
// Windows
SET DEBUG=express-locallibrary-tutorial:* & npm start
// macOS or Linux
DEBUG=express-locallibrary-tutorial:* npm start
```
- If you previously set up [nodemon](/en-US/docs/Learn/Server-side/Express_Nodejs/skeleton_website#enable_server_restart_on_file_changes), you can instead use:
```bash
npm run serverstart
```
Then navigate to a number of LocalLibrary URLs, and verify that you don't get an error page (HTTP 404). A small set of URLs are listed below for your convenience:
- `http://localhost:3000/`
- `http://localhost:3000/catalog`
- `http://localhost:3000/catalog/books`
- `http://localhost:3000/catalog/bookinstances/`
- `http://localhost:3000/catalog/authors/`
- `http://localhost:3000/catalog/genres/`
- `http://localhost:3000/catalog/book/5846437593935e2f8c2aa226`
- `http://localhost:3000/catalog/book/create`
## Summary
We've now created all the routes for our site, along with dummy controller functions that we can populate with a full implementation in later articles. Along the way we've learned a lot of fundamental information about Express routes, handling exceptions, and some approaches for structuring our routes and controllers.
In our next article we'll create a proper welcome page for the site, using views (templates) and information stored in our models.
## See also
- [Basic routing](https://expressjs.com/en/starter/basic-routing.html) (Express docs)
- [Routing guide](https://expressjs.com/en/guide/routing.html) (Express docs)
{{PreviousMenuNext("Learn/Server-side/Express_Nodejs/mongoose", "Learn/Server-side/Express_Nodejs/Displaying_data", "Learn/Server-side/Express_Nodejs")}}
| 0 |
Subsets and Splits