ஜாவாஸ்கிரிப்ட் இல்

Noah Rousseau

ஞாயிறு, 29 செப்டம்பர், 2024 ’அன்று’ முற்பகல் 10:34:37

பல தயாரிப்புகளுக்கான பயனுள்ள ஜாவாஸ்கிரிப்ட் கவுண்டர் புதுப்பிப்புகள்

ஜாவாஸ்கிரிப்ட் டைனமிக் உள்ளீட்டு கூறுகளுடன் பணிபுரிவது சவாலாக இருக்கும், குறிப்பாக உள்ளே உள்ள மதிப்புகளை நிபந்தனையுடன் புதுப்பிக்கும்போது என்றால்-வேறு அறிக்கைகள். ஆன்லைன் ஷாப்பிங் கார்ட்டில் பொருட்களைச் சேர்ப்பது போன்ற சூழ்நிலைகளில் மொத்தங்களையும் தொகைகளையும் துல்லியமாகப் பதிவு செய்வது மிகவும் முக்கியமானது. இருப்பினும், இந்த சூழ்நிலையில் பல விஷயங்களை நிர்வகிப்பது டெவலப்பர்களுக்கு அடிக்கடி சிரமங்களை அளிக்கிறது.

ஷாப்பிங் பேஸ்கெட்டில் புதிய விஷயங்களைத் தேர்ந்தெடுப்பது, முன்பு தேர்ந்தெடுத்த உருப்படிகளுக்கான கவுண்டரை மீட்டமைக்கச் செய்யும் ஒரு பொதுவான சிக்கலை இந்த இடுகை விவாதிக்கும். கவுண்டர்கள் முதலில் சரியாகச் செயல்பட்டாலும், உருப்படிகளுக்கு இடையே மாற்றும்போது அவை மீட்டமைக்கப்படும். கார்ட்டில் உள்ள அனைத்து தயாரிப்புகளும் சரியான அளவைக் குறிக்காததால் பயனர்கள் இந்த நடத்தையால் குழப்பமடைகின்றனர்.

இந்தச் சிக்கல் எழும் குறியீடு உதாரணத்தைப் பார்த்து, அதற்கான காரணத்தைப் பற்றி விவாதிப்போம். சுமூகமான செயல்பாட்டிற்கு, ஒவ்வொரு தயாரிப்பின் கவுண்டரையும் எப்படிக் கட்டுக்குள் வைத்திருப்பது என்பதைத் தெரிந்துகொள்வது மற்றும் அனைத்து உள்ளீட்டு எண்களும் மாறாமல் இருப்பதற்கான உத்தரவாதம் அவசியம். சில மாற்றங்களுடன், என்றால்-வேறு ஜாவாஸ்கிரிப்ட் லாஜிக்கைப் பயன்படுத்தும் கூற்றுகள் இதைத் தகுந்த முறையில் கையாளும்.

இந்தக் கட்டுரையைப் படித்து முடிப்பதற்குள், சிக்கலைச் சரிசெய்வது மற்றும் கவுண்டர்கள் அனைத்தையும் பாதுகாப்பது எப்படி என்பதை நீங்கள் அறிந்துகொள்வீர்கள், உங்கள் ஷாப்பிங் கார்ட் ஒவ்வொரு பொருளுக்கும் இடையில் மாறும்போதும் அதன் சரியான அளவை எப்போதும் காண்பிக்கும்.

கட்டளை	பயன்பாட்டின் உதாரணம்
cart = {}	கார்ட் உருப்படி கவுண்டர் சேமிப்பிற்கான வெற்றுப் பொருளை வரையறுக்கிறது. இந்த பொருளின் உதவியுடன், உருப்படிகளுக்கு இடையில் மாற்றும்போது நிலையை மீட்டமைக்காமல், ஒவ்வொரு தயாரிப்புக்கான மொத்தங்களையும் அளவுகளையும் மாறும் வகையில் கண்காணிக்கலாம்.
updateCart(item, price, counterKey)	ஒவ்வொரு முறையும் ஒரு பொருளைக் கிளிக் செய்யும் போது வண்டியை மாற்றியமைக்கும் அசல் அம்சம். எண்ணிக்கை மற்றும் தொகையைப் புதுப்பிக்க, உருப்படியின் பெயர், விலை மற்றும் ஒவ்வொரு பொருளுக்கும் ஒரு சிறப்பு விசைக்கான அளவுருக்கள் தேவை.
cart[counterKey]	ஒவ்வொரு பொருளுக்கும் கார்ட் பொருளுக்கு ஒரு சொத்தை ("மைலோகவுண்டர்" போன்றவை) அணுகுகிறது அல்லது சேர்க்கிறது. விசை ஏற்கனவே இல்லாவிட்டால், அது குறிப்பிட்ட தயாரிப்புக்காக மட்டுமே எண்ணிக்கை அதிகரிக்கப்படுவதை உறுதிசெய்கிறது.
renderCart()	உள்ளடக்கங்களை மாறும் வகையில் வழங்க, வண்டியில் உள்ள ஒவ்வொரு பொருளின் மீதும் மீண்டும் செயல்படும் செயல்பாடு. தயாரிப்பு மொத்தத்தையும் அளவுகளையும் காட்ட, அது தேவையான HTML ஐ உருவாக்குகிறது மற்றும் பூஜ்ஜியமற்ற கவுண்டர்களைத் தேடுகிறது.
for (var item in cartItems)	வண்டியில் உள்ள ஒவ்வொரு பொருளுக்கும் மீண்டும் மீண்டும். ரெண்டரிங் செய்வதற்கு முன், இந்த லூப் ஒவ்வொரு பொருளின் எண்ணிக்கையையும் தீர்மானிக்கிறது.
document.getElementById()	அவற்றின் தனித்துவமான ஐடியின் அடிப்படையில் HTML கூறுகளை ("மைலோ" மற்றும் "ஓவல்டைன்" போன்றவை) தேர்ந்தெடுக்கிறது. கார்ட்டில் உள்ள ஒவ்வொரு தயாரிப்புகளுடனும் தொடர்பு கொள்ள நிகழ்வு கேட்பவர்களை இணைப்பதன் மூலம் UI ஐ JavaScript லாஜிக்குடன் இணைப்பதை இது சாத்தியமாக்குகிறது.
console.assert()	சோதனைக்கான மாதிரி அலகு சோதனையில் பயன்படுத்தப்பட்டது. கார்ட்டில் உள்ள உண்மையான மதிப்புகள் எதிர்பார்க்கப்படும் மதிப்புகளுடன் ("மைலோ" எண்ணிக்கை) பொருந்துகின்றனவா என்பதை இது சரிபார்க்கிறது. சோதனை தோல்வியடையும் போது கன்சோலில் பிழை ஏற்படுகிறது, இது சிக்கலைக் கண்டறிய உதவுகிறது.
innerHTML +=	வண்டியில் உள்ள அட்டவணை வரிசை போன்ற ஏற்கனவே உள்ள உறுப்பில் புதிய HTML உள்ளடக்கத்தைச் சேர்க்கிறது. இந்த நுட்பத்தின் மூலம், தற்போதைய உள்ளடக்கத்தை அழிக்காமல் புதிய தயாரிப்பு உள்ளீடுகளை ஷாப்பிங் கார்ட்டில் மாறும் வகையில் சேர்க்கலாம்.
addEventListener('click')	ஒவ்வொரு தயாரிப்பின் பொத்தான் அல்லது படத்திலும் கிளிக் நிகழ்வு கேட்பவரைச் சேர்க்கிறது. கார்ட்டின் அளவுகள் மற்றும் மொத்தங்களை மாறும் வகையில் மாற்றுவதன் மூலம், ஒரு பொருளை பயனர் கிளிக் செய்யும் போது தொடர்புடைய செயல்பாடு செயல்படுத்தப்படுகிறது.

ஜாவாஸ்கிரிப்ட் மூலம் டைனமிக் கார்ட் புதுப்பிப்பு சிக்கல்களைத் தீர்க்கிறது

ஷாப்பிங் கார்ட்டில் பல தயாரிப்புகளை நிர்வகிக்க ஜாவாஸ்கிரிப்டைப் பயன்படுத்தும் போது மேற்கூறிய ஸ்கிரிப்ட்கள் அடிக்கடி ஏற்படும் சிக்கலைத் தீர்க்கின்றன. முதன்மைச் சிக்கல் என்னவென்றால், புதிய உருப்படியைச் சேர்ப்பது முன்பு சேர்க்கப்பட்ட உருப்படிகளுக்கான கவுண்டர்களை மீட்டமைக்கிறது. ஸ்கிரிப்ட்கள் இதை நிவர்த்தி செய்ய நிகழ்வு கேட்பவர்களுடன் சேர்த்து உருப்படிகளின் எண்ணிக்கை மற்றும் மொத்தங்களைச் சேமிக்க ஒரு பொருள் அடிப்படையிலான முறையைப் பயன்படுத்துகின்றன. ஒவ்வொரு தயாரிப்பின் கவுண்டரும் புதுப்பிக்கப்பட்டு மற்றவற்றில் குறுக்கிடாமல் தனித்தனியாக பராமரிக்கப்படும் என்று நாங்கள் உத்தரவாதம் அளிக்கிறோம் வண்டி பொருள். இந்த முறை மீட்டமைவு சிக்கலை நீக்குகிறது, இதனால் ஒவ்வொரு தயாரிப்புக்கான எண்ணிக்கை துல்லியமாக இருக்கும்.

தி updateCart வண்டியில் தயாரிப்புகளைச் சேர்ப்பதை மாறும் வகையில் நிர்வகிக்கும் முறை, தீர்வின் ஒரு முக்கிய அங்கமாகும். ஒரு பொருள் வண்டியில் உள்ளதா என்பதைத் தீர்மானிக்க, இந்தச் செயல்பாடு தனித்துவமான கவுண்டர் விசையை ("மைலோகவுண்டர்" போன்றவை) பயன்படுத்துகிறது. உருப்படி சேர்க்கப்படுவது இதுவே முதல் முறை என்றால், ஸ்கிரிப்ட் கவுண்டரைத் துவக்குகிறது. இல்லையெனில், செயல்பாடு மொத்த விலையை மீண்டும் கணக்கிடுகிறது மற்றும் தற்போதைய கவுண்டரை அதிகரிக்கிறது. தி உள் HTML பண்புக்கூறு HTML ஐ மேம்படுத்துகிறது, இதனால் பயனர் மாற்றங்களை இப்போதே பார்க்க முடியும்.

வண்டியில் உள்ள ஒவ்வொரு பொருளின் துல்லியமான காட்சிக்கு உத்தரவாதம் அளிக்கப்படுகிறது ரெண்டர்கார்ட் செயல்பாடு. இது மூலம் மீண்டும் நிகழ்கிறது வண்டிப் பொருட்கள் பொருள், ஒவ்வொரு தயாரிப்பின் எண்ணிக்கையும் பூஜ்ஜியத்தை மீறுகிறதா என்பதைச் சரிபார்க்கிறது. அவ்வாறான நிலையில், ஒவ்வொரு பொருளின் தொகையையும் மொத்த விலையையும் காட்ட தேவையான HTML ஐ செயல்பாடு உருவாக்குகிறது. இது புதிய தயாரிப்புகளைச் சேர்ப்பதால் பழையவற்றை மேலெழுத முடியாது மற்றும் வண்டியின் காட்சி மின்னோட்டத்தை பராமரிக்கிறது. ஆன்லைன் பயன்பாடுகளில், டைனமிக் உள்ளடக்கத்தைக் கையாள இந்த நுட்பம் மிகவும் உதவியாக இருக்கும்.

மேலும், console.assert உருப்படி கவுண்டர்கள் மற்றும் மொத்தங்கள் நோக்கம் கொண்டதாக செயல்படுகின்றன என்பதை சரிபார்க்க அலகு சோதனைகளில் பயன்படுத்தப்படுகிறது. தயாரிப்பு பொத்தான்களைக் கிளிக் செய்வதன் மூலம், எதிர்பார்க்கப்படும் கவுண்டர் மதிப்புகள், இல் சேமிக்கப்பட்ட உண்மையான முடிவுகளுடன் பொருந்துவதை உறுதிசெய்தல் வண்டி பொருள், இந்த சோதனைகள் பயனர் தொடர்புகளைப் பின்பற்றுகின்றன. இது சரியான பகுத்தறிவுக்கு உத்தரவாதம் அளிக்கிறது மற்றும் பிழைகள் கண்டறியப்படாமல் தடுக்கிறது. எல்லாவற்றையும் கருத்தில் கொண்டால், ஜாவாஸ்கிரிப்டில் இயங்கும் ஒரு வணிக வண்டியில் தயாரிப்பு புதுப்பிப்புகளை நிர்வகிப்பதற்கான ஸ்கிரிப்டுகள் மீண்டும் பயன்படுத்தக்கூடிய மற்றும் மட்டு அணுகுமுறையை வழங்குகின்றன.

ஜாவாஸ்கிரிப்ட் ஷாப்பிங் கார்ட்டில் டைனமிக் தயாரிப்பு கவுண்டர்களைக் கையாளுதல்

டைனமிக் கார்ட் புதுப்பிப்புகளுக்கு அடிப்படை ஜாவாஸ்கிரிப்டைப் பயன்படுத்துதல்

var milo = document.getElementById('milo');
var ovaltine = document.getElementById('ovaltine');
var bournvita = document.getElementById('bournvita');
var miloPrice = 2000.00, miloCounter = 0, miloAmount = 0;
var ovaltinePrice = 1500.00, ovaltineCounter = 0, ovaltineAmount = 0;
var bournvitaPrice = 1850.00, bournvitaCounter = 0, bournvitaAmount = 0;

var cart = {}; // Object to store counters for each item

function updateCart(item, price, counterKey) {
    if (!cart[counterKey]) { cart[counterKey] = 1; } 
    else { cart[counterKey] += 1; }
    var total = cart[counterKey] * price;
    document.getElementById('cartdetails').innerHTML +=
    '<tr><td>' + cart[counterKey] + '</td><td>' + total + '</td></tr>';
}

milo.addEventListener('click', function() { updateCart('milo', miloPrice, 'miloCounter'); });
ovaltine.addEventListener('click', function() { updateCart('ovaltine', ovaltinePrice, 'ovaltineCounter'); });
bournvita.addEventListener('click', function() { updateCart('bournvita', bournvitaPrice, 'bournvitaCounter'); });

ஜாவாஸ்கிரிப்ட் பொருள்களைப் பயன்படுத்தி கார்ட் உருப்படி புதுப்பிப்புகளைக் கையாளுதல்

பொருள் அடிப்படையிலான மாநில நிர்வாகத்துடன் JavaScript ஐப் பயன்படுத்துதல்

var cartItems = {
    'milo': { price: 2000, count: 0, total: 0 },
    'ovaltine': { price: 1500, count: 0, total: 0 },
    'bournvita': { price: 1850, count: 0, total: 0 }
};

function updateCartItem(item) {
    cartItems[item].count += 1;
    cartItems[item].total = cartItems[item].count * cartItems[item].price;
    renderCart();
}

function renderCart() {
    var cartHTML = '';
    for (var item in cartItems) {
        if (cartItems[item].count > 0) {
            cartHTML += '<tr><td>' + cartItems[item].count + '</td><td>' + cartItems[item].total + '</td></tr>';
        }
    }
    document.getElementById('cartdetails').innerHTML = cartHTML;
}

document.getElementById('milo').addEventListener('click', function() { updateCartItem('milo'); });
document.getElementById('ovaltine').addEventListener('click', function() { updateCartItem('ovaltine'); });
document.getElementById('bournvita').addEventListener('click', function() { updateCartItem('bournvita'); });

JavaScript கார்ட் கவுண்டர் செயல்பாட்டிற்கான அலகு சோதனை

சோதனை நிகழ்வுகளுடன் எளிய ஜாவாஸ்கிரிப்ட் செயல்பாடுகளைப் பயன்படுத்துதல்

function testCartCounter() {
    var testCart = { 'milo': 0, 'ovaltine': 0, 'bournvita': 0 };
    function clickProduct(item) { testCart[item] += 1; }
    clickProduct('milo');
    clickProduct('ovaltine');
    console.assert(testCart['milo'] === 1, 'Milo should have 1 count');
    console.assert(testCart['ovaltine'] === 1, 'Ovaltine should have 1 count');
    clickProduct('milo');
    console.assert(testCart['milo'] === 2, 'Milo should have 2 counts');
    console.log('All tests passed');
}

testCartCounter();

ஜாவாஸ்கிரிப்ட் ஷாப்பிங் கார்ட்களில் நிலையைப் பராமரித்தல் மற்றும் எதிர் மீட்டமைப்புகளைத் தடுப்பது

ஜாவாஸ்கிரிப்டில் டைனமிக் ஷாப்பிங் கார்ட்களுடன் பணிபுரியும் போது, குறிப்பாக புதிய தயாரிப்புகள் சேர்க்கப்படும் போது, வண்டியில் உள்ள ஒவ்வொரு பொருளின் நிலையையும் பராமரிப்பது பொதுவான சிரமமாகும். தயாரிப்புகளுக்கு இடையே மாறும்போது நிகழ்வு கேட்போர் எண்ணிக்கையை மீட்டமைக்கும்போது சிக்கல் பொதுவாக எழுகிறது, ஏனெனில் அவை ஒவ்வொரு தயாரிப்புக்கும் சரியாக சேமிக்கப்படவில்லை அல்லது தக்கவைக்கப்படவில்லை. வண்டியில் உள்ள ஒவ்வொரு பொருளின் நிலையையும் உள்ளடக்கிய உலகளாவிய பொருளை உருவாக்குவது இதை கையாள மிகவும் பயனுள்ள முறையாக இருக்கும். இந்த முறையில், புதிய உருப்படியைக் கிளிக் செய்தாலும் முந்தைய உருப்படிகளின் கவுண்டர்கள் மாறாது.

ஒரு உலகளாவிய பொருளில் சேமிப்பதன் மூலம் மற்ற ஸ்கிரிப்ட் கூறுகளின் குறுக்கீடு இல்லாமல் ஒவ்வொரு தயாரிப்பின் அளவு மற்றும் விலையை நீங்கள் அணுகலாம் மற்றும் திருத்தலாம் வண்டிப் பொருட்கள். கூடுதலாக, பொருள் அடிப்படையிலான முறையானது நன்கு வரையறுக்கப்பட்ட கட்டமைப்பை வழங்குகிறது, இது ஒரே நேரத்தில் பல பொருட்களை நிர்வகிக்க உதவுகிறது. ஒவ்வொரு முறையும் ஒரு பொருளைக் கிளிக் செய்யும் போது பொருளின் தொடர்புடைய பகுதி மாற்றியமைக்கப்படுகிறது, மேலும் மாற்றங்கள் வணிக வண்டி இடைமுகத்தில் உடனடியாகக் காட்டப்படும்.

கார்ட்டின் ஒவ்வொரு ரெண்டருக்கும் அல்லது புதுப்பித்தலுக்கும் முந்தைய உருப்படி நிலைகள் சரிபார்க்கப்பட்டு பராமரிக்கப்படுகின்றன என்பதை உறுதிப்படுத்துவதும் முக்கியமானது. இதைச் செய்ய, கார்ட்டில் உள்ள சமீபத்திய தரவைப் பயன்படுத்தி வண்டியை ரெண்டர் செய்யவும் வண்டிப் பொருட்கள் பொருள். முந்தைய தரவை மேலெழுதுவதில் உள்ள சிக்கலைத் தவிர்த்து, பொருட்களைச் சேர்த்த பிறகும் அல்லது அகற்றிய பிறகும் வண்டியில் உள்ள எல்லாப் பொருட்களும் சரியான எண்கள் மற்றும் மொத்தங்களைக் காட்டுவதற்கு இந்த முறை உத்தரவாதம் அளிக்கிறது.

JavaScript ஷாப்பிங் கார்ட் லாஜிக் பற்றி அடிக்கடி கேட்கப்படும் கேள்விகள்

நான் பொருட்களை நகர்த்தும்போது கவுண்டர்கள் தொடங்குவதை எப்படி நிறுத்துவது?
எதிர் மீட்டமைப்புகளைத் தவிர்க்க, உலகளாவிய பொருளைப் பயன்படுத்தி ஒவ்வொரு பொருளுக்கும் தனித்தனியாக மொத்தங்களையும் அளவுகளையும் பதிவு செய்யலாம் cartItems.
எனது கார்ட்டில் ஒரு புதிய பொருளைச் சேர்க்கும்போது, அது ஏன் முந்தைய உள்ளீடுகளை மேலெழுதுகிறது?
கார்ட்டின் அசல் HTML ஐ மாற்றியமைக்கும் குறியீட்டின் விளைவாக இது நிகழ்கிறது. அதை சரிசெய்ய, பயன்படுத்தி புதிய பொருட்களை இணைக்கவும் innerHTML += உள்ளவற்றை அகற்றாமல்.
கார்ட்டை டைனமிக் முறையில் புதுப்பிக்க சிறந்த வழி எது?
ஜாவாஸ்கிரிப்ட் தரவுகளுடன் கார்ட் எப்போதும் புதுப்பித்த நிலையில் இருப்பதை உறுதிசெய்ய, இது போன்ற செயல்பாட்டைப் பயன்படுத்தவும் renderCart கார்ட் உருப்படிகள் அனைத்திலும் திரும்பத் திரும்பச் சென்று காட்சியை மாற்றுகிறது.
எனது கவுண்டர்கள் சரியாக வேலை செய்கின்றன என்பதை நான் எவ்வாறு சரிபார்க்க முடியும்?
சிக்கல்களைக் கண்டறிய உதவ, பயன்படுத்தவும் console.assert உங்கள் கார்ட் எண்ணிக்கைகள் ஒவ்வொரு தொடர்புக்குப் பிறகும் சரியான மதிப்புகளைக் காட்டுகின்றனவா என்பதைச் சரிபார்க்க.
வெவ்வேறு தயாரிப்புகளுக்கு ஒரே குறியீட்டைப் பயன்படுத்த முடியுமா?
ஆம், குறியீட்டை மாடுலரைஸ் செய்வதன் மூலமும், செயல்பாடுகளைப் பயன்படுத்துவதன் மூலமும் குறைந்தபட்ச மாற்றங்களுடன் எத்தனை பொருட்களின் தர்க்கத்தை நீங்கள் கையாளலாம் updateCart.

ஜாவாஸ்கிரிப்டில் எதிர் மீட்டமைப்புகளைத் தடுப்பது பற்றிய இறுதி எண்ணங்கள்

ஒரு டைனமிக் வண்டியின் நிலையை அப்படியே வைத்திருப்பதற்கான ரகசியம், ஒரு பொருளில் உருப்படி-குறிப்பிட்ட தகவல்களை, மொத்தங்கள் மற்றும் கவுண்டர்களை சேமிப்பதாகும். புதிய தயாரிப்புகள் அறிமுகப்படுத்தப்பட்டாலும், முந்தைய பொருட்கள் அவற்றின் துல்லியமான மதிப்புகளைப் பேணுவதை இந்த நுட்பம் உறுதி செய்கிறது. கவுண்டர்கள் ஒன்றுக்கு மீட்டமைக்கப்படும் சிக்கல் தவிர்க்கப்பட்டது.

சேமிக்கப்பட்ட தரவைப் பயன்படுத்தி வண்டியை மாறும் வகையில் வழங்குவதன் மூலம் பயனர் அனுபவம் மேலும் மேம்படுத்தப்படுகிறது. இந்த முறையைப் பயன்படுத்துவதன் மூலம், கார்ட் மிகவும் பதிலளிக்கக்கூடியதாகவும் ஊடாடக்கூடியதாகவும் மாறும், மேலும் தற்போதைய பயனர் தொடர்புகளைப் பிரதிபலிக்கும் வகையில் தயாரிப்பு விலை மற்றும் அளவுகள் புதுப்பிக்கப்படுகின்றன.

ஜாவாஸ்கிரிப்ட் டைனமிக் கார்ட் கவுண்டர்களுக்கான குறிப்புகள் மற்றும் ஆதாரங்கள்

ஜாவாஸ்கிரிப்டைப் பயன்படுத்துவது பற்றிய விரிவான நுண்ணறிவுகளுக்கு என்றால்-வேறு நிபந்தனைகள் மற்றும் DOM கூறுகளை புதுப்பித்தல், பார்வையிடவும் MDN Web Docs - என்றால்... வேறு .
ஜாவாஸ்கிரிப்டைப் பயன்படுத்தி டைனமிக் உள்ளடக்கத்தை நிர்வகித்தல் மற்றும் HTML உறுப்புகளைப் புதுப்பித்தல் பற்றி மேலும் அறிக W3Schools - JavaScript HTML DOM .
JavaScript பயன்பாடுகளில் கவுண்டர் மற்றும் கார்ட் தொடர்பான சிக்கல்களைத் தீர்க்க, இந்த வழிகாட்டியைப் பார்க்கவும் ஸ்டாக் ஓவர்ஃப்ளோ - ஜாவாஸ்கிரிப்டில் கவுண்டர் ரீசெட் .
இந்த டுடோரியலுடன் ஜாவாஸ்கிரிப்டில் பொருள் சார்ந்த கார்ட் லாஜிக்கை கட்டமைப்பதற்கான சிறந்த நடைமுறைகளை ஆராயுங்கள் JavaScript.info - பொருள் அடிப்படைகள் .