The .not() traversing method excludes elements from the current jQuery collection — it keeps everything that does not match your selector, callback, DOM node, or jQuery object. This tutorial covers the official list and div demos, DOM-element exclusion, comparisons with .filter() and .is(), and callback-based removal.
Remove matches
.not(".x")
Since 1.4
Remove one
Inverse
Core API
Often you need to act on almost every element in a selection — all list items except one, all divs except green and blue, all inputs except disabled ones. The .not() method removes unwanted elements from the current set so you can style or manipulate the rest.
Available since jQuery 1.0 (callback and jQuery-object forms since 1.4), .not() is the inverse of .filter(). Where .filter() keeps matches, .not() keeps non-matches. The returned jQuery object is a new subset — the original collection is unchanged until you reassign the variable.
.not() MethodGiven a jQuery object representing a set of DOM elements, .not(selectorOrFunctionOrElement) tests each element against the argument. Elements that match are dropped; everything else stays in the result. With a callback, returning true excludes the element — the opposite of .filter(), where true means keep.
This is set narrowing, not tree traversal. .not() only considers elements already in the current collection — it does not search descendants or siblings. Compare with .find(), which drills down, and .is(), which returns a boolean without changing the set.
$("li").not(":nth-child(2n)") excludes even-position items — items 2 and 4 — leaving 1, 3, and 5. The same pattern with .filter(":nth-child(2n+1)") would keep the same result.
General forms of .not:
.not( selector )
.not( function )
.not( selection )index and element. Elements for which the function returns true are excluded.$( "li" ).not( ":nth-child(2n)" ).css( "background-color", "red" );
// Red on items 1, 3, 5 — even-position items excluded| Goal | Code |
|---|---|
| Exclude by class | $("li").not(".active") |
| Exclude multiple selectors | $("div").not(".green, #blueone") |
| Remove one DOM node | $("li").not(document.getElementById("skip")) |
| Exclude via callback | $("input").not(function(){ return this.disabled; }) |
| Keep matches instead | $("li").filter(".active") |
| Boolean test only | $("li").is(".active") |
.not() vs .filter() vs .is()Three methods that test the current set — exclude, keep, or boolean-check.
excludeRemove matches — keep non-matches
keepKeep matches — drop non-matches
true/falseTest set — no new collection returned
oppositetrue excludes in .not(); true keeps in .filter()
Examples 1–3 follow the official jQuery API documentation. Use DevTools or the Try-it links to run each snippet in the browser.
Official jQuery demos for excluding elements from a matched set.
Style list items that are not on even positions — the core official list lesson.
$( "li" ).not( ":nth-child(2n)" ).css( "background-color", "red" );:nth-child(2n) matches items 2 and 4. .not() removes them from the set before .css() runs on items 1, 3, and 5.
Remove one list item by native DOM reference — useful when another library provides the node.
$( "li" ).not( document.getElementById( "notli" ) )
.css( "background-color", "red" );Passing a DOM node to .not() removes that exact element if it appears in the current set. Equivalent to .not("#notli") when the id is known.
Exclude multiple selectors — divs without class green and without id blueone.
$( "div" ).not( ".green, #blueone" )
.css( "border-color", "red" );Comma-separated selectors in .not() exclude any element matching either rule. Green and blue divs stay untouched; the rest get the red border.
Compare with .filter(), then exclude via callback logic.
.not() vs .filter() on the Same SetSee how opposite logic produces complementary subsets.
$( "#not-demo li" ).not( ".active" ).css( "color", "gray" );
$( "#filter-demo li" ).filter( ".active" ).css( "color", "blue" );
// .not('.active') → inactive | .filter('.active') → activeTogether, .not('.active') and .filter('.active') partition the same list into inactive and active groups — mutually exclusive subsets covering the whole set.
Use the function form when exclusion logic is more than a simple selector.
$( "input" ).not( function() {
return this.disabled;
}).addClass( "enabled-field" );Returning true from the callback excludes the element. Here, disabled inputs are dropped; enabled ones receive the class — the callback mirror of .filter(function(){ return !this.disabled; }).
$("li").not("#skip") or DOM-node exclusion.$(".tab").not(".active") for inactive tabs..not(":disabled").$("div").not(".green, #blueone").$("p").not($("#selected")) when you already have a jQuery object.$("tr").not(":nth-child(even)") for odd rows only..not() Excludes From the Matched SetjQuery object holds candidate elements.
Selector, callback, DOM node, or jQuery object.
Matching elements are removed from the result.
New subset — push stack for .end().
.filter() — same arguments, opposite keep/exclude logic.true excludes the element (opposite of .filter())..find()..end() to restore the previous set..not() has been part of jQuery since 1.0+ (function form since 1.4). It relies on selector matching with no browser-specific behavior beyond jQuery itself.
Supported in jQuery 1.x, 2.x, and 3.x across all modern browsers and IE with supported jQuery builds. Native equivalent: manual array filter — jQuery .not() integrates with the collection stack and selector engine.
Bottom line: Safe in any jQuery project. Use .not() to exclude; use .filter() when you need to keep matches.
The jQuery .not() method removes elements from the current collection — keeping everything that does not match your selector, callback, DOM node, or jQuery object. It is the natural inverse of .filter() for set narrowing.
Remember the official list lesson: $("li").not(":nth-child(2n)") styles items 1, 3, and 5 by excluding even positions. Reach for .filter() when you want to keep matches, and .is() when you only need a true/false answer.
.not() when exclusion reads clearer than inverted .filter().filter() — opposite logic, same set.end() after .not() when continuing on the full set.not() when you need to keep matches — use .filter().not() with .remove() — .not() does not delete DOM nodes.not() to search inside elements — use .find() first.is() when you need a modified collection to chain further.not()Remove matches — keep the rest.
Exclude
APIInverse
CompareBoolean
Comparetrue drops
LogicRemove one
APIjQuery added the callback form of .not() in version 1.4 alongside .filter(function) — same signature, inverted boolean meaning. Before that, developers often wrote .filter(function(){ return !condition; }); .not(function){ return condition; } expresses exclusion more directly.
Explore more DOM traversal methods as the collection grows.
6 people found this page helpful