እርምጃዎችን በተወሰነ የጃቫስክሪፕት የጊዜ ክፍተት ይድገሙ። SetTimeOut እና SetInterval፣ በጃቫስክሪፕት መጠቀም የትኛው የተሻለ ነው? ዝቅተኛ የሰዓት ቆጣሪ መዘግየት

  • ከ፥
  • የተመዘገበ: 2014.07.08
  • ልጥፎች: 3,896
  • የተወደዱ: 497
ርዕስ፡ SetTimeOut እና SetInterval፣ በጃቫስክሪፕት መጠቀም የትኛው የተሻለ ነው?

የ setInterval ተግባር በመደበኛ ክፍተቶች ውስጥ ብዙ ጊዜ ኮድን ለማስኬድ የተነደፈ ነው። ሆኖም ግን, እሱ በርካታ ጉዳቶች አሉት, በተለይም በተለያዩ አሳሾች ውስጥ የተለየ ባህሪ.

የመጀመሪያው ልዩነት ለቀጣዩ ጅምር ጊዜ ቆጣሪው በተዘጋጀበት ጊዜ ውስጥ ያለው ልዩነት ነው. አንድ ትንሽ ፈተና እንፍጠር-የቀድሞው ሩጫ ከተጀመረበት ጊዜ አንስቶ እና ከመጨረሻው በኋላ ያለፈውን ጊዜ እንለካለን.

var d1 = አዲስ ቀን (), d2 = አዲስ ቀን (); setInterval(ተግባር() (var d = አዲስ ቀን()); document.body.innerHTML += (መ - d1) + "" + (መ - d2) +"
"; // በተግባሩ መጀመሪያ ላይ ምልክት ያድርጉ d1 = አዲስ ቀን (); እያለ (አዲስ ቀን () - d1< 200); // ничего не делаем 200 миллисекунд // И в конце функции d2 = new Date(); }, 1000);

ውጤቱ ከሁለተኛው መስመር ጀምሮ መረጃ ሰጭ ይሆናል።

በፋየርፎክስ, ኦፔራ, ሳፋሪ እና Chrome ውስጥ ሁኔታው ​​ተመሳሳይ ይሆናል-የመጀመሪያው ቁጥር በግምት ከ 1000 ጋር እኩል ይሆናል, ሁለተኛው - 200 ያነሰ ይሆናል. ልዩነቱ በእሴቶች መስፋፋት ላይ ብቻ ይሆናል. በጣም ትንሹ ልዩነት በ Chrome እና ኦፔራ ውስጥ ነው.

2 ምላሽ በ PunBB (በPunBB 2017.06.08 16:45 የተስተካከለ)
  • ከ: ሞስኮ, ሶቭኮዝናይ 3, አፕ. 98
  • የተመዘገበ: 2014.07.08
  • ልጥፎች: 3,896
  • የተወደዱ: 497

ሌላው ብዙም የማይታይ እና ለመራባት በጣም አስቸጋሪ የሆነ ነገር ግን አንዳንድ ጊዜ ብዙ ችግር ሊፈጥር የሚችል የስርዓት ጊዜ ለውጦችን መቋቋም ነው። የሚከተለውን ፈተና ካካሄዱ

setInterval (ተግባር () ( document.body.innerHTML = Math.random ();), 500);

እና ከጀመሩ በኋላ የስርዓቱን ጊዜ ወደ አንድ ደቂቃ ያቀናብሩ ፣ ከዚያ በፋየርፎክስ እና ሳፋሪ አሳሾች ውስጥ የቁጥሮች ለውጥ ለአፍታ ይቆማል እና ከአንድ ደቂቃ በኋላ እንደገና ይጀምራል። በእርግጥ የስርዓት ጊዜን በእጅ መተርጎም በጣም ያልተለመደ ሁኔታ ነው ፣ ግን ብዙ ስርዓቶች በይነመረብ ላይ ጊዜን በራስ-ሰር ለማመሳሰል ተዋቅረዋል ፣ ስለሆነም በአንዳንድ ሁኔታዎች ይህ ሁኔታ ቅናሽ ሊደረግ አይችልም።

ሌላው የ setInterval ተግባር ትንሽ ጉዳቱ ድርጊቱን ለማስቆም እንዲቻል፣ መታወቂያውን የሆነ ቦታ ማስታወስ ያስፈልግዎታል፣ ሁልጊዜም ምቹ አይደለም።

3 በ PunBB ምላሽ ይስጡ
  • ከ: ሞስኮ, ሶቭኮዝናይ 3, አፕ. 98
  • የተመዘገበ: 2014.07.08
  • ልጥፎች: 3,896
  • የተወደዱ: 497
ድጋሚ፡ SetTimeOut እና SetInterval፣ በጃቫስክሪፕት መጠቀም የትኛው የተሻለ ነው?

የተዘረዘሩትን የsetInterval ጉዳቶችን ለማስወገድ ብዙ setTimeout መጠቀም ይችላሉ።

ለ setInterval አስፈላጊው አማራጭ ተደጋጋሚ የሰዓት ጊዜ መውጫ ነው፡-

/** በምትኩ: var timerId = setInterval (ተግባር () (ማስጠንቀቂያ ("ምልክት");), 2000); */ var timerId = setTimeout (የተግባር ምልክት () (ማስጠንቀቂያ ("ምልክት"); timerId = setTimeout (tick, 2000);), 2000);

ከላይ ባለው ኮድ ውስጥ, የሚቀጥለው አፈፃፀም ቀዳሚው ከተጠናቀቀ በኋላ ወዲያውኑ ይዘጋጃል.

Recursive setTimeout ከ setInterval የበለጠ ተለዋዋጭ የጊዜ ዘዴ ነው፣ ምክንያቱም እስከሚቀጥለው አፈጻጸም ድረስ ያለው ጊዜ አሁን ባለው ውጤት ላይ በመመስረት በተለያዩ መንገዶች መርሐግብር ሊይዝ ይችላል።

ለምሳሌ በየ 5 ሰከንድ አገልጋዩን ለአዲስ መረጃ የሚጠይቅ አገልግሎት አለን። አገልጋዩ ከመጠን በላይ ከተጫነ, የምርጫ ክፍተቱን ወደ 10, 20, 60 ሰከንድ ከፍ ማድረግ ይችላሉ ... እና ሁሉም ነገር ወደ መደበኛው ሲመለስ ይመልሱት.

እኛ በመደበኛነት ሲፒዩ-ተኮር ተግባራትን የምንሠራ ከሆነ ፣በእነሱ አፈፃፀማቸው ላይ ያሳለፈውን ጊዜ ለመገመት እና የሚቀጥለውን መጀመር ቀደም ብሎ ወይም በኋላ ማቀድ እንችላለን።

4 በ PunBB ምላሽ ይስጡ
  • ከ: ሞስኮ, ሶቭኮዝናይ 3, አፕ. 98
  • የተመዘገበ: 2014.07.08
  • ልጥፎች: 3,896
  • የተወደዱ: 497
ድጋሚ፡ SetTimeOut እና SetInterval፣ በጃቫስክሪፕት መጠቀም የትኛው የተሻለ ነው?

Recursive setTimeout በጥሪዎች መካከል ለአፍታ ማቆም ዋስትና ይሰጣል፣ setInterval ግን አያደርገውም።

ሁለቱን ኮዶች እናወዳድር። የመጀመሪያው setInterval ይጠቀማል፡-

var i = 1; setInterval (ተግባር () (func (i);), 100);

ሁለተኛው ተደጋጋሚ setTimeout ይጠቀማል፡-

var i = 1; setTimeout(ተግባር አሂድ() (func(i)); setTimeout (ሩጫ፣ 100);)፣ 100);

በsetInterval፣ የውስጥ ሰዓት ቆጣሪው በትክክል በየ100 ሚሴው ያቃጥላል እና func(i) ይደውላል፦

በ setInterval መካከል በ Func ጥሪዎች መካከል ያለው ትክክለኛ ቆም ማለት በኮዱ ላይ ከተጠቀሰው ያነሰ ነው!

ይህ ተፈጥሯዊ ነው, ምክንያቱም የተግባሩ የስራ ጊዜ በምንም መልኩ ግምት ውስጥ አይገባም;

ፈንክ ከጠበቅነው በላይ የተወሳሰበ ሆኖ ከ100 ሚሴ በላይ ጊዜ ፈጅቶበት ሊሆን ይችላል።

በዚህ ሁኔታ አስተርጓሚው ተግባሩን እስኪያጠናቅቅ ድረስ ይጠብቃል ፣ ከዚያ የሰዓት ቆጣሪውን ያረጋግጡ እና ወደ setInterval የሚደውሉበት ጊዜ ቀድሞውኑ ካለፈ (ወይም ካለፈ) የሚቀጥለው ጥሪ ወዲያውኑ ይመጣል።

ተግባሩ ከ setInterval ባለበት ማቆም ረዘም ያለ ከሆነ፣ ጥሪዎች ያለ ምንም መቆራረጥ ይከሰታሉ።

5 በሴምፓይ መልሱ
  • ከ፡ እየሩሳሌም
  • የተመዘገበ: 2015.06.02
  • ልጥፎች፡ 958
  • የተወደዱ: 274
ድጋሚ፡ SetTimeOut እና SetInterval፣ በጃቫስክሪፕት መጠቀም የትኛው የተሻለ ነው?

ሁሉም በእጃቸው ባለው ተግባር ላይ የተመሰረተ ነው. መጀመሪያ ላይ SetTimeOut የሰዓት ቆጣሪውን አንድ ጊዜ ለማስጀመር ስራ ላይ ይውላል፣ እና SetInterval አንድ loop ለመጀመር ይጠቅማል። ነገር ግን ሁለቱም ተግባራት ስክሪፕቶችን በብስክሌት ለማሄድ ጥቅም ላይ ሊውሉ ይችላሉ፣ ለምሳሌ፣ በ SetTimeOut ተግባር ውስጥ ደጋግመው ካስኬዷቸው፣ ከ SetInterval ጋር ተመሳሳይነት ይኖራቸዋል።

በአሁኑ ጊዜ የ SetInterval ጉዳቱ የስክሪፕቱ (ተግባር) አፈፃፀም ጊዜን ከግምት ውስጥ አያስገባም ማለት ነው ፣ እና ለምሳሌ ፣ ለከባድ ጥያቄዎች ከተጠቀሙበት ፣ ከዚያ የጊዜ ክፍተት በከፍተኛ ሁኔታ ይቀንሳል ፣ እና እሱ በተለያዩ አሳሾች ውስጥ ሊለያይ ይችላል።

ግን በድጋሚ፣ ተግባሩ ወይም ጥያቄው ከተቀነሰ፣ የመጨረሻ ተጠቃሚው ልዩነቱን አይሰማውም።
ስለዚህ, ምን ጥቅም ላይ እንደሚውል ሁሉም ሰው ለራሱ መወሰን ነው.

የጃቫስክሪፕት ጊዜ ማብቂያ ከተወሰነ ጊዜ መዘግየት በኋላ (በሚሊሰከንዶች) ኮድን የሚያከናውን ቤተኛ የጃቫስክሪፕት ተግባር ነው። ተጠቃሚው በገጽዎ ላይ የተወሰነ ጊዜ ካሳለፈ በኋላ ብቅ ባይ ማሳየት ሲፈልጉ ይህ ጠቃሚ ሊሆን ይችላል። ወይም በኤለመንቱ ላይ ሲያንዣብቡ ውጤቱ የተወሰነ ጊዜ ካለፈ በኋላ እንዲጀምር ይፈልጋሉ? በዚህ መንገድ ተጠቃሚው በአጋጣሚ ቢያንዣብብ ሳይታሰብ ተፅዕኖን ከማስነሳት መቆጠብ ይችላሉ።

ቀላል የጊዜ መውጫ ምሳሌ

ይህ ባህሪ እንዴት እንደሚሰራ ለማሳየት, የሚከተለውን ማሳያ እንዲመለከቱ ሀሳብ አቀርባለሁ, በዚህ ውስጥ ብቅ ባይ መስኮት ቁልፉ ከተነካ ከሁለት ሰከንዶች በኋላ ይታያል.

ማሳያ ይመልከቱ

አገባብ

የኤምዲኤን ሰነድ ለ setTimeout የሚከተለውን አገባብ ያቀርባል፡-

var timeoutID = window.setTimeout(func,); var timeoutID = window.setTimeout(code,);

  • timeoutID - ጊዜ ቆጣሪውን ለማሰናከል ከ clearTimeout () ጋር በማጣመር ጥቅም ላይ ሊውል የሚችል የቁጥር መታወቂያ;
  • func - የሚፈፀም ተግባር;
  • ኮድ (በተለዋጭ አገባብ) - የሚፈፀም ኮድ መስመር;
  • መዘግየት - የመዘግየቱ ጊዜ በሚሊሰከንዶች, ከዚያ በኋላ ተግባሩ ይጀምራል. ነባሪው ዋጋ 0 ነው።
setTimeout vs window.setTimeout

ከላይ ያለው አገባብ window.setTimeout ይጠቀማል። ለምን፧

በእውነቱ፣ setTimeout እና window.setTimeout በተግባር አንድ አይነት ተግባር ናቸው። ብቸኛው ልዩነት በሁለተኛው አገላለጽ የ setTimeout ዘዴን እንደ ዓለም አቀፋዊ የመስኮት ዕቃ ንብረት እንጠቀማለን ።

በግሌ ይህ ኮዱን የበለጠ የተወሳሰበ ያደርገዋል ብዬ አስባለሁ። በቀዳሚ ቅደም ተከተል ሊገኝ እና ሊመለስ የሚችል አማራጭ የጃቫ ስክሪፕት ጊዜ ማብቂያ ዘዴን ብንገልጽ የበለጠ ችግር ውስጥ እንገባለን።

በዚህ መማሪያ ውስጥ, ከመስኮቱ ነገር ጋር መበላሸት አልፈልግም, ግን በአጠቃላይ, የትኛውን አገባብ እንደሚጠቀሙ መወሰን የእርስዎ ነው.

የአጠቃቀም ምሳሌዎች

ይህ የተግባሩ ስም ሊሆን ይችላል፡-

ተግባር ፍንዳታ ()) (ማስጠንቀቂያ ("ቡም!");) setTimeout (ፍንዳታ, 2000);

ተግባሩን የሚያመለክተው ተለዋዋጭ፡-

var የሚፈነዳ = ተግባር ()) (ማስጠንቀቂያ ("ቡም!");); setTimeout (ፍንዳታ, 2000);

ወይም የማይታወቅ ተግባር፡-

setTimeout (ተግባር ()) (ማስጠንቀቂያ ("ቡም!");), 2000);

  • እንዲህ ዓይነቱ ኮድ በደንብ ያልተረዳ ነው, ስለዚህ, ዘመናዊ ለማድረግ ወይም ለማረም አስቸጋሪ ይሆናል;
  • የኤቫል () ዘዴን መጠቀምን ያካትታል, ይህም ተጋላጭነት ሊሆን ይችላል;
  • ይህ ዘዴ ከሌሎች ይልቅ ቀርፋፋ ነው ምክንያቱም የጃቫስክሪፕት አስተርጓሚውን ማስኬድ ያስፈልገዋል።

እንዲሁም ኮዱን ለመፈተሽ የጃቫስክሪፕት ጊዜ ማብቂያ ማንቂያ ዘዴን እየተጠቀምን መሆኑን ልብ ይበሉ።

መለኪያዎችን ወደ setTimout በማለፍ ላይ

በመጀመሪያው (እና ተሻጋሪ አሳሽ) አማራጭ ውስጥ መለኪያዎችን ወደ መልሶ ጥሪ ተግባር እናስተላልፋለን ፣ በ setTimeout በመጠቀም ይከናወናል።

በሚከተለው ምሳሌ፣ ከሰላምታ ድርድር የዘፈቀደ ሰላምታ አውጥተን ወደ ሰላምታ() ተግባር እንደ ልኬት እናስተላልፋለን፣ ይህም በsetTimeout ከ1 ሰከንድ መዘግየት ጋር ነው የሚከናወነው፡

ተግባር ሰላምታ (ሰላምታ) (ኮንሶል.ሎግ (ሰላምታ);) ተግባር getRandom (arr) (ተመለስ arr;) var ሰላምታ = ["ሄሎ", "Bonjour", "Guten Tag"], randomGreeting = getRandom (ሰላምታ); setTimeout (ተግባር ()) (ሰላምታ (የዘፈቀደ ሰላምታ);), 1000);

ማሳያ ይመልከቱ

አማራጭ ዘዴ

በአንቀጹ መጀመሪያ ላይ በተሰጠው አገባብ ውስጥ በጃቫስክሪፕት ጊዜ ማብቂያ ወደተፈፀመው የመልሶ ጥሪ ተግባር ግቤቶችን ማስተላለፍ የሚችሉበት ሌላ ዘዴ አለ። ይህ ዘዴ መዘግየቱን ተከትሎ የሁሉንም መለኪያዎች ውጤት ያመለክታል.

በቀደመው ምሳሌ ላይ በመመስረት, እኛ እናገኛለን:

setTimeout (ሰላምታ፣ 1000፣ የዘፈቀደ ሰላምታ);

ይህ ዘዴ በ IE 9 እና ከዚያ በታች አይሰራም, ያለፉ መለኪያዎች እንደ ያልተገለጹ ይወሰዳሉ. ነገር ግን ይህንን ችግር ለመፍታት በኤምዲኤን ላይ ልዩ ፖሊፊሊል አለ.

ተዛማጅ ችግሮች እና "ይህ"

በsetTimeout የሚሰራው ኮድ ከጠራው ተግባር ተለይቶ ይሰራል። በዚህ ምክንያት, ይህንን ቁልፍ ቃል በመጠቀም ሊፈቱ የሚችሉ አንዳንድ ችግሮች ያጋጥሙናል.

var ሰው = (የመጀመሪያ ስም: "ጂም", ማስተዋወቅ: ተግባር ()) (console.log ("Hi, I"m" + this.firstName);)); ሰው. አስተዋውቋል (); // ውጤቶች: ሰላም, I "m Jim setTimeout(person.introduce, 50); // ውጤቶች፡ ሰላም፣ እኔ አልገለጽም።

የዚህ ውፅዓት ምክንያት በመጀመሪያው ምሳሌ ላይ ይህ ወደ ሰው ዕቃ ይጠቁማል, በሁለተኛው ምሳሌ ደግሞ የመጀመሪያ ስም ንብረት የሌለውን ዓለም አቀፋዊ የዊንዶው ነገርን ያመለክታል.

ይህንን አለመመጣጠን ለማስወገድ ብዙ ዘዴዎችን መጠቀም ይችላሉ-

ይህ እንዲዋቀር አስገድደው

ይህ አዲስ ተግባር የሚፈጥር ዘዴን በመጠቀም ሊሰራ ይችላል ፣ ሲጠራ ፣ የዚህ ቁልፍ እሴት የተወሰነ እሴት ይጠቀማል። በእኛ ሁኔታ, የተጠቀሰው ሰው ይቃወማል. ይህ በመጨረሻ ይሰጠናል-

setTimeout (ሰው.introduce.bind (ሰው), 50);

ማሳሰቢያ፡ የማሰሪያ ዘዴው በECMAScript 5 ውስጥ ገብቷል፣ ይህ ማለት በዘመናዊ አሳሾች ውስጥ ብቻ ይሰራል ማለት ነው። በሌሎች ውስጥ, ሲጠቀሙ, የJavaScript execution ስህተት "የተግባር ጊዜ ማብቂያ ስህተት" ይደርስዎታል.

ቤተ-መጽሐፍትን ተጠቀም

ብዙ ቤተ-መጻሕፍት ይህን ችግር ለመፍታት አብሮ የተሰሩ ተግባራትን ያካትታሉ። ለምሳሌ የ jQuery.proxy() ዘዴ። አንድ ተግባር ይወስዳል እና ሁልጊዜ የተወሰነ አውድ የሚጠቀም አዲስ ይመልሳል። በእኛ ሁኔታ፣ አገባቡ የሚከተለው ይሆናል፡-

setTimeout($.proxy(ሰው.ማስተዋወቅ፣ሰው)፣50);

ማሳያ ይመልከቱ

ሰዓት ቆጣሪውን በማሰናከል ላይ

የsetTimeout መመለሻ ዋጋ የ clearTimeout() ተግባርን በመጠቀም ጊዜ ቆጣሪውን ለማሰናከል የሚያገለግል የቁጥር መታወቂያ ነው።

var ቆጣሪ = setTimeout (myFunction, 3000); clearTimeout (ሰዓት ቆጣሪ);

በተግባር እንየው። በሚከተለው ምሳሌ, "የጀምር ቆጠራ" ቁልፍን ጠቅ ካደረጉ, ቆጠራው ይጀምራል. ከተጠናቀቀ በኋላ ድመቶቹ የራሳቸውን ያገኛሉ. ነገር ግን "መቁጠር አቁም" የሚለውን ቁልፍ ከተጫኑ የጃቫስክሪፕት ጊዜ ማብቂያ ጊዜ ቆጣሪ ቆሞ እንደገና ይጀምራል።

ምሳሌ ተመልከት

እናጠቃልለው

setTimeout ያልተመሳሰለ ተግባር ነው፣ ይህ ማለት ለዚህ ተግባር የተደረገው ጥሪ ወረፋ ውስጥ ይገባል እና ሁሉም ሌሎች ቁልል ላይ ያሉ ድርጊቶች ከተጠናቀቁ በኋላ ብቻ ይከናወናል። ከሌሎች ተግባራት ወይም የተለየ ክር ጋር በአንድ ጊዜ መሮጥ አይችልም።

ምንጭ፡ http://learn.javascript.ru/settimeout-setinterval

ከሞላ ጎደል ሁሉም የጃቫስክሪፕት ትግበራዎች ከተወሰነ ጊዜ በኋላ የሚጠራውን ተግባር መርሐግብር ለማስያዝ የሚያስችል የውስጥ ሰዓት ቆጣሪ አላቸው።

በተለይም ይህ ባህሪ በአሳሾች እና በ Node.JS አገልጋይ ውስጥ ይደገፋል.

setTimeout

አገባብ፡

var timerId = setTimeout(func/code፣ delay[፣ arg1፣ arg2...])

መለኪያዎች፡-

  • func / ኮድ
    • የሚፈጸም ተግባር ወይም ኮድ መስመር።
    • ሕብረቁምፊው ለተኳሃኝነት ይጠበቃል እና አይመከርም።
  • መዘግየት
    • መዘግየት በሚሊሰከንዶች፣ 1000 ሚሊሰከንዶች ከ1 ሰከንድ ጋር እኩል ነው።
  • arg1፣ arg2…
    • ወደ ተግባሩ የሚተላለፉ ክርክሮች. በ IE9- ውስጥ አይደገፍም።
    • በመዘግየቱ መለኪያ ውስጥ ከተጠቀሰው ጊዜ በኋላ ተግባሩ ይፈጸማል.

ለምሳሌ፣ የሚከተለው ኮድ ከአንድ ሰከንድ በኋላ ማንቂያ ("ሄሎ") ያስነሳል።

ተግባር func () (ማስጠንቀቂያ ("ሄሎ");) setTimeout (func, 1000);

የመጀመሪያው ነጋሪ እሴት ሕብረቁምፊ ከሆነ፣ አስተርጓሚው ከዚያ ሕብረቁምፊ ውስጥ የማይታወቅ ተግባር ይፈጥራል።

ያም ማለት ይህ ግቤት በትክክል ተመሳሳይ ነው የሚሰራው፡

SetTimeout ("ማንቂያ ("ሄሎ"), 1000);

በምትኩ ስም-አልባ ተግባራትን ተጠቀም፡-

SetTimeout (ተግባር () (ማስጠንቀቂያ ("ሄሎ")), 1000);

የተግባር እና አውድ መለኪያዎች

IE10ን ጨምሮ በሁሉም ዘመናዊ አሳሾች ውስጥ setTimeout የተግባር መለኪያዎችን እንዲገልጹ ያስችልዎታል።

ከታች ያለው ምሳሌ ከ IE9- በስተቀር በሁሉም ቦታ "ሄሎ, እኔ ቫስያ ነኝ" ይታያል.

ተግባር sayHi (ማን) ( ማንቂያ ("ሄሎ፣ እኔ" + ማን ነኝ);) setTimeout (sayHi, 1000, "Vasya");

ነገር ግን፣ በአብዛኛዎቹ ጉዳዮች ከአሮጌው IE ድጋፍ እንፈልጋለን፣ እና ክርክሮችን እንዲገልጹ አይፈቅድልዎትም:: ስለዚህ እነሱን ለማስተላለፍ ጥሪውን በማይታወቅ ተግባር ያጠቃልላሉ፡-

ተግባር sayHi (ማን) (ማስጠንቀቂያ ("ሃይ, እኔ" + ማን ነኝ);) setTimeout (ተግባር () ( sayHi ("Vasya")), 1000);

ወደ setTimeout መደወል ይህንን አውድ አያልፍም።

በተለይም የነገር ዘዴን በsetTimeout በኩል መጥራት በአለምአቀፍ አውድ ውስጥ ይሰራል። ይህ ወደ የተሳሳተ ውጤት ሊያመራ ይችላል.

ለምሳሌ፣ ከአንድ ሰከንድ በኋላ user.sayHi()ን እንጥራ፡-

ተግባር የተጠቃሚ (መታወቂያ) ተግባር () (ማስጠንቀቂያ (ይህ .id);); ) var ተጠቃሚ = አዲስ ተጠቃሚ (12345); setTimeout (user.sayHi, 1000); // የሚጠበቀው 12345፣ ግን “ያልተገለጸ” ያወጣል።

setTimeout የተጠቃሚውን.sayHi ተግባርን በአለምአቀፍ አውድ ውስጥ ስለሚያሄደው በዚህ በኩል የነገሩን መዳረሻ አይኖረውም።

በሌላ አነጋገር፣ እነዚህ ሁለት ጥሪዎች ወደ setTimeout ተመሳሳይ ነገር ያደርጋሉ፡-

// (1) አንድ መስመር setTimeout (user.sayHi, 1000); // (2) በሁለት መስመሮች ተመሳሳይ ነገር var func = user.sayHi; setTimeout (func, 1000);

እንደ እድል ሆኖ, ይህ ችግር መካከለኛ ተግባር በመፍጠር በቀላሉ ይፈታል.

ተግባር ተጠቃሚ (መታወቂያ) (ይህ .id = መታወቂያ; ይህ .sayHi = ተግባር () (ማስጠንቀቂያ (ይህ .id);); var ተጠቃሚ = አዲስ ተጠቃሚ (12345); setTimeout (ተግባር () (user.sayHi ();), 1000);

የመጠቅለያ ተግባር ክርክሮችን አሳሽ ለማለፍ እና የማስፈጸሚያ አውድ ለመጠበቅ ይጠቅማል።

የአፈፃፀም መሰረዝ

የsetTimeout ተግባር ድርጊቱን ለመሰረዝ የሚያገለግል የሰዓት አይድን ይመልሳል።

አገባብ፡

ClearTimeout(timerID)

በሚከተለው ምሳሌ፣ የጊዜ ማብቂያ አውጥተናል ከዚያም ሰርዘናል (ሀሳባችንን ቀይረናል)። በውጤቱም, ምንም ነገር አይከሰትም.

var timerId = setTimeout (ተግባር () (ማስጠንቀቂያ (1))፣ 1000); clearTimeout (timerID); setInterval

የsetInterval ዘዴ ከ setTimeout ጋር ተመሳሳይ የሆነ አገባብ አለው።

var timerId = setInterval(func/code፣ delay[፣ arg1፣ arg2...])

የክርክሩ ትርጉም አንድ ነው። ግን እንደ setTimeout በተለየ መልኩ ተግባሩን አንድ ጊዜ አያሄድም ነገር ግን በተወሰነ የጊዜ ክፍተት ላይ በመደበኛነት ይደግማል። በመደወል ማስፈጸምን ማቆም ይችላሉ፡-

ClearInterval(timerID)

የሚከተለው ምሳሌ፣ ሲሮጥ፣ “አቁም” የሚለውን ቁልፍ እስኪጫኑ ድረስ በየሁለት ሰኮንዱ መልእክት ያሳያል፡-

var i = 1;

var ቆጣሪ = setInterval (ተግባር () (ማስጠንቀቂያ (i ++)), 2000);

በsetInterval ውስጥ ጥሪዎችን መደርደር እና መደራረብ

የጥሪ setInterval (ተግባር ፣ መዘግየት) ተግባሩ በተጠቀሰው የጊዜ ክፍተት እንዲፈፀም ያደርገዋል። ግን እዚህ ረቂቅ ነገር አለ.

በእውነቱ፣ በጥሪዎች መካከል ያለው ለአፍታ ማቆም ከተጠቀሰው የጊዜ ክፍተት ያነሰ ነው።

ለምሳሌ፣ setInterval(ተግባር() (func(i++))፣ 100) እንውሰድ። በየ 100 ሚ.ሰ. ተግባር ይሰራል፣ በእያንዳንዱ ጊዜ ቆጣሪውን ይጨምራል።

ከታች ባለው ሥዕል ላይ የቀይ ማገጃው የማስፈጸሚያ ጊዜ ነው. የኢንተርብሎክ ጊዜ በተግባሮች መካከል ያለው ጊዜ ነው እና ከተዘጋጀው መዘግየት ያነሰ ነው!

ማለትም አሳሹ የራሱን የአፈፃፀም ጊዜ ግምት ውስጥ ሳያስገባ በየ100 ሚ.

የአንድ ተግባር አፈፃፀም ከመዘግየቱ የበለጠ ጊዜ የሚወስድ ከሆነ ይከሰታል። ለምሳሌ, ተግባሩ ውስብስብ ነው, ግን መዘግየቱ ትንሽ ነው. ወይም ተግባሩ የማስፈጸሚያውን ክር የሚከለክሉ የማስጠንቀቂያ / ማረጋገጫ / ፈጣን መግለጫዎችን ይዟል። ነገሮች አስደሳች መሆን የሚጀምሩት እዚህ ላይ ነው።

አሳሹ ስራ ስለበዛበት አንድ ተግባር መጀመር ካልተቻለ፣ አሳሹ ነፃ እንደወጣ ወረፋ ይደረግና ተፈፃሚ ይሆናል።

ከታች ያለው ምስል ለመፈጸም ረጅም ጊዜ የሚወስድ ተግባር ምን እንደሚሆን ያሳያል።

በsetInterval የተጀመረው የተግባር ጥሪ ወደ ወረፋው ተጨምሯል እና ሲቻል ወዲያውኑ ይከሰታል፡

ሁለተኛው የተግባር ማስጀመር ከመጀመሪያው መጨረሻ በኋላ ወዲያውኑ ይከሰታል.

ማስፈጸሚያ ከአንድ ጊዜ በላይ አልተሰለፈም።

አንድ ተግባር ከበርካታ የታቀዱ ግድያዎችን ለማስፈጸም ረዘም ያለ ጊዜ ከወሰደ አሁንም አንድ ጊዜ ወረፋ ይይዛል። ስለዚህ የማስጀመሪያዎች "መከማቸት" የለም.

ከታች ባለው ምስል ላይ setInterval ተግባሩን በ200ms ውስጥ ለማስፈጸም ይሞክራል እና ጥሪውን ያሰፋል። በ 300ms እና 400ms ሰዓት ቆጣሪው እንደገና ይነሳል, ነገር ግን ምንም ነገር አይከሰትም.

ወደ setInterval (ተግባር ፣ መዘግየት) መደወል በአፈፃፀም መካከል ትክክለኛ መዘግየትን አያረጋግጥም።

ትክክለኛው መዘግየቱ ከተጠቀሰው የበለጠ ወይም ያነሰ በሚሆንበት ጊዜ ሁኔታዎች አሉ. በአጠቃላይ, ቢያንስ መዘግየቶች ሊኖሩ እንደሚችሉ እውነታ አይደለም.

የተከተተ setTimeout መድገም

መደበኛ መደጋገም ብቻ ሳይሆን በሩጫ መካከል መዘግየት በሚያስፈልግበት ጊዜ setTimeout ተግባሩ በተፈጸመ ቁጥር እንደገና ለማዘጋጀት ይጠቅማል።

ከታች በመካከላቸው 2 ሰከንድ ክፍተቶች ያለው ማንቂያ የሚሰጥ ምሳሌ ነው።

ዝቅተኛ የሰዓት ቆጣሪ መዘግየት

የአሳሽ ጊዜ ቆጣሪው በጣም ዝቅተኛው መዘግየት አለው። በዘመናዊ አሳሾች በግምት ከዜሮ እስከ 4ms ይለያያል። በትላልቅ ሰዎች ረዘም ያለ እና 15 ሚ.

በደረጃው መሰረት, ዝቅተኛው መዘግየት 4ms ነው. ስለዚህ በsetTimeout(...,1) እና setTimeout(...,4) መካከል ምንም ልዩነት የለም።

የsetTimeout እና setInterval የዜሮ መዘግየት ባህሪ አሳሽ-ተኮር ነው።

  • በኦፔራ ውስጥ setTimeout(..., 0) ከ setTimeout(..., 4) ጋር ተመሳሳይ ነው። ከ setTimeout(.. ,2) ባነሰ ድግግሞሽ ነው የሚሰራው። ይህ የዚህ አሳሽ ባህሪ ነው።
  • በInternet Explorer ዜሮ መዘግየት setInterval(.., 0) አይሰራም። ይህ በተለይ በ setInterval ላይ ተፈጻሚ ይሆናል፣ i.e. setTimeout(.., 0) በትክክል ይሰራል።
    • ትክክለኛው ቀስቃሽ ድግግሞሽ

    ማነሳሳት በጣም ያነሰ ሊሆን ይችላል በአንዳንድ ሁኔታዎች፣ መዘግየቱ 4ms ላይሆን ይችላል፣ ግን 30ms ወይም እንዲያውም 1000ms።

    አብዛኛዎቹ አሳሾች (በዋነኛነት ዴስክቶፕ ያሉት) ትር ባይሰራም setTimeout/setInterval መስራታቸውን ቀጥለዋል። በተመሳሳይ ጊዜ, ቁጥራቸው (Chrome, FF, IE10) ዝቅተኛውን የሰዓት ቆጣሪ ድግግሞሽ በሰከንድ 1 ጊዜ ይቀንሳል. የሰዓት ቆጣሪው በ “ዳራ” ትር ውስጥ ይሰራል ፣ ግን አልፎ አልፎ።

    በባትሪ ሃይል፣ በላፕቶፕ ላይ፣ አሳሾች ብዙ ጊዜ ኮድ ለማስፈጸም እና የባትሪ ሃይልን ለመቆጠብ ድግግሞሹን ይቀንሳሉ። IE በተለይ ለዚህ ታዋቂ ነው. በቅንብሮች ላይ በመመስረት ቅነሳው ብዙ ጊዜ ሊደርስ ይችላል. የሲፒዩ ጭነት በጣም ከፍተኛ ከሆነ ጃቫ ስክሪፕት የሰዓት ቆጣሪዎችን በጊዜው ማካሄድ ላይችል ይችላል። ይህ አንዳንድ የሴቲንግInterval ሩጫዎችን ያልፋል።

    ማጠቃለያ: የ 4ms ድግግሞሽ ትኩረት ሊሰጠው የሚገባ ነው, ነገር ግን በእሱ ላይ መቁጠር የለብዎትም.

    በኮንሶል ላይ የውፅአት ክፍተቶች በጥሪዎች መካከል ያለውን የጊዜ ክፍተቶች የሚቆጥረው ኮድ ይህን ይመስላል።

    var timeMark = አዲስ ቀን; setTimeout (ተግባር go () (var diff = አዲስ ቀን - timeMark; // የሚቀጥለውን መዘግየት ከገጹ ኮንሶል ይልቅ ወደ ኮንሶሉ ያትሙ .log(diff) ፤ // በመጨረሻው ላይ ያለውን ጊዜ አስታውስ ፣ // ለመለካት በጥሪዎች መካከል መዘግየት ማርክ = አዲስ ቀን; ዘዴው setTimeout (func, 0) ነው

    ይህ ብልሃት የጃቫስክሪፕት ጠለፋዎችን ታሪክ ውስጥ ለማስገባት ብቁ ነው።

    የአሁኑ ስክሪፕት ካለቀ በኋላ ማስኬድ ከፈለጉ ተግባሩ በsetTimeout (func, 0) ተጠቅልሏል።

    ዋናው ነገር setTimeout ወዲያውኑ ተግባሩን ፈጽሞ አይሰራም። አተገባበሩን ብቻ ያቅዳል። ነገር ግን የጃቫ ስክሪፕት አስተርጓሚ የታቀዱትን ተግባራት ማከናወን የሚጀምረው አሁን ያለው ስክሪፕት ከተፈጸመ በኋላ ብቻ ነው።

    በመደበኛው መሠረት ፣ setTimeout ከ 0 መዘግየት ጋር አንድን ተግባር ማከናወን አይችልም ቀደም ብለን እንደተናገርነው መዘግየቱ ብዙውን ጊዜ 4ms ይሆናል። ግን እዚህ ያለው ዋናው ነገር በማንኛውም ሁኔታ አፈፃፀም የሚከናወነው የአሁኑን ኮድ ከተፈጸመ በኋላ ነው.

    ለምሳሌ፡-

    var ውጤት; ተግባር ሾው ውጤት () (ማስጠንቀቂያ (ውጤት);) setTimeout (showResult, 0); ውጤት = 2 * 2; // 4 ድምር ያወጣል።

    የ setInterval(func፣ delay) እና setTimeout(func፣ delay) ስልቶች በመደበኛነት/እያንዳንዱ መዘግየት በሚሊሰከንዶች አንዴ እንዲሰሩ ያስችሉዎታል።

    ሁለቱም ዘዴዎች የሰዓት ቆጣሪ መታወቂያውን ይመለሳሉ. clearInterval/ clearTimeout በመደወል አፈጻጸምን ለማስቆም ይጠቅማል።

    | | setInterval | setTimeout | || -------- | ------- | | ጊዜ | ጥሪው በጥብቅ በሰዓት ቆጣሪ ላይ ነው። አስተርጓሚው ስራ ከበዛበት አንድ ጥሪ ተሰልፏል። የተግባር ማስፈጸሚያ ጊዜ ግምት ውስጥ አይገባም, ስለዚህ ከአንዱ ሩጫ መጨረሻ እስከ ሌላኛው መጀመሪያ ያለው የጊዜ ልዩነት ሊለያይ ይችላል. | ተደጋጋሚ ጥሪ ወደ setTimeout የሚደረገው ከsetInterval ይልቅ በአፈፃፀም መካከል ቋሚ ለአፍታ ማቆም አስፈላጊ ነው። | | መዘግየት | ዝቅተኛ መዘግየት፡ 4 ሚሴ | ዝቅተኛ መዘግየት፡ 4 ሚሴ | | የአሳሽ ባህሪያት | መዘግየት 0 በ IE ውስጥ አይሰራም በኦፔራ፣ ዜሮ መዘግየት ከ4ms ጋር እኩል ነው፣ እና ሌሎች መዘግየቶች በትክክል ይስተናገዳሉ፣ መደበኛ ያልሆኑ 1ms፣ 2ms እና 3ms ጨምሮ። |

    በመስኮቱ እና በሰራተኛ መገናኛዎች ላይ የቀረበው የsetInterval() ዘዴ አንድ ተግባርን ደጋግሞ ይደውላል ወይም የኮድ ቅንጣቢ ያስፈጽማል፣ በእያንዳንዱ ጥሪ መካከል የተወሰነ የጊዜ መዘግየት።

    ክፍተቱን በልዩ ሁኔታ የሚለይ የ interval መታወቂያ ይመልሳል፣ ስለዚህ በኋላ ላይ clearInterval() በመደወል ሊያስወግዱት ይችላሉ። ይህ ዘዴ በWindowOrWorkerGlobalScope ድብልቅ ይገለጻል። አገባብ = var intervalIDስፋት .setInterval(, መዘግየት, [አዝናኝ, arg1, ...]); አገባብ = var intervalIDስፋት arg2, መዘግየትኮድ ); Parameters func በእያንዳንዱ መዘግየት በሚሊሰከንዶች የሚፈጸም ተግባር። ተግባሩ ምንም ነጋሪ እሴቶች አልተላለፈም, እና ምንም የመመለሻ ዋጋ አይጠበቅም. code የአማራጭ አገባብ ከተግባር ይልቅ ሕብረቁምፊን እንዲያካትቱ ይፈቅድልዎታል ይህም በእያንዳንዱ መዘግየት በሚሊሰከንዶች የተጠናቀረ እና የሚፈጸም ነው። ይህ አገባብ ነው። .setInterval(አይመከርም

    ማሳሰቢያ፡-በመጀመሪያው አገባብ ወደ setInterval() ተጨማሪ ክርክሮችን ማለፍ በInternet Explorer 9 እና ከዚያ በፊት አይሰራም። ይህን ተግባር በዚያ አሳሽ ላይ ለማንቃት ከፈለጉ ፖሊፊልን መጠቀም አለቦት (ክፍሉን ይመልከቱ)።

    ዋጋ መመለስ

    የተመለሰው intervalID ቁጥራዊ፣ ዜሮ ያልሆነ እሴት ሲሆን ይህም ወደ setInterval() ጥሪ የተፈጠረውን ሰዓት ቆጣሪ የሚለይ ነው። ይህ ዋጋ ጊዜ ማብቂያውን ለመሰረዝ ሊታለፍ ይችላል።

    setInterval() እና setTimeout() ተመሳሳይ የመታወቂያ ገንዳ እንደሚጋሩ፣ እና clearInterval() እና clearTimeout() በቴክኒካል በተለዋዋጭነት ጥቅም ላይ ሊውሉ እንደሚችሉ ማወቅ ጠቃሚ ሊሆን ይችላል። ግልጽ ለማድረግ ግን ኮድዎን በሚጠብቁበት ጊዜ ግራ መጋባትን ለማስወገድ ሁልጊዜ እነሱን ለማዛመድ መሞከር አለብዎት።

    ማስታወሻ፡ የመዘግየቱ ነጋሪ እሴት ወደ ፊርማ 32-ቢት ኢንቲጀር ተቀይሯል። ይህ በ IDL ውስጥ እንደ የተፈረመ ኢንቲጀር ስለተገለፀ ወደ 2147483647 ሚሴ መዘግየቱን በትክክል ይገድባል።

    ምሳሌዎች ምሳሌ 1፡ መሰረታዊ አገባብ

    የሚከተለው ምሳሌ የ setInterval()" መሰረታዊ አገባብ ያሳያል።

    Var intervalID = window.setInterval (myCallback, 500, "Parameter 1", "Parameter 2"); ተግባር myCallback (a, b) (// የእርስዎ ኮድ እዚህ // መለኪያዎች ሙሉ በሙሉ አማራጭ ናቸው. console.log (a); console.log (b)

    ምሳሌ 2፡ ሁለት ቀለሞችን መቀያየር

    የሚከተለው ምሳሌ የማቆሚያ ቁልፍ እስኪጫን ድረስ የፍላሽ ጽሑፍ() ተግባርን በሰከንድ አንድ ጊዜ ይጠራል።

    setInterval/clearInterval ምሳሌ var nIntervId;

    የተግባር ለውጥColor () ( nIntervId = setInterval (flashText, 1000);) ተግባር flashText () (var oElem = document.getElementById("my_box"); oElem.style.color = oElem.style.color == "ቀይ"? " blue" : "ቀይ"፤ // oElem.style.color == "ቀይ" ? "ሰማያዊ" : "ቀይ" ተርነሪ ኦፕሬተር ነው። ) ተግባር stopTextColor() ( clearInterval(nIntervId);)

    ሰላም አለም

    ተወ

    ምሳሌ 3፡ የጽሕፈት መኪና ማስመሰል

    የሚከተለው ምሳሌ የጽሕፈት መኪናን በመጀመሪያ በማጽዳት እና በመቀጠል ከተወሰኑ የመራጮች ቡድን ጋር የሚዛመድ ይዘትን ወደ NodeList ቀስ በቀስ በመተየብ ያስመስለዋል።< nPos) { return true; } var oRel, bExit = false; if (aMap.length === nPos) { aMap.push(0); } while (aMap < oSheet.parts.length) { oRel = oSheet.parts]; scroll(oRel, nPos + 1, bEraseAndStop) ? aMap++ : bExit = true; if (bEraseAndStop && (oRel.ref.nodeType - 1 | 1) === 3 && oRel.ref.nodeValue) { bExit = true; oCurrent = oRel.ref; sPart = oCurrent.nodeValue; oCurrent.nodeValue = ""; } oSheet.ref.appendChild(oRel.ref); if (bExit) { return false; } } aMap.length--; return true; } function typewrite () { if (sPart.length === 0 && scroll(aSheets, 0, true) && nIdx++ === aSheets.length - 1) { clean(); return; } oCurrent.nodeValue += sPart.charAt(0); sPart = sPart.slice(1); } function Sheet (oNode) { this.ref = oNode; if (!oNode.hasChildNodes()) { return; } this.parts = Array.prototype.slice.call(oNode.childNodes); for (var nChild = 0; nChild < this.parts.length; nChild++) { oNode.removeChild(this.parts); this.parts = new Sheet(this.parts); } } var nIntervId, oCurrent = null, bTyping = false, bStart = true, nIdx = 0, sPart = "", aSheets = , aMap = ; this.rate = nRate || 100; this.play = function () { if (bTyping) { return; } if (bStart) { var aItems = document.querySelectorAll(sSelector); if (aItems.length === 0) { return; } for (var nItem = 0; nItem < aItems.length; nItem++) { aSheets.push(new Sheet(aItems)); /* Uncomment the following line if you have previously hidden your elements via CSS: */ // aItems.style.visibility = "visible"; } bStart = false; } nIntervId = setInterval(typewrite, this.rate); bTyping = true; }; this.pause = function () { clearInterval(nIntervId); bTyping = false; }; this.terminate = function () { oCurrent.nodeValue += sPart; sPart = ""; for (nIdx; nIdx < aSheets.length; scroll(aSheets, 0, false)); clean(); }; } /* usage: */ var oTWExample1 = new Typewriter(/* elements: */ "#article, h1, #info, #copyleft", /* frame rate (optional): */ 15); /* default frame rate is 100: */ var oTWExample2 = new Typewriter("#controls"); /* you can also change the frame rate value modifying the "rate" property; for example: */ // oTWExample2.rate = 150; onload = function () { oTWExample1.play(); oTWExample2.play(); }; span.intLink, a, a:visited { cursor: pointer; color: #000000; text-decoration: underline; } #info { width: 180px; height: 150px; float: right; background-color: #eeeeff; padding: 4px; overflow: auto; font-size: 12px; margin: 4px; border-radius: 5px; /* visibility: hidden; */ }

    ጃቫ ስክሪፕት የጽሕፈት መኪና - ኤምዲኤን ምሳሌ ተግባር የጽሕፈት መኪና (sSelector, nRate) (ተግባር ንፁህ () ( clearInterval (nIntervId); bTyping = false; bStart = true; oCurrent = null; aSheets.length = nIdx = 0; ) ተግባር ማሸብለል (oSheet, nPos) , bEraseAndStop) (! oSheet. hasOwn Property("ክፍሎች") ከሆነ || aMap.length

    የቅጂLeft 2012 በሞዚላ ገንቢ አውታረ መረብ

    ቪቫመስ ብላንድት ማሳ ut ሜቱስ ማቲስ በፍሪንጊላ ሌክተስ ኢምፐርዲየት። Proin ac ante a felis ornare vehicula። Fusce pellentesque lacus vitae eros convallis ut mollis magna pellentesque. ፔለንተስክ ፕላስራት enim እና lacus ultricies vitae facilisis nisi fringilla። በቲንሲዳንት ቲንሲደንት.

    ጃቫ ስክሪፕት የጽሕፈት መኪና

    Lorem ipsum dolor sit amet, consectetur adipiscing elit. ኑላም አልትሪስ ዶሎር አክ ዶሎር ኢፐርዲየት ኡላምኮርፐር። Suspendisse quam ሊቤሮ፣ ሉክተስ ኦክተር ሞሊስ ሴድ፣ ማሌሱዳዳ ኮንዲሜንተም ማኛ። Quisque በ ante tellus፣ በፕላዝራት ኢስት ውስጥ። ፔለንቴስክ መኖሪያ ሞርቢ ትራይስቲክ ሴኔክተስ እና ኔቱስ እና ማሌሱዳ ዝናዎች አሲ ቱርፒስ ኢጌስታስ። Donec a mi magna፣ quis mattis dolor። Etiam sit አሜት ሊጉላ ኩይስ urna auctor imperdiet nec faucibus ante። Mauris vel consectetur dolor. Nunc eget elit eget velit pulvinar fringilla consectetur aliquam purus. Curabitur convallis፣ justo posuere porta egestas፣ velit erat ornare tortor፣ non viverra justo diam eget arcu። ፋሴለስ አዲፒስሲንግ fermentum nibh ac commodo። Nam turpis nunc፣ suscipit a hendrerit vitae፣ volutpat non ipsum።
    ፋሰልለስ አሲ ኒስል ሎሬም፡-

    ዱይስ ሎቦርቲስ ሳፒየን ኩይስ ኒስላ ሉክተስ ፖርቲተር። በጊዜያዊ ሴምፐር ሊቤሮ፣ eu tincidunt dolor eleifend ሲት አሜት። Ut nec velit በዶሎር ቲንሲደንት ሮንከስ ያልሆነ ዲአም። Morbi auctor ornare orci፣ non euismod felis gravida nec. Curabitur elementum nisi a eros rutrum nec blandit diam placerat. አኔአን ቲንሲደንት ሪስሱስ ኡት ኒሲ ኮንሴክተቱር ኩርሰስ። Ut vitae quam elit. Donec dignissim est በ quam tempor consequat ውስጥ። አሊኳም አሊኳም ዲአም ኖ ፌሊስ ኮንቫሊስ ሱሲፒት። ኑላ ፋሲሊሲ። ዶኔክ ላከስ ሪሰስ፣ ዲግኒስም እና ፍሪንጊላ እና ኢጌስታስ ቬል ኤሮስ። Duis malesuada accumsan dui፣ at fringilla mauris bibStartum quis። Cras adipiscing ultricies fermentum. Praesent bibStartum condimentum feugiat.

    Nam faucibus፣ ligula eu fringilla pulvinar፣ lectus tellus iaculis nunc፣ vitae selerisque metus leo non metus። ፕሮይን ማቲስ ሎቦርቲስ ሎቦርቲስ። Quisque accumsan faucibus erat፣ vel varius tortor ultricies ac. Lorem ipsum dolor sit amet, consectetur adipiscing elit. ሴድ ኔክ ሊበሮ ኑንክ። Nullam tortor nunc፣ elementum a consectetur et፣ ultrises eu orci. Lorem ipsum dolor sit amet, consectetur adipiscing elit. ፔለንቴስኬ አንድ ኒስል ኢዩ ሴም ቬሂኩላ ኢገስታስ።

    የመልሶ ጥሪ ክርክሮች

    ቀደም ሲል እንደተብራራው፣ የኢንተርኔት ኤክስፕሎረር ስሪቶች 9 እና ከዚያ በታች ክርክሮችን ወደ መልሶ ጥሪ ተግባር በsetTimeout() ወይም setInterval() ውስጥ ማለፍን አይደግፉም። የሚከተለው IE-specific code ይህንን ገደብ የማለፍ ዘዴን ያሳያል። ለመጠቀም በቀላሉ የሚከተለውን ኮድ በስክሪፕትዎ አናት ላይ ያክሉ።

    /*\ |*| |*| የዘፈቀደ ክርክሮችን ወደ |*| ለማለፍ የሚያስችል IE-specific polyfill የጃቫስክሪፕት ጊዜ ቆጣሪዎች መልሶ መደወያ ተግባራት (HTML5 መደበኛ አገባብ)።.setInterval |*| https://site/User:fusionchess |*| |*| አገባብ፡|*| var timeoutID = window.setTimeout(func, delay[, arg1, arg2, ...]); |*| var timeoutID = window.setTimeout(ኮድ፣ መዘግየት); |*| var intervalID = window.setInterval (func, delay[, arg1, arg2, ...]); |*| var intervalID = window.setInterval (ኮድ, መዘግየት); |*| \*/ ከሆነ (document.all & & !window.setTimeout.isPolyfill) (var __nativeST__ = window.setTimeout; window.setTimeout = ተግባር (vCallback, nDelay /*, ክርክርToPass1, ክርክርToPass2, ወዘተ. */) (var aArgs = Array) .prototype.slice.call (ክርክሮች, 2); መመለስ __nativeST __ (vCallback.apply ( null, aArgs): vCallback, nDelay); ከሆነ (ሰነድ.ሁሉም && !window.setInterval.isPolyfill) (var __nativeSI__ = window.setInterval; window.setInterval = ተግባር (vCallback, nDelay /*, argumentToPass1, argumentToPass2, ወዘተ. */) (var aArgs = Array.prototype. slice.call(ክርክሮች, 2)፤ __nativeSI__(vCallback ለምሳሌ ተግባር () (vCallback.apply (null, aArgs); ): vCallback, nDelay);

    መልሶ መደወልዎን ለመደወል ሌላ አማራጭ ስም-አልባ ተግባርን መጠቀም ነው፣ ምንም እንኳን ይህ መፍትሄ ትንሽ የበለጠ ውድ ቢሆንም። ለምሳሌ፥

    Var intervalID = setInterval(ተግባር() (myFunc("አንድ""ሁለት""ሶስት");, 1000);

    var intervalID = setInterval (ተግባር (arg1) () .ቢንድ (ያልተገለጸ, 10), 1000;

    እንቅስቃሴ-አልባ ትሮች ጌኮ 5.0 (ፋየርፎክስ 5.0 / ተንደርበርድ 5.0 / SeaMonkey 2.2) ያስፈልገዋል

    ከ Gecko 5.0 (Firefox 5.0 / Thunderbird 5.0 / SeaMonkey 2.2) ጀምሮ, ክፍተቶች በሴኮንድ ከአንድ ጊዜ በላይ በማይንቀሳቀሱ ትሮች ውስጥ ይቃጠላሉ.

    "ይህ" ችግር

    አንድ ዘዴን ወደ ኢንተርቫል () ወይም ሌላ ማንኛውንም ተግባር ሲያልፉ ይህ ዋጋ በተሳሳተ መንገድ ይጠራል። ይህ ችግር በጃቫስክሪፕት ማጣቀሻ ውስጥ በዝርዝር ተብራርቷል.

    ማብራሪያ

    MyArray = ["ዜሮ", "አንድ", "ሁለት"]; myArray.myMethod = ተግባር (sProperty) (ማስጠንቀቂያ (arguments.length> 0? ይህ: ይህ);); myArray.myMethod (); // "ዜሮ, አንድ, ሁለት" myArray.myMethod (1) ያትማል; // "አንድ" setTimeout (myArray.myMethod, 1000) ያትማል; // ከ 1 ሰከንድ ጊዜ በኋላ "" ያትማል (myArray.myMethod, 1500, "1"); // ከ 1.5 ሰከንድ በኋላ "ያልተገለጸ" ያትማል // "ይህን" ነገር በ .ጥሪ ማለፍ አይሰራም // ምክንያቱም ይህ በውስጡ ያለውን ዋጋ ይለውጠዋል setTimeout በራሱ // በ myArray ውስጥ ያለውን ዋጋ መለወጥ እንፈልጋለን. .myMethod // በእውነቱ ፣ ይህ ስህተት ይሆናል ፣ ምክንያቱም setTimeout ኮድ ይህ የመስኮት ነገር እንዲሆን ይጠብቃል፡ setTimeout.call(myArray, myArray.myMethod, 2000); setTimeout.call (myArray, myArray.myMethod, 2500, 2);

    እንደሚመለከቱት ይህንን ነገር በቀድሞው ጃቫስክሪፕት ውስጥ ወደ መልሶ ጥሪ ተግባር ለማለፍ ምንም መንገዶች የሉም።

    ሊሆን የሚችል መፍትሄ

    "ይህን" ችግር ለመፍታት የሚቻልበት መንገድ ሁለቱን ቤተኛ setTimeout() ወይም setInterval() ሁለንተናዊ ተግባራትን በሁለት መተካት ነው። ተወላጅ ያልሆኑበFunction.prototype.call ዘዴ በኩል ጥሪያቸውን የሚያነቃቁ። የሚከተለው ምሳሌ ሊተካ የሚችልበትን ሁኔታ ያሳያል።

    // የ"ይህን" ነገር በጃቫስክሪፕት ሰዓት ቆጣሪዎች በኩል እንዲያልፍ ያንቁ var __nativeST__ = window.setTimeout, __nativeSI__ = window.setInterval; window.setTimeout = ተግባር (vCallback፣ nDelay /*፣ argumentToPass1፣ argumentToPass2፣ወዘተ */) ( var oThis = this, aArgs = Array.prototype.slice.call(ክርክሮች፣ 2)፤ __nativeST__(vCallback exampleof function ? ተግባር) መመለስ። () ( vCallback.apply (oThis, aArgs); ): vCallback, nDelay); window.setInterval = ተግባር (vCallback፣ nDelay /*፣ argumentToPass1፣ argumentToPass2፣ወዘተ */) (var oThis = this, aArgs = Array.prototype.slice.call(ክርክሮች፣ 2)፤ __nativeSI__(vCallback example of function ? ተግባር) ይመለሱ። () ( vCallback.apply (oThis, aArgs); ): vCallback, nDelay);

    እነዚህ ሁለቱ መተኪያዎች በ IE ውስጥ የሰዓት ቆጣሪዎችን የመመለሻ ተግባራት የዘፈቀደ ነጋሪ እሴቶችን HTML5 መደበኛ ምንባብ ያስችላሉ። ስለዚህ እንደ ጥቅም ላይ ሊውሉ ይችላሉ መደበኛ ያልሆነ ታዛዥፖሊሙም እንዲሁ። ለ ሀ ይመልከቱ ደረጃውን የጠበቀፖሊ ሙሌት.

    አዲስ የባህሪ ሙከራ፡-

    MyArray = ["ዜሮ", "አንድ", "ሁለት"]; myArray.myMethod = ተግባር (sProperty) (ማስጠንቀቂያ (arguments.length> 0? ይህ: ይህ);); setTimeout (ማንቂያ, 1500, "ጤና ይስጥልኝ ዓለም!"); // የ setTimeout እና setInterval መደበኛ አጠቃቀም ተጠብቆ ይቆያል፣ ግን... setTimeout.call(myArray, myArray.myMethod, 2000); // ከ 2 ሰከንድ በኋላ "ዜሮ, አንድ, ሁለት" ያትማል setTimeout.call (myArray, myArray.myMethod, 2500, 2); // ከ 2.5 ሰከንድ በኋላ "ሁለት" ያትማል

    ለተጨማሪ ውስብስብ ግን አሁንም ሞጁል ሥሪት ( ዴሞን) የጃቫስክሪፕት ዴይሞን አስተዳደርን ይመልከቱ። ይህ ይበልጥ የተወሳሰበ ስሪት ለሚከተሉት ዘዴዎች ትልቅ እና ሊሰፋ የሚችል ስብስብ እንጂ ሌላ አይደለም። ዴሞንገንቢ. ሆኖም ፣ የ ዴሞንኮንስትራክተሩ ራሱ ክሎኑ እንጂ ሌላ አይደለም። ሚኒ ዴሞንከተጨማሪ ድጋፍ ጋር ለ initእና ሲጀመርበ ቅጽበት ወቅት የተገለጹ ተግባራት ዴሞን. ስለዚህ የ ሚኒ ዴሞንማዕቀፍ ለቀላል እነማዎች የሚመከር መንገድ ሆኖ ይቆያል ፣ ምክንያቱም ዴሞንያለ እሱ ዘዴዎች ስብስብ በመሠረቱ የእሱ ክሎኒ ነው።

    minidaemon.js /*\ |*| |*| :: ሚኒ ዴሞን:: |*| |*| ክለሳ #2 - ሴፕቴምበር 26, 2014.setInterval |*| https://site/User:fusionchess |*| https://github.com/madmurphy/minidaemon.js |*| |*| ይህ ማዕቀፍ በጂኤንዩ ትንሹ አጠቃላይ የህዝብ ፈቃድ፣ ስሪት 3 ወይም ከዚያ በኋላ የተለቀቀ ነው። |*| http://www.gnu.org/licenses/lgpl-3.0.html |*| \*/ ተግባር MiniDaemon (oOwner, fTask, nRate, nLen) (ከሆነ (!< 2) { throw new TypeError("MiniDaemon - not enough arguments"); } if (oOwner) { this.owner = oOwner; } this.task = fTask; if (isFinite(nRate) && nRate >0) (ይህ.ደረጃ = Math.floor (nRate);) ከሆነ (nLen> 0) (ይህ.ርዝመት = Math.floor (nLen);)) MiniDaemon.prototype.owner = null; MiniDaemon.prototype.task = ባዶ; MiniDaemon.prototype.rate = 100; MiniDaemon.prototype.length = Infinity;< 1: this.INDEX + 1 >ይህ.ርዝመት; ); MiniDaemon.prototype.synchronize = ተግባር () (ይህ.PAUSED ከሆነ) (መመለስ;) clearInterval (this.SESSION); this.SESSION = setInterval (MiniDaemon.forceCall, ይህ. ደረጃ, ይህ); MiniDaemon.prototype.pause = ተግባር () ( clearInterval (this.SESSION); ይህ.PAUSED = እውነት; ); MiniDaemon.prototype.start = ተግባር (bReverse) (var bBackw = ቡሊያን (bReverse); ከሆነ (this.BACKW === bBackw && (this.isAtEnd () || !this.PAUSED)) (ተመለስ;) this.BACKW = bBackw; ይህ.PAUSED = ሐሰት;

    MiniDaemon ክርክሮችን ወደ መልሶ ጥሪ ተግባር ያስተላልፋል። ይህንን ባህሪ ከማይደግፉ አሳሾች ጋር ለመስራት ከፈለጉ ፣ ከላይ ከቀረቡት ዘዴዎች ውስጥ አንዱን ይጠቀሙ።

    አገባብ

    var myDaemon = አዲስ ሚኒ ዴሞን ( ይህ ነገር, መልሶ መደወል[ , ደረጃ [, ርዝመት]]);

    የአጠቃቀም ማስታወሻዎች መግለጫ

    የsetInterval() ተግባር በተለምዶ እንደ እነማ ላሉ ተደጋጋሚ ተግባራት መዘግየትን ለማዘጋጀት ይጠቅማል። በ WindowOrWorkerGlobalScope.clearInterval() በመጠቀም ክፍተቱን መሰረዝ ይችላሉ።

    ተግባርዎ እንዲጠራዎት ከፈለጉ አንድ ጊዜከተጠቀሰው መዘግየት በኋላ, ይጠቀሙ.

    የማዘግየት ገደቦች

    ክፍተቶችን መደርደር ይቻላል፤ ማለትም፣ ለsetInterval() መልሶ መደወል በተራው ወደ setInterval() መደወል ይችላል፣ ምንም እንኳን የመጀመሪያው አሁንም እየሄደ ቢሆንም። ይህ ሊያስከትል የሚችለውን ተፅእኖ ለመቀነስ። አፈጻጸም፣ ክፍተቶች ከአምስት ደረጃዎች በላይ ከተጣበቁ፣ አሳሹ ለክፍለ ጊዜው የ 4 ሚሴ ዝቅተኛ ዋጋን በራስ-ሰር ያስፈጽማል። ከ4 ሚሴ በታች የሆነ እሴትን ወደ setInterval() ጥሪዎች 4 ሚሰ ላይ ይሰካል።

    ምንም እንኳን እነዚህ የተለመዱ ሊሆኑ ባይችሉም አሳሾች ለጊዜ ልዩነት ይበልጥ ጥብቅ የሆኑ ዝቅተኛ እሴቶችን በአንዳንድ ሁኔታዎች ሊያስገድዱ ይችላሉ። እንዲሁም ወደ መልሶ መደወል በሚደረጉ ጥሪዎች መካከል ያለው ትክክለኛው የጊዜ መጠን ከተጠቀሰው መዘግየት የበለጠ ሊሆን እንደሚችል ልብ ይበሉ። ለምሳሌ በWindowOrWorkerGlobalScope.setTimeout() ላይ ከተጠቀሰው በላይ የሚዘገዩበትን ምክንያቶች ይመልከቱ።

    የማስፈጸሚያ የቆይታ ጊዜ ከክፍለ-ጊዜ ድግግሞሽ ያነሰ መሆኑን ያረጋግጡ

    የርስዎ አመክንዮ ከክፍተቱ ጊዜ በላይ ለመፈፀም ሊወስድ የሚችልበት እድል ካለ setTimeout()ን በመጠቀም የተሰየመ ተግባርን ደጋግመው እንዲጠሩት ይመከራል። ለምሳሌ፣ በየ 5 ሰከንድ የርቀት አገልጋይን ለመጠየቅ setInterval()ን ብንጠቀም የኔትወርክ መዘግየት፣ ምላሽ የማይሰጥ አገልጋይ እና ሌሎች በርካታ ጉዳዮች ጥያቄው በተያዘለት ጊዜ እንዳይጠናቀቅ ሊያደርጉ ይችላሉ። እንደዚያው፣ የግድ በሥርዓት የማይመለሱ የXHR ጥያቄዎች እራስዎን ማግኘት ይችላሉ።

    የጃቫ ስክሪፕት ጊዜ ቆጣሪዎች እንዴት እንደሚሠሩ መረዳት በጣም አስፈላጊ ነው። ብዙውን ጊዜ ባህሪያቸው ስለ መልቲ-ስነ-ስርጭት ካለን ግንዛቤ ጋር አይዛመድም ፣ እና ይህ በእውነቱ እነሱ በአንድ ነጠላ ክር ውስጥ የተገደሉ በመሆናቸው ነው። የሰዓት ቆጣሪዎችን ማስተዳደር የምንችልባቸውን አራት ተግባራትን እንመልከት፡-

    • var id = setTimeout (fn, መዘግየት); - ከተወሰነ መዘግየት በኋላ የተሰጠውን ተግባር የሚጠራ ቀላል ሰዓት ቆጣሪ ይፈጥራል። ተግባሩ ጊዜ ቆጣሪው ባለበት የሚቆምበት ልዩ መታወቂያ ይመልሳል።
    • var id = setInterval (fn, መዘግየት); - ከ setTimeout ጋር ተመሳሳይ ነው ፣ ግን ተግባሩን በተወሰነ የጊዜ ክፍተት (እስከ ማቆም) ይደውላል።
    • clearInterval(መታወቂያ);, clearTimeout(መታወቂያ); - የሰዓት ቆጣሪ መታወቂያ ይቀበላል (ከላይ ከተገለጹት ተግባራት በአንዱ የተመለሰ) እና የመልሶ መደወልን መፈጸም ያቆማል"ሀ.
    ሊታሰብበት የሚገባው ዋናው ሀሳብ የሰዓት ቆጣሪ መዘግየት ጊዜ ትክክለኛነት ዋስትና የለውም. ለመጀመር አሳሹ ሁሉንም ያልተመሳሰሉ የጃቫ ስክሪፕት ሁነቶችን በአንድ ክር (እንደ መዳፊት ጠቅታ ወይም የሰዓት ቆጣሪ ያሉ) እና የዝግጅቱ ተራ በሚሆንበት ጊዜ ብቻ ይሰራል። ይህ በተሻለ ሁኔታ በሚከተለው ሥዕል ይታያል።

    በዚህ አኃዝ ውስጥ መውሰድ ያለብዎት በጣም ብዙ መረጃ አለ፣ ነገር ግን እሱን መረዳቱ የጃቫ ስክሪፕት ተመሳሳይነት እንዴት እንደሚሰራ ጥልቅ ግንዛቤ ይሰጥዎታል። ይህ ገበታ በአቀባዊ በሚሊሰከንዶች ጊዜን ይወክላል፣ ሰማያዊዎቹ ብሎኮች የጃቫስክሪፕት ኮድ የተፈጸሙ ብሎኮችን ያሳያሉ። ለምሳሌ የመጀመሪያው ብሎክ በአማካይ በ18ሚሴ ይፈፀማል፣ የመዳፊት ጠቅታ ለ11ሚሴ ያህል ይከለክላል፣ወዘተ።

    ጃቫ ስክሪፕት አንድ ኮድ ብቻ ነው ማስፈጸሚያ የሚችለው (በነጠላ ክር የአፈጻጸም ባህሪ ምክንያት) እያንዳንዳቸው ሌሎች ያልተመሳሰሉ ክስተቶችን አፈጻጸም ያግዳል። ይህ ማለት ያልተመሳሰለ ክስተት ሲከሰት (እንደ የመዳፊት ጠቅታ፣ የሰዓት ቆጣሪ ጥሪ ወይም የኤክስኤምኤል ኤችቲቲፒ ጥያቄ ማጠናቀቅ) ወደ ወረፋ ይጨመራል እና በኋላ ይፈጸማል (በእርግጥ አተገባበሩ እንደ አሳሽ ይለያያል፣ ግን እንስማማበት) “ወረፋ” ብለው ይጠሩታል።

    ለመጀመር፣ ሁለት ሰዓት ቆጣሪዎች በጃቫስክሪፕት ብሎክ ውስጥ እንደሚጀምሩ እናስብ፡ setTimeout በ10ms መዘግየት እና setInterval በተመሳሳይ መዘግየት። የሰዓት ቆጣሪው በሚጀምርበት ጊዜ ላይ በመመስረት፣ የመጀመሪያውን ብሎክ ኮድ ገና ባላጠናቀቅንበት ጊዜ ይቃጠላል። ይሁን እንጂ ወዲያውኑ እንደማይቃጠል ልብ ይበሉ (ይህ በነጠላ ክር ምክንያት የማይቻል ነው). በምትኩ፣ የዘገየው ተግባር ወረፋ እና በሚቀጥለው ጊዜ ላይ ይከናወናል።

    እንዲሁም, የመጀመሪያው የጃቫስክሪፕት እገዳ በሚፈፀምበት ጊዜ, የመዳፊት ጠቅታ ይከሰታል. የዚህ ያልተመሳሰለ ክስተት ተቆጣጣሪ (እና ያልተመሳሰለ ነው ምክንያቱም እኛ መተንበይ ስለማንችል) በዚህ ጊዜ በቀጥታ መተግበር ስለማይችል እንደ ሰዓት ቆጣሪው በሰልፍ ያበቃል።

    የጃቫስክሪፕት ኮድ የመጀመሪያ ብሎክ ከተሰራ በኋላ አሳሹ “ለመፈፀም ምን እየጠበቀ ነው?” የሚለውን ጥያቄ ይጠይቃል። በዚህ አጋጣሚ የመዳፊት ጠቅታ ተቆጣጣሪ እና ሰዓት ቆጣሪ በመጠባበቅ ሁኔታ ላይ ናቸው። አሳሹ ከመካከላቸው አንዱን ይመርጣል (ጠቅታ ተቆጣጣሪው) እና ያስፈጽመዋል. የሰዓት ቆጣሪው በአፈፃፀም ወረፋው ውስጥ ለሚቀጥለው ጊዜ የሚቆይ ጊዜ ይጠብቃል።

    የመዳፊት ጠቅታ ተቆጣጣሪው እየፈፀመ እያለ፣ የመጀመሪያው የጊዜ ክፍተት መልሶ መደወል እንደሚቀጣጠል ልብ ይበሉ። ልክ እንደ ሰዓት ቆጣሪ መልሶ መደወያ፣ ወረፋ ይደረጋል። ነገር ግን፣ ክፍተቱ እንደገና ሲቀጣጠል (የጊዜ ቆጣሪው መልሶ መደወል በሚሰራበት ጊዜ) ከወረፋው እንደሚወገድ ልብ ይበሉ። አንድ ትልቅ ኮድ በሚሰራበት ጊዜ እያንዳንዱ የጊዜ ክፍተት መልሶ መደወል" ከተሰለፈ ብዙ ተግባራትን ለመጥራት ይጠብቃል ፣ በመካከላቸው ምንም መዘግየት ሳይኖር ግድያው እስኪጠናቀቅ ድረስ ይጠብቃሉ ። ይልቁንስ አሳሾች ተጨማሪ እስኪጠፉ ድረስ ይጠብቃሉ ። ወደ ወረፋው ሌላ ከማከልዎ በፊት ተግባራት ይቀራሉ።

    ስለዚህ፣ የ interval-callback ሦስተኛው መተኮስ አስቀድሞ ከተተገበረበት ቅጽበት ጋር ሲገጣጠም ጉዳዩን ልንመለከተው እንችላለን። ይህ አንድ አስፈላጊ ነጥብ ያሳያል-እረፍቶች በአሁኑ ጊዜ እየሄደ ያለውን ነገር አይጨነቁም ፣ በአፈፃፀም መካከል ያለውን የመዘግየት ጊዜ ከግምት ውስጥ ሳያስገባ ወደ ወረፋው ውስጥ ይጨምራሉ።

    በመጨረሻም ፣ ሁለተኛው የጊዜ ክፍተት ጥሪ ከተጠናቀቀ በኋላ ፣ ለጃቫ ስክሪፕት ሞተር ምንም የሚቀረው ነገር እንደሌለ እናያለን። ይህ ማለት አሳሹ አዲስ ያልተመሳሰሉ ክስተቶች እስኪከሰቱ ድረስ ይጠብቃል። ይህ በ 50ms ምልክት ላይ ይከሰታል፣ የትርፍ ጊዜ መደወል እንደገና ይሰራል። በዚህ ጊዜ ምንም የሚያግድ ነገር አይኖርም, ስለዚህ ወዲያውኑ ይሰራል.

    በsetTimeout እና setInterval መካከል ያለውን ልዩነት በጥሩ ሁኔታ የሚያሳይ ምሳሌ እንመልከት።
    setTimeout(ተግባር())(/* አንዳንድ ረጅም የኮድ እገዳ... */ setTimeout(arguments.callee, 10);), 10);
    እነዚህ ሁለት አማራጮች በአንደኛው እይታ እኩል ናቸው, ግን በእውነቱ ግን አይደሉም. setTimeoutን የሚጠቀም ኮድ ሁል ጊዜ ከቀዳሚው ጥሪ በኋላ ቢያንስ 10ሚሴ መዘግየት ይኖረዋል (ብዙ ሊሆን ይችላል ነገር ግን በጭራሽ አይቀንስም)፣ ሴቲ ኢንተርቫልን የሚጠቀም ኮድ ግን ያለፈው ጥሪ ምንም ይሁን ምን በየ10 ሚሴ መጠራቱ አይቀርም።

    ከላይ ያለውን ሁሉንም ነገር እናጠቃልል-
    - የጃቫ ስክሪፕት ሞተሮች አንድ-ክር አካባቢን ይጠቀማሉ ፣ ያልተመሳሰሉ ክስተቶችን ወደ አፈፃፀም እየጠበቀ ወደ ወረፋ ይለውጣሉ ፣
    - የ setTimeout እና setInterval ተግባራት በተመሳሰለ ኮድ ውስጥ በመሠረታዊነት ይከናወናሉ ፣
    - የሰዓት ቆጣሪው በአሁኑ ጊዜ መፈፀም ካልቻለ እስከሚቀጥለው የማስፈጸሚያ ነጥብ ድረስ ይዘገያል (ይህም ከተፈለገው መዘግየት ይረዝማል)።
    - ክፍተቶች (setInterval) አፈፃፀማቸው ከተጠቀሰው መዘግየት የበለጠ ጊዜ የሚወስድ ከሆነ ሳይዘገይ አንድ በአንድ ሊከናወኑ ይችላሉ።

    ይህ ሁሉ ለልማት በጣም ጠቃሚ መረጃ ነው. የጃቫ ስክሪፕት ሞተር እንዴት እንደሚሰራ ማወቅ በተለይም ብዙ ያልተመሳሰሉ ክስተቶች (ብዙውን ጊዜ የሚከሰት) የላቁ መተግበሪያዎችን ለመገንባት ትልቅ መሰረት ይጥላል።



    ተዛማጅ ጽሑፎች