Key Takeaways

  • CSS Attribute Selectors Offer Highly Flexible Targeting: Target elements based on substrings, the beginning or end of attribute values, and more.
  • Case Sensitivity Matters: Ensure your selectors match the exact capitalization of attribute values.
  • Combine Selectors for Precision: Achieve granular styling control by combining attribute selectors.
  • Pseudo-classes Enhance Interactivity: Target elements based on user interactions (hover, focus) and element states (empty, checked).

Discover the power of CSS attribute selectors for precise styling control. Learn how to target elements based on attribute values, substrings, positions, and more.

Optimize your CSS for enhanced flexibility and efficiency.

CSS Substring Matching: Target Elements with Precision

Sometimes you’ll want to target elements where an attribute’s value contains a specific substring, but it’s not part of a space-separated list. CSS provides a powerful solution for this scenario: the asterisk-equals ([attr*="val"]) selector.

How It Works:

  • The Asterisk (*) is Key: This symbol tells the selector to find the substring “val” anywhere within the specified attribute’s value.
  • Not the Universal Selector: Note, the asterisk here is different from its universal selector usage.

Example: Targeting “Cloudy” Planets

Let’s illustrate the concept by styling your “cloudy” planets:


span[class*="cloud"] {font-style: italic;} 



<span class="barren rocky">Mercury</span> 
<span class="cloudy barren">Venus</span> 
<span class="life-bearing cloudy">Earth</span> 

Result: This rule italicizes elements with “cloudy” within their class attribute.

Key Points

  • Flexibility: Target elements based on substrings within any attribute value, not just ‘class’.
  • Versatility: Find partial matches anywhere within the attribute’s value.

Master Flexible CSS Styling with Substring Matching

Substring attribute selectors open a world of creative CSS targeting possibilities. With the [attr*="val"] pattern, you can style elements based on a substring found anywhere within their attribute values.

Example: Highlighting W3C Links

Want to make links to the W3C website stand out? Forget extra classes:


a[href*=""] {font-weight: bold;} 

Key Points:

  • Beyond ‘class’ and ‘href’: Target substrings within any attribute (like ‘src’, ‘title’, ‘id’).
  • Substring Flexibility: Find your target string regardless of its position within the attribute value.

More Substring Targeting Scenarios

  • Emphasize ‘Space’ Images:
img[src*="space"] {outline: 5px solid red;} 
  • Input Field Hints:
input[title*="format"] {background-color: #dedede;} 

Pattern Library Power: Targeting Class Substrings

Let’s extend your button example using the *[class|="btn"][class*="-arrow"] selector:


*[class|="btn"][class*="-arrow"]:after { content: "▼";} 
<button class="btn-small-arrow-active">Click Me</button>

Important Notes:

  • Case Sensitivity Matters: Most attributes are case-sensitive.
  • Whitespace Counts: Include spaces in your selector if they’re present within the target attribute value.

CSS: Target Elements by Attribute Starts

Need to target elements where an attribute value begins with a specific substring? The caret-equals ([att^="val"]) selector is your solution!

Example: Styling Link Types

Let’s make those external and email links stand out:


a[href^="https:"] {font-weight: bold;} 
a[href^="mailto:"] {font-style: italic;} 

Example: Highlighting Figures

Assuming your figure images use descriptive alt text that starts with “Figure”, you can style them distinctively:


img[alt^="Figure"] {border: 2px solid gray; display: block; margin: 2em auto;}

Important Considerations:

  • Specificity: This selector targets any element with an attribute value starting with your specified string. Ensure this aligns with your intended styling.

Example: Calendar Events

Let’s say you want to style events happening on Mondays, where the ‘title’ attribute begins with “Monday” (e.g., “Monday, March 5th, 2024”). Here’s the selector:



Key Points

  • Target Starts of Values: Precisely style elements based on how their attribute values begin.
  • Flexible Use Cases: From link types to image identification, this selector provides targeted styling control.

CSS: Style Elements Based on Attribute Endings

Want to style elements based on how their attributes end? The dollar-sign equals ([att$="val"]) selector is your tool. Let’s explore some common scenarios:

Example: Emphasizing PDF Links

Make those PDF links pop with a simple rule:


a[href$=".pdf"] {font-weight: bold;} 

Example: Styling Based on Image Format

Differentiate your image types visually with this approach:


img[src$=".gif"] { /* Styles for GIFs */ } 
img[src$=".jpg"] { /* Styles for JPEGs */ } 
img[src$=".png"] { /* Styles for PNGs */ } 

Example: Filtering Calendar Events by Year

To single out events from a specific year (like 2024), use this selector:



Key Points:

  • Match Endings: This selector offers precise control based on how attribute values conclude.
  • Diverse Use Cases: Style links by file type, images by format, or calendar events by year.

Targeting Attribute Endings with CSS

Want to style elements based on how their attributes end? The dollar-sign equals ([att$="val"]) selector has you covered. Here are common use cases:

Emphasizing Specific File Types:

  • PDF Links: Make PDF links stand out with a simple rule:
a[href$=".pdf"] {font-weight: bold;} 

Styling Images by Format:

  • Customize how your different image types display:
img[src$=".gif"] { /* Styles for GIFs */ } 
img[src$=".jpg"] { /* Styles for JPEGs */ } 
img[src$=".png"] { /* Styles for PNGs */ } 

Filtering Events by Year

  • Isolate events from a specific year (like 2024) using:

Key Point: Attribute Value Quoting

  • Play it Safe: Always quote values within attribute selectors for consistency and to avoid potential errors.
  • Special Characters: Quoting is essential if your values contain hyphens, digits at the start, or any other special characters.

Combining CSS Selectors for Greater Precision

So far, we’ve looked at targeting elements based on single attributes. But what if you want even more refined styling control? Let’s explore how CSS allows you to combine selectors for granular targeting.

Example: Styling Specific Image Links

Suppose you only want to style links to image files (and ensure they have descriptive alt text). Here’s how to combine selectors:


[alt] { /* Your styles for image links */} 

How it Works:

  1. Target File Extensions: The first part selects links ending in “.jpg”, “.png”, or “.gif”.
  2. Check for ‘alt’ Attribute: The [alt] part ensures that only image links with the ‘alt’ attribute are styled.

Beyond Images:

This technique applies to any scenario where you need to combine attribute-based criteria for precise styling.

Key Points

  • Flexibility: Combine selectors to achieve the exact level of targeting you need.
  • Accessibility Boost: Example above demonstrates how CSS can encourage good accessibility practices.

CSS Case Sensitivity Considerations

Before we dive deeper, there’s a crucial detail about CSS selectors: they’re case-sensitive. Let’s break down what this means for your styling:

  • Matching Matters: An attribute value of “Image.jpg” will not be selected by a rule targeting “image.jpg” – the case must be an exact match.
  • Common Pitfall: File extensions, URLs, and class names are all typically case-sensitive, so ensure your selectors align.

Example: Avoiding Mismatches

Let’s say you want to style links to your company website, but the domain might be written in different ways (e.g., “” vs. “”). Here’s a solution:


a[href*=""] { text-transform: uppercase; } 

Important Notes:

  • Substring Matching: We’re using the substring attribute selector (*=) to catch variations.
  • Browser Differences: Some older browsers might handle case-sensitivity differently. It’s best practice to keep your values consistent throughout your site.

Let’s explore the fascinating world of CSS selectors that target elements based on their positions and relationships within your HTML structure!

Selecting Elements Based on Their Position

CSS provides several tools for pinpointing elements based on where they appear in relation to their siblings (i.e., elements with the same parent).

  1. The :nth-child Selector:
    • Syntax: element:nth-child(pattern)
    • Example: Style every third list item:
li:nth-child(3n) { background-color: lightgray; } 
  1. Patterns: Supports formulas (an + b) for complex selections (e.g., ‘odd’, ‘even’).
  2. More Specific Position Selectors
  • element:first-child: Targets the first element among its siblings.
  • element:last-child: Targets the last element among its siblings.

Example: Highlighting the First Blog Post

Let’s make the first article excerpt in your blog listing distinctive:


article:first-child { border: 2px solid red; } 

Key Points:

  • Sibling Context: These selectors focus on where an element sits within a group of elements sharing the same parent.
  • Diverse Use Cases: Style navigation menus, highlight specific elements, and much more.

CSS Combinators: Selecting Elements by Relationship

CSS combinators enable you to precisely target elements based on their relationships with other elements in your HTML. Here’s a breakdown of the key types:

  1. Descendent Selector (space):
    • Syntax: ancestor descendant
    • Example: Style links only within navigation menus:
nav a { color: blue; } 
  1. Targets: Elements that are descendants (children, grandchildren, etc.) of a specified ancestor.
  2. Child Selector (>)
    • Syntax: parent > child
    • Example: Style list items that are direct children of an unordered list:
ul > li { margin-bottom: 10px; } 
  1. Targets: Only direct children, not any deeper-nested descendants.
  2. Adjacent Sibling Selector (+)
    • Syntax: element1 + element2
    • Example: Apply special formatting to paragraphs immediately following header tags:
 h2 + p { font-size: 1.2em; } 
  1. Targets: The second element only if it directly follows the first element.

Key Points:

  • Specificity: These selectors offer fine-grained control over your styling.
  • Clarity: Make your code more readable by precisely indicating the relationship between elements.

Unlocking the Power of CSS Pseudo-classes

Pseudo-classes act like extra filters you can apply to your selectors. They let you target elements based on their current state, position, or user interactions. Here’s a taste of some widely-used pseudo-classes:

  • Dynamic States:
    • :hover: Styles elements when the mouse hovers over them.
    • :active: Styles elements the moment they’re clicked or activated.
    • :focus: Styles elements when they receive keyboard focus.
  • Structural Targeting
    • :first-of-type:last-of-type: Select the first or last element of its particular type within a parent.
    • :nth-of-type: Similar to :nth-child but specific to an element type within its parent.

Example: Enhancing Link Behavior

Let’s make your links visually dynamic:


a:link { color: blue; } /* Unvisited links */
a:visited { color: purple; } /* Visited links */ 
a:hover { text-decoration: underline; } /* Mouse hover */
a:focus { outline: 2px solid orange; } /* Keyboard focus */

Key Points:

  • Interactivity: Pseudo-classes are essential for creating engaging user experiences.
  • Accessibility Aid: Pseudo-classes like :focus help ensure your site is keyboard-navigable.

Absolutely! Let’s go further into specialized pseudo-classes and advanced CSS selection techniques.

More CSS Pseudo-classes for Advanced Targeting

Let’s go beyond the basics with these powerful pseudo-classes:

  1. Form Input States:
    • :checked: Styles checkboxes or radio buttons that are selected.
    • :enabled:disabled: Style form elements based on whether they can be interacted with.
    • :required:optional: Styles inputs based on whether they’re required fields.
  2. Negation with :not():
    • Syntax: element:not(selector)
    • Example: Style all paragraphs except those within a specific “warning” section:
p:not(.warning p) { text-align: justify; } 
  1. UI Element States:
    • :empty: Targets elements that have no children (including text content).
    • :in-range:out-of-range: Used for styling form inputs based on their values being within or outside a specified range.

Example: Customizing Form Feedback

Let’s provide clear visual cues about form fields:


input:required { border: 2px solid red; }  
input:optional { border: 2px solid gray; } 
input:valid { background-color: lightgreen; } 
input:invalid { background-color: pink; } 

Key Points

  • Granular Control: Target elements with incredible precision based on their state or content.
  • Enhanced UX: Improve user experiences by styling form elements and providing clear feedback.

Elevate your CSS skills with the power of attribute selectors. Experiment with substring matching, case sensitivity considerations, combining selectors, and pseudo-classes for flexible, targeted styling that enhances your web designs.

Leave a Reply

Your email address will not be published. Required fields are marked *