JavaScript window.onload
සහ jQuery $(document).ready()
ක්රමවේදය අතර ඇති වෙනස්කම් මොනවාද?
$().ready()
විට එය ගිනි window.onload
ගනී.
JavaScript window.onload
සහ jQuery $(document).ready()
ක්රමවේදය අතර ඇති වෙනස්කම් මොනවාද?
$().ready()
විට එය ගිනි window.onload
ගනී.
Answers:
මෙම ready
වන අතර HTML ලේඛන, පටවා ඇත පසු සිදුවුවහොත් onload
සියළු අන්තර්ගතය (උදා: පින්තූර) ද පටවා ඇත විට අවස්ථාවට පසුව සිදුවේ.
මෙම onload
සිදුවීම DOM හි සම්මත සිදුවීමක් වන අතර ready
සිද්ධිය jQuery සඳහා විශේෂිත වේ. ready
සිද්ධියේ පරමාර්ථය වන්නේ ලේඛනය පූරණය කිරීමෙන් පසු එය හැකි ඉක්මනින් සිදුවිය යුතු අතර එමඟින් පිටුවේ ඇති මූලද්රව්යයන්ට ක්රියාකාරීත්වය එක් කරන කේතය සියලු අන්තර්ගතයන් පූරණය වන තෙක් බලා සිටිය යුතු නොවේ.
ready
අවස්ථාවට වේ jQuery විශේෂිත. එය DOMContentLoaded
බ්රව්සරයේ තිබේ නම් එය සිදුවීම භාවිතා කරයි , එසේ නොමැති නම් එය අනුකරණය කරයි. DOMContentLoaded
සියලුම බ්රව්සර්වල සිදුවීමට සහය නොදක්වන නිසා DOM හි නිශ්චිත සමානකමක් නොමැත .
onload
. සිදුවීම අවුලුවන onload
විට ආයාචනා කළ යුතු ශ්රිතයක් ගබඩා කරන වස්තු දේපලක නමකි load
.
window.onload
ජාවාස්ක්රිප්ට් ඉසව්වකි, නමුත් එය ක්රියාත්මක කිරීමේදී බ්රව්සර් (ෆයර්ෆොක්ස්, ඉන්ටර්නෙට් එක්ස්ප්ලෝරර් 6, ඉන්ටර්නෙට් එක්ස්ප්ලෝරර් 8, සහ ඔපෙරා ) හරහා සියුම් විචක්ෂණත්වයක් ඇති බැවින් , jQuery සපයන අතර ඒවා වියුක්ත කර පිටුවේ DOM සූදානම් වූ වහාම වෙඩි තබයි. (රූප ආදිය සඳහා රැඳී නොසිටින්න).document.ready
$(document).ready
(එය බව, සටහනක් නොවේ document.ready
නිර්වචනය නොකළ වන,) ඒ jQuery කාර්යය, ඔතන සහ ලබා ඇත , ස්ථාවර පහත සඳහන් සිදුවීම්:
document.ondomcontentready
/ document.ondomcontentloaded
- ලේඛනයේ DOM පටවන විට වෙඩි තබන නව සිදුවීමක් ( පින්තූර ආදිය පැටවීමට ටික කලකට පෙර විය හැක ); නැවතත්, ඉන්ටර්නෙට් එක්ස්ප්ලෝරර් සහ ලෝකයේ සෙසු රටවල තරමක් වෙනස් යwindow.onload
(එය පැරණි බ්රව්සර්වල පවා ක්රියාත්මක වේ), එය මුළු පිටුව පටවන විට (රූප, මෝස්තර, ආදිය) වෙඩි තබයි.load
සිදුවීම window
බ්රව්සර් හරහා සාධාරණ ලෙස ක්රියාත්මක වේ. JQuery සහ අනෙකුත් පුස්තකාල විසඳීමට උත්සාහ කරන ගැටළුව වන්නේ ඔබ සඳහන් කළ දෙයයි, එනම් load
රූප සහ ස්ටයිල් ෂීට් වැනි සියලු යැපෙන සම්පත් පටවන තුරු මෙම අවස්ථාව ඉවත් නොකෙරේ, එය DOM සම්පූර්ණයෙන්ම පටවා බොහෝ කාලයක් ගතවනු ඇත, විදැහුම්කරණය සහ අන්තර්ක්රියා සඳහා සූදානම්. බොහෝ පරිගණක වල ගිනි විශ්ලේෂණයට DOM සූදානම් වන විට කැඳවා ඇති බව මෙම අවස්ථාවට DOMContentLoaded
නොව DOMContentReady
.
onload
(FF / IE / Opera යන වෙනස්කම් ඇතත්) අවම වශයෙන් සමහර වස්තු මංකොල්ලකෑම අවශ්ය වේ. සම්බන්ධයෙන් ගත් කල DOMContentLoaded
, ඔබ සම්පූර්ණයෙන්ම නිවැරදි ය. පැහැදිලි කිරීම සඳහා සංස්කරණය කිරීම.
document.onload
භාවිතා කළ හැකි විය). Window.onload යන තාක් දුරට: window.onload = fn1;window.onload=fn2;
- fn2 පමණක් පමණක් පැටවීම සිදු වේ. සමහර නිදහස් වෙබ් හොස්ට් ඔවුන්ගේම කේත ලේඛනවලට ඇතුළු කරන අතර සමහර විට මෙය පිටුවේ කේතය ආවරණය කරයි.
$(document).ready()
jQuery සිදුවීමකි. $(document).ready()
DOM සූදානම් වූ වහාම JQuery හි ක්රමය කැඳවනු ලැබේ (එයින් අදහස් වන්නේ බ්රව්සරය HTML විග්රහ කොට DOM ගස ගොඩනගා ඇති බවයි). ලේඛනය හැසිරවීමට සූදානම් වූ වහාම කේතය ධාවනය කිරීමට මෙය ඔබට ඉඩ සලසයි.
උදාහරණයක් ලෙස, බ්රව්සරයක් DOMContentLoaded සිද්ධියට සහය දක්වන්නේ නම් (බොහෝ IE නොවන බ්රව්සර් මෙන්), එවිට එය එම සිදුවීමට වෙඩි තබයි. (DOMContentLoaded සිද්ධිය IE9 + හි IE ට පමණක් එකතු කර ඇති බව සලකන්න.)
මේ සඳහා සින්ටැක්ස් දෙකක් භාවිතා කළ හැකිය:
$( document ).ready(function() {
console.log( "ready!" );
});
හෝ කෙටිමං අනුවාදය:
$(function() {
console.log( "ready!" );
});
මේ සඳහා ප්රධාන කරුණු $(document).ready()
:
$
සමග jQuery
ඔබට ලැබෙන විට, "$ අර්ථ දක්වා නැත."$(window).load()
ඒ වෙනුවට භාවිතා කරන්න . window.onload()
ස්වදේශීය ජාවාස්ක්රිප්ට් ශ්රිතයකි. මෙම window.onload()
ඔබේ පිටුවේ සියලු ම අන්තර්ගත විශ්ලේෂණයට DOM (ලියවිල්ල වස්තුව ආකෘතිය), බැනර් දැන්වීම් හා රූප ඇතුළු දිස්වූ විට අවස්ථාවට විනි. මේ දෙක අතර ඇති තවත් වෙනසක් නම්, අපට එක් $(document).ready()
ශ්රිතයකට වඩා තිබිය හැකි අතර , අපට තිබිය හැක්කේ එක් onload
ශ්රිතයක් පමණි .
ඒ වින්ඩෝස් බර අවස්ථාවට ගිනි ඔබේ පිටුවේ සියලු ම අන්තර්ගත සම්පූර්ණයෙන්ම විශ්ලේෂණයට DOM (ලියවිල්ල වස්තුව ආකෘතිය) අන්තර්ගතය සහ ඇතුළු පැටවීමේදී අසමමිතික JavaScript , රාමු සහ රූප . ඔබට body onload = ද භාවිතා කළ හැකිය. දෙකම එක හා සමානයි; window.onload = function(){}
සහ <body onload="func();">
එකම සිදුවීම භාවිතා කිරීමේ විවිධ ක්රම වේ.
jQuery$document.ready
ශ්රිත සිදුවීම ඊට වඩා මඳක් කලින් ක්රියාත්මක වන අතර window.onload
එය DOM (ලේඛන වස්තු ආකෘතිය) ඔබේ පිටුවට පටවා ගත් පසු හැඳින්වේ. රූප, රාමු සම්පූර්ණයෙන් පැටවීම සඳහා එය බලා නොසිටිනු ඇත .
ඊළඟ ලිපියෙන් ගත් විට:
වෙනස් වන්නේ කෙසේද $document.ready()
?window.onload()
$(document).ready(function() {
// Executes when the HTML document is loaded and the DOM is ready
alert("Document is ready");
});
// .load() method deprecated from jQuery 1.8 onward
$(window).on("load", function() {
// Executes when complete page is fully loaded, including
// all frames, objects and images
alert("Window is loaded");
});
<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.7.2/jquery.min.js"></script>
$(document).ready()
ඉන්ටර්නෙට් එක්ස්ප්ලෝරර් සමඟ භාවිතා කිරීම ගැන සැලකිලිමත් වන වචනයක් . සම්පූර්ණ ලේඛනය පූරණය වීමට පෙර HTTP ඉල්ලීමකට බාධා ඇති වුවහොත් (නිදසුනක් ලෙස, පිටුවක් බ්රව්සරයට ගලා යන අතරතුර, තවත් සබැඳියක් ක්ලික් කරනු ලැබේ) IE විසින් $(document).ready
සිදුවීම අවුලුවනු ඇත .
$(document).ready()
සිදුවීම තුළ ඇති ඕනෑම කේතයක් DOM වස්තු ගැන සඳහන් කරන්නේ නම් , එම වස්තූන් සොයා ගැනීමට නොහැකි විභවයක් පවතින අතර ජාවාස්ක්රිප්ට් දෝෂ ඇතිවිය හැකිය. එක්කෝ එම වස්තූන් වෙත ඔබගේ යොමු කිරීම් ආරක්ෂා කරන්න, නැතහොත් එම වස්තු කවුළුව වෙත යොමු කරන කේතය කල් දමන්න.
වෙනත් බ්රව්සර්වල (විශේෂයෙන් ක්රෝම් සහ ෆයර්ෆොක්ස්) මෙම ගැටලුව ප්රතිනිෂ්පාදනය කිරීමට මට නොහැකි විය.
window.addEventListener
කවුළුවක් වෙත සිදුවීමක් එක් කිරීමට සැමවිටම භාවිතා කරන්න. ඒ නිසා ඔබට විවිධ සිදුවීම් හසුරුවන්නන් තුළ කේතය ක්රියාත්මක කළ හැකිය.
නිවැරදි කේතය:
window.addEventListener('load', function () {
alert('Hello!')
})
window.addEventListener('load', function () {
alert('Bye!')
})
අවලංගු කේතය:
window.onload = function () {
alert('Hello!') // it will not work!!!
}
window.onload = function () {
alert('Bye!')
}
මෙයට හේතුව, පැටවීම යනු වස්තුවේ දේපල පමණක් වන අතර එය නැවත ලියනු ලැබේ.
සමඟ සැසඳීමෙන්, පැටවීම වෙනුවට addEventListener
භාවිතා $(document).ready()
කිරීම වඩා හොඳය.
$(document).on('ready', handler)
jQuery වෙතින් සූදානම් සිදුවීමට බැඳී ඇත. DOM පටවන විට හසුරුවන්නා හැඳින්වේ . රූප වැනි වත්කම් තවමත් අතුරුදහන් . බන්ධනය කරන අවස්ථාවේ දී ලේඛනය සූදානම් නම් එය කිසි විටෙකත් කැඳවනු නොලැබේ. jQuery ඒ සඳහා DOMContentLoaded -Event භාවිතා කරයි , එය නොමැති නම් එය අනුකරණය කරයි.
$(document).on('load', handler)
සියලු සම්පත් සේවාදායකයෙන් පූරණය වූ පසු ඉවත් කරනු ලබන සිදුවීමකි . පින්තූර දැන් පටවා ඇත. අතර පැල්ටපෝමයක් අමු HTML සිදුවීමකි, සූදානම් jQuery විසින් ඉදිකර ඇත.
$(document).ready(handler)
ඇත්ත වශයෙන්ම පොරොන්දුවක් . ඇමතුම ලබා දෙන අවස්ථාවේදී ලේඛනය සූදානම් නම් හසුරුවන්නා වහාම කැඳවනු ලැබේ. එසේ නොමැති නම් එය ready
-එවන්ට් සමඟ බැඳී ඇත .
JQuery 1.8 ට පෙර , $(document).load(handler)
අන්වර්ථයක් ලෙස පැවතුනි $(document).on('load',handler)
.
$.fn.load
ඇති අතර එය තවදුරටත් සිදුවීම් බන්ධනය ලෙස හැසිරෙන්නේ නැත. ඇත්ත වශයෙන්ම, එය jquery 1.8 සිට යල්පැන ඇත. මම ඒ අනුව එය යාවත්කාලීන කළෙමි
මෙම $(document).ready()
යනු jQuery සුරකීම ලේඛනයක් සම්පූර්ණයෙන්ම අතර, පටවා ඇත විට සිදුවන, අවස්ථාවට window.onload
පිටුව මත රූප ඇතුළු සෑම දෙයක්ම පටවා විට, අවස්ථාවට පසුව සිදුවේ.
Window.onload යනු DOM හි පිරිසිදු ජාවාස්ක්රිප්ට් සිදුවීමක් වන අතර $(document).ready()
සිද්ධිය jQuery හි ක්රමයකි.
$(document).ready()
සාමාන්යයෙන් jQuery සඳහා වන එතීම යනු සියලුම පටවා ඇති මූලද්රව්යයන් jQuery හි භාවිතා කිරීමට වග බලා ගැනීමයි ...
එය ක්රියාත්මක වන ආකාරය තේරුම් ගැනීමට jQuery ප්රභව කේතය දෙස බලන්න:
jQuery.ready.promise = function( obj ) {
if ( !readyList ) {
readyList = jQuery.Deferred();
// Catch cases where $(document).ready() is called after the browser event has already occurred.
// we once tried to use readyState "interactive" here, but it caused issues like the one
// discovered by ChrisS here: http://bugs.jquery.com/ticket/12282#comment:15
if ( document.readyState === "complete" ) {
// Handle it asynchronously to allow scripts the opportunity to delay ready
setTimeout( jQuery.ready );
// Standards-based browsers support DOMContentLoaded
} else if ( document.addEventListener ) {
// Use the handy event callback
document.addEventListener( "DOMContentLoaded", completed, false );
// A fallback to window.onload, that will always work
window.addEventListener( "load", completed, false );
// If IE event model is used
} else {
// Ensure firing before onload, maybe late but safe also for iframes
document.attachEvent( "onreadystatechange", completed );
// A fallback to window.onload, that will always work
window.attachEvent( "onload", completed );
// If IE and not a frame
// continually check to see if the document is ready
var top = false;
try {
top = window.frameElement == null && document.documentElement;
} catch(e) {}
if ( top && top.doScroll ) {
(function doScrollCheck() {
if ( !jQuery.isReady ) {
try {
// Use the trick by Diego Perini
// http://javascript.nwbox.com/IEContentLoaded/
top.doScroll("left");
} catch(e) {
return setTimeout( doScrollCheck, 50 );
}
// detach all dom ready events
detach();
// and execute any waiting functions
jQuery.ready();
}
})();
}
}
}
return readyList.promise( obj );
};
jQuery.fn.ready = function( fn ) {
// Add the callback
jQuery.ready.promise().done( fn );
return this;
};
මේ දෙකම සඳහා ඉක්මන් යොමු කිරීමක් ලෙස මම පහත රූපය නිර්මාණය කර ඇත්තෙමි:
window.onload: සාමාන්ය ජාවාස්ක්රිප්ට් සිදුවීමක්.
document.ready: සම්පූර්ණ HTML පටවා ඇති විට නිශ්චිත jQuery සිදුවීමක්.
මතක තබා ගත යුතු එක් දෙයක් නම් (හෝ මා සිහිපත් කළ යුතු යැයි කිවහොත්) ඔබට හැකි තරම් ඒවා ගොඩගැසීමට onload
නොහැකි ready
වීමයි. වෙනත් වචන වලින් කිවහොත්, jQuery මැජික් ready
එකම පිටුවක බහු s වලට ඉඩ දෙයි , නමුත් ඔබට එය කළ නොහැක onload
.
අන්තිමයා onload
කලින් තිබූ ඕනෑම දෙයක් අභිබවා යයි onload
.
එය සමඟ ගනුදෙනු කිරීමට හොඳ ක්රමයක් වන්නේ එක් සයිමන් විලිසන් විසින් පැහැදිලිවම ලියා ඇති අතර බහු ජාවාස්ක්රිප්ට් ඔන්ලෝඩ් කාර්යයන් භාවිතා කිරීම විස්තර කර ඇත .
function addLoadEvent(func) {
var oldonload = window.onload;
if (typeof window.onload != 'function') {
window.onload = func;
}
else {
window.onload = function() {
if (oldonload) {
oldonload();
}
func();
}
}
}
// Example use:
addLoadEvent(nameOfSomeFunctionToRunOnPageLoad);
addLoadEvent(function() {
/* More code to run on page load */
});
Document.ready
(jQuery සිදුවීමක්) සියලුම මූලද්රව්ය ක්රියාත්මක වන විට වෙඩි තබනු ඇති අතර ඒවා ජාවාස්ක්රිප්ට් කේතයේ සඳහන් කළ හැකි නමුත් අන්තර්ගතය අනිවාර්යයෙන්ම පටවනු නොලැබේ. Document.ready
HTML ලේඛනය පටවන විට ක්රියාත්මක වේ.
$(document).ready(function() {
// Code to be executed
alert("Document is ready");
});
මෙම window.load
කෙසේ වෙතත් සම්පූර්ණෙයන් පටවා කිරීමට පිටුව සඳහා බලා සිටීමට වනු ඇත. අභ්යන්තර රාමු, රූප ආදිය මෙයට ඇතුළත් වේ.
$(window).load(function() {
//Fires when the page is loaded completely
alert("window is loaded");
});
Document.ready සිදුවීම සිදුවන්නේ HTML ලේඛනය පටවා ඇති විට වන අතර, window.onload
සිදුවීම සෑම විටම පසුව සිදු වේ, සියලු අන්තර්ගතයන් (රූප ආදිය) පටවා ඇති විට.
document.ready
පින්තූර පූරණය වන තෙක් බලා නොසිට, විදැහුම්කරණ ක්රියාවලියේදී "මුල්" මැදිහත් වීමට ඔබට අවශ්ය නම් ඔබට සිද්ධිය භාවිතා කළ හැකිය . ඔබගේ ස්ක්රිප්ට් "යමක් කිරීමට" පෙර ඔබට පින්තූර (හෝ වෙනත් "අන්තර්ගතයක්") අවශ්ය නම්, ඔබ බලා සිටිය window.onload
යුතුය.
උදාහරණයක් ලෙස, ඔබ "විනිවිදක දර්ශන" රටාවක් ක්රියාත්මක කරන්නේ නම් සහ රූප ප්රමාණ මත පදනම්ව ගණනය කිරීම් සිදු කිරීමට අවශ්ය නම්, ඔබට බලා සිටීමට අවශ්ය විය හැකිය window.onload
. එසේ නොමැතිනම්, පින්තූර කෙතරම් වේගයෙන් පටවනු ලැබේද යන්න මත පදනම්ව ඔබට අහඹු ගැටළු කිහිපයක් ඇතිවිය හැකිය. ඔබගේ ස්ක්රිප්ට් රූප පටවන නූල් සමඟ සමගාමීව ක්රියාත්මක වේ. ඔබගේ ස්ක්රිප්ට් එක ප්රමාණවත් තරම් දිගු නම් හෝ සේවාදායකය ප්රමාණවත් තරම් වේගවත් නම්, පින්තූර නියමිත වේලාවට පැමිණේ නම් ඔබට ගැටළුවක් නොපෙනේ. නමුත් ආරක්ෂිතම පුහුණුව වනුයේ රූප පැටවීමට ඉඩ දීමයි.
document.ready
පරිශීලකයින්ට "පැටවීම ..." ලකුණක් පෙන්වීම ඔබට හොඳ සිදුවීමක් විය හැකි අතර, සම්පත් පැටවීමට window.onload
අවශ්ය ඕනෑම ස්ක්රිප්ටින් එකක් සම්පූර්ණ කළ හැකි අතර අවසානයේ "පූරණය වේ ..." ලකුණ ඉවත් කරන්න.
උදාහරණ :-
// document ready events
$(document).ready(function(){
alert("document is ready..");
})
// using JQuery
$(function(){
alert("document is ready..");
})
// window on load event
function myFunction(){
alert("window is loaded..");
}
window.onload = myFunction;
window.onload
යනු ජාවාස්ක්රිප්ට් ඉන්බිල්ට් ශ්රිතයකි. window.onload
HTML පිටුව පූරණය වූ විට ප්රේරකය. window.onload
ලිවිය හැක්කේ එක් වරක් පමණි.
document.ready
jQuery පුස්තකාලයේ ශ්රිතයකි. document.ready
HTML සහ HTML ගොනුවට ඇතුළත් කර ඇති සියලුම ජාවාස්ක්රිප්ට් කේතය, CSS සහ රූප සම්පූර්ණයෙන්ම පටවන විට එය ක්රියාත්මක වේ.
document.ready
අවශ්යතා අනුව කිහිප වතාවක් ලිවිය හැකිය.
ඔබ කියන විට $(document).ready(f)
, ඔබ පහත සඳහන් දේ කිරීමට ස්ක්රිප්ට් එන්ජිමට කියයි:
$
එය තෝරන්න, එය දේශීය විෂය පථයට අයත් නොවන බැවින්, එය හැෂ් වගු සෙවීමක් කළ යුතු අතර එය ගැටීම් ඇති විය හැකිය.ready
තෝරාගත් වස්තුව ඇමතීම , එමඟින් ක්රමවේදය සොයා ගැනීමට සහ එය ක්රියාත්මක කිරීමට තෝරාගත් වස්තුවට තවත් හැෂ් වගු සෙවීමක් ඇතුළත් වේ.හොඳම දෙය නම්, මෙය හැෂ් වගු බැලීම් 2 ක් වන නමුත් එය jQuery විසින් සිදු කරන ලද අධික වැඩ නොසලකා හැරීමකි, jQuery වෙත $
කළ හැකි සියලු යෙදවුම්වල මුළුතැන්ගෙයි බේසම කොතැනද , එබැවින් නිවැරදි හසුරුවන්නා සඳහා විමසුම යැවීමට තවත් සිතියමක් තිබේ.
විකල්පයක් ලෙස, ඔබට මෙය කළ හැකිය:
window.onload = function() {...}
කැමති
onload
හැෂ් මේසයක් බැලීමෙන් දේපලක් තිබේද නැද්ද යන්න පරීක්ෂා කරන්න , මන්ද එය ශ්රිතයක් ලෙස හැඳින්වේ.හොඳම අවස්ථාවෙහිදී, මේ සඳහා තනි හැෂ් වගුවක් බැලීමට වැය වන අතර එය ලබා onload
ගත යුතුය.
ඉතා මැනවින්, jQuery විසින් ඔවුන්ගේ විමසුම් සම්පාදනය කරනුයේ ඔබට jQuery කිරීමට අවශ්ය දේ කිරීමට ඇලවිය හැකි නමුත් ධාවන කාලය jQuery යැවීමකින් තොරව ය. මේ ආකාරයෙන් ඔබට විකල්පයක් ඇත
eval
.window.onload සපයනු ලබන්නේ DOM api විසින් වන අතර එය පවසන්නේ “දී ඇති සම්පතක් පටවා ඇති විට පැටවීමේ සිදුවීම ගිනි ගනී” යන්නයි.
"ලේඛන පැටවීමේ ක්රියාවලිය අවසානයේදී පැටවීමේ සිදුවීම ගිනි ගනී. මෙම අවස්ථාවෙහිදී, ලේඛනයේ ඇති සියලුම වස්තූන් DOM හි ඇත. සියලුම රූප, ස්ක්රිප්ට්, සබැඳි සහ උප රාමු පැටවීම අවසන් කර ඇත." DOM onload
නමුත් jQuery $ (ලේඛනය) තුළ. සූදානම් () ක්රියාත්මක වන්නේ ජාවාස්ක්රිප්ට් කේතය ක්රියාත්මක කිරීමට ලේඛන වස්තු ආකෘතිය (DOM) සූදානම් වූ පසු පමණි. පින්තූර, ස්ක්රිප්ට්, අයිෆ්රේම් ආදිය මෙයට ඇතුළත් නොවේ. Jquery සූදානම් සිදුවීම
එබැවින් jquery සූදානම් කිරීමේ ක්රමය ඩොම් ඔන්ලෝඩ් ඉසව්වට වඩා කලින් ක්රියාත්මක වේ.