Rekursijos išvengimas „JavaScript“ skaidrių demonstravimo funkcijoje su pažadais

Rekursinės JavaScript funkcijos keitimas, kad būtų išvengta skambučių krūvos perpildymo

„JavaScript“ – pažadais pagrįstas metodas su intervalų ciklu, kad būtų išvengta pasikartojimo

const duration = 2000; // Time to display each slide in milliseconds
const sizes = [[4000, 500], [1000, 4000], [600, 400], [100, 200], [4000, 4000]];
let n = 0;
const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));

function showSlides(duration) {
  const myParent = document.querySelector('#slide-div');
  setInterval(async () => {
    let sizeIndex = n++ % sizes.length;
    let w = sizes[sizeIndex][0];
    let h = sizes[sizeIndex][1];
    let myRandomizer = `https://placehold.co/${w}x${h}?text=${w}x${h}`;

    try {
      let myResponse = await fetch(myRandomizer);
      let myBlob = await myResponse.blob();
      let myUrl = URL.createObjectURL(myBlob);
      URL.revokeObjectURL(myParent.querySelector('img').src);
      myParent.querySelector('img').src = myUrl;
    } catch (error) {
      console.error('Error: ', error);
    }
  }, duration);
}

Asinchroninio JavaScript naudojimas be rekursijos

JavaScript – sprendimas naudojant kilpą su pažadais ir vengiant setInterval

const duration = 2000; // Time to display each slide in milliseconds
const sizes = [[4000, 500], [1000, 4000], [600, 400], [100, 200], [4000, 4000]];
let n = 0;
const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));

async function showSlides(duration) {
  const myParent = document.querySelector('#slide-div');

  while (true) {
    let sizeIndex = n++ % sizes.length;
    let w = sizes[sizeIndex][0];
    let h = sizes[sizeIndex][1];
    let myRandomizer = `https://placehold.co/${w}x${h}?text=${w}x${h}`;

    try {
      let myResponse = await fetch(myRandomizer);
      let myBlob = await myResponse.blob();
      let myUrl = URL.createObjectURL(myBlob);
      URL.revokeObjectURL(myParent.querySelector('img').src);
      myParent.querySelector('img').src = myUrl;
    } catch (error) {
      console.error('Error: ', error);
    }

    await sleep(duration);
  }
}

Dažni klausimai apie rekursijos išvengimą „JavaScript“ skaidrių demonstracijoje

1. Kas yra „JavaScript“ rekursija ir kodėl tai yra problema skaidrių demonstracijose?
2. Rekursija įvyksta, kai funkcija išsikviečia pati save, o jei tai daroma nuolat, tai gali sukelti krūvos perpildymą. Skaidrių demonstracijoje tai sukeltų per daug atminties naudojimą ir gali sugesti naršyklė.
3. Kaip išvengti „JavaScript“ funkcijos rekursijos?
4. Vienas sprendimas yra naudoti setInterval arba setTimeout planuoti užduotis be pasikartojimo. Kitas variantas yra įvykiais pagrįstas modelis, kai funkcijas suaktyvina konkretūs vartotojo ar naršyklės įvykiai.
5. Kodėl mano bandymas naudoti while(true) užrakinti naršyklę?
6. Naudojant while(true) be asinchroninės operacijos kaip await arba setTimeout veikia nenutrūkstamu ciklu be pauzės, o tai blokuoja pagrindinę giją, todėl naršyklė užstringa.
7. Ar galiu naudoti Promises kad išvengtume pasikartojimo?
8. taip, Promises leisti asinchroniškai vykdyti be rekursinių funkcijų iškvietimų. Taip užtikrinama, kad kiekviena operacija būtų baigta prieš prasidedant kitai ir išvengiama krūvos perpildymo.
9. Kas yra requestAnimationFrame ir kaip tai padeda?
10. requestAnimationFrame yra metodas, leidžiantis sukurti sklandžią animaciją, sinchronizuotą su naršyklės atnaujinimo dažniu. Tai efektyvu ir neleidžia atlikti nereikalingų skaičiavimų, kai naršyklės skirtukas neaktyvus.

Nepertraukiamų kilpų pasikartojimo išvengimas

„JavaScript“ funkcijų pasikartojimo vengimas, ypač naudojant Pažadai, yra labai svarbus norint išlaikyti našumą. Perjungę į ciklais pagrįstą metodą arba įvykiais pagrįstą modelį, kūrėjai gali neleisti skambučių krūvos be galo augti ir išvengti naršyklės gedimų.

Naudojant tokius metodus kaip setInterval arba requestAnimationFrame, taip pat efektyviai tvarkydami asinchronines operacijas, galėsite sklandžiai atlikti tokias užduotis kaip skaidrių demonstravimas. Šie sprendimai siūlo geresnį atminties valdymą ir užkerta kelią problemoms, susijusioms su rekursiniais funkcijų iškvietimais, taip užtikrinant ilgalaikių procesų stabilumą.