Why first-child css doesn't work? [duplicate] - html

I have a bunch of elements with a class name red, but I can't seem to select the first element with the class="red" using the following CSS rule:
.home .red:first-child {
border: 1px solid red;
}
<div class="home">
<span>blah</span>
<p class="red">first</p>
<p class="red">second</p>
<p class="red">third</p>
<p class="red">fourth</p>
</div>
What is wrong in this selector and how do I correct it to target the first child with class red?

This is one of the most well-known examples of authors misunderstanding how :first-child works. Introduced in CSS2, the :first-child pseudo-class represents the very first child of its parent. That's it. There's a very common misconception that it picks up whichever child element is the first to match the conditions specified by the rest of the compound selector. Due to the way selectors work (see here for an explanation), that is simply not true.
Selectors level 3 introduces a :first-of-type pseudo-class, which represents the first element among siblings of its element type. This answer explains, with illustrations, the difference between :first-child and :first-of-type. However, as with :first-child, it does not look at any other conditions or attributes. In HTML, the element type is represented by the tag name. In the question, that type is p.
Unfortunately, there is no similar :first-of-class pseudo-class for matching the first child element of a given class. At the time this answer was first posted, the newly published FPWD of Selectors level 4 introduced an :nth-match() pseudo-class, designed around existing selector mechanics as I mentioned in the first paragraph by adding a selector-list argument, through which you can supply the rest of the compound selector to get the desired filtering behavior. In recent years this functionality was subsumed into :nth-child() itself, with the selector list appearing as an optional second argument, to simplify things as well as averting the false impression that :nth-match() matched across the entire document (see the final note below).
While we await cross-browser support (seriously, it's been nearly 10 years, and there has only been a single implementation for the last 5 of those years), one workaround that Lea Verou and I developed independently (she did it first!) is to first apply your desired styles to all your elements with that class:
/*
* Select all .red children of .home, including the first one,
* and give them a border.
*/
.home > .red {
border: 1px solid red;
}
... then "undo" the styles for elements with the class that come after the first one, using the general sibling combinator ~ in an overriding rule:
/*
* Select all but the first .red child of .home,
* and remove the border from the previous rule.
*/
.home > .red ~ .red {
border: none;
}
Now only the first element with class="red" will have a border.
Here's an illustration of how the rules are applied:
.home > .red {
border: 1px solid red;
}
.home > .red ~ .red {
border: none;
}
<div class="home">
<span>blah</span> <!-- [1] -->
<p class="red">first</p> <!-- [2] -->
<p class="red">second</p> <!-- [3] -->
<p class="red">third</p> <!-- [3] -->
<p class="red">fourth</p> <!-- [3] -->
</div>
No rules are applied; no border is rendered.
This element does not have the class red, so it's skipped.
Only the first rule is applied; a red border is rendered.
This element has the class red, but it's not preceded by any elements with the class red in its parent. Thus the second rule is not applied, only the first, and the element keeps its border.
Both rules are applied; no border is rendered.
This element has the class red. It is also preceded by at least one other element with the class red. Thus both rules are applied, and the second border declaration overrides the first, thereby "undoing" it, so to speak.
As a bonus, although it was introduced in Selectors 3, the general sibling combinator is actually pretty well-supported by IE7 and newer, unlike :first-of-type and :nth-of-type() which are only supported by IE9 onward. If you need good browser support, you're in luck.
In fact, the fact that the sibling combinator is the only important component in this technique, and it has such amazing browser support, makes this technique very versatile — you can adapt it for filtering elements by other things, besides class selectors:
You can use this to work around :first-of-type in IE7 and IE8, by simply supplying a type selector instead of a class selector (again, more on its incorrect usage in the question in a later section):
article > p {
/* Apply styles to article > p:first-of-type, which may or may not be :first-child */
}
article > p ~ p {
/* Undo the above styles for every subsequent article > p */
}
You can filter by attribute selectors or any other simple selectors instead of classes.
You can also combine this overriding technique with pseudo-elements even though pseudo-elements technically aren't simple selectors.
Note that in order for this to work, you will need to know in advance what the default styles will be for your other sibling elements so you can override the first rule. Additionally, since this involves overriding rules in CSS, you can't achieve the same thing with a single selector for use with the Selectors API, or Selenium's CSS locators.
On a final note, keep in mind that this answer assumes that the question is looking for any number of first child elements having a given class. There is neither a pseudo-class nor even a generic CSS solution for the nth match of a complex selector across the entire document — whether a solution exists depends heavily on the document structure. jQuery provides :eq(), :first, :last and more for this purpose, but note again that they function very differently from :nth-child() et al. Using the Selectors API, you can either use document.querySelector() to obtain the very first match:
var first = document.querySelector('.home > .red');
Or use document.querySelectorAll() with an indexer to pick any specific match:
var redElements = document.querySelectorAll('.home > .red');
var first = redElements[0];
var second = redElements[1];
// etc
Although the .red:nth-of-type(1) solution in the original accepted answer by Philip Daubmeier works (which was originally written by Martyn but deleted since), it does not behave the way you'd expect it to.
For example, if you only wanted to select the p here:
<p class="red"></p>
<div class="red"></div>
... then you can't use .red:first-of-type (equivalent to .red:nth-of-type(1)), because each element is the first (and only) one of its type (p and div respectively), so both will be matched by the selector.
When the first element of a certain class is also the first of its type, the pseudo-class will work, but this happens only by coincidence. This behavior is demonstrated in Philip's answer. The moment you stick in an element of the same type before this element, the selector will fail. Taking the markup from the question:
<div class="home">
<span>blah</span>
<p class="red">first</p>
<p class="red">second</p>
<p class="red">third</p>
<p class="red">fourth</p>
</div>
Applying a rule with .red:first-of-type will work, but once you add another p without the class:
<div class="home">
<span>blah</span>
<p>dummy</p>
<p class="red">first</p>
<p class="red">second</p>
<p class="red">third</p>
<p class="red">fourth</p>
</div>
... the selector will immediately fail, because the first .red element is now the second p element.

The :first-child selector is intended, like the name says, to select the first child of a parent tag. So this example will work (Just tried it here):
<body>
<p class="red">first</p>
<div class="red">second</div>
</body>
This won't work, though, if you've nested your tags under different parent tags, or if your tags of class red aren't the first tags under the parent.
Notice also that this doesn't only apply to the first such tag in the whole document, but every time a new parent is wrapped around it, like:
<div>
<p class="red">first</p>
<div class="red">second</div>
</div>
<div>
<p class="red">third</p>
<div class="red">fourth</div>
</div>
first and third will be red then.
For your case, you can use the :nth-of-type selector:
.red:nth-of-type(1)
{
border:5px solid red;
}
<div class="home">
<span>blah</span>
<p class="red">first</p>
<p class="red">second</p>
<p class="red">third</p>
<p class="red">fourth</p>
</div>
Credits to Martyn, who deleted his answer containing this approach.
More information about :nth-child() and :nth-of-type() is available at http://www.quirksmode.org/css/nthchild.html.
Be aware that this is a CSS3 selector, therefore some now outdated browser versions may not behave as expected (e.g. IE8 or older). Visit https://caniuse.com/?search=nth-of-type for more details.

The correct answer is:
.red:first-child, :not(.red) + .red { border:5px solid red }
Part I: If element is first to its parent and has class "red", it shall get border.
Part II: If ".red" element is not first to its parent, but is immediately following an element without class ".red", it shall also deserve the honor of said border.
Fiddle or it didn't happen.
Philip Daubmeier's answer, while accepted, is not correct - see attached fiddle.
BoltClock's answer would work, but unnecessarily defines and overwrites styles
(particularly an issue where it otherwise would inherit a different border - you don't want to declare other to border:none)
EDIT:
In the event that you have "red" following non-red several times, each "first" red will get the border. To prevent that, one would need to use BoltClock's answer. See fiddle

The above answers are too complex.
.class:first-of-type { }
This will select the first-type of class. MDN Source
Note: Tested with Chrome 91 and Firefox 89, June 2021.

I am surprised no one mentioned the cleanest solution:
.red:not(.red ~ .red) {
border: 1px solid red;
}
<div class="home">
<span>blah</span>
<p class="red">first</p>
<p class="red">second</p>
<p class="red">third</p>
<p class="red">fourth</p>
</div>

you could use first-of-type or nth-of-type(1)
.red {
color: green;
}
/* .red:nth-of-type(1) */
.red:first-of-type {
color: red;
}
<div class="home">
<span>blah</span>
<p class="red">first</p>
<p class="red">second</p>
<p class="red">third</p>
<p class="red">fourth</p>
</div>

To match your selector, the element must have a class name of red and must be the first child of its parent.
<div>
<span class="red"></span> <!-- MATCH -->
</div>
<div>
<span>Blah</span>
<p class="red"></p> <!-- NO MATCH -->
</div>
<div>
<span>Blah</span>
<div><p class="red"></p></div> <!-- MATCH -->
</div>

Since the other answers cover what's wrong with it, I'll try the other half, how to fix it. Unfortunately, I don't know that you have a CSS only solution here, at least not that I can think of. There are some other options though....
Assign a first class to the element when you generate it, like this:
<p class="red first"></p>
<div class="red"></div>
CSS:
.first.red {
border:5px solid red;
}
This CSS only matches elements with both first and red classes.
Alternatively, do the same in JavaScript, for example here's what jQuery you would use to do this, using the same CSS as above:
$(".red:first").addClass("first");

I got this one in my project.
div > .b ~ .b:not(:first-child) {
background: none;
}
div > .b {
background: red;
}
<div>
<p class="a">The first paragraph.</p>
<p class="a">The second paragraph.</p>
<p class="b">The third paragraph.</p>
<p class="b">The fourth paragraph.</p>
</div>

I am using below CSS to have a background image for the list ul li
#footer .module:nth-of-type(1)>.menu>li:nth-of-type(1){
background-position: center;
background-image: url(http://monagentvoyagessuperprix.j3.voyagesendirect.com/images/stories/images_monagentvoyagessuperprix/layout/icon-home.png);
background-repeat: no-repeat;
}
<footer id="footer">
<div class="module">
<ul class="menu ">
<li class="level1 item308 active current"></li>
<li> </li>
</ul>
</div>
<div class="module">
<ul class="menu "><li></li>
<li></li>
</ul>
</div>
<div class="module">
<ul class="menu ">
<li></li>
<li></li>
</ul>
</div>
</footer>

According to your updated problem
<div class="home">
<span>blah</span>
<p class="red">first</p>
<p class="red">second</p>
<p class="red">third</p>
<p class="red">fourth</p>
</div>
how about
.home span + .red{
border:1px solid red;
}
This will select class home, then the element span and finally all .red elements that are placed immediately after span elements.
Reference: http://www.w3schools.com/cssref/css_selectors.asp

For some reason none of the above answers seemed to be addressing the case of the real first and only first child of the parent.
#element_id > .class_name:first-child
All the above answers will fail if you want to apply the style to only the first class child within this code.
<aside id="element_id">
Content
<div class="class_name">First content that need to be styled</div>
<div class="class_name">
Second content that don't need to be styled
<div>
<div>
<div class="class_name">deep content - no style</div>
<div class="class_name">deep content - no style</div>
<div>
<div class="class_name">deep content - no style</div>
</div>
</div>
</div>
</div>
</aside>

The following code will definitely work well everywhere.
it is simple and short.
<div class="home">
<span>blah</span>
<p class="blue"> first-blue </p>
<p class="blue"> second-blue </p>
<p class="blue"> third-blue </p>
<p class="red"> first-red </p>
<p class="red"> second-red </p>
<p class="red"> third-red </p>
<p class="red"> fourth-red </p>
<p class="pink"> first-pink </p>
<p class="pink"> second-pink </p>
<p class="red"> new-first-red </p>
<p class="red"> new-second-red </p>
</div>
we can select the first-red with:
.home .red:not(.home .red ~ .red) {
background-color: blue;
}
if you want to select new-first-red too you should use + instead of ~.

You could use nth-of-type(1) but be sure that site doesn't need to support IE7 etc, if this is the case use jQuery to add body class then find element via IE7 body class then the element name, then add in the nth-child styling to it.

You can change your code to something like this to get it work
<div class="home">
<span>blah</span>
<p class="red">first</p>
<p class="red">second</p>
<p class="red">third</p>
<p class="red">fourth</p>
</div>
This does the job for you
.home span + .red{
border:3px solid green;
}
Here is a CSS reference from SnoopCode about that.

All in All, after reading this all page and other ones and a lot of documentation. Here's the summary:
For first/last child: Safe to use now (Supported by all modern browsers)
:nth-child() Also safe to use now (Supported by all modern browsers). But be careful it even counts siblings! So, the following won't work properly:
/* This should select the first 2 element with class display_class
* but it will NOT WORK Because the nth-child count even siblings
* including the first div skip_class
*/
.display_class:nth-child(-n+2){
background-color:green;
}
<ul>
<li class="skip_class">test 1</li>
<li class="display_class">test 2 should be in green</li>
<li class="display_class">test 3 should be in green</li>
<li class="display_class">test 4</li>
</ul>
Currently, there is a selector :nth-child(-n+2 of .foo) that supports selection by class but not supported by modern browsers so not useful.
So, that leaves us with Javascript solution (we'll fix the example above):
// Here we'll go through the elements with the targeted class
// and add our classmodifer to only the first 2 elements!
[...document.querySelectorAll('.display_class')].forEach((element,index) => {
if (index < 2) element.classList.add('display_class--green');
});
.display_class--green {
background-color:green;
}
<ul>
<li class="skip_class">test 1</li>
<li class="display_class">test 2 should be in green</li>
<li class="display_class">test 3 should be in green</li>
<li class="display_class">test 4</li>
</ul>

A quick 'n dirty jQuery solution for marking first and last element within a group of elements with the same classnames:
$('.my-selector').each(function(index, item) {
if (!$(item).next().hasClass('my-selector')) {
$(item).addClass('last');
}
if (!$(item).prev().hasClass('my-selector')) {
$(item).addClass('first');
}
});
.my-selector {
padding: 5px;
background: #ccc;
}
.my-selector.first {
background: #fcc;
}
.my-selector.last {
background: #cfc;
}
<script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/3.3.1/jquery.min.js"></script>
<div>
<span>first element...</span>
<div class="my-selector">Row 1</div>
<div class="my-selector">Row 2</div>
<div class="my-selector">Row 3</div>
<div class="my-selector">Row 4</div>
<span>other elements...</span>
<div class="my-selector">Row 3</div>
<div class="my-selector">Row 4</div>
</div>

Try This Simple and Effective
.home > span + .red{
border:1px solid red;
}

just use
.home > .red ~ .red{
border: 1px solid red;
}
it will work.

I believe that using relative selector + for selecting elements placed immediately after, works here the best (as few suggested before).
It is also possible for this case to use this selector
.home p:first-of-type
but this is element selector not the class one.
Here you have nice list of CSS selectors: https://kolosek.com/css-selectors/

Could you try something like this:
.red:first-of-type {
border: 5px solid red;
}
you also can use this for last element (if you need it):
.red:last-of-type {
border: 5px solid red;
}

Try this solution:
.home p:first-of-type {
border:5px solid red;
width:100%;
display:block;
}
<div class="home">
<span>blah</span>
<p class="red">first</p>
<p class="red">second</p>
<p class="red">third</p>
<p class="red">fourth</p>
</div>
CodePen link

I think a lot of people have explained already. your code is selecting only first child of the first instance. If you want to select all the first children of red class, you need to use
.home > .red:first-child {
/* put your styling here */
}

Related

CSS selector for first element on every print page [duplicate]

I have a bunch of elements with a class name red, but I can't seem to select the first element with the class="red" using the following CSS rule:
.home .red:first-child {
border: 1px solid red;
}
<div class="home">
<span>blah</span>
<p class="red">first</p>
<p class="red">second</p>
<p class="red">third</p>
<p class="red">fourth</p>
</div>
What is wrong in this selector and how do I correct it to target the first child with class red?
This is one of the most well-known examples of authors misunderstanding how :first-child works. Introduced in CSS2, the :first-child pseudo-class represents the very first child of its parent. That's it. There's a very common misconception that it picks up whichever child element is the first to match the conditions specified by the rest of the compound selector. Due to the way selectors work (see here for an explanation), that is simply not true.
Selectors level 3 introduces a :first-of-type pseudo-class, which represents the first element among siblings of its element type. This answer explains, with illustrations, the difference between :first-child and :first-of-type. However, as with :first-child, it does not look at any other conditions or attributes. In HTML, the element type is represented by the tag name. In the question, that type is p.
Unfortunately, there is no similar :first-of-class pseudo-class for matching the first child element of a given class. At the time this answer was first posted, the newly published FPWD of Selectors level 4 introduced an :nth-match() pseudo-class, designed around existing selector mechanics as I mentioned in the first paragraph by adding a selector-list argument, through which you can supply the rest of the compound selector to get the desired filtering behavior. In recent years this functionality was subsumed into :nth-child() itself, with the selector list appearing as an optional second argument, to simplify things as well as averting the false impression that :nth-match() matched across the entire document (see the final note below).
While we await cross-browser support (seriously, it's been nearly 10 years, and there has only been a single implementation for the last 5 of those years), one workaround that Lea Verou and I developed independently (she did it first!) is to first apply your desired styles to all your elements with that class:
/*
* Select all .red children of .home, including the first one,
* and give them a border.
*/
.home > .red {
border: 1px solid red;
}
... then "undo" the styles for elements with the class that come after the first one, using the general sibling combinator ~ in an overriding rule:
/*
* Select all but the first .red child of .home,
* and remove the border from the previous rule.
*/
.home > .red ~ .red {
border: none;
}
Now only the first element with class="red" will have a border.
Here's an illustration of how the rules are applied:
.home > .red {
border: 1px solid red;
}
.home > .red ~ .red {
border: none;
}
<div class="home">
<span>blah</span> <!-- [1] -->
<p class="red">first</p> <!-- [2] -->
<p class="red">second</p> <!-- [3] -->
<p class="red">third</p> <!-- [3] -->
<p class="red">fourth</p> <!-- [3] -->
</div>
No rules are applied; no border is rendered.
This element does not have the class red, so it's skipped.
Only the first rule is applied; a red border is rendered.
This element has the class red, but it's not preceded by any elements with the class red in its parent. Thus the second rule is not applied, only the first, and the element keeps its border.
Both rules are applied; no border is rendered.
This element has the class red. It is also preceded by at least one other element with the class red. Thus both rules are applied, and the second border declaration overrides the first, thereby "undoing" it, so to speak.
As a bonus, although it was introduced in Selectors 3, the general sibling combinator is actually pretty well-supported by IE7 and newer, unlike :first-of-type and :nth-of-type() which are only supported by IE9 onward. If you need good browser support, you're in luck.
In fact, the fact that the sibling combinator is the only important component in this technique, and it has such amazing browser support, makes this technique very versatile — you can adapt it for filtering elements by other things, besides class selectors:
You can use this to work around :first-of-type in IE7 and IE8, by simply supplying a type selector instead of a class selector (again, more on its incorrect usage in the question in a later section):
article > p {
/* Apply styles to article > p:first-of-type, which may or may not be :first-child */
}
article > p ~ p {
/* Undo the above styles for every subsequent article > p */
}
You can filter by attribute selectors or any other simple selectors instead of classes.
You can also combine this overriding technique with pseudo-elements even though pseudo-elements technically aren't simple selectors.
Note that in order for this to work, you will need to know in advance what the default styles will be for your other sibling elements so you can override the first rule. Additionally, since this involves overriding rules in CSS, you can't achieve the same thing with a single selector for use with the Selectors API, or Selenium's CSS locators.
On a final note, keep in mind that this answer assumes that the question is looking for any number of first child elements having a given class. There is neither a pseudo-class nor even a generic CSS solution for the nth match of a complex selector across the entire document — whether a solution exists depends heavily on the document structure. jQuery provides :eq(), :first, :last and more for this purpose, but note again that they function very differently from :nth-child() et al. Using the Selectors API, you can either use document.querySelector() to obtain the very first match:
var first = document.querySelector('.home > .red');
Or use document.querySelectorAll() with an indexer to pick any specific match:
var redElements = document.querySelectorAll('.home > .red');
var first = redElements[0];
var second = redElements[1];
// etc
Although the .red:nth-of-type(1) solution in the original accepted answer by Philip Daubmeier works (which was originally written by Martyn but deleted since), it does not behave the way you'd expect it to.
For example, if you only wanted to select the p here:
<p class="red"></p>
<div class="red"></div>
... then you can't use .red:first-of-type (equivalent to .red:nth-of-type(1)), because each element is the first (and only) one of its type (p and div respectively), so both will be matched by the selector.
When the first element of a certain class is also the first of its type, the pseudo-class will work, but this happens only by coincidence. This behavior is demonstrated in Philip's answer. The moment you stick in an element of the same type before this element, the selector will fail. Taking the markup from the question:
<div class="home">
<span>blah</span>
<p class="red">first</p>
<p class="red">second</p>
<p class="red">third</p>
<p class="red">fourth</p>
</div>
Applying a rule with .red:first-of-type will work, but once you add another p without the class:
<div class="home">
<span>blah</span>
<p>dummy</p>
<p class="red">first</p>
<p class="red">second</p>
<p class="red">third</p>
<p class="red">fourth</p>
</div>
... the selector will immediately fail, because the first .red element is now the second p element.
The :first-child selector is intended, like the name says, to select the first child of a parent tag. So this example will work (Just tried it here):
<body>
<p class="red">first</p>
<div class="red">second</div>
</body>
This won't work, though, if you've nested your tags under different parent tags, or if your tags of class red aren't the first tags under the parent.
Notice also that this doesn't only apply to the first such tag in the whole document, but every time a new parent is wrapped around it, like:
<div>
<p class="red">first</p>
<div class="red">second</div>
</div>
<div>
<p class="red">third</p>
<div class="red">fourth</div>
</div>
first and third will be red then.
For your case, you can use the :nth-of-type selector:
.red:nth-of-type(1)
{
border:5px solid red;
}
<div class="home">
<span>blah</span>
<p class="red">first</p>
<p class="red">second</p>
<p class="red">third</p>
<p class="red">fourth</p>
</div>
Credits to Martyn, who deleted his answer containing this approach.
More information about :nth-child() and :nth-of-type() is available at http://www.quirksmode.org/css/nthchild.html.
Be aware that this is a CSS3 selector, therefore some now outdated browser versions may not behave as expected (e.g. IE8 or older). Visit https://caniuse.com/?search=nth-of-type for more details.
The correct answer is:
.red:first-child, :not(.red) + .red { border:5px solid red }
Part I: If element is first to its parent and has class "red", it shall get border.
Part II: If ".red" element is not first to its parent, but is immediately following an element without class ".red", it shall also deserve the honor of said border.
Fiddle or it didn't happen.
Philip Daubmeier's answer, while accepted, is not correct - see attached fiddle.
BoltClock's answer would work, but unnecessarily defines and overwrites styles
(particularly an issue where it otherwise would inherit a different border - you don't want to declare other to border:none)
EDIT:
In the event that you have "red" following non-red several times, each "first" red will get the border. To prevent that, one would need to use BoltClock's answer. See fiddle
The above answers are too complex.
.class:first-of-type { }
This will select the first-type of class. MDN Source
Note: Tested with Chrome 91 and Firefox 89, June 2021.
I am surprised no one mentioned the cleanest solution:
.red:not(.red ~ .red) {
border: 1px solid red;
}
<div class="home">
<span>blah</span>
<p class="red">first</p>
<p class="red">second</p>
<p class="red">third</p>
<p class="red">fourth</p>
</div>
you could use first-of-type or nth-of-type(1)
.red {
color: green;
}
/* .red:nth-of-type(1) */
.red:first-of-type {
color: red;
}
<div class="home">
<span>blah</span>
<p class="red">first</p>
<p class="red">second</p>
<p class="red">third</p>
<p class="red">fourth</p>
</div>
To match your selector, the element must have a class name of red and must be the first child of its parent.
<div>
<span class="red"></span> <!-- MATCH -->
</div>
<div>
<span>Blah</span>
<p class="red"></p> <!-- NO MATCH -->
</div>
<div>
<span>Blah</span>
<div><p class="red"></p></div> <!-- MATCH -->
</div>
Since the other answers cover what's wrong with it, I'll try the other half, how to fix it. Unfortunately, I don't know that you have a CSS only solution here, at least not that I can think of. There are some other options though....
Assign a first class to the element when you generate it, like this:
<p class="red first"></p>
<div class="red"></div>
CSS:
.first.red {
border:5px solid red;
}
This CSS only matches elements with both first and red classes.
Alternatively, do the same in JavaScript, for example here's what jQuery you would use to do this, using the same CSS as above:
$(".red:first").addClass("first");
I got this one in my project.
div > .b ~ .b:not(:first-child) {
background: none;
}
div > .b {
background: red;
}
<div>
<p class="a">The first paragraph.</p>
<p class="a">The second paragraph.</p>
<p class="b">The third paragraph.</p>
<p class="b">The fourth paragraph.</p>
</div>
I am using below CSS to have a background image for the list ul li
#footer .module:nth-of-type(1)>.menu>li:nth-of-type(1){
background-position: center;
background-image: url(http://monagentvoyagessuperprix.j3.voyagesendirect.com/images/stories/images_monagentvoyagessuperprix/layout/icon-home.png);
background-repeat: no-repeat;
}
<footer id="footer">
<div class="module">
<ul class="menu ">
<li class="level1 item308 active current"></li>
<li> </li>
</ul>
</div>
<div class="module">
<ul class="menu "><li></li>
<li></li>
</ul>
</div>
<div class="module">
<ul class="menu ">
<li></li>
<li></li>
</ul>
</div>
</footer>
According to your updated problem
<div class="home">
<span>blah</span>
<p class="red">first</p>
<p class="red">second</p>
<p class="red">third</p>
<p class="red">fourth</p>
</div>
how about
.home span + .red{
border:1px solid red;
}
This will select class home, then the element span and finally all .red elements that are placed immediately after span elements.
Reference: http://www.w3schools.com/cssref/css_selectors.asp
For some reason none of the above answers seemed to be addressing the case of the real first and only first child of the parent.
#element_id > .class_name:first-child
All the above answers will fail if you want to apply the style to only the first class child within this code.
<aside id="element_id">
Content
<div class="class_name">First content that need to be styled</div>
<div class="class_name">
Second content that don't need to be styled
<div>
<div>
<div class="class_name">deep content - no style</div>
<div class="class_name">deep content - no style</div>
<div>
<div class="class_name">deep content - no style</div>
</div>
</div>
</div>
</div>
</aside>
The following code will definitely work well everywhere.
it is simple and short.
<div class="home">
<span>blah</span>
<p class="blue"> first-blue </p>
<p class="blue"> second-blue </p>
<p class="blue"> third-blue </p>
<p class="red"> first-red </p>
<p class="red"> second-red </p>
<p class="red"> third-red </p>
<p class="red"> fourth-red </p>
<p class="pink"> first-pink </p>
<p class="pink"> second-pink </p>
<p class="red"> new-first-red </p>
<p class="red"> new-second-red </p>
</div>
we can select the first-red with:
.home .red:not(.home .red ~ .red) {
background-color: blue;
}
if you want to select new-first-red too you should use + instead of ~.
You could use nth-of-type(1) but be sure that site doesn't need to support IE7 etc, if this is the case use jQuery to add body class then find element via IE7 body class then the element name, then add in the nth-child styling to it.
You can change your code to something like this to get it work
<div class="home">
<span>blah</span>
<p class="red">first</p>
<p class="red">second</p>
<p class="red">third</p>
<p class="red">fourth</p>
</div>
This does the job for you
.home span + .red{
border:3px solid green;
}
Here is a CSS reference from SnoopCode about that.
All in All, after reading this all page and other ones and a lot of documentation. Here's the summary:
For first/last child: Safe to use now (Supported by all modern browsers)
:nth-child() Also safe to use now (Supported by all modern browsers). But be careful it even counts siblings! So, the following won't work properly:
/* This should select the first 2 element with class display_class
* but it will NOT WORK Because the nth-child count even siblings
* including the first div skip_class
*/
.display_class:nth-child(-n+2){
background-color:green;
}
<ul>
<li class="skip_class">test 1</li>
<li class="display_class">test 2 should be in green</li>
<li class="display_class">test 3 should be in green</li>
<li class="display_class">test 4</li>
</ul>
Currently, there is a selector :nth-child(-n+2 of .foo) that supports selection by class but not supported by modern browsers so not useful.
So, that leaves us with Javascript solution (we'll fix the example above):
// Here we'll go through the elements with the targeted class
// and add our classmodifer to only the first 2 elements!
[...document.querySelectorAll('.display_class')].forEach((element,index) => {
if (index < 2) element.classList.add('display_class--green');
});
.display_class--green {
background-color:green;
}
<ul>
<li class="skip_class">test 1</li>
<li class="display_class">test 2 should be in green</li>
<li class="display_class">test 3 should be in green</li>
<li class="display_class">test 4</li>
</ul>
A quick 'n dirty jQuery solution for marking first and last element within a group of elements with the same classnames:
$('.my-selector').each(function(index, item) {
if (!$(item).next().hasClass('my-selector')) {
$(item).addClass('last');
}
if (!$(item).prev().hasClass('my-selector')) {
$(item).addClass('first');
}
});
.my-selector {
padding: 5px;
background: #ccc;
}
.my-selector.first {
background: #fcc;
}
.my-selector.last {
background: #cfc;
}
<script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/3.3.1/jquery.min.js"></script>
<div>
<span>first element...</span>
<div class="my-selector">Row 1</div>
<div class="my-selector">Row 2</div>
<div class="my-selector">Row 3</div>
<div class="my-selector">Row 4</div>
<span>other elements...</span>
<div class="my-selector">Row 3</div>
<div class="my-selector">Row 4</div>
</div>
Try This Simple and Effective
.home > span + .red{
border:1px solid red;
}
just use
.home > .red ~ .red{
border: 1px solid red;
}
it will work.
I believe that using relative selector + for selecting elements placed immediately after, works here the best (as few suggested before).
It is also possible for this case to use this selector
.home p:first-of-type
but this is element selector not the class one.
Here you have nice list of CSS selectors: https://kolosek.com/css-selectors/
Could you try something like this:
.red:first-of-type {
border: 5px solid red;
}
you also can use this for last element (if you need it):
.red:last-of-type {
border: 5px solid red;
}
Try this solution:
.home p:first-of-type {
border:5px solid red;
width:100%;
display:block;
}
<div class="home">
<span>blah</span>
<p class="red">first</p>
<p class="red">second</p>
<p class="red">third</p>
<p class="red">fourth</p>
</div>
CodePen link
I think a lot of people have explained already. your code is selecting only first child of the first instance. If you want to select all the first children of red class, you need to use
.home > .red:first-child {
/* put your styling here */
}

How to select one hr tag amidst many within a div tag without any class or id

So i have this sort of structure
<div class="about_page">
<hr>
<hr>
</div>
How do i select the second hr tag and style it in such a way that it wont affect the first.
Note that i dont have access to the Html of the code so i cant add any id or class selectors to the code. I also do not have access to write any javascript for the code. I want to use pure css
You can use the :nth-child() Selector.
In your case:
.about_page hr:nth-child(2) {
/* your style here */
}
Via CSS you may take a look at selector ~(difference with child and sibling selectors) and initial or unset values
https://www.quirksmode.org/css/cascading/values.html
The inherit, initial, and unset keywords are special values you can give to any CSS property.
example below is changing the border-color value to the second hr encountered within a container , any content can stand in between first, second and other hr.
hr:first-of-type~hr {/* reset css value after the first hr seen in the container */
border-color: red;
}
hr:first-of-type~hr~hr {/* reset to older value any hr following the second hr from the container*/
border-color: initial;
/* or border-color:unset; */
}
<div class="about_page">
<hr>
<div>something</div>
<hr>
<hr>
<p>some text</p>
<hr>
<hr>
<div>something</div>
<hr>
</div>
works too with just hrs
<div class="about_page">
<hr>
<hr>
<hr>
<hr>
<hr>
<hr>
</div>

remove/change css attribute of first element inside form [duplicate]

I have a bunch of elements with a class name red, but I can't seem to select the first element with the class="red" using the following CSS rule:
.home .red:first-child {
border: 1px solid red;
}
<div class="home">
<span>blah</span>
<p class="red">first</p>
<p class="red">second</p>
<p class="red">third</p>
<p class="red">fourth</p>
</div>
What is wrong in this selector and how do I correct it to target the first child with class red?
This is one of the most well-known examples of authors misunderstanding how :first-child works. Introduced in CSS2, the :first-child pseudo-class represents the very first child of its parent. That's it. There's a very common misconception that it picks up whichever child element is the first to match the conditions specified by the rest of the compound selector. Due to the way selectors work (see here for an explanation), that is simply not true.
Selectors level 3 introduces a :first-of-type pseudo-class, which represents the first element among siblings of its element type. This answer explains, with illustrations, the difference between :first-child and :first-of-type. However, as with :first-child, it does not look at any other conditions or attributes. In HTML, the element type is represented by the tag name. In the question, that type is p.
Unfortunately, there is no similar :first-of-class pseudo-class for matching the first child element of a given class. At the time this answer was first posted, the newly published FPWD of Selectors level 4 introduced an :nth-match() pseudo-class, designed around existing selector mechanics as I mentioned in the first paragraph by adding a selector-list argument, through which you can supply the rest of the compound selector to get the desired filtering behavior. In recent years this functionality was subsumed into :nth-child() itself, with the selector list appearing as an optional second argument, to simplify things as well as averting the false impression that :nth-match() matched across the entire document (see the final note below).
While we await cross-browser support (seriously, it's been nearly 10 years, and there has only been a single implementation for the last 5 of those years), one workaround that Lea Verou and I developed independently (she did it first!) is to first apply your desired styles to all your elements with that class:
/*
* Select all .red children of .home, including the first one,
* and give them a border.
*/
.home > .red {
border: 1px solid red;
}
... then "undo" the styles for elements with the class that come after the first one, using the general sibling combinator ~ in an overriding rule:
/*
* Select all but the first .red child of .home,
* and remove the border from the previous rule.
*/
.home > .red ~ .red {
border: none;
}
Now only the first element with class="red" will have a border.
Here's an illustration of how the rules are applied:
.home > .red {
border: 1px solid red;
}
.home > .red ~ .red {
border: none;
}
<div class="home">
<span>blah</span> <!-- [1] -->
<p class="red">first</p> <!-- [2] -->
<p class="red">second</p> <!-- [3] -->
<p class="red">third</p> <!-- [3] -->
<p class="red">fourth</p> <!-- [3] -->
</div>
No rules are applied; no border is rendered.
This element does not have the class red, so it's skipped.
Only the first rule is applied; a red border is rendered.
This element has the class red, but it's not preceded by any elements with the class red in its parent. Thus the second rule is not applied, only the first, and the element keeps its border.
Both rules are applied; no border is rendered.
This element has the class red. It is also preceded by at least one other element with the class red. Thus both rules are applied, and the second border declaration overrides the first, thereby "undoing" it, so to speak.
As a bonus, although it was introduced in Selectors 3, the general sibling combinator is actually pretty well-supported by IE7 and newer, unlike :first-of-type and :nth-of-type() which are only supported by IE9 onward. If you need good browser support, you're in luck.
In fact, the fact that the sibling combinator is the only important component in this technique, and it has such amazing browser support, makes this technique very versatile — you can adapt it for filtering elements by other things, besides class selectors:
You can use this to work around :first-of-type in IE7 and IE8, by simply supplying a type selector instead of a class selector (again, more on its incorrect usage in the question in a later section):
article > p {
/* Apply styles to article > p:first-of-type, which may or may not be :first-child */
}
article > p ~ p {
/* Undo the above styles for every subsequent article > p */
}
You can filter by attribute selectors or any other simple selectors instead of classes.
You can also combine this overriding technique with pseudo-elements even though pseudo-elements technically aren't simple selectors.
Note that in order for this to work, you will need to know in advance what the default styles will be for your other sibling elements so you can override the first rule. Additionally, since this involves overriding rules in CSS, you can't achieve the same thing with a single selector for use with the Selectors API, or Selenium's CSS locators.
On a final note, keep in mind that this answer assumes that the question is looking for any number of first child elements having a given class. There is neither a pseudo-class nor even a generic CSS solution for the nth match of a complex selector across the entire document — whether a solution exists depends heavily on the document structure. jQuery provides :eq(), :first, :last and more for this purpose, but note again that they function very differently from :nth-child() et al. Using the Selectors API, you can either use document.querySelector() to obtain the very first match:
var first = document.querySelector('.home > .red');
Or use document.querySelectorAll() with an indexer to pick any specific match:
var redElements = document.querySelectorAll('.home > .red');
var first = redElements[0];
var second = redElements[1];
// etc
Although the .red:nth-of-type(1) solution in the original accepted answer by Philip Daubmeier works (which was originally written by Martyn but deleted since), it does not behave the way you'd expect it to.
For example, if you only wanted to select the p here:
<p class="red"></p>
<div class="red"></div>
... then you can't use .red:first-of-type (equivalent to .red:nth-of-type(1)), because each element is the first (and only) one of its type (p and div respectively), so both will be matched by the selector.
When the first element of a certain class is also the first of its type, the pseudo-class will work, but this happens only by coincidence. This behavior is demonstrated in Philip's answer. The moment you stick in an element of the same type before this element, the selector will fail. Taking the markup from the question:
<div class="home">
<span>blah</span>
<p class="red">first</p>
<p class="red">second</p>
<p class="red">third</p>
<p class="red">fourth</p>
</div>
Applying a rule with .red:first-of-type will work, but once you add another p without the class:
<div class="home">
<span>blah</span>
<p>dummy</p>
<p class="red">first</p>
<p class="red">second</p>
<p class="red">third</p>
<p class="red">fourth</p>
</div>
... the selector will immediately fail, because the first .red element is now the second p element.
The :first-child selector is intended, like the name says, to select the first child of a parent tag. So this example will work (Just tried it here):
<body>
<p class="red">first</p>
<div class="red">second</div>
</body>
This won't work, though, if you've nested your tags under different parent tags, or if your tags of class red aren't the first tags under the parent.
Notice also that this doesn't only apply to the first such tag in the whole document, but every time a new parent is wrapped around it, like:
<div>
<p class="red">first</p>
<div class="red">second</div>
</div>
<div>
<p class="red">third</p>
<div class="red">fourth</div>
</div>
first and third will be red then.
For your case, you can use the :nth-of-type selector:
.red:nth-of-type(1)
{
border:5px solid red;
}
<div class="home">
<span>blah</span>
<p class="red">first</p>
<p class="red">second</p>
<p class="red">third</p>
<p class="red">fourth</p>
</div>
Credits to Martyn, who deleted his answer containing this approach.
More information about :nth-child() and :nth-of-type() is available at http://www.quirksmode.org/css/nthchild.html.
Be aware that this is a CSS3 selector, therefore some now outdated browser versions may not behave as expected (e.g. IE8 or older). Visit https://caniuse.com/?search=nth-of-type for more details.
The correct answer is:
.red:first-child, :not(.red) + .red { border:5px solid red }
Part I: If element is first to its parent and has class "red", it shall get border.
Part II: If ".red" element is not first to its parent, but is immediately following an element without class ".red", it shall also deserve the honor of said border.
Fiddle or it didn't happen.
Philip Daubmeier's answer, while accepted, is not correct - see attached fiddle.
BoltClock's answer would work, but unnecessarily defines and overwrites styles
(particularly an issue where it otherwise would inherit a different border - you don't want to declare other to border:none)
EDIT:
In the event that you have "red" following non-red several times, each "first" red will get the border. To prevent that, one would need to use BoltClock's answer. See fiddle
The above answers are too complex.
.class:first-of-type { }
This will select the first-type of class. MDN Source
Note: Tested with Chrome 91 and Firefox 89, June 2021.
I am surprised no one mentioned the cleanest solution:
.red:not(.red ~ .red) {
border: 1px solid red;
}
<div class="home">
<span>blah</span>
<p class="red">first</p>
<p class="red">second</p>
<p class="red">third</p>
<p class="red">fourth</p>
</div>
you could use first-of-type or nth-of-type(1)
.red {
color: green;
}
/* .red:nth-of-type(1) */
.red:first-of-type {
color: red;
}
<div class="home">
<span>blah</span>
<p class="red">first</p>
<p class="red">second</p>
<p class="red">third</p>
<p class="red">fourth</p>
</div>
To match your selector, the element must have a class name of red and must be the first child of its parent.
<div>
<span class="red"></span> <!-- MATCH -->
</div>
<div>
<span>Blah</span>
<p class="red"></p> <!-- NO MATCH -->
</div>
<div>
<span>Blah</span>
<div><p class="red"></p></div> <!-- MATCH -->
</div>
Since the other answers cover what's wrong with it, I'll try the other half, how to fix it. Unfortunately, I don't know that you have a CSS only solution here, at least not that I can think of. There are some other options though....
Assign a first class to the element when you generate it, like this:
<p class="red first"></p>
<div class="red"></div>
CSS:
.first.red {
border:5px solid red;
}
This CSS only matches elements with both first and red classes.
Alternatively, do the same in JavaScript, for example here's what jQuery you would use to do this, using the same CSS as above:
$(".red:first").addClass("first");
I got this one in my project.
div > .b ~ .b:not(:first-child) {
background: none;
}
div > .b {
background: red;
}
<div>
<p class="a">The first paragraph.</p>
<p class="a">The second paragraph.</p>
<p class="b">The third paragraph.</p>
<p class="b">The fourth paragraph.</p>
</div>
I am using below CSS to have a background image for the list ul li
#footer .module:nth-of-type(1)>.menu>li:nth-of-type(1){
background-position: center;
background-image: url(http://monagentvoyagessuperprix.j3.voyagesendirect.com/images/stories/images_monagentvoyagessuperprix/layout/icon-home.png);
background-repeat: no-repeat;
}
<footer id="footer">
<div class="module">
<ul class="menu ">
<li class="level1 item308 active current"></li>
<li> </li>
</ul>
</div>
<div class="module">
<ul class="menu "><li></li>
<li></li>
</ul>
</div>
<div class="module">
<ul class="menu ">
<li></li>
<li></li>
</ul>
</div>
</footer>
According to your updated problem
<div class="home">
<span>blah</span>
<p class="red">first</p>
<p class="red">second</p>
<p class="red">third</p>
<p class="red">fourth</p>
</div>
how about
.home span + .red{
border:1px solid red;
}
This will select class home, then the element span and finally all .red elements that are placed immediately after span elements.
Reference: http://www.w3schools.com/cssref/css_selectors.asp
For some reason none of the above answers seemed to be addressing the case of the real first and only first child of the parent.
#element_id > .class_name:first-child
All the above answers will fail if you want to apply the style to only the first class child within this code.
<aside id="element_id">
Content
<div class="class_name">First content that need to be styled</div>
<div class="class_name">
Second content that don't need to be styled
<div>
<div>
<div class="class_name">deep content - no style</div>
<div class="class_name">deep content - no style</div>
<div>
<div class="class_name">deep content - no style</div>
</div>
</div>
</div>
</div>
</aside>
The following code will definitely work well everywhere.
it is simple and short.
<div class="home">
<span>blah</span>
<p class="blue"> first-blue </p>
<p class="blue"> second-blue </p>
<p class="blue"> third-blue </p>
<p class="red"> first-red </p>
<p class="red"> second-red </p>
<p class="red"> third-red </p>
<p class="red"> fourth-red </p>
<p class="pink"> first-pink </p>
<p class="pink"> second-pink </p>
<p class="red"> new-first-red </p>
<p class="red"> new-second-red </p>
</div>
we can select the first-red with:
.home .red:not(.home .red ~ .red) {
background-color: blue;
}
if you want to select new-first-red too you should use + instead of ~.
You could use nth-of-type(1) but be sure that site doesn't need to support IE7 etc, if this is the case use jQuery to add body class then find element via IE7 body class then the element name, then add in the nth-child styling to it.
You can change your code to something like this to get it work
<div class="home">
<span>blah</span>
<p class="red">first</p>
<p class="red">second</p>
<p class="red">third</p>
<p class="red">fourth</p>
</div>
This does the job for you
.home span + .red{
border:3px solid green;
}
Here is a CSS reference from SnoopCode about that.
All in All, after reading this all page and other ones and a lot of documentation. Here's the summary:
For first/last child: Safe to use now (Supported by all modern browsers)
:nth-child() Also safe to use now (Supported by all modern browsers). But be careful it even counts siblings! So, the following won't work properly:
/* This should select the first 2 element with class display_class
* but it will NOT WORK Because the nth-child count even siblings
* including the first div skip_class
*/
.display_class:nth-child(-n+2){
background-color:green;
}
<ul>
<li class="skip_class">test 1</li>
<li class="display_class">test 2 should be in green</li>
<li class="display_class">test 3 should be in green</li>
<li class="display_class">test 4</li>
</ul>
Currently, there is a selector :nth-child(-n+2 of .foo) that supports selection by class but not supported by modern browsers so not useful.
So, that leaves us with Javascript solution (we'll fix the example above):
// Here we'll go through the elements with the targeted class
// and add our classmodifer to only the first 2 elements!
[...document.querySelectorAll('.display_class')].forEach((element,index) => {
if (index < 2) element.classList.add('display_class--green');
});
.display_class--green {
background-color:green;
}
<ul>
<li class="skip_class">test 1</li>
<li class="display_class">test 2 should be in green</li>
<li class="display_class">test 3 should be in green</li>
<li class="display_class">test 4</li>
</ul>
A quick 'n dirty jQuery solution for marking first and last element within a group of elements with the same classnames:
$('.my-selector').each(function(index, item) {
if (!$(item).next().hasClass('my-selector')) {
$(item).addClass('last');
}
if (!$(item).prev().hasClass('my-selector')) {
$(item).addClass('first');
}
});
.my-selector {
padding: 5px;
background: #ccc;
}
.my-selector.first {
background: #fcc;
}
.my-selector.last {
background: #cfc;
}
<script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/3.3.1/jquery.min.js"></script>
<div>
<span>first element...</span>
<div class="my-selector">Row 1</div>
<div class="my-selector">Row 2</div>
<div class="my-selector">Row 3</div>
<div class="my-selector">Row 4</div>
<span>other elements...</span>
<div class="my-selector">Row 3</div>
<div class="my-selector">Row 4</div>
</div>
Try This Simple and Effective
.home > span + .red{
border:1px solid red;
}
just use
.home > .red ~ .red{
border: 1px solid red;
}
it will work.
I believe that using relative selector + for selecting elements placed immediately after, works here the best (as few suggested before).
It is also possible for this case to use this selector
.home p:first-of-type
but this is element selector not the class one.
Here you have nice list of CSS selectors: https://kolosek.com/css-selectors/
Could you try something like this:
.red:first-of-type {
border: 5px solid red;
}
you also can use this for last element (if you need it):
.red:last-of-type {
border: 5px solid red;
}
Try this solution:
.home p:first-of-type {
border:5px solid red;
width:100%;
display:block;
}
<div class="home">
<span>blah</span>
<p class="red">first</p>
<p class="red">second</p>
<p class="red">third</p>
<p class="red">fourth</p>
</div>
CodePen link
I think a lot of people have explained already. your code is selecting only first child of the first instance. If you want to select all the first children of red class, you need to use
.home > .red:first-child {
/* put your styling here */
}

nth-child not targeting the correct element?

.test:nth-child(1),
.test:nth-child(2),
.test:nth-child(3) {
color: #0F0
}
<div class="test">
<p>Test</p>
</div>
<div class="reuinIt">
<p>Test</p>
</div>
<div class="test">
<p>Test</p>
</div>
<div class="test">
<p>Test</p>
</div>
https://jsfiddle.net/dkfj2xzj/13/ <- UPDATED with my jQuery code if it helps
Why is it not skipping the .ruinIt class and not targeting the third .test?
I'm adding <div>s dynamically and when a <div> without the .checkDrop class is added I need to skip it.
Thanks
It's because the nth-child selector does not mean it's the nth of that specific class. It means that it's the nth sibling overall.
So the nth-child(2) refers to your .reuinIt class, however, it does not also have the .test class and therefore it does not receive any styling.
Your last .test class is the nth-child(4) however that has no styling rules applied.
If you'd like to see a working example, I've updated your fiddle here.
EXAMPLES
The :nth-child
The important thing to remember here is that the :nth-child selector specifically targets HTML elements based on their index/position inside their containers/parent elements.
Have a look at the example below and take note of how the corresponding commented :nth-child selector's index continues to increment regardless of the type of element it's targeting.
<div id="container">
<h1>Heading 1</h1> <!-- h1:nth-child(1) -->
<p>Paragraph 1</p> <!-- p:nth-child(2) -->
<p>Paragraph 2</p> <!-- p:nth-child(3) -->
<h2>Heading 2</h2> <!-- h2:nth-child(4) -->
<p>Paragraph 3</p> <!-- p:nth-child(5) -->
</div>
The :nth-of-type
The cool thing about :nth-of-type is that it ignores all of the other elements that are not of the same type, i.e. if the element you are targeting is a <p>, it will ignore all of the surrounding "non-<p>" elements when calculating its index.
The below example will provide you with a basic understanding of the indexing rules that :nth-of-type follows:
<div id="container">
<h1>Heading 1</h1> <!-- h1:nth-of-type(1) -->
<p>Paragraph 1</p> <!-- p:nth-of-type(1) -->
<p>Paragraph 2</p> <!-- p:nth-of-type(2) -->
<h2>Heading 2</h2> <!-- h2:nth-of-type(1) -->
<p>Paragraph 3</p> <!-- p:nth-of-type(3) -->
</div>
A little more complexity with :nth-of-type
It is however very important to remember that :nth-of-type bases it's indexing values on the HTML Element Type regardless of the CSS Class you are using to call the property.
Have a look at the below example:
<div id="container">
<h1>Heading 1</h1> <!-- h1:nth-of-type(1) -->
<p class="my-class">Paragraph 1</p> <!-- .my-class:nth-of-type(1) -->
<p>Paragraph 2</p> <!-- p:nth-of-type(2) -->
<h2 class="my-class">Heading 2</h2> <!-- .my-class:nth-of-type(1) -->
<p class="my-class">Paragraph 3</p> <!-- .my-class:nth-of-type(3) -->
<h1 class="my-class">Heading 3</h1> <!-- .my-class:nth-of-type(2) -->
</div>
This example is a little more complex, but it helps if you see CSS Declarations as a sort of filtering rule. For example, if create a CSS declaration by typing:
p:nth-of-type(2) {
background-color: red;
}
I am essentially telling the browser 2 things:
Only <p> tags should be affected and,
Only if they are the second <p> tags amidst their siblings
The difficulty comes in when I write CSS that looks like this:
.my-class:nth-of-type(1) {
background-color: red;
}
By not specifying an element type, my rule essentially reads with the following filter:
Only elements with the class my-class should be affected and,
Only if those elements are the first sibling of their type of elements.
If were to apply the above CSS to the HTML in the example (see fiddle for working example), we would get an output that looks like this:
In the output above, you'll see that both the first <h2> and the first <p> elements were affected regardless of whether or not their siblings had the my-class class name applied.
The code .test:nth-child(2) doesn't mean "the second element of the class test in its container". It means just "element that has a test class and is the second child of its container".
The behavior you expected can be expressed with CSS Selectors 4 as :nth-child(2 of .test). Unfortunately, this syntax is currently supported only in Safari.
Try below code for targeting nth-child:
You can first parent div for all child div.
.parent_div .test:nth-child(1) {
color: red;
}
.parent_div .test:nth-child(3) {
color: red;
}
.parent_div .test:nth-child(4) {
color: red;
}
<div class="parent_div">
<div class="test">
<p>Test</p>
</div>
<div class="reuinIt">
<p>Test</p>
</div>
<div class="test">
<p>Test</p>
</div>
<div class="test">
<p>Test</p>
</div>
</div>
.test:nth-child(2) selector means select an element having class .test when it is 2nd child of its parent. Similarly .test:nth-child(3) will select 3rd element of a parent if it will have .test class.
In your case 2nd element doesn't have .test class so it is not selecting it. If you wants to target them 3rd div element you need to use .test:nth-child(3)(As it is 3rd element of its parent, not 2nd).
Correct selector will be:
.test:nth-child(1), .test:nth-child(3), .test:nth-child(4) {color: #0F0;}
.test:nth-child(1), .test:nth-child(3), .test:nth-child(4)
{color: #0F0}
<div class="test">
<p>Test0</p>
</div>
<div class="reuinIt">
<p>Test1</p>
</div>
<div class="test">
<p>Test2</p>
</div>
<div class="test">
<p>Test3</p>
</div>
You can try this:
.test:nth-child(1),
.test:nth-child(2),
.test:nth-child(3) {
color: #0F0
}
<div class="test">
<p>Test</p>
<p>Test</p>
<p>Test</p>
</div>
<div class="reuinIt">
<p>Test</p>
</div>
You are confused between the usage of nth-child & nth-of-type. nth-child will consider all the tags and all the elements. If you want to specifically count a certain type of element or class, don't make use of nth-child. Go for nth-of-type. But, moreover nth-of-type is not supported currently for the classes though it works fine for html tags (may be in future it will get supported). All you need to do is change the nth-child numbers to 1, 3, 4. That's the only way you can get your results.
Fiddle: https://jsfiddle.net/jw66uj1p/
.test:nth-of-type(1),
.test:nth-of-type(3),
.test:nth-of-type(4) {
color: #0F0
}

How to target the first of a certain class in a ul li using CSS? [duplicate]

I have a bunch of elements with a class name red, but I can't seem to select the first element with the class="red" using the following CSS rule:
.home .red:first-child {
border: 1px solid red;
}
<div class="home">
<span>blah</span>
<p class="red">first</p>
<p class="red">second</p>
<p class="red">third</p>
<p class="red">fourth</p>
</div>
What is wrong in this selector and how do I correct it to target the first child with class red?
This is one of the most well-known examples of authors misunderstanding how :first-child works. Introduced in CSS2, the :first-child pseudo-class represents the very first child of its parent. That's it. There's a very common misconception that it picks up whichever child element is the first to match the conditions specified by the rest of the compound selector. Due to the way selectors work (see here for an explanation), that is simply not true.
Selectors level 3 introduces a :first-of-type pseudo-class, which represents the first element among siblings of its element type. This answer explains, with illustrations, the difference between :first-child and :first-of-type. However, as with :first-child, it does not look at any other conditions or attributes. In HTML, the element type is represented by the tag name. In the question, that type is p.
Unfortunately, there is no similar :first-of-class pseudo-class for matching the first child element of a given class. At the time this answer was first posted, the newly published FPWD of Selectors level 4 introduced an :nth-match() pseudo-class, designed around existing selector mechanics as I mentioned in the first paragraph by adding a selector-list argument, through which you can supply the rest of the compound selector to get the desired filtering behavior. In recent years this functionality was subsumed into :nth-child() itself, with the selector list appearing as an optional second argument, to simplify things as well as averting the false impression that :nth-match() matched across the entire document (see the final note below).
While we await cross-browser support (seriously, it's been nearly 10 years, and there has only been a single implementation for the last 5 of those years), one workaround that Lea Verou and I developed independently (she did it first!) is to first apply your desired styles to all your elements with that class:
/*
* Select all .red children of .home, including the first one,
* and give them a border.
*/
.home > .red {
border: 1px solid red;
}
... then "undo" the styles for elements with the class that come after the first one, using the general sibling combinator ~ in an overriding rule:
/*
* Select all but the first .red child of .home,
* and remove the border from the previous rule.
*/
.home > .red ~ .red {
border: none;
}
Now only the first element with class="red" will have a border.
Here's an illustration of how the rules are applied:
.home > .red {
border: 1px solid red;
}
.home > .red ~ .red {
border: none;
}
<div class="home">
<span>blah</span> <!-- [1] -->
<p class="red">first</p> <!-- [2] -->
<p class="red">second</p> <!-- [3] -->
<p class="red">third</p> <!-- [3] -->
<p class="red">fourth</p> <!-- [3] -->
</div>
No rules are applied; no border is rendered.
This element does not have the class red, so it's skipped.
Only the first rule is applied; a red border is rendered.
This element has the class red, but it's not preceded by any elements with the class red in its parent. Thus the second rule is not applied, only the first, and the element keeps its border.
Both rules are applied; no border is rendered.
This element has the class red. It is also preceded by at least one other element with the class red. Thus both rules are applied, and the second border declaration overrides the first, thereby "undoing" it, so to speak.
As a bonus, although it was introduced in Selectors 3, the general sibling combinator is actually pretty well-supported by IE7 and newer, unlike :first-of-type and :nth-of-type() which are only supported by IE9 onward. If you need good browser support, you're in luck.
In fact, the fact that the sibling combinator is the only important component in this technique, and it has such amazing browser support, makes this technique very versatile — you can adapt it for filtering elements by other things, besides class selectors:
You can use this to work around :first-of-type in IE7 and IE8, by simply supplying a type selector instead of a class selector (again, more on its incorrect usage in the question in a later section):
article > p {
/* Apply styles to article > p:first-of-type, which may or may not be :first-child */
}
article > p ~ p {
/* Undo the above styles for every subsequent article > p */
}
You can filter by attribute selectors or any other simple selectors instead of classes.
You can also combine this overriding technique with pseudo-elements even though pseudo-elements technically aren't simple selectors.
Note that in order for this to work, you will need to know in advance what the default styles will be for your other sibling elements so you can override the first rule. Additionally, since this involves overriding rules in CSS, you can't achieve the same thing with a single selector for use with the Selectors API, or Selenium's CSS locators.
On a final note, keep in mind that this answer assumes that the question is looking for any number of first child elements having a given class. There is neither a pseudo-class nor even a generic CSS solution for the nth match of a complex selector across the entire document — whether a solution exists depends heavily on the document structure. jQuery provides :eq(), :first, :last and more for this purpose, but note again that they function very differently from :nth-child() et al. Using the Selectors API, you can either use document.querySelector() to obtain the very first match:
var first = document.querySelector('.home > .red');
Or use document.querySelectorAll() with an indexer to pick any specific match:
var redElements = document.querySelectorAll('.home > .red');
var first = redElements[0];
var second = redElements[1];
// etc
Although the .red:nth-of-type(1) solution in the original accepted answer by Philip Daubmeier works (which was originally written by Martyn but deleted since), it does not behave the way you'd expect it to.
For example, if you only wanted to select the p here:
<p class="red"></p>
<div class="red"></div>
... then you can't use .red:first-of-type (equivalent to .red:nth-of-type(1)), because each element is the first (and only) one of its type (p and div respectively), so both will be matched by the selector.
When the first element of a certain class is also the first of its type, the pseudo-class will work, but this happens only by coincidence. This behavior is demonstrated in Philip's answer. The moment you stick in an element of the same type before this element, the selector will fail. Taking the markup from the question:
<div class="home">
<span>blah</span>
<p class="red">first</p>
<p class="red">second</p>
<p class="red">third</p>
<p class="red">fourth</p>
</div>
Applying a rule with .red:first-of-type will work, but once you add another p without the class:
<div class="home">
<span>blah</span>
<p>dummy</p>
<p class="red">first</p>
<p class="red">second</p>
<p class="red">third</p>
<p class="red">fourth</p>
</div>
... the selector will immediately fail, because the first .red element is now the second p element.
The :first-child selector is intended, like the name says, to select the first child of a parent tag. So this example will work (Just tried it here):
<body>
<p class="red">first</p>
<div class="red">second</div>
</body>
This won't work, though, if you've nested your tags under different parent tags, or if your tags of class red aren't the first tags under the parent.
Notice also that this doesn't only apply to the first such tag in the whole document, but every time a new parent is wrapped around it, like:
<div>
<p class="red">first</p>
<div class="red">second</div>
</div>
<div>
<p class="red">third</p>
<div class="red">fourth</div>
</div>
first and third will be red then.
For your case, you can use the :nth-of-type selector:
.red:nth-of-type(1)
{
border:5px solid red;
}
<div class="home">
<span>blah</span>
<p class="red">first</p>
<p class="red">second</p>
<p class="red">third</p>
<p class="red">fourth</p>
</div>
Credits to Martyn, who deleted his answer containing this approach.
More information about :nth-child() and :nth-of-type() is available at http://www.quirksmode.org/css/nthchild.html.
Be aware that this is a CSS3 selector, therefore some now outdated browser versions may not behave as expected (e.g. IE8 or older). Visit https://caniuse.com/?search=nth-of-type for more details.
The correct answer is:
.red:first-child, :not(.red) + .red { border:5px solid red }
Part I: If element is first to its parent and has class "red", it shall get border.
Part II: If ".red" element is not first to its parent, but is immediately following an element without class ".red", it shall also deserve the honor of said border.
Fiddle or it didn't happen.
Philip Daubmeier's answer, while accepted, is not correct - see attached fiddle.
BoltClock's answer would work, but unnecessarily defines and overwrites styles
(particularly an issue where it otherwise would inherit a different border - you don't want to declare other to border:none)
EDIT:
In the event that you have "red" following non-red several times, each "first" red will get the border. To prevent that, one would need to use BoltClock's answer. See fiddle
The above answers are too complex.
.class:first-of-type { }
This will select the first-type of class. MDN Source
Note: Tested with Chrome 91 and Firefox 89, June 2021.
I am surprised no one mentioned the cleanest solution:
.red:not(.red ~ .red) {
border: 1px solid red;
}
<div class="home">
<span>blah</span>
<p class="red">first</p>
<p class="red">second</p>
<p class="red">third</p>
<p class="red">fourth</p>
</div>
you could use first-of-type or nth-of-type(1)
.red {
color: green;
}
/* .red:nth-of-type(1) */
.red:first-of-type {
color: red;
}
<div class="home">
<span>blah</span>
<p class="red">first</p>
<p class="red">second</p>
<p class="red">third</p>
<p class="red">fourth</p>
</div>
To match your selector, the element must have a class name of red and must be the first child of its parent.
<div>
<span class="red"></span> <!-- MATCH -->
</div>
<div>
<span>Blah</span>
<p class="red"></p> <!-- NO MATCH -->
</div>
<div>
<span>Blah</span>
<div><p class="red"></p></div> <!-- MATCH -->
</div>
Since the other answers cover what's wrong with it, I'll try the other half, how to fix it. Unfortunately, I don't know that you have a CSS only solution here, at least not that I can think of. There are some other options though....
Assign a first class to the element when you generate it, like this:
<p class="red first"></p>
<div class="red"></div>
CSS:
.first.red {
border:5px solid red;
}
This CSS only matches elements with both first and red classes.
Alternatively, do the same in JavaScript, for example here's what jQuery you would use to do this, using the same CSS as above:
$(".red:first").addClass("first");
I got this one in my project.
div > .b ~ .b:not(:first-child) {
background: none;
}
div > .b {
background: red;
}
<div>
<p class="a">The first paragraph.</p>
<p class="a">The second paragraph.</p>
<p class="b">The third paragraph.</p>
<p class="b">The fourth paragraph.</p>
</div>
I am using below CSS to have a background image for the list ul li
#footer .module:nth-of-type(1)>.menu>li:nth-of-type(1){
background-position: center;
background-image: url(http://monagentvoyagessuperprix.j3.voyagesendirect.com/images/stories/images_monagentvoyagessuperprix/layout/icon-home.png);
background-repeat: no-repeat;
}
<footer id="footer">
<div class="module">
<ul class="menu ">
<li class="level1 item308 active current"></li>
<li> </li>
</ul>
</div>
<div class="module">
<ul class="menu "><li></li>
<li></li>
</ul>
</div>
<div class="module">
<ul class="menu ">
<li></li>
<li></li>
</ul>
</div>
</footer>
According to your updated problem
<div class="home">
<span>blah</span>
<p class="red">first</p>
<p class="red">second</p>
<p class="red">third</p>
<p class="red">fourth</p>
</div>
how about
.home span + .red{
border:1px solid red;
}
This will select class home, then the element span and finally all .red elements that are placed immediately after span elements.
Reference: http://www.w3schools.com/cssref/css_selectors.asp
For some reason none of the above answers seemed to be addressing the case of the real first and only first child of the parent.
#element_id > .class_name:first-child
All the above answers will fail if you want to apply the style to only the first class child within this code.
<aside id="element_id">
Content
<div class="class_name">First content that need to be styled</div>
<div class="class_name">
Second content that don't need to be styled
<div>
<div>
<div class="class_name">deep content - no style</div>
<div class="class_name">deep content - no style</div>
<div>
<div class="class_name">deep content - no style</div>
</div>
</div>
</div>
</div>
</aside>
The following code will definitely work well everywhere.
it is simple and short.
<div class="home">
<span>blah</span>
<p class="blue"> first-blue </p>
<p class="blue"> second-blue </p>
<p class="blue"> third-blue </p>
<p class="red"> first-red </p>
<p class="red"> second-red </p>
<p class="red"> third-red </p>
<p class="red"> fourth-red </p>
<p class="pink"> first-pink </p>
<p class="pink"> second-pink </p>
<p class="red"> new-first-red </p>
<p class="red"> new-second-red </p>
</div>
we can select the first-red with:
.home .red:not(.home .red ~ .red) {
background-color: blue;
}
if you want to select new-first-red too you should use + instead of ~.
You could use nth-of-type(1) but be sure that site doesn't need to support IE7 etc, if this is the case use jQuery to add body class then find element via IE7 body class then the element name, then add in the nth-child styling to it.
You can change your code to something like this to get it work
<div class="home">
<span>blah</span>
<p class="red">first</p>
<p class="red">second</p>
<p class="red">third</p>
<p class="red">fourth</p>
</div>
This does the job for you
.home span + .red{
border:3px solid green;
}
Here is a CSS reference from SnoopCode about that.
All in All, after reading this all page and other ones and a lot of documentation. Here's the summary:
For first/last child: Safe to use now (Supported by all modern browsers)
:nth-child() Also safe to use now (Supported by all modern browsers). But be careful it even counts siblings! So, the following won't work properly:
/* This should select the first 2 element with class display_class
* but it will NOT WORK Because the nth-child count even siblings
* including the first div skip_class
*/
.display_class:nth-child(-n+2){
background-color:green;
}
<ul>
<li class="skip_class">test 1</li>
<li class="display_class">test 2 should be in green</li>
<li class="display_class">test 3 should be in green</li>
<li class="display_class">test 4</li>
</ul>
Currently, there is a selector :nth-child(-n+2 of .foo) that supports selection by class but not supported by modern browsers so not useful.
So, that leaves us with Javascript solution (we'll fix the example above):
// Here we'll go through the elements with the targeted class
// and add our classmodifer to only the first 2 elements!
[...document.querySelectorAll('.display_class')].forEach((element,index) => {
if (index < 2) element.classList.add('display_class--green');
});
.display_class--green {
background-color:green;
}
<ul>
<li class="skip_class">test 1</li>
<li class="display_class">test 2 should be in green</li>
<li class="display_class">test 3 should be in green</li>
<li class="display_class">test 4</li>
</ul>
A quick 'n dirty jQuery solution for marking first and last element within a group of elements with the same classnames:
$('.my-selector').each(function(index, item) {
if (!$(item).next().hasClass('my-selector')) {
$(item).addClass('last');
}
if (!$(item).prev().hasClass('my-selector')) {
$(item).addClass('first');
}
});
.my-selector {
padding: 5px;
background: #ccc;
}
.my-selector.first {
background: #fcc;
}
.my-selector.last {
background: #cfc;
}
<script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/3.3.1/jquery.min.js"></script>
<div>
<span>first element...</span>
<div class="my-selector">Row 1</div>
<div class="my-selector">Row 2</div>
<div class="my-selector">Row 3</div>
<div class="my-selector">Row 4</div>
<span>other elements...</span>
<div class="my-selector">Row 3</div>
<div class="my-selector">Row 4</div>
</div>
Try This Simple and Effective
.home > span + .red{
border:1px solid red;
}
just use
.home > .red ~ .red{
border: 1px solid red;
}
it will work.
I believe that using relative selector + for selecting elements placed immediately after, works here the best (as few suggested before).
It is also possible for this case to use this selector
.home p:first-of-type
but this is element selector not the class one.
Here you have nice list of CSS selectors: https://kolosek.com/css-selectors/
Could you try something like this:
.red:first-of-type {
border: 5px solid red;
}
you also can use this for last element (if you need it):
.red:last-of-type {
border: 5px solid red;
}
Try this solution:
.home p:first-of-type {
border:5px solid red;
width:100%;
display:block;
}
<div class="home">
<span>blah</span>
<p class="red">first</p>
<p class="red">second</p>
<p class="red">third</p>
<p class="red">fourth</p>
</div>
CodePen link
I think a lot of people have explained already. your code is selecting only first child of the first instance. If you want to select all the first children of red class, you need to use
.home > .red:first-child {
/* put your styling here */
}