How can I change a class of an HTML element in response to an onClick event using JavaScript?

21 upvote
  flag
"The class attribute is mostly used to point to a class in a style sheet. However, it can also be used by a JavaScript (via the HTML DOM) to make changes to HTML elements with a specified class." -w3schools.com/tags/att_standard_class.asp – Triynko
6 upvote
  flag
element.setAttribute(name, value); Replace name with class. Replace value with whatever name you have given the class, enclosed in quotes. This avoids needing to delete the current class and adding a different one. This jsFiddle example shows full working code. – Sandy Good
upvote
  flag
For changing a class of HTML element with onClick use this code: <input type='button' onclick='addNewClass(this)' value='Create' /> and in javascript section: function addNewClass(elem){ elem.className="newClass"; } Online – Iman Bahrampour

29 Answers 11

This is easiest with a library like jQuery:

<input type="button" onClick="javascript:test_byid();" value="id='second'" />

<script>
function test_byid()
{
    $("#second").toggleClass("highlight");
}
</script>
7 upvote
  flag
What does the javascript: pseudo-protocol do in a script-event ... It seems totally stupid to tell the javascript-interpretator, that it should treat script in a script-event as script !-) Only use of the javascript: pseudo-protocol is where you instead would use an url !o] – roenving
5 upvote
  flag
In that context, it isn't the pseudo-protocol - it's a loop label ... only there is no loop for it TO label. – Quentin
8 upvote
  flag
Actually, that is not a pseudo-protocol, it is interpreted as a JavaScript label, like what you can use in a loop. One could easily do onClick="myScriptYo:do_it();". But, please, don't do it. – kzh

No offense, but it's unclever to change class on-the-fly as it forces the CSS interpreter to recalculate the visual presentation of the entire web page.

The reason is that it is nearly impossible for the CSS interpreter to know if any inheritance or cascading could be changed, so the short answer is:

Never ever change className on-the-fly !-)

But usually you'll only need to change a property or two, and that is easily implemented:

function highlight(elm){
    elm.style.backgroundColor ="#345";
    elm.style.color = "#fff";
}
10 upvote
  flag
i've never experienced any performance issues with switching CSS classes myself. I think whatever performance hit there might be, it's far outweighed by the messiness of having styles/presentation mixed up in your javascript. – nickf
4 upvote
  flag
Hrm, obviously you never tested it ... In a realtime application consisting of thousands of rows nested with other elements I recognized a delay of several seconds, remaking it only to change properties it wasn't possible to recognize delay ... – roenving
5 upvote
  flag
Why would you even want thousands of rows nested with other elements? Also, what operating system & browser was this delay with? – Peter Boughton
37 upvote
  flag
If changing a className is causing noticeable performance problems, you have much bigger problems in the structure and design of your page/app. If not, shaving off a few milliseconds is not a good reason to pollute your application logic with styles. – eyelidlessness
26 upvote
  flag
this is the worst idea ever. changing classes is by far and away the easiest and cleanest way to update your CSS on the fly. – Jason
4 upvote
  flag
To the “thousands of rows” unbelievers: doxygen. Hierarchical, collapsible menus in a side frame. IE7 had fatal issues with this so I used Firefox. – Erik Olson
1 upvote
  flag
I'm wondering why you haven't deleted your answer yet! (it's 2016) – Alex Jolig
1 upvote
  flag
@AlexJolig - the user hasn't logged in since 2009 – Krease
1 upvote
  flag
This is the second-most downvoted answer on the site. – Mr Anderson
upvote
  flag
I think "don't do it in the first place" is not an acceptable answer for "how to do it". – Lajos Meszaros
upvote
  flag
So instead of changing a class you go with writing inline styles by hand. You are taking CSS's job. By the way, if you edit the style attribute, it will also redraw the page as it would if you would have changed the class. "obviously you never tested it" - show us some exact data on how your solution is faster. And please don't give us data like "It's 40% faster, when you execute 20 million changes" or something like that. – Lajos Meszaros

You can use node.className like so:

document.getElementById('foo').className = 'bar';

This should work in IE5.5 and up according to PPK.

8 upvote
  flag
this would overwrite any and all other classes on the object... so it is not that simple. – Eric Sebasta
up vote 3076 down vote accepted

Modern HTML5 Techniques for changing classes

Modern browsers have added classList which provides methods to make it easier to manipulate classes without needing a library:

document.getElementById("MyElement").classList.add('MyClass');

document.getElementById("MyElement").classList.remove('MyClass');

if ( document.getElementById("MyElement").classList.contains('MyClass') )

document.getElementById("MyElement").classList.toggle('MyClass');

Unfortunately, these do not work in Internet Explorer prior to v10, though there is a shim to add support for it to IE8 and IE9, available from this page. It is, though, getting more and more supported.

Simple cross-browser solution

The standard JavaScript way to select an element is using document.getElementById("Id"), which is what the following examples use - you can of course obtain elements in other ways, and in the right situation may simply use this instead - however, going into detail on this is beyond the scope of the answer.

To change all classes for an element:

To replace all existing classes with one or more new classes, set the className attribute:

document.getElementById("MyElement").className = "MyClass";

(You can use a space-delimited list to apply multiple classes.)

To add an additional class to an element:

To add a class to an element, without removing/affecting existing values, append a space and the new classname, like so:

document.getElementById("MyElement").className += " MyClass";

To remove a class from an element:

To remove a single class to an element, without affecting other potential classes, a simple regex replace is required:

document.getElementById("MyElement").className =
   document.getElementById("MyElement").className.replace
      ( /(?:^|\s)MyClass(?!\S)/g , '' )
/* Code wrapped for readability - above is all one statement */

An explanation of this regex is as follows:

(?:^|\s) # Match the start of the string, or any single whitespace character

MyClass  # The literal text for the classname to remove

(?!\S)   # Negative lookahead to verify the above is the whole classname
         # Ensures there is no non-space character following
         # (i.e. must be end of string or a space)

The g flag tells the replace to repeat as required, in case the class name has been added multiple times.

To check if a class is already applied to an element:

The same regex used above for removing a class can also be used as a check as to whether a particular class exists:

if ( document.getElementById("MyElement").className.match(/(?:^|\s)MyClass(?!\S)/) )


Assigning these actions to onclick events:

Whilst it is possible to write JavaScript directly inside the HTML event attributes (such as onclick="this.className+=' MyClass'") this is not recommended behaviour. Especially on larger applications, more maintainable code is achieved by separating HTML markup from JavaScript interaction logic.

The first step to achieving this is by creating a function, and calling the function in the onclick attribute, for example:

<script type="text/javascript">
    function changeClass()
    {
        // Code examples from above
    }
</script>
...
<button onclick="changeClass()">My Button</button>

(It is not required to have this code in script tags, this is simply for brevity of example, and including the JavaScript in a distinct file may be more appropriate.)

The second step is to move the onclick event out of the HTML and into JavaScript, for example using addEventListener

<script type="text/javascript">
    function changeClass()
    {
        // Code examples from above
    }

    window.onload = function()
    {
        document.getElementById("MyElement").addEventListener( 'click', changeClass);
    }
</script>
...
<button id="MyElement">My Button</button>

(Note that the window.onload part is required so that the contents of that function are executed after the HTML has finished loading - without this, the MyElement might not exist when the JavaScript code is called, so that line would fail.)


JavaScript Frameworks and Libraries

The above code is all in standard JavaScript, however it is common practise to use either a framework or a library to simplify common tasks, as well as benefit from fixed bugs and edge cases that you might not think of when writing your code.

Whilst some people consider it overkill to add a ~50 KB framework for simply changing a class, if you are doing any substantial amount of JavaScript work, or anything that might have unusual cross-browser behaviour, it is well worth considering.

(Very roughly, a library is a set of tools designed for a specific task, whilst a framework generally contains multiple libraries and performs a complete set of duties.)

The examples above have been reproduced below using jQuery, probably the most commonly used JavaScript library (though there are others worth investigating too).

(Note that $ here is the jQuery object.)

Changing Classes with jQuery:

$('#MyElement').addClass('MyClass');

$('#MyElement').removeClass('MyClass');

if ( $('#MyElement').hasClass('MyClass') )

In addition, jQuery provides a shortcut for adding a class if it doesn't apply, or removing a class that does:

$('#MyElement').toggleClass('MyClass');


Assigning a function to a click event with jQuery:

$('#MyElement').click(changeClass);

or, without needing an id:

$(':button:contains(My Button)').click(changeClass);


86 upvote
  flag
Great answer Peter. One question... why is it better to do with with JQuery than Javascript? JQuery is great, but if this is all you need to do - what justifies including the entire JQuery libray instead of a few lines of JavaScript? – mattstuehler
16 upvote
  flag
@mattstuehler 1) the phrase "better yet x" often means "better yet (you can) x". 2) To get to the heart of the matter, jQuery is designed to aid in accessing/manipulating the DOM, and very often if you need to do this sort of thing once you have to do it all over the place. – Barry
4 upvote
  flag
Be ware of that in case of Add Class Name there MUSt be White Space in front of the Class Name you want to add. – didxga
1 upvote
  flag
if you add a class does the previous class get removed, or you have to do that manually? – Gabor Magyar
1 upvote
  flag
Previous classes will stay. You'll have to remove other classes manually if you want to do that. – Micharch54
23 upvote
  flag
One bug with this solution: When you click on your button multiple times, it will add the Class of " MyClass" to the element multiple times, rather than checking to see if it already exists. Thus you could end up with an HTML class attribute looking something like this: class="button MyClass MyClass MyClass" – Web_Designer
9 upvote
  flag
I guess the solution to that would be: if ( ! document.getElementById("MyElement").className.match(/(?:^|\‌​s)MyClass(?!\S)/) ) or, with jQuery: if ( ! $j('#MyElement').hasClass('MyClass') ) (although I suspect addClass wont add duplicates?) – Peter Boughton
27 upvote
  flag
If you're trying to remove a class 'myClass' and you have a class 'prefix-myClass' the regex you gave above for removing a class will leave you with 'prefix-' in your className :O – jinglesthula
11 upvote
  flag
Wow, three years and 183 upvotes and nobody spotted that until now. Thanks jinglesthula, I've corrected the regex so it wont incorrectly remove parts of class names. // I guess this is a good example of why a Framework (like jQuery) is worth using - bugs like this are caught and fixed sooner, and don't require changes to normal code. – Peter Boughton
2 upvote
  flag
I've done some minor edits to improve the answer - hopefully people agree they are improvements? If there's anything else I've missed let me know (or just edit the answer yourself). – Peter Boughton
2 upvote
  flag
@PeterBoughton Not sure if you think this is an improvement, but I like: (' '+document.getElementById("MyElement").className+' ').replace( ' '+MyClass+' ' , '' ) – Paulpro
1 upvote
  flag
@PaulP.R.O. you are collapsing the surrounding spaces and regex to a null, which will concatenate the surrounding class name strings (if any) together. I think elem.className = elem.className.replace( ' ' + classname + ' ' , ' ' ) is what we want. Thanks! – Cris Stringfellow
2 upvote
  flag
I use similar methods, but with a g (general) regex. the reason is exactly the issue described by @Web_Designer above: if the user clicks several times, you end up with multiple instances of the same class, and all instances must be removed to remove the class. – Christophe
1 upvote
  flag
Importing an entire library to accomplish one, simple task is precisely why there is so much overhead drifting around the internet. So I disagree that resorting to JQuery is the "better" solution. – b1nary.atr0phy
3 upvote
  flag
I have just made substantial additions to this answer - the bulk is the same, but I would appreciate feedback on if there's any mistakes or places for further improvement. – Peter Boughton
4 upvote
  flag
When creating the regex with a variable for the class name I had to look up the syntax: var regExp = new RegExp('(?:^|\\s)' + classToAddOrRemove + '(?!\\S)', 'g'); – Sprockincat
1 upvote
  flag
This has got to be the most complete answer to just about any question on StackOverflow. Great job! – ChronoFish
2 upvote
  flag
One important detail missing here is the difference between framework and library. jQuery is a library, not a framework. Just for the safe of the example, a framework would be angularJs, for example. – brunoais
2 upvote
  flag
(You can specify a space-delimited list of elements.) You must mean a list of classes to assign, not elements to select. – DrJonOsterman
upvote
  flag
Really excellent answer that fails completely to answer the OP's question: how do you change the value of an existing class? – Peter Flynn
1 upvote
  flag
If it doesn't answer the OP's question, why did they mark it as the solution? Your question appears to be a different one (possibly you want to change the CSS properties/declarations linked to a class name? not sure if browsers allow that) - why not clarify what you're after in a new question which explains precisely what you want / are trying to achieve? – Peter Boughton
upvote
  flag
With regards to the "To add an additional class to an element" point (2nd in list), I find it's best to grab the current el.className, string concat with " class-to-add", and finally call a .trim() on the string before updating the target element. That said, I don't think CSS really cares about the \s, an element's individual classes are determined by a space-separated list anyway. – ZaLiTHkA
upvote
  flag
heh: var a=[];e.className=((a=e.className.split(" ")).splice(a.indexOf(oldClass),1,newClass)&&a).join(" ").trim(); :D – Duncan
upvote
  flag
Can you please rearrange things? In my opinion the classList with shim for browser support should be at the top. – Marcel Burkhard
1 upvote
  flag
would b cool if smth like this worked too, to remove a class name: document.getElementById("MyElement").className -= " MyClass"; – Nick Humphrey
1 upvote
  flag
so the answer simply is $('#MyElement').toggleClass('MyClass'); thanks, It works for me – shady sherif
upvote
  flag
Hello there. I was wondering what you would say about using word boundaries instead of (?:\s) at the beginning and (?!\S) near the end of your regular expression. Comments? document.getElementById("MyElement").className.replace( /\bMyClass\b/g , '' ). I never seem to have reason to use many of the regular expression short cuts, but this seems (seems) like it could work too. Although, \b has limits on what it considers to be a word character, and you never know what someone might use as a class name. – Anthony Rutledge
2 upvote
  flag
\b matches next to hyphens. – Peter Boughton
upvote
  flag
There are faster methods than removing class using RegExp, especially if you're going to turn it into a polyfill. See jsperf.com/removeclass-methods – 10basetom
upvote
  flag
The code in the To remove a class from an element: and To check if a class is already applied to an element: sections are missing ; from the end of the line. Is there a reason for this? It would also be nice if there was a note in To remove a class from an element: indicating what happens to spaces. Otherwise, this is a very good answer. – Trisped
upvote
  flag
I would prefer (^start(\s+start)*\s*)|((?:\s+)start(?!\S+)) to remove the word start from a whitespace-separeted list. – Andreas Dyballa
upvote
  flag
Angular: angular.element(document.getElementById("MyElement")).remove‌​Class("class-name"); angular.element(document.getElementById("MyElement")).addCla‌​ss("class-name") – Zymotik
upvote
  flag
Hi this is very nice answer. I want change class on some condition on loading html not click event on button. please refer to this question: //allinonescript.com/questions/38028756/… – pankaj
upvote
  flag
Your method for removing a class almost takes care of removing extra spaces that may appear after removing items. But it can happen that the result will start with a leading space. If you add a .trim(), your method for removing a class will not contain any extra spaces. – rosell.dk
upvote
  flag
Also, you can safely remove the "?:" in the beginning of the RegEx, such that it reads: new RegExp​("​(\\s|^​)"+className+"​(?!\\S​)","g"​) – rosell.dk
upvote
  flag
I have created an extensive test of alternatives for removing a class name. Your solution is in the test. The test is available here – rosell.dk
1 upvote
  flag
Comment of @Sprockincat must be included as part of such an elaborate answer. Thanks #Sprockincat.... Though its not recommended to say Thanks in comments ;-) – nagu
upvote
  flag
very good job & great talk! learn by analogy – xgqfrms
upvote
  flag
@Zymotik you may want to add another separate answer instead of editing someone else's answer. It's a helpful snippet but it should be it's own answer. – TankorSmash
upvote
  flag

The line

document.getElementById("MyElement").className = document.getElementById("MyElement").className.replace(/\bMyClass\b/','')

should be:

document.getElementById("MyElement").className = document.getElementById("MyElement").className.replace('/\bMyClass\b/','');
8 upvote
  flag
Incorrect. The RegEx is delimeted by the forward slashes. Adding quotes causes it to fail in IE, returning the string of the class you're trying to remove rather than actually removing the class. – Dylan

Change an element's CSS class with JavaScript in ASP.NET:

Protected Sub Page_Load(ByVal sender As Object, ByVal e As System.EventArgs) Handles Me.Load
    If Not Page.IsPostBack Then
        lbSave.Attributes.Add("onmouseover", "this.className = 'LinkButtonStyle1'")
        lbSave.Attributes.Add("onmouseout", "this.className = 'LinkButtonStyle'")
        lbCancel.Attributes.Add("onmouseover", "this.className = 'LinkButtonStyle1'")
        lbCancel.Attributes.Add("onmouseout", "this.className = 'LinkButtonStyle'")
    End If
End Sub
42 upvote
  flag
I knew there was a reason I hated working with ASP.NET. – iandisme

In one of my old projects that did not use jQuery, I built the following functions for adding, removing, and checking if element has class:

function hasClass(ele, cls) {
    return ele.className.match(new RegExp('(\\s|^)' + cls + '(\\s|$)'));
}
function addClass(ele, cls) {
    if (!hasClass(ele, cls)) ele.className += " " + cls;
}
function removeClass(ele, cls) {
    if (hasClass(ele, cls)) {
        var reg = new RegExp('(\\s|^)' + cls + '(\\s|$)');
        ele.className = ele.className.replace(reg, ' ');
    }
}

So, for example, if I want onclick to add some class the the button I can use this:

<script type="text/javascript">
    function changeClass(btn, cls) {
        if(!hasClass(btn, cls)) {
            addClass(btn, cls);
        }
    }
</script>
...
<button onclick="changeClass(this, "someClass")">My Button</button>

By now for sure it would just better to use jQuery.

8 upvote
  flag
This is great for when your client doesn't let you use jQuery. (Cause you end up almost building your own library.) – Mike
1 upvote
  flag
@Mike If the client doesn't let you use jQuery, could you not just go through and rebuild only the features you needed into your own library? – kfrncs
4 upvote
  flag
@kfrncs Because I don't generally need that large of a framework. For the project I was thinking of, the only functions I needed were the 3 classname(has,add,remove) functions and the cookie(has, add, remove) functions. Everything else was either custom, or natively well supported. So everything together was then only 150 lines before minifying, including comments. – Mike
1 upvote
  flag
Dude, its 4am and thank you much. Vanilla JS is what we're use on my project and this was a life saver. – LessQuesar
upvote
  flag
This is my favorite solution for this. I use it everywhere. I believe it is the most elegant way to achieve adding and removing classes when your project does not already have another way of doing it. – WebWanderer
upvote
  flag
It should be noted that after using addClass and removeClass on the same element, the element's className will contain an additional space. The className modifying line of removeClass should be updated to ele.className = ele.className.replace(reg, ' ').trim().replace(/\s{2,}/g, ' ');. This removes trailing whitespace left over and collapses multiple whitespaces into a single space in the className. – WebWanderer

You could also just do:

document.getElementById('id').classList.add('class');
document.getElementById('id').classList.remove('class');

And to toggle a class (remove if exists else add it):

document.getElementById('id').classList.toggle('class');
60 upvote
  flag
I believe this is HTML5 dependent. – John
11 upvote
  flag
You’ll need Eli Grey’s classList shim. – ELLIOTTCABLE
43 upvote
  flag
worth noting this doesn't work in IE versions less than 8.. – Lloyd
15 upvote
  flag
Mozilla Developer Network states that it doesn't work, natively, in Internet Explorers less than 10. I find the statement to be true, in my testing. Apparently, the Eli Grey shim is required for Internet Explorer 8-9. Unfortunately, I couldn't find it on his site (even with searching). The shim is available on the Mozilla link. – doubleJ
upvote
  flag
Feature not supported until a few hours ago (added on IE10 and Android 3) – andreszs
1 upvote
  flag
4 upvote
  flag
atow "classList" has partial support in IE10+; no support for Opera Mini; else full support in remaining standard browsers: caniuse.com/#search=classlist – Nick Humphrey
upvote
  flag
I think the Eli Grey shim can be found here... – Wilf
upvote
  flag
i love how little u made me read – Squirrl

Using pure JavaScript code:

function hasClass(ele, cls) {
    return ele.className.match(new RegExp('(\\s|^)' + cls + '(\\s|$)'));
}

function addClass(ele, cls) {
    if (!this.hasClass(ele, cls)) ele.className += " " + cls;
}

function removeClass(ele, cls) {
    if (hasClass(ele, cls)) {
        var reg = new RegExp('(\\s|^)' + cls + '(\\s|$)');
        ele.className = ele.className.replace(reg, ' ');
    }
}

function replaceClass(ele, oldClass, newClass){
    if(hasClass(ele, oldClass)){
        removeClass(ele, oldClass);
        addClass(ele, newClass);
    }
    return;
}

function toggleClass(ele, cls1, cls2){
    if(hasClass(ele, cls1)){
        replaceClass(ele, cls1, cls2);
    }else if(hasClass(ele, cls2)){
        replaceClass(ele, cls2, cls1);
    }else{
        addClass(ele, cls1);
    }
}

Just to add on information from another popular framework, Google Closures, see their dom/classes class:

goog.dom.classes.add(element, var_args)

goog.dom.classes.addRemove(element, classesToRemove, classesToAdd)

goog.dom.classes.remove(element, var_args)

One option for selecting the element is using goog.dom.query with a CSS3 selector:

var myElement = goog.dom.query("#MyElement")[0];

This is working for me:

function setCSS(eleID) {
    var currTabElem = document.getElementById(eleID);

    currTabElem.setAttribute("class", "some_class_name");
    currTabElem.setAttribute("className", "some_class_name");
}
upvote
  flag
Excellent answer! Just left to add : Set for each CSS class name for selector to specify a style for a group of class elements – Roman Polen.
upvote
  flag
This works for me on FF, but when I've tried to use el.className = "newStyle"; it didn't worked, why? – Lukasz 'Severiaan' Grela
upvote
  flag
You can use el.setAttribute('class', newClass) or better el.className = newClass. But not el.setAttribute('className', newClass). – Oriol

Wow, surprised there are so many overkill answers here...

<div class="firstClass" onclick="this.className='secondClass'">
20 upvote
  flag
yes, but unobtrusive javascript is better practice.. – Lloyd
13 upvote
  flag
I would say unobtrusive javascript is terrible practice for writing example code... – Gabe
19 upvote
  flag
I would disagree, because I think example code should set a good example. – thomasrutter
1 upvote
  flag
A good example should instruct and spark the imagination at the same time. It should not replace thought, but inspire it. – Anthony Rutledge
3 upvote
  flag
The other answers aren't overkill, they also keep existing classes on the element. – gcampbell

A couple of minor notes and tweaks on the previous regexes:

You'll want to do it globally in case the class list has the class name more than once. And, you'll probably want to strip spaces from the ends of the class list and convert multiple spaces to one space to keep from getting runs of spaces. None of these things should be a problem if the only code dinking with the class names uses the regex below and removes a name before adding it. But. Well, who knows who might be dinking with the class name list.

This regex is case insensitive so that bugs in class names may show up before the code is used on a browser that doesn't care about case in class names.

var s = "testing   one   four  one  two";
var cls = "one";
var rg          = new RegExp("(^|\\s+)" + cls + "(\\s+|$)", 'ig');
alert("[" + s.replace(rg, ' ') + "]");
var cls = "test";
var rg          = new RegExp("(^|\\s+)" + cls + "(\\s+|$)", 'ig');
alert("[" + s.replace(rg, ' ') + "]");
var cls = "testing";
var rg          = new RegExp("(^|\\s+)" + cls + "(\\s+|$)", 'ig');
alert("[" + s.replace(rg, ' ') + "]");
var cls = "tWo";
var rg          = new RegExp("(^|\\s+)" + cls + "(\\s+|$)", 'ig');
alert("[" + s.replace(rg, ' ') + "]");

I would use jQuery and write something like this:

jQuery(function($) {
    $("#some-element").click(function() {
        $(this).toggleClass("clicked");
    });
});

This code adds a function to be called when an element of the id some-element is clicked. The function appends clicked to the element's class attribute if it's not already part of it, and removes it if it's there.

Yes you do need to add a reference to the jQuery library in your page to use this code, but at least you can feel confident the most functions in the library would work on pretty much all the modern browsers, and it will save you time implementing your own code to do the same.

Thanks

8 upvote
  flag
You only have to write jQuery in its long form once. jQuery(function($) { }); makes $ available inside the function in all cases. – ThiefMaster

Here's my version, fully working:

function addHTMLClass(item, classname) {
    var obj = item
    if (typeof item=="string") {
        obj = document.getElementById(item)
    }
    obj.className += " " + classname
}

function removeHTMLClass(item, classname) {
    var obj = item
    if (typeof item=="string") {
        obj = document.getElementById(item)
    }
    var classes = ""+obj.className
    while (classes.indexOf(classname)>-1) {
        classes = classes.replace (classname, "")
    }
    obj.className = classes
}

Usage:

<tr onmouseover='addHTMLClass(this,"clsSelected")'
onmouseout='removeHTMLClass(this,"clsSelected")' >
4 upvote
  flag
That will break class foobar if you try to remove class foo. The JS in the intrinsic event handler attributes was broken before being edited. The 4 year old accepted answer is much better. – Quentin
1 upvote
  flag
thanks, i fixed it (not the prefix problem). it's the old accepted answer that have a bug with the regexp. – alfred
upvote
  flag
The code still have the foobar problem. See the test here – rosell.dk

As well you could extend HTMLElement object, in order to add methods to add, remove, toggle and check classes (gist):

HTMLElement = typeof(HTMLElement) != 'undefiend' ? HTMLElement : Element;

HTMLElement.prototype.addClass = function(string) {
  if (!(string instanceof Array)) {
    string = string.split(' ');
  }
  for(var i = 0, len = string.length; i < len; ++i) {
    if (string[i] && !new RegExp('(\\s+|^)' + string[i] + '(\\s+|$)').test(this.className)) {
      this.className = this.className.trim() + ' ' + string[i];
    }
  }
}

HTMLElement.prototype.removeClass = function(string) {
  if (!(string instanceof Array)) {
    string = string.split(' ');
  }
  for(var i = 0, len = string.length; i < len; ++i) {
    this.className = this.className.replace(new RegExp('(\\s+|^)' + string[i] + '(\\s+|$)'), ' ').trim();
  }
}

HTMLElement.prototype.toggleClass = function(string) {
  if (string) {
    if (new RegExp('(\\s+|^)' + string + '(\\s+|$)').test(this.className)) {
      this.className = this.className.replace(new RegExp('(\\s+|^)' + string + '(\\s+|$)'), ' ').trim();
    } else {
      this.className = this.className.trim() + ' ' + string;
    }
  }
}

HTMLElement.prototype.hasClass = function(string) {
  return string && new RegExp('(\\s+|^)' + string + '(\\s+|$)').test(this.className);
}

And then just use like this (on click will add or remove class):

document.getElementById('yourElementId').onclick = function() {
  this.toggleClass('active');
}

Here is demo.

1 upvote
  flag
this one is a little verbose...here is a very succinct solution...jsfiddle.net/jdniki/UaT3P – zero_cool
5 upvote
  flag
Sorry @Jackson_Sandland but you've totally missed the point, which is not to use jQuery at all. – moka

I use the following vanilla JavaScript functions in my code. They use regular expressions and indexOf but do not require quoting special characters in regular expressions.

function addClass(el, cn) {
    var c0 = (" " + el.className + " ").replace(/\s+/g, " "),
        c1 = (" " + cn + " ").replace(/\s+/g, " ");
    if (c0.indexOf(c1) < 0) {
        el.className = (c0 + c1).replace(/\s+/g, " ").replace(/^ | $/g, "");
    }
}

function delClass(el, cn) {
    var c0 = (" " + el.className + " ").replace(/\s+/g, " "),
        c1 = (" " + cn + " ").replace(/\s+/g, " ");
    if (c0.indexOf(c1) >= 0) {
        el.className = c0.replace(c1, " ").replace(/\s+/g, " ").replace(/^ | $/g, "");
    }
}

You can also use element.classList in modern browsers.

Here is simple jQuery code to do that.

$(".class1").click(function(argument) {
    $(".parentclass").removeClass("classtoremove");
    setTimeout(function (argument) {
        $(".parentclass").addClass("classtoadd");
    }, 100);
});

Here,

  • Class1 is a listener for an event.
  • The parent class is the class which hosts the class you want to change
  • Classtoremove is the old class you have.
  • Class to add is the new class that you want to add.
  • 100 is the timeout delay during which the class is changed.

Good Luck.

Just thought I'd throw this in:

function inArray(val, ary){
  for(var i=0,l=ary.length; i<l; i++){
    if(ary[i] === val){
      return true;
    }
  }
  return false;
}
function removeClassName(classNameS, fromElement){
  var x = classNameS.split(/\s/), s = fromElement.className.split(/\s/), r = [];
  for(var i=0,l=s.length; i<l; i++){
    if(!iA(s[i], x))r.push(s[i]);
  }
  fromElement.className = r.join(' ');
}
function addClassName(classNameS, toElement){
  var s = toElement.className.split(/\s/);
  s.push(c); toElement.className = s.join(' ');
}

Here's a toggleClass to toggle/add/remove a class on an element:

// If newState is provided add/remove theClass accordingly, otherwise toggle theClass
function toggleClass(elem, theClass, newState) {
    var matchRegExp = new RegExp('(?:^|\\s)' + theClass + '(?!\\S)', 'g');
    var add=(arguments.length>2 ? newState : (elem.className.match(matchRegExp) == null));

    elem.className=elem.className.replace(matchRegExp, ''); // clear all
    if (add) elem.className += ' ' + theClass;
}

see jsfiddle

also see my answer here for creating a new class dynamically

Change an element's class in vanilla JavaScript with IE6 support

You may try to use node attributes property to keep compatibility with old browsers even IE6:

function getClassNode(element) {
  for (var i = element.attributes.length; i--;)
    if (element.attributes[i].nodeName === 'class')
      return element.attributes[i];
}

function removeClass(classNode, className) {
  var index, classList = classNode.value.split(' ');
  if ((index = classList.indexOf(className)) > -1) {
    classList.splice(index, 1);
    classNode.value = classList.join(' ');
  }
}

function hasClass(classNode, className) {
  return classNode.value.indexOf(className) > -1;
}

function addClass(classNode, className) {
  if (!hasClass(classNode, className))
    classNode.value += ' ' + className;
}

document.getElementById('message').addEventListener('click', function() {
  var classNode = getClassNode(this);
  var className = hasClass(classNode, 'red') && 'blue' || 'red';

  removeClass(classNode, 'red');
  removeClass(classNode, 'blue');

  addClass(classNode, className);
})
.red {
  color: red;
}
.red:before {
  content: 'I am red! ';
}
.red:after {
  content: ' again';
}
.blue {
  color: blue;
}
.blue:before {
  content: 'I am blue! '
}
<span id="message" class="">Click me</span>

Working JavaScript code:

<div id="div_add" class="div_add">Add class from Javascript</div>
<div id="div_replace" class="div_replace">Replace class from Javascript</div>
<div id="div_remove" class="div_remove">Remove class from Javascript</div>
<button onClick="div_add_class();">Add class from Javascript</button>
<button onClick="div_replace_class();">Replace class from Javascript</button>
<button onClick="div_remove_class();">Remove class from Javascript</button>
<script type="text/javascript">
    function div_add_class()
    {
        document.getElementById("div_add").className += " div_added";
    }
    function div_replace_class()
    {
        document.getElementById("div_replace").className = "div_replaced";
    }
    function div_remove_class()
    {
        document.getElementById("div_remove").className = "";
    }
</script>

You can download a working code from this link.

1 upvote
  flag
This will break elements with more than one class. – gcampbell

This is nice one that I found helpful.

function classChangeFn() {
        document.getElementById("MyElement").className = "";
    }

window.onload = function(){
        document.getElementById("MyElement").addEventListener( 'click' , classChangeFn );
    }

It can be done.

HTML:

<div class="red" id="text">
<a href="#" onclick="changeClass();">Fahad</a>
</div>

CSS:

.red a{
  color:red;
}
.black a{
  color:black;
}

JavaScript:

function changeClass(){
document.getElementById("text").className = "black";
}

Fiddle.

After a long search i found the best class management solution without the document.getElementById()

var els = [].slice.apply(document.getElementsByClassName("no-js"));
for (var i = 0; i < els.length; i++) {
    els[i].className = els[i].className.replace(/ *\bno-js\b/g, "js");
}

The original place of solution: //allinonescript.com/a/8708944/1589669

just say myElement.classList="new-class" unless you need to maintain other existing classes in which case you can use the classList.add, .remove methods.

var doc = document;
var divOne = doc.getElementById("one");
var goButton = doc.getElementById("go");

goButton.addEventListener("click", function() {
  divOne.classList="blue";
});
div{
  min-height:48px;
  min-width:48px;
}
.bordered{
  border: 1px solid black;
}
.green{
  background:green;
}
.blue{
  background: blue;
}
<button id="go">Change Class</button>

<div id="one" class="bordered green">

</div>

OK, I think in this case you should use jQuery or write your own Methods in pure javascript, my preference is adding my own methods rather than injecting all jQuery to my application if I don't need that for other reasons.

I'd like to do something like below as methods to my javascript framework to add few functionalities which handle adding classes, deleting classes, etc similar to jQuery, this is fully supported in IE9+, also my code is written in ES6, so you need to make sure your browser support it or you using something like babel, otherwise need to use ES5 syntax in your code, also in this way, we finding element via ID, which means the element needs to have an ID to be selected:

//simple javascript utils for class management in ES6
var classUtil = {

  addClass: (id, cl) => {
    document.getElementById(id).classList.add(cl);
  },

  removeClass: (id, cl) => {
    document.getElementById(id).classList.remove(cl);
  },

  hasClass: (id, cl) => {
    return document.getElementById(id).classList.contains(cl);
  },

  toggleClass: (id, cl) => {
    document.getElementById(id).classList.toggle(cl);
  }

}

and you can simply call use them as below, imagine your element has id of 'id' and class of 'class', make sure you pass them as a string, you can use the util as below:

classUtil.addClass('myId', 'myClass');
classUtil.removeClass('myId', 'myClass');
classUtil.hasClass('myId', 'myClass');
classUtil.toggleClass('myId', 'myClass');

If you want to remove a class, you can do:

ELEMENT.classList.remove("CLASS_NAME");

To add a class:

ELEMENT.classList.add('CLASS_NAME');

From here : https://developer.mozilla.org/en-US/docs/Web/API/Element/classList

On click action, You can try using:

replace( oldClass, newClass )
Replaces an existing class with a new class.

Ex:

var myDiv = document.getElementById('myElement'); 
myDiv.classList.contains('myCssClass');
myDiv.classList.replace("myCssClass", "myCssClass_new");

Not the answer you're looking for? Browse other questions tagged or ask your own question.