என் ஜாவாஸ்கிரிப்ட்

Mauve Garcia

ஞாயிறு, 29 செப்டம்பர், 2024 ’அன்று’ முற்பகல் 8:17:19

இடைவெளியை நிறுத்துவதில் தெளிவான இடைவெளி ஏன் தோல்வியடைகிறது என்பதைப் புரிந்துகொள்வது

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

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

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

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

கட்டளை	பயன்பாட்டின் உதாரணம்
இடைவெளி ()	'state', setInterval(getState, 2000); - இந்தச் செயல்பாடு முன்னரே தீர்மானிக்கப்பட்ட இடைவெளியில் ஒரு வெளிப்பாட்டை மதிப்பிடுகிறது அல்லது ஒரு செயல்பாட்டை மீண்டும் மீண்டும் அழைக்கிறது. இந்த இடைவெளிகளைக் கட்டுப்படுத்துவதும் அகற்றுவதும் விஷயத்தின் முக்கிய அம்சம் என்பதால் இது பிரச்சினைக்கு அவசியம்.
தெளிவான இடைவெளி()	தனித்துவமான இடைவெளி (iv_st); - இது setInterval செயல்முறைக்கு முற்றுப்புள்ளி வைக்கிறது. இடைவெளி சரியாகப் பயன்படுத்தப்படாவிட்டால், அது தொடர்ந்து இயங்கும். கொடுக்கப்பட்ட சந்தர்ப்பங்களில், முக்கிய நோக்கம் இடைவெளியை முடிப்பதாகும்.
$.ajax()	$.ajax({url: "/lib/thumb_state.php?m=0" }); - சேவையகத்திலிருந்து தரவைப் பெறுவதற்கான ஒத்திசைவற்ற அழைப்பு. இது இடைவேளையின் முடிவுப் புள்ளியைப் பாதிக்கும் சிக்கலின் சூழலில் சேவையகத்திலிருந்து 'நிலையை' மீட்டெடுக்கிறது.
() உடன் தொடங்குகிறது	data.startsWith('9'): இந்த ஸ்ட்ரிங் முறையானது, திருப்பி அனுப்பப்படும் தரவு ஒரு குறிப்பிட்ட எழுத்தில் தொடங்குகிறதா என்பதை தீர்மானிக்கிறது. இங்கே, சர்வரின் பதில் இடைவெளியை வெளியிடுவதை நியாயப்படுத்துகிறதா என்று மதிப்பிடுகிறது.
console.log()	console.log(iv_st, "இடைவெளி ஐடி:"); - இது ஒரு கண்டறியும் கருவியாக இருந்தாலும், எல்லாம் சரியாகச் செயல்படுகிறதா அல்லது அழிக்கப்படுகிறதா என்பதை உறுதிசெய்ய, இந்த விஷயத்தில் இடைவெளி ஐடியைக் காண்பிப்பது மிகவும் முக்கியம்.
$('#id').html()	jQuery முறை $('#'+id).html('Fetching state...'); HTML உறுப்பின் உள்ளடக்கத்தை மாற்றியமைக்கிறது. எடுத்துக்காட்டில், இடைவெளியின் நிலை குறித்து உடனடி கருத்துக்களை வழங்க இது பெரும்பாலும் பயன்படுத்தப்படுகிறது.
என்றால் (iv_st === பூஜ்யம்)	ஒன்றுக்கு மேற்பட்ட இடைவெளிகள் இருந்தால், இந்த நிபந்தனை (iv_st === பூஜ்யம்) {... } இடைவெளி அழிக்கப்பட்டதா என்பதைச் சரிபார்க்கிறது, இது செயல்திறன் சிக்கல்களைத் தடுக்க அவசியம்.
வெற்றி: செயல்பாடு(தரவு)	success: function(data) {... } - $.ajax முறையின் ஒரு அங்கமான இந்த கால்பேக் செயல்பாடு, சர்வர் கோரிக்கையை வெற்றிகரமாக முடித்தவுடன் செயல்படுத்தப்படுகிறது. இடைவெளியை எவ்வாறு கையாள்வது என்பதைத் தீர்மானிக்க, திரும்பிய தரவைப் பயன்படுத்துகிறது.

ஜாவாஸ்கிரிப்ட் இடைவெளி மேலாண்மையை தெளிவான இடைவெளியுடன் விளக்குகிறது

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

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

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

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

தெளிவான இடைவெளியைக் கையாளுதல்: ஜாவாஸ்கிரிப்ட் நேரச் சிக்கல்களை நிவர்த்தி செய்தல்

இந்த அணுகுமுறையின் குறிக்கோள், ஜாவாஸ்கிரிப்டை டைனமிக் ஃப்ரண்ட்-எண்ட் சூழலில் பயன்படுத்துவதன் மூலம் setInterval மற்றும் clearInterval செயல்பாடுகளின் செயல்திறனை அதிகரிப்பதாகும்.

// Solution 1: Basic ClearInterval Issue Resolution
// This script ensures the clearInterval function works as intended.
var iv_st = setInterval(getState, 2000, 'state');
// Function to fetch and update the state
function getState(id) {
  console.log("Interval ID:", iv_st);
  $('#'+id).html('Fetching state...');
  $.ajax({
    url: "/lib/thumb_state.php?m=0",
    success: function(data) {
      if (data) {
        if (data.startsWith('9')) {
          clearInterval(iv_st); // Properly clearing interval
          $('#'+id).html('Process complete');
        } else {
          $('#'+id).html('Still running...');
        }
      }
    }
  });
}

பாதுகாப்பு சோதனைகளுடன் மேம்பட்ட தெளிவான இடைவெளி

இந்த முறை பல இடைவெளிகளை அமைப்பதை தவிர்க்க கூடுதல் பாதுகாப்பு சோதனைகளுடன் இடைவெளி செல்லுபடியாகும் சோதனையையும் உள்ளடக்கியது.

// Solution 2: Adding Safety Checks and Interval Validity
var iv_st = null;
function startInterval() {
  if (iv_st === null) { // Only start if no interval exists
    iv_st = setInterval(getState, 2000, 'state');
    console.log('Interval started:', iv_st);
  }
}
// Function to fetch state and clear interval based on condition
function getState(id) {
  $.ajax({
    url: "/lib/thumb_state.php?m=0",
    success: function(data) {
      if (data && data.startsWith('9')) {
        clearInterval(iv_st);
        iv_st = null; // Reset interval variable
        $('#'+id).html('Process complete');
      }
    }
  });
}

தெளிவான இடைவெளியுடன் PHP-ஜாவாஸ்கிரிப்ட் ஒருங்கிணைப்பு

சர்வர் பக்க தரவுகளின் அடிப்படையில் இடைவெளிகளை மாறும் வகையில் கட்டுப்படுத்த, இந்த அணுகுமுறை ஜாவாஸ்கிரிப்ட் மற்றும் PHP ஆகியவற்றை உள்ளடக்கியது.

// Solution 3: PHP and JavaScript Integration for Dynamic Interval Control
var iv_st;
<?php echo "<script type='text/javascript'>"; ?>
iv_st = setInterval(getState, 2000, 'state');
<?php echo "</script>"; ?>
function getState(id) {
  console.log(iv_st);
  $('#'+id).html('Fetching data...');
  $.ajax({
    url: "/lib/thumb_state.php?m=0",
    success: function(data) {
      if (data && data.startsWith('9')) {
        clearInterval(iv_st);
        iv_st = null;
        $('#'+id).html('Data complete');
      }
    }
  });
}

ஜாவாஸ்கிரிப்ட் பயன்பாடுகளில் இடைவெளி மேலாண்மையை மேம்படுத்துதல்

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

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

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

ஜாவாஸ்கிரிப்ட் இடைவெளி மேலாண்மை பற்றிய பொதுவான கேள்விகள்

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

ஜாவாஸ்கிரிப்ட் இடைவெளி சரிசெய்தல் முடிவடைகிறது

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

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

ஜாவாஸ்கிரிப்டில் இடைவெளி மேலாண்மைக்கான குறிப்புகள் மற்றும் மூலப் பொருள்

இந்தக் கட்டுரை டெவலப்பர்கள் எதிர்கொள்ளும் நிஜ உலக JavaScript சவால்களை அடிப்படையாகக் கொண்டது தெளிவான இடைவெளி மற்றும் இடைவெளியை அமைக்கவும் செயல்பாடுகள். இடைவெளி மேலாண்மை மற்றும் AJAX ஒருங்கிணைப்பு பற்றிய கூடுதல் தகவலுக்கு, MDN Web Docs ஐப் பார்வையிடவும் MDN setInterval Reference .
செயல்திறன் மேம்படுத்தல் மற்றும் பிழை கையாளுதல் உட்பட JavaScript இடைவெளிகளை எவ்வாறு நிர்வகிப்பது மற்றும் அழிப்பது என்பது பற்றிய கூடுதல் தீர்வுகளை ஆராய, இந்த விரிவான வழிகாட்டியைப் பார்க்கவும்: SitePoint ஜாவாஸ்கிரிப்ட் டைமர்கள் .
PHP மற்றும் ஜாவாஸ்கிரிப்ட்டின் மேம்பட்ட ஒருங்கிணைப்பு மற்றும் சர்வர் பக்க தரவுகளுடன் டைனமிக் இடைவெளி கையாளுதலுக்காக, இந்த PHP-JS இன்டராக்ஷன் டுடோரியல் நுண்ணறிவுகளை வழங்குகிறது: PHP கையேடு: எதிரொலி .

என் ஜாவாஸ்கிரிப்ட் இடைவெளியை ஏன் clearInterval நிறுத்தவில்லை?