- A Short History of Style for the Web
- What Is CSS?
- How Is CSS Used?
- Basic CSS Syntax
- The Basics of Selectors
- Basic Properties: Font Styles
- Inheritance
- Getting Specific: class and id Selectors
- Common Text Layout Properties
- Combinators: Descendant and Child Selectors
- Common Background Properties
- Dynamic Selectors
- Basic Page Layout
- Advanced Page Layout
- Positioning
- Advanced Selectors
- Display Types
- More Properties
- Media Types
- Importing Style Sheets
- Quality Assurance
- Specific Challenges and Techniques
This chapter is from the book
This chapter is from the book
This chapter is from the book
Combinators: Descendant and Child Selectors
So far, we've selected elements based on their individual qualities—their type and their class and id values. But we can also select elements based on their place in the document structure. We can select any element descended from another element, for example, any element of class chapter descended from a div element. Or we can get more specific, and specify that the element must be a child element (that is, contained directly within a particular element).
Descendant Selectors
The first of these two new kinds of selector is the descendant selector. It selects an element based on the elements that contain it (either directly, as their parent element, or as a container of their parent, and so on up the tree). We can select elements based on one containment relationship, or chain together selectors to make them more and more specific. Let's start with the simplest case, where we have just two elements.
In the last chapter, we cautioned against the indiscriminate addition of class and id values to elements, suggesting rather it makes sense to give an id value to significant, unique parts of a document (for example, the header part of a page, which will usually be a div element, which contains a heading and probably page or site navigation). Other common "landmarks" in a page include the main content of the page and footers. We'll look at page layout in great detail in Chapter 9, which will also focus on markup conventions for page layouts.
Let's suppose we have the main content block of our page contained within a div with class main (we've chosen this name from the ARIA landmarks, which we cover in detail in Chapter 6). Now, we can select only elements inside this element—for example, only paragraphs inside the main content—not those inside the footer or header using a descendent selector:
div#main p{
}
|
Rather than having to give a class of main to each paragraph in the main content div, we can use this descendant selector instead. Descendant selectors are the single most overlooked aspect of CSS in relation to their value. Learning to use id judiciously for marking up landmark elements and descendant selectors for selecting their contents is one of the most useful techniques you'll learn as a web developer.
Child Selectors
Child selectors are closely related to descendant selectors, but they differ both in their syntax, as well as what they select. They select descendant elements of other elements, but only when the element is a child of the first selected element—that is, only when it is directly contained within the first selected element. These can be useful in situations like those just discussed, but they give us even more specific ways to select elements based on the structure of the document.
Child selectors, instead of simply having a space between the component selectors, have a greater-than sign (>) between them. So, for example, to select only headings of level 2 that are directly inside the main div, we'd use this:
#main>h2{}
|
As mentioned, we can also chain together selectors to make them even more specific.
Chaining
Nested lists are a particularly good example of the ways in which chaining is useful. Lists can be nested several deep. Suppose we have a list such as this one:
<ul>
<li>HTML and XHTML</li>
<li><ul>
<li>principles of markup</li>
<li>syntax</li>
<li>semantics</li>
<li>validity</li>
<li>accessibility</li>
</ul></li>
<li><ul>
<li>HTML versions</li>
<li><ul>
<li>HTML 4.01</li>
<li>XHTML 1.0, 1.1</li>
</ul></li>
</ul></li>
</ul>
|
Let's suppose we wanted to style only the list items nested three levels deep. We could do this by adding a class value to each such list item—though that's something we've suggested time and again that we should try to avoid. We should always see whether there's an approach using CSS before adding markup specifically for styling a document. The selector li will select every list item in the document, which won't do. Similarly, ul li will select all of the list items that are inside an unordered list. Now if we think about the structure, we know the elements we want to select are list items inside unordered lists, inside unordered lists, inside unordered lists. So, working backwards, our selector for these list items would be:
ul ul ul li {}
|
Similarly, we can select the second-level indented elements using this:
ul ul li {}
|
But, if you think it through a bit, we have a problem. A list that is nested three levels deep is also listed two levels deep. So this statement selects any lists that are nested either two or three levels deep. But let's suppose these lists are contained within the same div of id main. This selector will select the same lists (all of them being descendants of the main div):
#main ul ul li {}
|
On the other hand, if we want to select only those list items contained inside an ordered list that is itself contained inside an ordered list that is directly inside that the main div, we'd use:
div#main>ul ul li {}
|
This example shows how even seemingly intractable problems of selecting elements without resorting to adding class and id values solely for presentation can often, with some ingenuity, be solved with CSS selectors. In Chapter 12, we'll see how CSS3 provides microsurgical tools for selecting elements with CSS, but the most important thing is to start "thinking in CSS," which means really understanding and exploring selectors.
But, as you must be expecting by this point, there's just one little hitch. We've mentioned browser support for CSS in passing, and how it's long caused headaches for developers. In Chapter 7 we'll go into this whole issue in significant detail, but here's where we run into the issue in practical terms for the first time.
Although all modern browsers support child selectors, until Internet Explorer 7, Internet Explorer did not. This means that the reasonably large percentage of users who use IE 6 won't see any style applied using child selectors without the use of workarounds such as JavaScript libraries, which add support to IE for features it doesn't support. We'll go into this in detail in Chapter 7, so don't worry too much about the issue now.
Specificity of Child and Descendant Selectors
How does specificity work with selectors like these? Earlier we said that id selectors trump class selectors, which themselves trump type selectors. Often, that's all you need to know, but in the case of child and descendant selectors, which may be made up of type, class, and id selectors, how do we determine which is the more specific selector? Well, each different kind of selector is given a value. Type selectors are worth 1, class selectors are worth 10, and id selectors are worth 100. We then add up the total value of all the component selectors for a child or descendant selector. (Really.)
So this selector:
#main ul ul li
|
would be worth 103 (100 for the id selector, and 3 for the three type selectors), whereas this one:
chapter ul li
|
would be worth 12 (10 for the class selector, and 2 for the two type selectors). The selector with the highest value is the most specific, and it trumps any selectors with a lower specificity.
Note that this doesn't apply to group selectors. Instead of adding up the individual selectors in the group, we treat each of the comma-separated selectors in the group as belonging to different statements. So, for instance, this selector:
#main ul li, .chapter p
|
is really two selectors—one with a specificity of 102, and one of 12.