JavaScript Academy · पाठ

एनीमेशन टाइमिंग — समय-आधारित लूप का परिचय

छोटा एनीमेशन लूप बनाएँ, समय-आधारित (delta) अपडेट का उपयोग करें, requestAnimationFrame का अनुकरण करें और सरल ईज़िंग जोड़ें।

पाठ 3, कुल 3 में से8 चरण

एनीमेशन टाइमिंग — समय-आधारित लूप का परिचय, CoddyKit पर JavaScript Academy का एक निःशुल्क पाठ है। यह 3 में से 3वाँ पाठ है। इस अध्ययन पथ के 3 तक कोई भी पाठ पूरा पढ़ना निःशुल्क है — इसके बाद CoddyKit PRO हर पाठ अनलॉक करता है, साथ ही अंतर्निर्मित कोड संपादक और चौबीसों घंटे एआई शिक्षक के साथ व्यावहारिक अभ्यास भी उपलब्ध कराता है। यह JavaScript Academy सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। JavaScript Academy पाठ्यक्रम में कुल 3 पाठ शामिल हैं।

समय-आधारित एनीमेशन क्यों?

लक्ष्य: समय-आधारित अपडेट के साथ सहज गति चलाना।

  • requestAnimationFrame का अनुकरण करना
  • समय-अंतर मापना
  • इकाइयाँ प्रति सेकंड की गति से चलना
  • बहुत हल्का गति-समायोजन जोड़ना
एनीमेशन टाइमिंग — समय-आधारित लूप का परिचय — चित्र 1

अनुकरण किया गया rAF

यहाँ DOM नहीं है, इसलिए लगभग 16ms पर setTimeout का उपयोग करके requestAnimationFrame का अनुकरण करते हैं।

// requestFrame: simulate ~60 FPS with setTimeout
function requestFrame(fn) {
  // ~16ms between frames for ~60fps
  return setTimeout(function () { fn(Date.now()); }, 16);
}

function cancelFrame(id) {
  clearTimeout(id);
}

// Tiny demo: schedule one frame
requestFrame(function (ts) {
  console.log("frame at", ts);
});
एनीमेशन टाइमिंग — समय-आधारित लूप का परिचय — चित्र 2

समय-अंतर की मूल बातें

हर फ़्रेम में समय-अंतर निकालें: (now − last) / 1000। इससे गति वास्तविक समय के अनुसार बदलती है।

// Time-based loop: compute delta time in seconds
let running = true;
let last = Date.now();

function loop() {
  if (!running) { return; }
  const now = Date.now();
  const dt = (now - last) / 1000; // seconds
  last = now;

  // Print a tiny delta preview
  console.log("dt", dt.toFixed(3), "s");

  requestFrame(loop);
}

// Start the loop and stop after a few frames
loop();
setTimeout(function () {
  running = false;
  console.log("stop");
}, 60);
एनीमेशन टाइमिंग — समय-आधारित लूप का परिचय — चित्र 3

प्रति सेकंड इकाइयाँ

स्थिति अपडेट करने के लिए speed × dt का उपयोग करें, ताकि अलग-अलग फ़्रेम दरों पर गति एक जैसी रहे।

// Move with a speed in units/second
let x = 0;               // position
const speed = 50;        // units per second

let lastT = Date.now();
let frames = 0;

function moveLoop() {
  const now = Date.now();
  const dt = (now - lastT) / 1000;
  lastT = now;

  // Distance = speed * time
  x = x + speed * dt;
  frames = frames + 1;

  console.log("x", Math.round(x));

  if (frames < 5) {
    requestFrame(moveLoop);
  } else {
    console.log("final x", Math.round(x));
  }
}

moveLoop();
एनीमेशन टाइमिंग — समय-आधारित लूप का परिचय — चित्र 4

बहुत हल्का गति-समायोजन प्रदर्शन

गति-समायोजन वक्र का आकार तय करता है। यहाँ easeOutQuad तेज़ी से शुरू होता है और अंत के पास धीमा हो जाता है।

// Ease from 0 to 1 over duration using easeOutQuad
function easeOutQuad(t) {
  // t in [0,1]
  return 1 - (1 - t) * (1 - t);
}

async function tween(durationMs) {
  let start = Date.now();
  let id = null;

  function step() {
    const now = Date.now();
    const t = Math.min(1, (now - start) / durationMs);
    const eased = easeOutQuad(t);
    console.log("eased", eased.toFixed(2));

    if (t < 1) {
      id = requestFrame(step);
    } else {
      cancelFrame(id);
      console.log("done");
    }
  }

  step();
}

tween(60);
एनीमेशन टाइमिंग — समय-आधारित लूप का परिचय — चित्र 5

निश्चित-चरण का स्वाद

निश्चित चरण तर्क को स्थिर कर सकता है; फ़्रेम देर से आने पर संचायक उसकी भरपाई कर लेता है।

// Fixed-step taste: step a physics tick and catch up using an accumulator
let acc = 0;                  // accumulated time
const step = 1 / 30;          // 30 FPS fixed step in seconds
let lastTime = Date.now();
let value = 0;
let fixedFrames = 0;

function fixedLoop() {
  const now = Date.now();
  const dt = (now - lastTime) / 1000;
  lastTime = now;
  acc = acc + dt;

  // Run zero or more fixed steps to catch up
  while (acc >= step) {
    // Update logic at a fixed rate
    value = value + 1;        // pretend physics
    acc = acc - step;
  }

  console.log("value", value);

  fixedFrames = fixedFrames + 1;
  if (fixedFrames < 5) {
    requestFrame(fixedLoop);
  } else {
    console.log("fixed stop");
  }
}

fixedLoop();
एनीमेशन टाइमिंग — समय-आधारित लूप का परिचय — चित्र 6

समय-अंतर बनाम निश्चित चरण—प्रश्नोत्तरी

त्वरित जाँच: समय-अंतर क्यों?

एनीमेशन टाइमिंग — समय-आधारित लूप का परिचय — चित्र 7

पुनरावलोकन

पुनरावलोकन: आपने setTimeout से rAF का अनुकरण किया, समय-अंतर मापा, इकाइयाँ प्रति सेकंड की गति से चलाया, धीमा होने वाला गति-समायोजन जोड़ा और संचायक के साथ निश्चित चरण का तरीका देखा।

एनीमेशन टाइमिंग — समय-आधारित लूप का परिचय — चित्र 8
शुरुआत निःशुल्क

एआई शिक्षक के साथ JavaScript सीखें — निःशुल्क

अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।

पाठ्यक्रम
59
पाठ
200

अक्सर पूछे जाने वाले प्रश्न

क्या “एनीमेशन टाइमिंग — समय-आधारित लूप का परिचय” पाठ निःशुल्क है?

हाँ — JavaScript Academy अध्ययन पथ के 3 तक कोई भी पाठ, जिसमें “एनीमेशन टाइमिंग — समय-आधारित लूप का परिचय” भी शामिल है, यहाँ वेब पर पूरा पढ़ना निःशुल्क है। इसके बाद CoddyKit PRO हर पाठ अनलॉक करता है, साथ ही अंतर्निर्मित कोड संपादक और चौबीसों घंटे एआई शिक्षक के साथ इंटरैक्टिव अभ्यास भी उपलब्ध कराता है। JavaScript Academy पाठ्यक्रम में कुल 3 पाठ शामिल हैं।

“एनीमेशन टाइमिंग — समय-आधारित लूप का परिचय” में मैं क्या सीखूँगा?

छोटा एनीमेशन लूप बनाएँ, समय-आधारित (delta) अपडेट का उपयोग करें, requestAnimationFrame का अनुकरण करें और सरल ईज़िंग जोड़ें। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ JavaScript Academy का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।

क्या JavaScript Academy शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?

पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर JavaScript Academy शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 3 में से 3वाँ पाठ है।

“एनीमेशन टाइमिंग — समय-आधारित लूप का परिचय” पाठ पूरा करने में कितना समय लगता है?

CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।

क्या मैं इस JavaScript Academy पाठ में कोड लिख और चला सकता हूँ?

हाँ। हर JavaScript Academy पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।

इस पाठ्यक्रम के सभी पाठ

  1. setTimeout, setInterval और टाइमर का खिसकाव
  2. डिबाउंस बनाम थ्रॉटल — स्वयं बनाना
  3. एनीमेशन टाइमिंग — समय-आधारित लूप का परिचय
← JavaScript Academy पर वापस जाएँ