Css nth-child from 1 to 5

To make it the more generic possible you can use this:

tr:not(:nth-child(1n+6)):not(:nth-child(3))  { 
    /* your rules here */

To explain it a little: you are saying you want to select the elements that are not from 6 on (so the first 5) and not 3rd, if you wrote


you were targeting the rows from 5 on, since you were selecting the rows

(1*0) + 6 [ = 6 ]

(1*1) + 6 [ = 7 ]

(1*2) + 6 [ = 8 ]

...and so on. This is what it means the expression (1n+X), where X in our case is 6.

Adding the :not pseudo selector to the expression above, you are saying you want to select the rows which are not from 5 on, so you will select from 5 down, the 1st, 2nd, 3rd, 4th and 5th.

Plus, adding one more :not selector, which targets the 3rd, you will get what you want => The first 5 without the 3rd!

/***************** UPDATED! I added a jsfiddle *******************/

Here you can see it working in this jsfiddle

The :nth-child() CSS pseudo-class matches elements based on their position among a group of siblings.

Try it

Note that, in the element:nth-child() syntax, the child count includes children of any element type; but it is considered a match only if the element at that child position is of the specified element type.


:nth-child() takes a single argument that describes a pattern for matching element indices in a list of siblings. Element indices are 1-based.

:nth-child( <nth> [ of <complex-selector-list> ]? )

Keyword values


Represents elements whose numeric position in a series of siblings is odd: 1, 3, 5, etc.


Represents elements whose numeric position in a series of siblings is even: 2, 4, 6, etc.

Functional notation


Represents elements in a list whose indices match those found in a custom pattern of numbers, defined by An+B, where:

  • A is an integer step size,
  • B is an integer offset,
  • n is all nonnegative integers, starting from 0.

It can be read as the An+B-th element of a list.


Example selectors

tr:nth-child(odd) or tr:nth-child(2n+1)

Represents the odd rows of an HTML table: 1, 3, 5, etc.

tr:nth-child(even) or tr:nth-child(2n)

Represents the even rows of an HTML table: 2, 4, 6, etc.


Represents the seventh element.


Represents elements 5 [=5×1], 10 [=5×2], 15 [=5×3], etc. The first one to be returned as a result of the formula is 0 [=5x0], resulting in a no-match, since the elements are indexed from 1, whereas n starts from 0. This may seem weird at first, but it makes more sense when the B part of the formula is >0, like in the next example.


Represents the seventh and all following elements: 7 [=0+7], 8 [=1+7], 9 [=2+7], etc.


Represents elements 4 [=(3×0)+4], 7 [=(3×1)+4], 10 [=(3×2)+4], 13 [=(3×3)+4], etc.


Represents the first three elements. [=-0+3, -1+3, -2+3]


Represents every <p> element in a group of siblings. This selects the same elements as a simple p selector (although with a higher specificity).

p:nth-child(1) or p:nth-child(0n+1)

Represents every <p> that is the first element in a group of siblings. This is the same as the :first-child selector (and has the same specificity).


Represents the eighth through the fifteenth <p> elements of a group of siblings.

Detailed example


  <code>span:nth-child(2n+1)</code>, WITHOUT an <code>&lt;em&gt;</code> among
  the child elements.
<p>Children 1, 3, 5, and 7 are selected.</p>
<div class="first">
  <span>Span 1!</span>
  <span>Span 2</span>
  <span>Span 3!</span>
  <span>Span 4</span>
  <span>Span 5!</span>
  <span>Span 6</span>
  <span>Span 7!</span>

<br />

  <code>span:nth-child(2n+1)</code>, WITH an <code>&lt;em&gt;</code> among the
  child elements.
  Children 1, 5, and 7 are selected.<br />
  3 is used in the counting because it is a child, but it isn't selected because
  it isn't a <code>&lt;span&gt;</code>.
<div class="second">
  <em>This is an `em`.</em>

<br />

  <code>span:nth-of-type(2n+1)</code>, WITH an <code>&lt;em&gt;</code> among the
  child elements.
  Children 1, 4, 6, and 8 are selected.<br />
  3 isn't used in the counting or selected because it is an
  <code>&lt;em&gt;</code>, not a <code>&lt;span&gt;</code>, and
  <code>nth-of-type</code> only selects children of that type. The
  <code>&lt;em&gt;</code> is completely skipped over and ignored.
<div class="third">
  <em>This is an `em`.</em>


html {
  font-family: sans-serif;

div em {
  padding: 5px;
  border: 1px solid green;
  display: inline-block;
  margin-bottom: 3px;

.first span:nth-child(2n + 1),
.second span:nth-child(2n + 1),
.third span:nth-of-type(2n + 1) {
  background-color: lime;



Unknown specification
# nth-child-pseudo

Browser compatibility

BCD tables only load in the browser

See also

How do I select all nth child in CSS?

The :nth-child(n) selector matches every element that is the nth child of its parent. n can be a number, a keyword (odd or even), or a formula (like an + b). Tip: Look at the :nth-of-type() selector to select the element that is the nth child, of the same type (tag name), of its parent.

How do I get the last 4 child in CSS?

CSS :last-child Selector.
Definition and Usage. The :last-child selector matches every element that is the last child of its parent. Tip: p:last-child is equal to p:nth-last-child(1). ... .
Browser Support. The numbers in the table specifies the first browser version that fully supports the selector. ... .
CSS Syntax. :last-child {.

How do you get a nth child?

Use the querySelector() method to get the nth child of an element, e.g. document. querySelector('#parent :nth-child(3)') . The :nth-child pseudo class returns the element that matches the provided position. Here is the HTML for the examples in this article.

How do you target the nth child in SCSS?

Writing Complex :nth-child() Selectors It works exactly the same as :nth-child except that it starts from the end of the parent. For example, you can select the first three children of a parent by using the selector :nth-child(-n + 3) . You can use :nth-last-child(-n + 3) to select the last three.

Tải thêm tài liệu liên quan đến bài viết Css nth-child from 1 to 5