How do you add important (!important) in CSS?

How do you add important (!important) in CSS?
Share This Story

CSS (Cascading Style Sheets) is a powerful language used to style and format web documents. Web developers and designers must have a deep understanding of CSS to create visually appealing and functional websites. One important concept to grasp is the use of the !important rule. In this article, we will explore what the !important rule is, how it works, and when it should be used.

Understanding the !important Rule in CSS

In CSS, the !important rule is used to give a particular style declaration the highest priority. It overrides any other styles that may be applied to an element. When the !important rule is used, it ensures that the specified style will be applied, regardless of any conflicting styles.

The !important rule is often used when you need to override specific styles that have been applied by default or by other stylesheets. It allows you to exert more control over the appearance of elements on your website.

Here is an example of how the !important rule can be used:

h1 {color: red !important;}

In the above example, the text color for all <h1> elements will be set to red, overriding any other styles that may have been applied. The !important rule ensures that this style of declaration takes precedence over others.

How Does the !important Rule Work in CSS?

When a style rule is marked with the !important declaration, it is given the highest priority and will be applied regardless of specificity or order in the stylesheet. This means that any conflicting styles that have been applied to the element will be overridden.

Typically, styles are applied based on the specificity of selectors. Styles with higher specificity, such as an ID selector, take precedence over styles with lower specificity, such as a class selector. However, the !important rule allows certain styles to be prioritized over others regardless of specificity.

It’s important to note that while the !important rule can be a valuable tool, it should be used sparingly. Overusing the !important rule can lead to messy and hard-to-manage stylesheets, making it difficult to maintain or update your website’s design in the future.

When to Use the !important Rule

While the !important rule can be a powerful tool, it is advised to use it judiciously. Overusing !important can lead to poor code maintainability and make it difficult to troubleshoot or modify styles later on. However, there are some situations where using the !important rule is appropriate and can be beneficial:

  1. Overriding Inline Styles: Inline styles are applied directly to an HTML element using the style attribute. Inline styles have high specificity and are difficult to override. In such cases, the !important rule can be used to override these inline styles and apply custom styles.
  2. Handling Third-Party Stylesheets: When using third-party stylesheets, such as a CSS framework or a plugin, sometimes their styles may conflict with your custom styles. In such cases, the !important rule can be used to give your styles priority over those from the external stylesheet.
  3. Accessibility Considerations: In some cases, the !important rule may be necessary to ensure that certain styles, such as those related to accessibility, are always applied and cannot be overridden. Examples include ensuring sufficient color contrast for readability or providing alternative text for images.

Best Practices for Using the !important Rule

When using the !important rule, it’s important to follow some best practices to maintain clean and manageable code:

  1. Use Specificity First: Before resorting to the !important rule, try to make your styles more specific. Adjust the selectors or add more specific rules to target the desired elements. This will help maintain better code organization and reduce the reliance on !important.
  2. Use a Separate Stylesheet: Instead of scattering !important rules throughout your CSS, consider creating a separate stylesheet specifically for overriding styles. This helps keep your main stylesheet clean and separates the styles that need to be overridden.
  3. Document the Use of !important: When using the !important rule, make sure to document the reasoning behind it to help future developers understand its purpose. Comment on your code to explain why certain styles require the !important rule.
  4. Test and Verify: After applying the !important rule, thoroughly test your website to ensure that the desired styles are being applied correctly and that there are no unintended consequences or conflicts.

Frequently Asked Questions

What is the purpose of adding !important in CSS?

Adding !important to a CSS property declaration gives it the highest specificity, ensuring that the style defined with !important will override any conflicting styles, even those with higher specificity.

How do I use the !important rule in CSS?

To use the !important rule, simply add it immediately after the property value in a CSS rule declaration. For example – color: red !important;

Can I use !important with every CSS property?

Yes, you can use !important with any CSS property. However, it’s recommended to use it sparingly and only when absolutely necessary, as it can make your styles harder to manage and maintain.

What happens if multiple styles have !important?

When multiple styles have the !important declaration for the same property, the rule with the highest specificity will take precedence. If two rules have equal specificity and both use !important, the one declared later in the stylesheet will apply.

Is it a good practice to use !important?

Using !important should be avoided whenever possible. It can make your styles harder to maintain and debug, as it can lead to unexpected behavior. Instead, strive to write clean, specific CSS rules to avoid the need for !important.


The !important rule in CSS can be a powerful tool when used appropriately. It allows you to override styles and exert more control over the appearance of elements on your website. However, it should be used sparingly and with caution. By following best practices, such as using specificity first and documenting the use of !important, you can maintain a clean and manageable codebase while still taking advantage of the benefits that the !important rule offers.

Similar Blogs