Come posso cambiare la classe di un elemento con JavaScript?


2776

Come posso cambiare una classe di un elemento HTML in risposta a un onclickevento usando JavaScript?


28
"L'attributo class viene utilizzato principalmente per indicare una classe in un foglio di stile. Tuttavia, può anche essere utilizzato da un JavaScript (tramite il DOM HTML) per apportare modifiche agli elementi HTML con una classe specificata." - w3schools.com/tags/att_standard_class.asp
Triynko

11
element.setAttribute(name, value); Sostituisci namecon class. Sostituisci valuecon qualsiasi nome tu abbia dato la classe, racchiuso tra virgolette. Questo evita la necessità di eliminare la classe corrente e di aggiungerne una diversa. Questo esempio di jsFiddle mostra il codice di lavoro completo.
Alan Wells,

3
Per cambiare una classe di elementi HTML con onClick usa questo codice: <input type='button' onclick='addNewClass(this)' value='Create' /> e nella sezione javascript: function addNewClass(elem){ elem.className="newClass";} Online
Iman Bahrampour,

@Triynko - quel link su w3schools è cambiato, sembra nel settembre 2012. Ecco quella pagina su Archive.org dal 12 settembre 2012: classe HTML Attribute-w3schools . Ecco il link per la pagina di sostituzione su w3schools.com: classe HTML Attribute-w3schools .
Kevin Fegan,

Risposte:


3881

Moderne tecniche HTML5 per cambiare classe

I browser moderni hanno aggiunto classList che fornisce metodi per semplificare la manipolazione delle classi senza la necessità di una libreria:

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');

Sfortunatamente, questi non funzionano in Internet Explorer prima della v10, anche se esiste uno shim per aggiungere supporto a IE8 e IE9, disponibili da questa pagina . Tuttavia, sta diventando sempre più supportato .

Semplice soluzione cross-browser

Sta usando il modo JavaScript standard per selezionare un elemento document.getElementById("Id"), che è quello che usano i seguenti esempi - puoi ovviamente ottenere elementi in altri modi, e nella giusta situazione puoi semplicemente usare thisinvece - entrare in dettaglio su questo è al di là dell'ambito della risposta.

Per modificare tutte le classi per un elemento:

Per sostituire tutte le classi esistenti con una o più nuove classi, imposta l'attributo className:

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

(È possibile utilizzare un elenco delimitato da spazi per applicare più classi.)

Per aggiungere una classe aggiuntiva a un elemento:

Per aggiungere una classe a un elemento, senza rimuovere / influire sui valori esistenti, aggiungi uno spazio e il nuovo nome classe, in questo modo:

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

Per rimuovere una classe da un elemento:

Per rimuovere una singola classe in un elemento, senza influire su altre potenziali classi, è necessaria una semplice sostituzione regex:

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

Una spiegazione di questa regex è la seguente:

(?:^|\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)

Il gflag indica al sostituto di ripetere come richiesto, nel caso in cui il nome della classe sia stato aggiunto più volte.

Per verificare se una classe è già applicata a un elemento:

Lo stesso regex usato sopra per la rimozione di una classe può anche essere usato come controllo dell'esistenza di una determinata classe:

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


Assegnando queste azioni agli eventi onclick:

Sebbene sia possibile scrivere JavaScript direttamente all'interno degli attributi dell'evento HTML (come onclick="this.className+=' MyClass'"), questo non è un comportamento raccomandato. Soprattutto su applicazioni più grandi, si ottiene un codice più gestibile separando il markup HTML dalla logica di interazione JavaScript.

Il primo passo per raggiungere questo obiettivo è creare una funzione e chiamare la funzione nell'attributo onclick, ad esempio:

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

(Non è necessario avere questo codice nei tag di script, questo è semplicemente per brevità di esempio, e includere JavaScript in un file distinto potrebbe essere più appropriato.)

Il secondo passo è spostare l'evento onclick fuori dall'HTML e in JavaScript, ad esempio usando 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>

(Si noti che la parte window.onload è necessaria in modo che il contenuto di quella funzione venga eseguito dopo che il caricamento del codice HTML è terminato - senza questo, MyElement potrebbe non esistere quando viene chiamato il codice JavaScript, quindi quella riga non avrebbe esito positivo.)


Framework e librerie JavaScript

Il codice sopra è tutto in JavaScript standard, tuttavia è pratica comune utilizzare un framework o una libreria per semplificare le attività comuni, oltre a beneficiare di bug fissi e casi limite che potresti non pensare quando scrivi il tuo codice.

Mentre alcune persone considerano eccessivo l'aggiunta di un framework di ~ 50 KB per la semplice modifica di una classe, se si sta eseguendo una quantità sostanziale di lavoro JavaScript o qualcosa che potrebbe avere un comportamento insolito tra i browser, vale la pena prendere in considerazione.

(Molto approssimativamente, una libreria è un insieme di strumenti progettati per un'attività specifica, mentre un framework generalmente contiene più librerie ed esegue una serie completa di compiti.)

Gli esempi sopra sono stati riprodotti di seguito usando jQuery , probabilmente la libreria JavaScript più comunemente usata (anche se ce ne sono altri che vale la pena indagare).

(Nota che $qui è l'oggetto jQuery.)

Modifica delle classi con jQuery:

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

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

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

Inoltre, jQuery fornisce un collegamento per aggiungere una classe se non si applica o rimuovere una classe che fa:

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


Assegnare una funzione a un evento click con jQuery:

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

o, senza bisogno di un ID:

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



105
Ottima risposta Peter. Una domanda ... perché è meglio avere a che fare con JQuery che Javascript? JQuery è fantastico, ma se questo è tutto ciò che devi fare - cosa giustifica l'inclusione dell'intera libray JQuery invece di alcune righe di JavaScript?
mattstuehler,

23
@mattstuehler 1) la frase "meglio ancora x" spesso significa "meglio ancora (puoi) x". 2) Per arrivare al nocciolo della questione, jQuery è progettato per aiutare ad accedere / manipolare il DOM e molto spesso se è necessario fare questo genere di cose una volta che lo si deve fare ovunque.
Barry,

31
Un bug con questa soluzione: quando si fa clic più volte sul pulsante, verrà aggiunta più volte la classe di "MyClass" all'elemento, anziché verificare se esiste già. Quindi potresti finire con un attributo di classe HTML simile a questo:class="button MyClass MyClass MyClass"
Web_Designer,

35
Se stai cercando di rimuovere una classe 'myClass' e hai una classe 'prefix-myClass', la regex che hai dato sopra per rimuovere una classe ti lascerà con 'prefisso-' nella tua
classe Nome

16
Wow, tre anni e 183 voti positivi e nessuno l'ha notato fino ad ora. Grazie jinglesthula, ho corretto il regex in modo che non rimuova erroneamente parti dei nomi delle classi. // Immagino che questo sia un buon esempio del motivo per cui vale la pena usare un Framework (come jQuery): bug come questo vengono individuati e corretti prima e non richiedono modifiche al codice normale.
Peter Boughton,

422

Potresti anche solo fare:

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

E per attivare / disattivare una classe (rimuovi se esiste altrimenti aggiungila):

document.getElementById('id').classList.toggle('class');

63
Credo che questo dipenda da HTML5.
Giovanni,

12
Avrai bisogno dello classListspessore di Eli Grey .
ELLIOTTCABLE

15
Mozilla Developer Network afferma che non funziona, in modo nativo, in Internet Explorer meno di 10. Trovo che l'affermazione sia vera, nei miei test. Apparentemente, lo spessore di Eli Grey è richiesto per Internet Explorer 8-9. Purtroppo, non sono riuscito a trovarlo sul suo sito (anche con la ricerca). Lo spessore è disponibile sul collegamento Mozilla.
doppioJ


4
atow "classList" ha un supporto parziale in IE10 +; nessun supporto per Opera Mini; altro pieno supporto nei restanti browser standard: caniuse.com/#search=classlist
Nick Humphrey

119

In uno dei miei vecchi progetti che non utilizzavano jQuery, ho creato le seguenti funzioni per aggiungere, rimuovere e verificare se l'elemento ha classe:

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, ' ');
    }
}

Quindi, ad esempio, se voglio onclickaggiungere un po 'di classe al pulsante, posso usare questo:

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

Ormai sicuramente sarebbe meglio usare jQuery.


8
Questo è ottimo per quando il tuo client non ti consente di usare jQuery. (Perché finisci quasi per costruire la tua biblioteca.)
Mike

1
@Mike Se il client non ti consente di utilizzare jQuery, non potresti semplicemente esaminare e ricostruire solo le funzionalità necessarie nella tua libreria?
kfrncs,

5
@kfrncs Perché generalmente non ho bisogno di una struttura così grande. Per il progetto a cui stavo pensando, le uniche funzioni di cui avevo bisogno erano le 3 funzioni classname (ha, aggiungi, rimuovi) e le funzioni cookie (ha, aggiungi, rimuovi). Tutto il resto era personalizzato o nativamente ben supportato. Quindi tutto insieme era solo 150 righe prima di essere minimizzato, inclusi i commenti.
Mike,

2
Amico, sono le 4 del mattino e grazie mille. Vanilla JS è ciò che usiamo nel mio progetto e questo è stato un salvavita.
LessQuesar,

Questa è la mia soluzione preferita per questo. Lo uso ovunque. Credo che sia il modo più elegante per ottenere l'aggiunta e la rimozione di classi quando il tuo progetto non ha già un altro modo di farlo.
WebWanderer,

77

Puoi usare node.classNamecosì:

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

Questo dovrebbe funzionare in IE5.5 e versioni successive secondo PPK .


11
questo sovrascriverebbe tutte le altre classi sull'oggetto ... quindi non è così semplice.
Eric Sebasta,

51

Wow, sorpreso che ci siano così tante risposte esagerate qui ...

<div class="firstClass" onclick="this.className='secondClass'">

14
Direi che javascript discreto è una pratica terribile per scrivere un codice di esempio ...
Gabe,

22
Non sarei d'accordo, perché penso che il codice di esempio dovrebbe dare il buon esempio.
thomasrutter,

1
Un buon esempio dovrebbe istruire e stimolare l'immaginazione allo stesso tempo. Non dovrebbe sostituire il pensiero, ma ispirarlo.
Anthony Rutledge,

4
Le altre risposte non sono eccessive, ma mantengono anche le classi esistenti sull'elemento.
gcampbell,

47

Utilizzando puro codice JavaScript:

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);
    }
}

33

Questo funziona per me:

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

    currTabElem.setAttribute("class", "some_class_name");
    currTabElem.setAttribute("className", "some_class_name");
}

Risposta eccellente! Appena lasciato da aggiungere: impostare per ciascun nome di classe CSS per il selettore per specificare uno stile per un gruppo di elementi di classe
Roman Polen.

Questo funziona per me su FF, ma quando ho provato a usare el.className = "newStyle"; non ha funzionato, perché?
Lukasz 'Severiaan' Grela,

1
Puoi usare el.setAttribute('class', newClass)o meglio el.className = newClass. Ma non el.setAttribute('className', newClass).
Oriol,

20

Inoltre puoi estendere l'oggetto HTMLElement, al fine di aggiungere metodi per aggiungere, rimuovere, attivare e controllare le classi ( 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);
}

E quindi basta usare in questo modo (al clic aggiungerà o rimuoverà la classe):

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

Ecco la demo .


1
questo è un po 'prolisso ... ecco una soluzione molto concisa
zero_cool

5
Mi dispiace @Jackson_Sandland ma hai perso del tutto il punto, che non è affatto usare jQuery.
moka,

17

Solo per aggiungere informazioni da un altro framework popolare, Google Closures, vedere la loro classe dom / class:

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

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

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

Un'opzione per selezionare l'elemento è usare goog.dom.query con un selettore CSS3:

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

14

Un paio di note e modifiche minori sulle regex precedenti:

Ti consigliamo di farlo globalmente nel caso in cui l'elenco delle classi abbia il nome della classe più di una volta. E probabilmente vorrai rimuovere gli spazi dalle estremità dell'elenco delle classi e convertire più spazi in uno spazio per evitare di ottenere serie di spazi. Nessuna di queste cose dovrebbe essere un problema se l'unico codice che annulla i nomi delle classi usa la regex seguente e rimuove un nome prima di aggiungerlo. Ma. Bene, chissà chi potrebbe essere stravagante con l'elenco dei nomi delle classi.

Questa regex non fa distinzione tra maiuscole e minuscole in modo che i bug nei nomi delle classi possano essere visualizzati prima che il codice venga utilizzato su un browser a cui non interessa il caso nei nomi delle classi.

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, ' ') + "]");

13

Modifica la classe CSS di un elemento con 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

13

Vorrei usare jQuery e scrivere qualcosa del genere:

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

Questo codice aggiunge una funzione da chiamare quando si fa clic su un elemento dell'id some-element . La funzione aggiunge clic all'attributo class dell'elemento se non fa già parte di esso e lo rimuove se è presente.

Sì, è necessario aggiungere un riferimento alla libreria jQuery nella tua pagina per utilizzare questo codice, ma almeno puoi essere sicuro che la maggior parte delle funzioni nella libreria funzionerebbe praticamente su tutti i browser moderni e ti farà risparmiare tempo nell'implementazione il tuo codice per fare lo stesso.

Grazie


8
Devi solo scrivere jQuerynella sua forma lunga una volta. jQuery(function($) { });rende $disponibile all'interno della funzione in tutti i casi.
ThiefMaster,

10

La linea

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

dovrebbe essere:

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

8
Non corretto. Il RegEx è delimitato dalle barre in avanti. L'aggiunta di virgolette causa un errore in IE, restituendo la stringa della classe che si sta tentando di rimuovere anziché rimuovere effettivamente la classe.
Dylan,

9

Modifica la classe di un elemento in JavaScript vaniglia con supporto IE6

Puoi provare a usare la attributesproprietà node per mantenere la compatibilità con i vecchi browser anche 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>


8

Ecco la mia versione, perfettamente funzionante:

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
}

Uso:

<tr onmouseover='addHTMLClass(this,"clsSelected")'
onmouseout='removeHTMLClass(this,"clsSelected")' >

4
Ciò interromperà la classe foobarse si tenta di rimuovere la classe foo. Il JS negli attributi del gestore eventi intrinseci è stato rotto prima di essere modificato. La risposta accettata per 4 anni è molto meglio.
Quentin,

1
grazie, l'ho risolto (non il problema con il prefisso). è la vecchia risposta accettata che ha un bug con regexp.
Alfredo

Il codice presenta ancora il foobarproblema. Guarda il test qui
rosell.dk,

8

Ecco una toggleClass per alternare / aggiungere / rimuovere una classe su un elemento:

// 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;
}

vedi jsfiddle

vedi anche la mia risposta qui per la creazione dinamica di una nuova classe


6

Uso le seguenti funzioni JavaScript vaniglia nel mio codice. Usano espressioni regolari e indexOfnon richiedono la citazione di caratteri speciali nelle espressioni regolari.

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, "");
    }
}

Puoi anche usare element.classList nei browser moderni.


3

LE OPZIONI.

Ecco un piccolo esempio rispetto agli esempi di classList per farti vedere quali sono le opzioni che hai a disposizione e come utilizzare classListper fare ciò che desideri.

style vs. classList

La differenza tra stylee classListè che con stylesi sta aggiungendo le proprietà di stile dell'elemento, ma classListè un pò il controllo delle classe (i) dell'elemento ( add, remove, toggle, contain), vi mostrerò come utilizzare il adde removeil metodo in quanto tali sono quelli popolari.


Esempio di stile

Se si desidera aggiungere margin-topproprietà in un elemento, si dovrebbe fare in questo modo:

// Get the Element
const el = document.querySelector('#element');

// Add CSS property 
el.style.margintop = "0px"
el.style.margintop = "25px" // This would add a 25px to the top of the element.

classList Esempio

Diciamo che abbiamo un <div class="class-a class-b">, in questo caso, abbiamo 2 classi aggiunte al nostro elemento div già, class-ae class-b, e vogliamo controllare quali classi removee quale classe a add. Qui è doveclassList diventa utile.

Rimuovere class-b

// Get the Element
const el = document.querySelector('#element');

// Remove class-b style from the element
el.classList.remove("class-b")

Inserisci class-c

// Get the Element
const el = document.querySelector('#element');

// Add class-b style from the element
el.classList.add("class-c")


1

Ho pensato di aggiungere questo:

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(' ');
}

1

basta dire a myElement.classList="new-class"meno che non sia necessario mantenere altre classi esistenti nel qual caso è possibile utilizzare i classList.add, .removemetodi.

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>


1

OK, penso che in questo caso dovresti usare jQuery o scrivere i tuoi metodi in javascript puro, la mia preferenza è aggiungere i miei metodi piuttosto che iniettare tutto jQuery nella mia applicazione se non ne ho bisogno per altri motivi.

Vorrei fare qualcosa come il seguente come metodi al mio framework javascript per aggiungere alcune funzionalità che gestiscono l'aggiunta di classi, l'eliminazione di classi, ecc. Simile a jQuery, questo è completamente supportato in IE9 +, anche il mio codice è scritto in ES6, quindi è necessario per assicurarti che il tuo browser lo supporti o usi qualcosa come babel, altrimenti devi usare la sintassi ES5 nel tuo codice, anche in questo modo, troviamo l'elemento tramite ID, il che significa che l'elemento deve avere un ID per essere selezionato:

//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);
  }

}

e puoi semplicemente chiamarli come sotto, immagina che il tuo elemento abbia id di "id" e classe di "classe", assicurati di passarli come una stringa, puoi usare l'ut come di seguito:

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

1

classList API DOM:

Un modo molto conveniente di aggiungere e rimuovere classi è l' classListAPI DOM. Questa API ci consente di selezionare tutte le classi di un elemento DOM specifico al fine di modificare l'elenco usando javascript. Per esempio:

const el = document.getElementById("main");
console.log(el.classList);
<div class="content wrapper animated" id="main"></div>

Nel registro possiamo osservare che stiamo recuperando un oggetto con non solo le classi dell'elemento, ma anche molti metodi e proprietà ausiliari. Questo oggetto eredita dall'interfaccia DOMTokenList , un'interfaccia utilizzata nel DOM per rappresentare un insieme di token separati da spazio (come le classi).

Esempio:

const el = document.getElementById('container');


function addClass () {
   el.classList.add('newclass');
}


function replaceClass () {
     el.classList.replace('foo', 'newFoo');
}


function removeClass () {
       el.classList.remove('bar');
}
button{
  margin: 20px;
}

.foo{
  color: red;
}

.newFoo {
  color: blue;
}

.bar{
  background-color:powderblue;
}

.newclass{
  border: 2px solid green;
}
<div class="foo bar" id="container">
  "Sed ut perspiciatis unde omnis 
  iste natus error sit voluptatem accusantium doloremque laudantium, 
  totam rem aperiam, eaque ipsa quae ab illo inventore veritatis et 
  quasi architecto beatae vitae dicta sunt explicabo. Nemo enim ipsam 
  voluptatem quia voluptas 
 </div>
  
<button onclick="addClass()">AddClass</button>
  
<button onclick="replaceClass()">ReplaceClass</button>
  
<button onclick="removeClass()">removeClass</button>
  


1

Sì, ci sono molti modi per farlo. Nella sintassi ES6 possiamo ottenere facilmente. Utilizzare questo codice per attivare e disattivare la classe.

const tabs=document.querySelectorAll('.menu li');

for(let tab of tabs){
  
  tab.onclick=function(){
    
  let activetab=document.querySelectorAll('li.active');
    
  activetab[0].classList.remove('active')
  
    tab.classList.add('active'); 
  }
  
}
body {
    padding:20px;
    font-family:sans-serif;    
}

ul {
    margin:20px 0;
    list-style:none;
}

li {
    background:#dfdfdf;
    padding:10px;
    margin:6px 0;
    cursor:pointer;
}

li.active {
    background:#2794c7;
    font-weight:bold;
    color:#ffffff;
}
<i>Please click an item:</i>

<ul class="menu">
  <li class="active"><span>Three</span></li>
  <li><span>Two</span></li>
  <li><span>One</span></li>
</ul>


1
function classed(el, class_name, add_class) {
  const re = new RegExp("(?:^|\\s)" + class_name + "(?!\\S)", "g");
  if (add_class && !el.className.match(re)) el.className += " " + class_name
  else if (!add_class) el.className = el.className.replace(re, '');
}

utilizzando la risposta accettata sopra qui è una semplice funzione cross-browser per aggiungere e rimuovere la classe

aggiungi classe:

classed(document.getElementById("denis"), "active", true)

rimuovere la classe:

classed(document.getElementById("denis"), "active", false)

1

Molte risposte, molte buone risposte.

TL; DR:

document.getElementById('id').className = 'class'

O

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

Questo è tutto.

E, se vuoi davvero conoscere il perché ed educarti, allora suggerisco di leggere la risposta di Peter Boughton , è perfetto.

Nota:
questo è possibile con ( documento o evento ):

  • getElementById()
  • getElementsByClassName()
  • querySelector()
  • querySelectorAll()

1

Esiste una proprietà className in javascript per modificare il nome della classe di un elemento HTML. Il valore della classe esistente verrà sostituito con quello nuovo che hai assegnato in className.

<!DOCTYPE html>
<html>
<head>
<title>How to change class of an HTML element in Javascript?</title>
<link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/4.7.0/css/font-awesome.min.css">
</head>
<body>
<h1 align="center"><i class="fa fa-home" id="icon"></i></h1><br />

<center><button id="change-class">Change Class</button></center>

<script>
var change_class=document.getElementById("change-class");
change_class.onclick=function()
{
    var icon=document.getElementById("icon");
    icon.className="fa fa-gear";
}

</script>
</body>
</html>

Credito: https://jaischool.com/javascript-lang/how-to-change-class-name-of-an-html-element-in-javascript.html


1

La domanda OP era Come posso cambiare la classe di un elemento con JavaScript?

I browser moderni ti consentono di farlo con una riga di javascript :

document.getElementById('id').classList.replace('span1','span2')

L' classListattributo fornisce un DOMTokenList che ha una varietà di metodi . Puoi operare sulla classList di un elemento usando semplici manipolazioni come add () , remove () o replace () . O ottieni classi molto sofisticate e manipolate come faresti con un oggetto o una mappa con keys () , valori () , entry ()

La risposta di Peter Boughton è ottima, ma ormai ha più di un decennio. Tutti i browser moderni ora supportano DOMTokenList - vedi https://caniuse.com/#search=classList e persino IE11 supporta alcuni metodi DOMTokenList


1

provare

element.className='second'


-2

Codice JavaScript funzionante:

<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>

Puoi scaricare un codice funzionante da questo link .


1
Questo romperà gli elementi con più di una classe.
gcampbell,

-4

Ecco un semplice codice jQuery per farlo.

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

Qui,

  • Class1 è un ascoltatore per un evento.
  • La classe genitore è la classe che ospita la classe che si desidera modificare
  • Classtoremove è la vecchia classe che hai.
  • La classe da aggiungere è la nuova classe che si desidera aggiungere.
  • 100 è il ritardo di timeout durante il quale la classe viene modificata.

In bocca al lupo.

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.