ජාවාස්ක්‍රිප්ට් සමඟ මූලද්‍රව්‍ය පන්තියක් වෙනස් කරන්නේ කෙසේද?


2782

onclickජාවාස්ක්‍රිප්ට් භාවිතයෙන් සිදුවීමකට ප්‍රතිචාර වශයෙන් HTML මූලද්‍රව්‍යයක පන්තියක් වෙනස් කරන්නේ කෙසේද ?


28
"පන්ති ගුණාංගය බොහෝ දුරට භාවිතා කරනුයේ ශෛලියක ඇති පන්තියකට යොමු කිරීම සඳහා ය. කෙසේ වෙතත්, එය ජාවාස්ක්‍රිප්ට් එකකට (HTML DOM හරහා) විශේෂිත පන්තියක් සමඟ HTML මූලද්‍රව්‍යවල වෙනස්කම් කිරීමට භාවිතා කළ හැකිය." - w3schools.com/tags/att_standard_class.asp
Triynko

11
element.setAttribute(name, value);nameසමඟ ප්රතිස්ථාපනය කරන්න class. වෙනුවට valueඔබ මිල කැඳවීම් බහා පන්ති, දී ඇති ඕනෑම දෙයක් නම සමඟ. මෙය වත්මන් පංතිය මකාදැමීම සහ වෙනත් එකක් එකතු කිරීම වළක්වයි. මෙම jsFiddle උදාහරණයෙන් සම්පූර්ණ ක්‍රියාකාරී කේතය පෙන්වයි.
ඇලන් වෙල්ස්

3
OnClick සමඟ HTML මූලද්‍රව්‍යයක් වෙනස් කිරීම සඳහා මෙම කේතය භාවිතා කරන්න: <input type='button' onclick='addNewClass(this)' value='Create' /> සහ ජාවාස්ක්‍රිප්ට් කොටසේ: function addNewClass(elem){ elem.className="newClass";} ඔන්ලයින්
ඉමාන් බහ්රම්පූර්

Ri ට්රින්කෝ - w3 පාසල්වල සබැඳිය වෙනස් වී ඇති අතර එය 2012 සැප්තැම්බර් මාසයේ දී මෙන් පෙනේ. මෙන්න Archive.org හි 12 / සැප්තැම්බර් / 2012 සිට එම පිටුව: HTML පන්තියේ ගුණාංග- w3 පාසල් . W3schools.com හි ප්‍රතිස්ථාපන පිටුව සඳහා සබැඳිය මෙන්න: HTML පන්තියේ ගුණාංග- w3 පාසල් .
කෙවින් ෆෙගන්

Answers:


3883

පන්ති වෙනස් කිරීම සඳහා නවීන HTML5 තාක්ෂණික ක්‍රම

නවීන බ්රවුසරයන් එකතු කර ඇත classList පහසු පුස්තකාල යාමකින් තොරව පන්ති මෙහෙයවීම සඳහා කිරීමට ක්රම සපයන:

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

අවාසනාවකට මෙන්, මේවා v10 ට පෙර ඉන්ටර්නෙට් එක්ස්ප්ලෝරර් හි ක්‍රියා නොකරයි, නමුත් මෙම පිටුවෙන් ලබා ගත හැකි IE8 සහ IE9 සඳහා සහය එක් කිරීමට ෂිම් එකක් ඇත . එහෙත්, එය වැඩි වැඩියෙන් සහාය ලබා ගැනීමකි .

සරල හරස් බ්රවුසර විසඳුමක්

මූලද්‍රව්‍යයක් තෝරා ගැනීම සඳහා සම්මත ජාවාස්ක්‍රිප්ට් ක්‍රමය භාවිතා කරයි document.getElementById("Id"), එය පහත උදාහරණ භාවිතා කරයි - ඔබට ඇත්ත වශයෙන්ම වෙනත් ආකාරවලින් මූලද්‍රව්‍ය ලබා ගත හැකි අතර නිවැරදි තත්වයේදී සරලව භාවිතා කළ හැකියthis ඒ වෙනුවට - කෙසේ වෙතත්, මේ පිළිබඳව විස්තරාත්මකව බැලීම සීමාවෙන් ඔබ්බට ය පිළිතුරේ.

මූලද්රව්යයක් සඳහා සියලු පන්ති වෙනස් කිරීමට:

පවත්නා සියලුම පන්ති නව පන්ති එකක් හෝ කිහිපයක් සමඟ ප්‍රතිස්ථාපනය කිරීමට, පන්තියේ නම ගුණාංගය සකසන්න:

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

(ඔබට බහු පන්ති යෙදීම සඳහා අවකාශය වෙන් කළ ලැයිස්තුවක් භාවිතා කළ හැකිය.)

මූලද්රව්යයකට අතිරේක පන්තියක් එක් කිරීමට:

මූලද්‍රව්‍යයකට පන්තියක් එක් කිරීමට, පවතින අගයන් ඉවත් නොකර / බලපාන්නේ නැතිව, අවකාශයක් සහ නව පන්ති නාමය එකතු කරන්න,

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

මූලද්‍රව්‍යයකින් පන්තියක් ඉවත් කිරීමට:

මූලද්‍රව්‍යයකට තනි පන්තියක් ඉවත් කිරීම සඳහා, වෙනත් විභව පන්ති වලට බලපෑමක් නොකර, සරල රීජෙක්ස් ප්‍රතිස්ථාපනය අවශ්‍ය වේ:

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

මෙම රීජෙක්ස් පිළිබඳ පැහැදිලි කිරීමක් පහත පරිදි වේ:

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

එම g ධජය අවශ්ය ලෙස නැවත කිරීමට වෙනුවට, නඩුවේ පන්ති නම කීප වරක් එකතු කර ඇත, පවසයි.

මූලද්‍රව්‍යයකට පන්තියක් දැනටමත් යොදවා ඇත්දැයි පරීක්ෂා කිරීමට:

පංතියක් ඉවත් කිරීම සඳහා ඉහත භාවිතා කළ රීජෙක්ස් විශේෂිත පන්තියක් තිබේද යන්න පරීක්ෂා කිරීමක් ලෙසද භාවිතා කළ හැකිය:

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


ඔන්ක්ලික් සිදුවීම් සඳහා මෙම ක්‍රියා පැවරීම:

ජාවාස්ක්‍රිප්ට් කෙලින්ම HTML සිදුවීම් ගුණාංග තුළ ලිවීමට හැකි අතර (වැනි onclick="this.className+=' MyClass'" ) මෙය නිර්දේශිත හැසිරීම නොවේ. විශේෂයෙන් විශාල යෙදුම් වලදී, ජාවාස්ක්‍රිප්ට් අන්තර්ක්‍රියා තර්කනයෙන් HTML සලකුණු වෙන් කිරීමෙන් වඩාත් නඩත්තු කළ හැකි කේතයක් ලබා ගත හැකිය.

මෙය සාක්ෂාත් කර ගැනීමේ පළමු පියවර වන්නේ ශ්‍රිතයක් නිර්මාණය කිරීම සහ ඔන්ක්ලික් ගුණාංගයේ ශ්‍රිතය ඇමතීම ය.

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

(මෙම කේතය ස්ක්‍රිප්ට් ටැග් වල තිබීම අවශ්‍ය නොවේ, මෙය හුදෙක් නිදසුනෙහි සාරාංශය සඳහා වන අතර, විශේෂ ගොනුවක ජාවාස්ක්‍රිප්ට් ඇතුළත් කිරීම වඩාත් යෝග්‍ය වේ.)

දෙවන පියවර වන්නේ ඔන්ක්ලික් සිදුවීම HTML වලින් සහ ජාවාස්ක්‍රිප්ට් වෙත ගෙන යාමයි, උදාහරණයක් ලෙස 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>

( HTML පැටවීම අවසන් වූ පසු එම ශ්‍රිතයේ අන්තර්ගතය ක්‍රියාත්මක වන පරිදි window.onload කොටස අවශ්‍ය බව සලකන්න - මෙය නොමැතිව, ජාවාස්ක්‍රිප්ට් කේතය කැඳවූ විට MyElement නොපවතින බැවින් එම රේඛාව අසාර්ථක වනු ඇත.)


ජාවාස්ක්‍රිප්ට් රාමු සහ පුස්තකාල

ඉහත කේතය සියල්ලම සම්මත ජාවාස්ක්‍රිප්ට් වල ඇත, කෙසේ වෙතත් පොදු කාර්යයන් සරල කිරීම සඳහා රාමුවක් හෝ පුස්තකාලයක් භාවිතා කිරීම සාමාන්‍ය සිරිතකි, එසේම ඔබේ කේතය ලිවීමේදී ඔබ නොසිතන ස්ථාවර දෝෂ සහ අද්දර අවස්ථා වලින් ප්‍රයෝජන ලබා ගැනීම.

පංතියක් වෙනස් කිරීම සඳහා K 50 KB රාමුවක් එක් කිරීම සමහර අය අධික ලෙස සලකන අතර, ඔබ සැලකිය යුතු ප්‍රමාණයේ ජාවාස්ක්‍රිප්ට් වැඩක් කරන්නේ නම් හෝ අසාමාන්‍ය හරස් බ්‍රව්සර් හැසිරීමක් ඇති ඕනෑම දෙයක් නම්, එය සලකා බැලීම වටී.

(ඉතා දළ වශයෙන්, පුස්තකාලයක් යනු නිශ්චිත කාර්යයක් සඳහා නිර්මාණය කර ඇති මෙවලම් සමූහයකි, රාමුවක් තුළ සාමාන්‍යයෙන් පුස්තකාල කිහිපයක් අඩංගු වන අතර සම්පූර්ණ රාජකාරි මාලාවක් ඉටු කරයි.)

ඉහත උදාහරණ jQuery භාවිතයෙන් පහත ප්‍රතිනිෂ්පාදනය කර ඇත , බොහෝ විට බහුලව භාවිතා වන ජාවාස්ක්‍රිප්ට් පුස්තකාලය (විමර්ශනය කිරීමට වටින තවත් ඒවා ඇතත්).

( $මෙහි jQuery වස්තුව බව සලකන්න .)

JQuery සමඟ පන්ති වෙනස් කිරීම:

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

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

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

ඊට අමතරව, පංතියක් අදාළ නොවන්නේ නම් එකතු කිරීම හෝ එසේ කරන පන්තියක් ඉවත් කිරීම සඳහා කෙටිමඟක් jQuery සපයයි:

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


JQuery සමඟ ක්ලික් කිරීමේ සිදුවීමකට ශ්‍රිතයක් පැවරීම:

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

හෝ, හැඳුනුම්පතක් අවශ්‍ය නොවී:

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



106
නියම පිළිතුර පීටර්. එක් ප්‍රශ්නයක් ... ජාවාස්ක්‍රිප්ට් වලට වඩා JQuery සමඟ සම්බන්ධ වීම වඩා හොඳ ඇයි ? JQuery විශිෂ්ටයි, නමුත් ඔබ කළ යුත්තේ මෙය නම් - ජාවාස්ක්‍රිප්ට් පේළි කිහිපයක් වෙනුවට සමස්ත JQuery ලිබ්‍රේ ඇතුළු සාධාරණීකරණය කරන්නේ කුමක්ද?
mattstuehler

23
attmattstuehler 1) “වඩා හොඳ x” යන වාක්‍ය ඛණ්ඩයේ බොහෝ විට අදහස් කරන්නේ “වඩා හොඳ (ඔබට හැකි x)” යන්නයි. 2) කාරණයේ හදවතට ළඟාවීම සඳහා, jQuery නිර්මාණය කර ඇත්තේ DOM වෙත ප්‍රවේශ වීමට / හැසිරවීමට සහාය වීම සඳහා වන අතර බොහෝ විට ඔබට මෙවැනි දෙයක් කිරීමට අවශ්‍ය නම් එය සෑම තැනකම කළ යුතුය.
බැරී

31
මෙම විසඳුම සමඟ ඇති එක් දෝෂයකි: ඔබ ඔබේ බොත්තම මත කිහිප වතාවක් ක්ලික් කළ විට, එය දැනටමත් තිබේදැයි පරීක්ෂා කරනවාට වඩා "MyClass" පන්තිය මූලද්‍රව්‍යයට කිහිප වතාවක් එකතු කරනු ඇත. මේ අනුව ඔබට HTML පන්තියේ ගුණාංගයක් මේ වගේ දෙයක් සමඟ අවසන් විය හැකිය:class="button MyClass MyClass MyClass"
Web_Designer

35
ඔබ 'මයික්ලාස්' පංතියක් ඉවත් කිරීමට උත්සාහ කරන්නේ නම් සහ ඔබට පංතියේ 'උපසර්ගය-මයික්ලාස්' තිබේ නම්, පංතියක් ඉවත් කිරීම සඳහා ඔබ ඉහත ලබා දුන් රීජෙක්ස් ඔබේ පන්තියේ නමෙහි 'උපසර්ගය' තබනු ඇත: ඕ
ජින්ගල්ස්ටූලා

16
ඇවැත්නි, අවුරුදු තුනක් සහ ඉහළ නැංවීම් 183 ක් වන අතර මේ දක්වා කිසිවෙකු එය දුටුවේ නැත. ස්තූතියි jinglesthula, මම රීජෙක්ස් නිවැරදි කර ඇති බැවින් පන්ති නාමවල කොටස් වැරදියට ඉවත් නොකරමි. // රාමුවක් (jQuery වැනි) භාවිතා කිරීම වටින්නේ මන්ද යන්නට මෙය හොඳ උදාහරණයක් යැයි මම සිතමි - මෙවැනි දෝෂ ඉක්මනින් හසු වී ඉක්මනින් නිවැරදි කරනු ලැබේ, සාමාන්‍ය කේතයේ වෙනස්කම් අවශ්‍ය නොවේ.
පීටර් බූටන්

422

ඔබටත් කළ හැක්කේ:

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

පංතියක් ටොගල කිරීමට (තිබේ නම් ඉවත් කරන්න, නැතිනම් එය එකතු කරන්න):

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

64
මෙය HTML5 මත රඳා පවතින බව මම විශ්වාස කරමි.
ජෝන්

12
ඔබට එලී ග්‍රේගේ classListෂිම් අවශ්‍ය වේ.
ELLIOTTCABLE

15
මොසිල්ලා සංවර්ධක ජාලය පවසන්නේ එය 10 ට අඩු අන්තර්ජාල ගවේෂකයන් තුළ ස්වදේශීයව ක්‍රියාත්මක නොවන බවයි. මගේ පරීක්ෂණයෙන් එම ප්‍රකාශය සත්‍ය බව මට පෙනේ. පෙනෙන විදිහට, ඉන්ටර්නෙට් එක්ස්ප්ලෝරර් 8-9 සඳහා එලී ග්‍රේ ෂිම් අවශ්‍ය වේ. අවාසනාවට, මට එය ඔහුගේ වෙබ් අඩවියෙන් සොයාගත නොහැකි විය (සෙවීම සමඟ වුවද). ෂිම් මොසිල්ලා සබැඳියෙන් ලබා ගත හැකිය.
doubleJ


4
atow "classList" ට IE10 + හි අර්ධ සහය ඇත; ඔපෙරා මිනි සඳහා සහය නොදක්වයි; ඉතිරිව ඇති සම්මත බ්‍රව්සර් සඳහා පූර්ණ සහාය: caniuse.com/#search=classlist
නික් හම්ෆ්රි

119

JQuery භාවිතා නොකළ මගේ පැරණි ව්‍යාපෘතියක, මූලද්‍රව්‍යයට පන්තියක් තිබේදැයි එකතු කිරීම, ඉවත් කිරීම සහ පරීක්ෂා කිරීම සඳහා මම පහත සඳහන් කාර්යයන් ගොඩනගා ගතිමි:

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

උදාහරණයක් ලෙස, onclickබොත්තමට යම් පන්තියක් එක් කිරීමට අවශ්‍ය නම් මට මෙය භාවිතා කළ හැකිය:

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

මේ වන විට නිසැකවම jQuery භාවිතා කිරීම වඩා හොඳ වනු ඇත.


8
ඔබේ සේවාදායකයා ඔබට jQuery භාවිතා කිරීමට ඉඩ නොදෙන විට මෙය විශිෂ්ටයි. (ඔබ ඔබේම පුස්තකාලයක් තැනීම අවසන් කිරීමට හේතුව.)
මයික්

1
Ike මයික් සේවාදායකයා ඔබට jQuery භාවිතා කිරීමට ඉඩ නොදෙන්නේ නම්, ඔබට ගොස් ඔබේ පුස්තකාලයට අවශ්‍ය අංග පමණක් නැවත ගොඩනඟා ගත නොහැකිද?
kfrncs

5
fkfrncs මට සාමාන්‍යයෙන් එතරම් විශාල රාමුවක් අවශ්‍ය නොවන නිසා. මා සිතමින් සිටි ව්‍යාපෘතිය සඳහා, මට අවශ්‍ය එකම කාර්යය වූයේ පන්ති නාම 3 (ඇත, එකතු කරන්න, ඉවත් කරන්න) සහ කුකී (ඇත, එකතු කරන්න, ඉවත් කරන්න) කාර්යයන්ය. අනෙක් සෑම දෙයක්ම සිරිතක් විය, නැතහොත් දේශීයව හොඳින් සහාය විය. ඒ නිසා සෑම දෙයක්ම එකට එකතු වූයේ අදහස් දැක්වීම් ඇතුළුව අවම කිරීමට පෙර පේළි 150 ක් පමණි.
මයික්

2
මචන්, පාන්දර 4 යි, බොහොම ස්තුතියි. වැනිලා ජේඑස් යනු අපගේ ව්‍යාපෘතිය සඳහා අප භාවිතා කරන අතර මෙය ජීවිතාරක්ෂකයෙකි.
LessQuesar

මේ සඳහා මගේ ප්‍රියතම විසඳුම මෙයයි. මම එය සෑම තැනකම භාවිතා කරමි. ඔබේ ව්‍යාපෘතියට දැනටමත් වෙනත් ක්‍රමයක් නොමැති විට පන්ති එකතු කිරීම සහ ඉවත් කිරීම සාක්ෂාත් කර ගැනීම සඳහා වඩාත් අලංකාර ක්‍රමය එය යැයි මම විශ්වාස කරමි.
වෙබ් වොන්ඩරර්

77

ඔබට එසේ භාවිතා කළ හැකිය node.className:

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

PPK ට අනුව මෙය IE5.5 සහ ඊට ඉහළින් ක්‍රියා කළ යුතුය .


11
මෙය වස්තුව මත ඇති අනෙකුත් සියලුම පංති නැවත ලියයි ... එබැවින් එය එතරම් සරල නැත.
එරික් සෙබස්ටා

51

ඇවැත්නි, පුදුමයට කරුණක් නම් මෙහි අතිරික්ත පිළිතුරු බොහොමයක් තිබීමයි ...

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

14
උදාහරණ කේතය ලිවීම සඳහා නොවරදින ජාවාස්ක්‍රිප්ට් භයානක පුරුද්දක් යැයි මම කියමි ...
ගේබ්

22
මම එකඟ නොවෙමි, මන්ද උදාහරණ කේතය හොඳ ආදර්ශයක් විය යුතු යැයි මම සිතමි.
thomasrutter

1
හොඳ උදාහරණයක් මඟින් පරිකල්පනය එකවරම ඉගැන්විය යුතුය. එය සිතුවිලි විස්ථාපනය නොකළ යුතුය.
ඇන්තනි රට්ලෙජ්

4
අනෙක් පිළිතුරු අතිරික්ත නොවේ, ඒවා දැනට පවතින පන්ති මූලද්‍රව්‍යය මත තබා ගනී.
gcampbell

47

පිරිසිදු ජාවාස්ක්‍රිප්ට් කේතය භාවිතා කිරීම:

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

මෙය මා වෙනුවෙන් වැඩ කරයි:

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

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

විශිෂ්ට පිළිතුර! එක් කිරීමට ඉතිරිව ඇත: පන්ති අංග සමූහයක් සඳහා ශෛලියක් නියම කිරීම සඳහා තේරීම් කාරක සඳහා එක් එක් CSS පන්තියේ නම සකසන්න
රෝමන් පොලන්.

මෙය මට FF හි වැඩ කරයි, නමුත් මම el.className = "newStyle" භාවිතා කිරීමට උත්සාහ කළ විට; ඒක වැඩ කළේ නැහැ, ඇයි?
ලූකස් 'සෙවරියන්' ග්‍රෙලා

1
ඔබට භාවිතා කළ හැකිය el.setAttribute('class', newClass)හෝ වඩා හොඳය el.className = newClass. නමුත් එසේ නොවේ el.setAttribute('className', newClass).
ඔරියෝල්

20

පංති එකතු කිරීම, ඉවත් කිරීම, ටොගල් කිරීම සහ පරීක්ෂා කිරීම සඳහා ක්‍රම එකතු කිරීම සඳහා ඔබට HTMLElement වස්තුව දිගු කළ හැකිය ( සාරාංශය ):

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

ඉන්පසු මේ ආකාරයට භාවිතා කරන්න (ක්ලික් කිරීම මඟින් පන්තිය එක් කරයි හෝ ඉවත් කරයි):

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

මෙන්න නිරූපණය .


1
මෙය ටිකක් වාචිකයි ... මෙන්න ඉතා සංක්ෂිප්ත විසඳුමක් ... jsfiddle.net/jdniki/UaT3P
zero_cool

5
කණගාටුයි ack ජැක්සන්_සැන්ඩ්ලන්ඩ් නමුත් ඔබට එය සම්පූර්ණයෙන්ම මග හැරී ඇත, එය කිසිසේත් jQuery භාවිතා නොකෙරේ.
moka

17

වෙනත් ජනප්‍රිය රාමුවක් වන ගූගල් වැසීම් වලින් තොරතුරු එක් කිරීමට, ඔවුන්ගේ ඩොම් / පන්ති පන්තිය බලන්න:

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

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

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

මූලද්‍රව්‍යය තෝරා ගැනීම සඳහා එක් විකල්පයක් වන්නේ CSS3 තේරීම් කාරකයක් සමඟ goog.dom.query භාවිතා කිරීමයි :

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

14

පෙර රීජෙක්ස් පිළිබඳ සුළු සටහන් සහ වෙනස් කිරීම් කිහිපයක්:

පංති ලැයිස්තුවට පන්තියේ නම එක් වරකට වඩා තිබේ නම් ඔබට එය ගෝලීයව කිරීමට අවශ්‍ය වනු ඇත. තවද, ඔබට බොහෝ විට පන්ති ලැයිස්තුවේ කෙළවරේ සිට අවකාශයන් ඉවත් කර අවකාශයන් ධාවනය නොකිරීමට බහු අවකාශයන් එක් අවකාශයක් බවට පරිවර්තනය කිරීමට අවශ්‍ය වනු ඇත. පංති නාම සමඟ සම්බන්ධ වන එකම කේතය පහත රීජෙක්ස් භාවිතා කර නමක් එක් කිරීමට පෙර ඉවත් කරන්නේ නම් මේ කිසිවක් ගැටළුවක් නොවිය යුතුය. එහෙත්. හොඳයි, පංතියේ නාම ලැයිස්තුව සමඟ සම්බන්ධ වන්නේ කවුරුන්දැයි කවුද දන්නේ.

පංති නාමවල ඇති නඩුව ගැන තැකීමක් නොකරන බ්‍රව්සරයක කේතය භාවිතා කිරීමට පෙර පන්ති නාමවල දෝෂ පෙන්වීමට මෙම රීජෙක්ස් සිද්ධි සංවේදී නොවේ.

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

ASP.NET හි JavaScript සමඟ මූලද්‍රව්‍යයේ CSS පන්තිය වෙනස් කරන්න :

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

මම jQuery භාවිතා කර මේ වගේ දෙයක් ලියමි:

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

මෙම කේතය මඟින් හැඳුනුම්පතේ කිසියම් මූලද්‍රව්‍යයක් ක්ලික් කළ විට හැඳින්විය යුතු ශ්‍රිතයක් එක් කරයි . මූලද්රව්යයේ පන්ති ගුණාංගයට එය දැනටමත් කොටසක් නොවේ නම් එය ක්ලික් කර ඇති අතර එය තිබේ නම් එය ඉවත් කරයි.

ඔව්, මෙම කේතය භාවිතා කිරීම සඳහා ඔබේ පිටුවේ ඇති jQuery පුස්තකාලයට සඳහනක් එක් කිරීමට ඔබට අවශ්‍යය, නමුත් අවම වශයෙන් ඔබට පුස්තකාලයේ බොහෝ කාර්යයන් නවීන බ්‍රව්සර් සියල්ලම ක්‍රියාත්මක වන බව විශ්වාස කළ හැකිය. එය කිරීමට ඔබේම කේතය.

ස්තූතියි


8
ඔබට ලිවිය jQueryයුත්තේ එහි දිගු ස්වරූපයෙන් එක් වරක් පමණි. jQuery(function($) { });කරයි $සියලු අවස්ථාවල දී මෙම උත්සවය තුල ලබා ගත හැකි.
හොරා මාස්ටර්

10

ඉර

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

විය යුතුයි:

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

8
වැරදියි. රෙජෙක්ස් ඉදිරි කප්පාදුවලින් වෙන් කර ඇත. උපුටා දැක්වීම් එකතු කිරීමෙන් එය IE හි අසමත් වීමට හේතු වන අතර, ඔබ පන්තිය ඉවත් කිරීමට වඩා ඉවත් කිරීමට උත්සාහ කරන පන්තියේ නූල නැවත ලබා දෙයි.
ඩිලන්

9

IE6 සහය ඇතිව වැනිලා ජාවාස්ක්‍රිප්ට් හි මූලද්‍රව්‍ය පන්තියක් වෙනස් කරන්න

attributesIE6 පවා පැරණි බ්‍රව්සර් සමඟ අනුකූල වීම සඳහා ඔබට නෝඩ් දේපල භාවිතා කිරීමට උත්සාහ කළ හැකිය :

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

මෙන්න මගේ අනුවාදය, සම්පූර්ණයෙන්ම ක්‍රියාත්මක වේ:

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
}

භාවිතය:

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

4
foobarඔබ පන්තිය ඉවත් කිරීමට උත්සාහ කළහොත් එය පන්තිය බිඳ දමනු ඇත foo. සංස්කරණය කිරීමට පෙර සහජ සිදුවීම් හසුරුවන ගුණාංගවල JS කැඩී ගියේය. අවුරුදු 4 ක් පැරණි පිළිගත් පිළිතුර වඩා හොඳය.
ක්වෙන්ටින්

1
ස්තූතියි, මම එය නිවැරදි කළෙමි (උපසර්ගය ගැටළුව නොවේ). රීජෙක්ස් සමඟ දෝෂයක් ඇති පැරණි පිළිගත් පිළිතුර එයයි.
ඇල්ෆ්‍රඩ්

කේතය තවමත් foobarගැටළුව ඇත. පරීක්ෂණය මෙතැනින්
rosell.dk

8

මූලද්‍රව්‍යයක් මත පන්තියක් ටොගල් කිරීමට / එකතු කිරීමට / ඉවත් කිරීමට ටොගල් ක්ලාස් මෙන්න:

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

බලන්න jsfiddle

මගේ පිළිතුරත් බලන්න නව පංතියක් ගතිකව නිර්මාණය කිරීම සඳහා මෙහි


6

මම මගේ කේතයේ පහත වැනිලා ජාවාස්ක්‍රිප්ට් කාර්යයන් භාවිතා කරමි. ඔවුන් නිත්‍ය ප්‍රකාශන භාවිතා කරන indexOfනමුත් සාමාන්‍ය ප්‍රකාශනවල විශේෂ අක්ෂර උපුටා දැක්වීම අවශ්‍ය නොවේ.

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

නවීන බ්‍රව්සර්වල ඔබට element.classList භාවිතා කළ හැකිය .


3

විකල්ප.

ඔබට ලබා ගත හැකි විකල්ප classListමොනවාද සහ ඔබට අවශ්‍ය දේ කිරීමට භාවිතා කරන්නේ කෙසේද යන්න බැලීමට කුඩා ශෛලියට එදිරිව පන්ති ලැයිස්තු උදාහරණ මෙන්න .

style එදිරිව. classList

අතර වෙනස styleහා classListසමග බව ය styleඔබ අංගයක් ශෛලිය ගුණ එකතු කරනවා, නමුත් classListටිකක් පන්ති (ලිපින) මූලද්රව්යයේ (පාලනය වේ add, remove, toggle, contain), මම භාවිතා කරන ආකාරය ඔබට පෙන්වා දෙනු ඇත addසහ removeඑම බැවින් ක්රමය ජනප්‍රිය ඒවා.


විලාසිතාවේ උදාහරණය

ඔබට margin-topමූලද්‍රව්‍යයකට දේපළ එකතු කිරීමට අවශ්‍ය නම් , ඔබ එසේ කරන්නේ:

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

පන්ති ලැයිස්තු උදාහරණය

අපි තිබෙනවා කියා <div class="class-a class-b">, මේ අවස්ථාවේ දී, අපි 2 පන්ති දැනටමත් අපගේ div අංගයක් එකතු කර, class-aහා class-b, හා, අප කුමක් පන්ති පාලනය කිරීම සඳහා අවශ්ය removeහා කුමන පන්ති add. මෙතන තමයිclassListප්‍රයෝජනවත් .

ඉවත් කරන්න class-b

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

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

එකතු කරන්න class-c

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

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


1

මම හිතුවා මම මේක විසි කරනවා කියලා:

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

කියන්න myElement.classList="new-class"ඔබ භාවිතා කළ හැකි වන නඩුවේ අනෙකුත් පවතින පන්ති පවත්වා ගැනීමට අවශ්ය නම් classList.add, .removeක්රම.

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

හරි, මම හිතන්නේ මේ අවස්ථාවේ දී ඔබ jQuery භාවිතා කළ යුතුය, නැතහොත් ඔබේම ක්‍රම පිරිසිදු ජාවාස්ක්‍රිප්ට් වලින් ලිවිය යුතුය, මගේ මනාපය වන්නේ වෙනත් හේතු නිසා මට එය අවශ්‍ය නොවන්නේ නම් මගේ යෙදුමට සියලු jQuery එන්නත් කරනවාට වඩා මගේම ක්‍රම එකතු කිරීමයි.

JQuery හා සමාන පංති එකතු කිරීම, පන්ති මකා දැමීම යනාදිය හැසිරවිය හැකි ක්‍රියාකාරීත්වයන් කිහිපයක් එකතු කිරීම සඳහා මගේ ජාවාස්ක්‍රිප්ට් රාමුවට ක්‍රම ලෙස පහත දැක්වෙන දෙයක් කිරීමට මම කැමතියි, මෙය IE9 + හි පූර්ණ සහය දක්වයි, එසේම මගේ කේතය ES6 හි ලියා ඇත, එබැවින් ඔබට අවශ්‍යය ඔබගේ බ්‍රව්සරය එයට සහය දක්වන බවට හෝ ඔබ බාබෙල් වැනි දෙයක් භාවිතා කරන බවට වග බලා ගැනීමට, එසේ නොමැතිනම් ඔබේ කේතයේ ES5 සින්ටැක්ස් භාවිතා කිරීමට අවශ්‍ය වේ, මේ ආකාරයෙන්, අපි හැඳුනුම්පත හරහා මූලද්‍රව්‍යය සොයා ගනිමු, එයින් අදහස් කරන්නේ මූලද්‍රව්‍යය තෝරා ගැනීමට හැඳුනුම්පතක් තිබිය යුතු බවයි:

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

}

ඔබට පහත පරිදි ඒවා භාවිතා කළ හැකිය, ඔබේ මූලද්‍රව්‍යයට 'id' හැඳුනුම්පත සහ 'පන්තියේ' පන්තියක් ඇතැයි සිතන්න, ඔබ ඒවා නූලක් ලෙස සම්මත කර ඇති බවට වග බලා ගන්න, ඔබට පහත පරිදි උපයෝගීතාව භාවිතා කළ හැකිය:

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

1

classList DOM API:

පන්ති එකතු කිරීම සහ ඉවත් කිරීම ඉතා පහසු ක්‍රමයක් වන්නේ classListDOM API ය. ජාවාස්ක්‍රිප්ට් භාවිතයෙන් ලැයිස්තුව වෙනස් කිරීම සඳහා විශේෂිත DOM මූලද්‍රව්‍යයක සියලුම පන්ති තෝරා ගැනීමට මෙම API අපට ඉඩ දෙයි. උදාහරණයක් වශයෙන්:

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

මූලද්රව්යයේ පංති පමණක් නොව, බොහෝ සහායක ක්රම සහ ගුණාංග සහිත වස්තුවක් අප නැවත ලබා ගන්නා බව අපට ලොගයෙන් නිරීක්ෂණය කළ හැකිය. මෙම වස්තුව DOMTokenList අතුරුමුහුණතෙන් උරුම වේ , එය DOM හි අවකාශය වෙන් කළ ටෝකන සමූහයක් (පන්ති වැනි) නිරූපණය කිරීමට භාවිතා කරයි.

උදාහරණයක්:

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

ඔව් මෙය කිරීමට බොහෝ ක්‍රම තිබේ. ES6 සින්ටැක්ස් තුළ අපට පහසුවෙන් ළඟා කර ගත හැකිය. මෙම කේතය භාවිතා කර ටොගල් පන්තිය එකතු කරන්න සහ ඉවත් කරන්න.

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

ඉහත පිළිගත් පිළිතුර භාවිතා කිරීම පන්තිය එක් කිරීමට සහ ඉවත් කිරීමට සරල හරස් බ්‍රව්සර ශ්‍රිතයකි

පන්තිය එක් කරන්න:

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

පන්තිය ඉවත් කරන්න:

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

1

පිළිතුරු ගොඩක්, හොඳ පිළිතුරු ගොඩක්.

ටීඑල්; ඩීආර්:

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

හෝ

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

ඒක තමයි.

ඔබට ඇත්තටම හේතුව දැන ගැනීමට සහ ඔබව දැනුවත් කිරීමට අවශ්‍ය නම් මම පීටර් බොග්ටන්ගේ පිළිතුර කියවීමට යෝජනා කරමි , එය පරිපූර්ණයි.

සටහන:
( ලේඛනය හෝ සිද්ධිය ) සමඟ මෙය කළ හැකිය :

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

1

දේපළ නොමැති className ක HTML අංගයක් පන්ති නම වෙනස් කිරීමට ජාවාස්ක්රිප්ට් තුල. ඔබ පන්තියේ නමෙහි පවරා ඇති නව පන්තිය සමඟ පවතින පන්ති අගය ප්‍රතිස්ථාපනය වේ.

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

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


1

OP ප්‍රශ්නය වූයේ ජාවාස්ක්‍රිප්ට් සමඟ මූලද්‍රව්‍ය පන්තියක් වෙනස් කරන්නේ කෙසේද යන්නයි.

නවීන බ්‍රව්සර් ඔබට ජාවාස්ක්‍රිප්ට් පේළියකින් මෙය කිරීමට ඉඩ දෙයි :

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

මෙම classListලක්ෂණයට සතුව තිබූ DOMTokenList සපයයි විවිධ ක්රම . එකතු කිරීම () , ඉවත් කිරීම () හෝ ප්‍රතිස්ථාපනය () වැනි සරල හැසිරවීම් භාවිතා කරමින් ඔබට මූලද්‍රව්‍ය පන්ති ලැයිස්තුවක් මත ක්‍රියා කළ හැකිය . නැතහොත් ඔබ වස්තුවක් හෝ යතුරු () , අගයන් () , ඇතුළත් කිරීම් () සහිත සිතියමක් වැනි ඉතා නවීන පන්ති හසුරුවන්න.

පීටර් බූටන්ගේ පිළිතුර විශිෂ්ට එකක් නමුත් දැන් එය දශකයකට වඩා පැරණි ය. සියලුම නවීන බ්‍රව්සර් දැන් DOMTokenList සඳහා සහය දක්වයි - https://caniuse.com/#search=classList බලන්න සහ IE11 පවා සමහර DOMTokenList ක්‍රම සඳහා සහය දක්වයි


1

උත්සාහ කරන්න

element.className='second'


-2

වැඩ කරන ජාවාස්ක්‍රිප්ට් කේතය:

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

ඔබට මෙම සබැඳියෙන් වැඩකරන කේතයක් බාගත කළ හැකිය .


1
මෙය එක් පන්තියකට වඩා ඇති මූලද්‍රව්‍ය බිඳ දමනු ඇත.
gcampbell

-4

එය සිදු කිරීම සඳහා සරල jQuery කේතය මෙන්න.

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

මෙහි,

  • පංතිය 1 යනු සිදුවීමකට සවන්දෙන්නෙකි.
  • මව් පංතිය යනු ඔබට වෙනස් කිරීමට අවශ්‍ය පන්තිය සත්කාරක පන්තියයි
  • Classtoremove යනු ඔබ සතුව ඇති පැරණි පන්තියයි.
  • එකතු කිරීමට පන්තිය යනු ඔබට එකතු කිරීමට අවශ්‍ය නව පන්තියයි.
  • 100 යනු පන්තිය වෙනස් කරන කාලය ඉක්මවා යාමයි.

වාසනාව.

By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.