A Basic HTML5 Template
As you learn HTML5 and add new techniques to your toolbox, you’re likely to want to build yourself a boilerplate, from which you can begin all your HTML5-based projects. We encourage this, and you may also consider using one of the many online sources that provide a basic HTML5 starting point for you.
In this tutorial , however, we want to build our code from scratch and explain each piece as we go along. Of course, it would be impossible for even the most fantastical and unwieldy sample site we could dream up to include every new element or technique, so we’ll also explain many new features that don’t fit into the project. This way, you’ll be familiar with a wide set of options when deciding how to build your HTML5 and CSS3 websites and applications, enabling you to use this book as a quick reference for a number of features and techniques.
Let’s start simple, with a bare-bones HTML5 page:
<!DOCTYPE html> <html lang="en"> <head> <meta charset="utf-8"> <title>The HTML5 Herald</title> <meta name="description" content="The HTML5 Herald"> <meta name="author" content="SitePoint"> <link rel="stylesheet" href="css/styles.css"> <!--[if lt IE 9]> <script src="js/html5shim.js"></script> <![endif]--> </head> <body> <script src="js/scripts.js"></script> </body> </html>
With that basic template in place, let’s now examine some of the significant parts of the markup and how these might differ from how HTML was written prior to HTML5.
First, we have the Document Type Declaration, or doctype. This is simply a way to tell the browser—or any other parser—what type of document it’s looking at. In the case of HTML files, it means the specific version and flavor of HTML. The doctype should always be the first item at the top of any HTML file. Many years ago, the doctype declaration was an ugly and hard-to-remember mess. For XHTML 1.0 Strict:
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www ↵.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
And for HTML4 Transitional:
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http ↵://www.w3.org/TR/html4/loose.dtd">
Although that long string of text at the top of our documents hasn’t really hurt us (other than forcing our sites’ viewers to download a few extra bytes), HTML5 has done away with that indecipherable eyesore. Now all you need is this:
Simple, and to the point. The doctype can be written in uppercase, lowercase, or mixed case. You’ll notice that the “5” is conspicuously missing from the declaration. Although the current iteration of web markup is known as “HTML5,” it really is just an evolution of previous HTML standards—and future specifications will simply be a development of what we have today.
Because browsers are usually required to support all existing content on the Web, there’s no reliance on the doctype to tell them which features should be supported in a given document. In other words, the doctype alone is not going to make your pages HTML5-compliant. It’s really up to the browser to do this. In fact, you can use one of those two older doctypes with new HTML5 elements on the page and the page will render the same as it would if you used the new doctype.
Next up in any HTML document is the
html element, which has not changed significantly with HTML5. In our example, we’ve included the
lang attribute with a value of
en, which specifies that the document is in English. In XHTML-based markup, you were required to include an
xmlns attribute. In HTML5, this is no longer needed, and even the
lang attribute is unnecessary for the document to validate or function correctly.
The next part of our page is the
head section. The first line inside the
head is the one that defines the character encoding for the document. This is another element that’s been simplified since XHTML and HTML4, and is an optional feature, but recommended. In the past, you may have written it like this:
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
HTML5 improves on this by reducing the character-encoding
meta tag to the bare minimum:
In nearly all cases,
utf-8 is the value you’ll be using in your documents. A full explanation of character encoding is beyond the scope of this book, and it probably won’t be that interesting to you, either. Nonetheless, if you want to delve a little deeper, you can read up on the topic on W3C or WHATWG.
Important: Encoding Declaration
To ensure that all browsers read the character encoding correctly, the entire character-encoding declaration must be included somewhere within the first 512 characters of your document. It should also appear before any content-based elements (such as the
title element that follows it in our example site).
There’s much more we could write about this subject, but we want to keep you awake—so we’ll spare you those details! For now, we’re content to accept this simplified declaration and move on to the next part of our document:
<title>The HTML5 Herald</title> <meta name="description" content="The HTML5 Herald"> <meta name="author" content="SitePoint"> <link rel="stylesheet" href="css/styles.css">
In these lines, HTML5 barely differs from previous syntaxes. The page title (the only mandatory element inside the
head) is declared the same as it always was, and the meta tags we’ve included are merely optional examples to indicate where these would be placed; you could put as many valid
metaelements here as you like.
The key part of this chunk of markup is the stylesheet, which is included using the customary
linkelement. There are no required attributes for
link other than
type attribute (which was common in older versions of HTML) is not necessary, nor was it ever needed to indicate the content type of the stylesheet.
Leveling the Playing Field
The next element in our markup requires a bit of background information before it can be introduced. HTML5 includes a number of new elements, such as
section, which we’ll be covering later on. You might think this would be a major problem for older browser support for unrecognized elements, but you’d be wrong. This is because the majority of browsers don’t actually care what tags you use. If you had an HTML document with a
recipe tag (or even a
ziggy tag) in it, and your CSS attached some styles to that element, nearly every browser would proceed as if this were totally normal, applying your styling without complaint.
Of course, such a hypothetical document would fail to validate and may have accessibility problems, but it would render correctly in almost all browsers—the exception being old versions of Internet Explorer (IE). Prior to version 9, IE prevented unrecognized elements from receiving styling. These mystery elements were seen by the rendering engine as “unknown elements,” so you were unable to change the way they looked or behaved. This includes not only our imagined elements, but also any elements that had yet to be defined at the time those browser versions were developed. That means (you guessed it) the new HTML5 elements.
The good news is, at the time of writing, most people still using a version of IE are using version 9 or higher, and very few are on version 9, so this is not a big problem for most developers anymore; however, if a big chunk of your audience is still using IE8 or earlier, you’ll have to take action to ensure your designs don’t fall apart.
We’ve included this so-called “HTML5 shiv” in our markup as a script tag surrounded by conditional comments. Conditional comments are a proprietary feature implemented in Internet Explorer in version 9 and earlier. They provide you with the ability to target specific versions of that browser with scripts or styles. The following conditional comment is telling the browser that the enclosed markup should only appear to users viewing the page with Internet Explorer prior to version 9:
<!--[if lt IE 9]> <script src="js/html5shim.js"></script> <![endif]-->
Note: Not Everyone Can Benefit from the HTML5 Shiv
The Rest Is History
Looking at the rest of our starting template, we have the usual
body element along with its closing tag and the closing
Much like the
link tag discussed earlier, the
script tag does not require that you declare a
typeattribute. If you ever wrote XHTML, you might remember your
script tags looking like this:
type attribute is unnecessary in HTML5 documents:
We’ve put the
In some cases, however, (such as with the HTML5 shiv) the script may need to be placed in the head of your document, because you want it to take effect before the browser starts rendering the page.
After this quick introduction to HTML5 markup, you probably have a bunch of questions swirling in your head. Here are some answers to a few of the likely ones.
Why do these changes still work in older browsers?
To understand why this isn’t a problem, we can compare HTML5 to some of the new features added in CSS3, which we’ll be discussing in later tutorials.
In CSS, when a new feature is added (for example, the
border-radius property that adds rounded corners to elements), that feature also has to be added to browsers’ rendering engines, so older browsers will fail to recognize it. If a user is viewing the page on a browser with no support for
border-radius, the rounded corners will appear square. This happens because square corners are the default and the browser will ignore the
border-radius declaration. Other CSS3 features behave similarly, causing the experience to be degraded to some degree.
Many developers expect that HTML5 will work in a similar way. While this might be true for some of the advanced features and APIs we’ll be considering later in the book, it’s not the case with the changes we’ve covered so far; that is, the simpler syntax, fewer superfluous attributes, and the new doctype.
HTML5’s syntax was more or less defined after a careful study of what older browsers can and can’t handle. For example, the 15 characters that comprise the doctype declaration in HTML5 are the minimum characters required to make every browser display a page in standards mode.
Likewise, while XHTML required a lengthier character-encoding declaration and an extra attribute on the
html element for the purpose of validation, browsers never actually required them in order to display a page correctly. Again, the behavior of older browsers was carefully examined, and it was determined that the character encoding could be simplified and the
xmlns attribute removed—and browsers would still see the page the same way.
Note: Standards Mode versus Quirks Mode
When standards-based web design was in its infancy, browser makers were faced with a problem: supporting emerging standards would, in many cases, break backwards compatibility with existing web pages that were designed to older, nonstandard browser implementations. Browser makers needed a signal indicating that a given page was meant to be rendered according to the standards. They found such a signal in the doctype: new standards-compliant pages included a correctly formatted doctype, while older nonstandard pages generally didn’t. Using the doctype as a signal, browsers could switch between standards mode (in which they try to follow standards to the letter in the way they render elements) and quirks mode (where they attempt to mimic the “quirky” rendering capabilities of older browsers to ensure that the page renders how it was intended).
It’s safe to say that in the current development landscape, nearly every web page has a proper doctype, and thus will render in standards mode; it’s therefore unlikely that you’ll ever have to deal with a page rendered in quirks mode. Of course, if a user is viewing a web page using a very old browser (such as IE4), the page will be rendered using that browser’s rendering mode. This is what quirks mode mimics, and it will do so regardless of the doctype being used.
Although the XHTML and older HTML doctypes include information about the exact version of the specification they refer to, browsers have never actually made use of that information. As long as a seemingly correct doctype is present, they’ll render the page in standards mode. Consequently, HTML5’s doctype has been stripped down to the bare minimum required to trigger standards mode in any browser. Further information, along with a chart that outlines what will cause different browsers to render in quirks mode, can be found on Wikipedia. You can also read a good overview of standards and quirks mode on SitePoint’s CSS reference.
Shouldn’t all tags be closed?
In XHTML, all elements were required to be closed—either with a corresponding closing tag (such as
html) or in the case of void elements, a forward slash at the end of the tag. Void elements are elements that can’t contain child elements (such as
You can still use that style of syntax in HTML5—and you might prefer it for consistency and maintainability reasons—but adding a trailing slash on void elements is no longer required for validation. Continuing with the theme of “cutting the fat,” HTML5 allows you to omit the trailing slash from such elements, arguably leaving your markup cleaner and less cluttered.
It’s worth noting that in HTML5, most elements that can contain nested elements—but simply happen to be empty—still need to be paired with a corresponding closing tag. There are exceptions to this rule (such as
p tags and
li tags), but it’s simpler to assume that it’s universal.
What about other XHTML-based syntax customs?
While we’re on the subject, omitting closing slashes is just one aspect of HTML5-based syntax that differs from XHTML. In fact, syntax style issues are completely ignored by the HTML5 validator, which will only throw errors for code mistakes that threaten to disrupt your document in some way.
What this means is that through the eyes of the validator, the following five lines of markup are identical:
<link rel="stylesheet" href="css/styles.css" /> <link rel="stylesheet" href="css/styles.css"> <LINK REL="stylesheet" HREF="css/styles.css"> <Link Rel="stylesheet" Href="css/styles.css"> <link rel=stylesheet href=css/styles.css>
In HTML5, you can use lowercase, uppercase, or mixed-case tag names or attributes, as well as quoted or unquoted attribute values (as long as those values don’t contain spaces or other reserved characters), and it will all validate just fine.
In XHTML, all attributes were required to have values, even if those values were redundant. For example, in XHTML you’d often see markup like this:
<input type="text" disabled="disabled" />
In HTML5, attributes that are either “on” or “off” (called Boolean attributes) can simply be specified with no value. So, the aforementioned
input element can be written as follows:
<input type="text" disabled>
Hence, HTML5 has very loose requirements for validation, at least as far as syntax is concerned. Does this mean you should just go nuts and use whatever syntax you want on any given element? No, we certainly don’t recommend that.
We encourage developers to choose a syntax style and stick to it—especially if you are working in a team environment where code maintenance and readability are crucial. We also recommend (though this is optional) that you choose a minimalist coding style while staying consistent.
Here are some guidelines for you to consider using:
- Use lowercase for all elements and attributes as you would in XHTML.
- Despite some elements not requiring closing tags, we recommend that all elements containing content be closed (as in
- Although you can leave attribute values unquoted, it’s highly likely that you’ll have attributes that require quotes (for example, when declaring multiple classes separated by spaces, or when appending a query string value to a URL). As a result, we suggest that you always use quotes for the sake of consistency.
- Omit the trailing slash from void elements (such as
- Avoid providing redundant values for Boolean attributes (for instance, use
<input type="checkbox" checked>rather than
<input type="checkbox" checked="checked">).
Again, these recommendations are by no means universally accepted; however, we believe that they’re reasonable syntax suggestions for achieving clean, easy-to-read maintainable markup.
If you do run amok with your code style, including too much that’s unnecessary, you’re just adding extra bytes for no reason. You’re also potentially making your code harder to maintain, especially if you work with other developers on the same code base.
Defining the Page’s Structure
Now that we’ve broken down the basics of our template, let’s start adding some meat to the bones and give our page some structure.
Naturally, the first element we’ll look at is the
header element. The spec describes it succinctly as “a group of introductory or navigational aids.”
Contrary to what you might normally assume, you can include a new header element to introduce each section of your content. It’s not just reserved for the page header (which you might normally mark up with
<div id="header">). When we use the word “section” here, we’re not limiting ourselves to the actual
section element described in the next part; technically, we’re referring to what HTML5 calls “sectioning content.” This means any chunk of content that might need its own header, even if that means there are multiple such chunks on a single page.
header element can be used to include introductory content or navigational aids that are specific to any single section of a page, or apply to the entire page, or both.
header element will frequently be placed at the top of a page or section, its definition is independent from its position. Your site’s layout might call for the title of an article or blog post to be off to the left, right, or even below the content; regardless of which, you can still use
header to describe this content.
The next element you should become familiar with is HTML5’s
section element. The spec defines
section as follows:
section element represents a generic section of a document or application. A section, in this context, is a thematic grouping of content, typically with a heading.
It further explains that a
section shouldn’t be used as a generic container that exists for styling or scripting purposes only. If you’re unable to use
section as a generic container—for example, in order to achieve your desired CSS layout—then what should you use? Our old friend, the
div element, which is semantically meaningless.
Going back to the definition from the spec, the
section element’s content should be “thematic,” so it would be incorrect to use it in a generic way to wrap unrelated pieces of content.
Some examples of acceptable uses for
section elements include:
- individual sections of a tabbed interface
- segments of an “About” page; for example, a company’s “About” page might include sections on the company’s history, its mission statement, and its team
- different parts of a lengthy “terms of service” page
- various sections of an online news site; for example, articles could be grouped into sections covering sports, world affairs, and economic news
Every time new semantic markup is made available to web designers, there will be debate over what constitutes correct use of these elements, what the spec’s intention was, and so on. You may remember discussions about the appropriate use of the
dl element in previous HTML specifications. Unsurprisingly, HTML5 has not been immune to this phenomenon, particularly when it comes to the
section element. Even Bruce Lawson, a well-respected authority on HTML5, has admitted to using
section incorrectly in the past. For a bit of clarity, it’s well worth reading Bruce’s post explaining his error.
sectionis generic, so if a more specific semantic element is appropriate (such as
nav), use that instead.
sectionhas semantic meaning; it implies that the content it contains is related in some way. If you’re unable to succinctly describe all the content you’re trying to put in a
sectionusing just a few words, it’s likely you need a semantically neutral container instead: the humble
That said, as is always the case with semantics, it’s open to interpretation in some instances. If you feel you can make a case for why you’re using a given element rather than another, go for it. In the unlikely event that anyone ever calls you on it, the resulting discussion can be both entertaining and enriching for everyone involved, and might even contribute to the wider community’s understanding of the specification.
Keep in mind, also, that you’re permitted to nest
section elements inside existing
section elements, if it’s appropriate. For example, for an online news website, the World News section might be further subdivided into a section for each major global region.
article element is similar to the
section element, but there are some notable differences. Here’s the definition according to the spec:
The article element represents a complete, or self-contained, composition in a document, page, application, or site and that is, in principle, independently distributable or reusable, e.g. in syndication.
The key terms in that definition are self-contained composition and independently distributable. Whereas a
section can contain any content that can be grouped thematically, an
article must be a single piece of content that can stand on its own. This distinction can be hard to wrap your head around, so when in doubt, try the test of syndication: if a piece of content can be republished on another site without being modified, or if it can be pushed out as an update via RSS, or on social media sites such as Twitter or Facebook, it has the makings of an
Ultimately, it’s up to you to decide what constitutes an article, but here are some suggestions in line with recommendations in the spec:
- a forum post
- a magazine or newspaper article
- a blog entry
- a user-submitted comment on a blog entry or article
Finally, just like
article elements can be nested inside other
article elements. You can also nest a
section inside an
article, and vice versa. It all depends on the content you’re marking up.