Learn JavaScript

lesson ā§§ / ⧝ ¡ if, switch āφāϰ loop

Module ā§Ē ¡ if, switch āφāϰ loop

āϏāĻŋāĻĻā§āϧāĻžāĻ¨ā§āϤ āφāϰ loop: āĻĒ⧁āϰ⧋ āĻ›āĻŦāĻŋāϟāĻž

FreeāĻĒāĻĄāĻŧāĻž

āĻāχ lesson-āĻ āϝāĻž āĻļāĻŋāĻ–āĻŦ⧇

  • āĻāĻ•āϟāĻž if āφāϰ āĻāĻ•āϟāĻž else āϞāĻŋāϖ⧇ āĻĻ⧁āĻŸā§‹ āϞāĻžāχāύ⧇āϰ āĻāĻ•āϟāĻž āĻŦ⧇āϛ⧇ āύāĻŋāϤ⧇ āĻĒāĻžāϰāĻŦ⧇, āĻļāĻ°ā§āϤāϟāĻžāϕ⧇ truthy āĻŦāĻž falsy āĻšāĻŋāϏ⧇āĻŦ⧇ āĻĒāĻĄāĻŧ⧇āĨ¤
  • āĻāĻ•āϟāĻž for loop-āĻāϰ āϤāĻŋāύāϟāĻž āĻ…āĻ‚āĻļ⧇āϰ āύāĻžāĻŽ āĻŦāϞāϤ⧇ āĻĒāĻžāϰāĻŦ⧇, āφāϰ āϕ⧋āύāϟāĻž āĻ•āĻ–āύ āϚāϞ⧇ āϏ⧇āϟāĻž āĻŦāϞāϤ⧇ āĻĒāĻžāϰāĻŦ⧇āĨ¤
  • for...of āĻĻāĻŋāϝāĻŧ⧇ āĻāĻ•āϟāĻž list-āĻāϰ āĻĒā§āϰāϤāĻŋāϟāĻž value-āϰ āĻ“āĻĒāϰ āĻĻāĻŋāϝāĻŧ⧇ āϝ⧇āϤ⧇ āĻĒāĻžāϰāĻŦ⧇, āφāϰ loop āϕ⧇āύ āĻĨāĻžāĻŽā§‡ āϏ⧇āϟāĻž āĻŦ⧁āĻāĻŋāϝāĻŧ⧇ āĻŦāϞāϤ⧇ āĻĒāĻžāϰāĻŦ⧇āĨ¤

Zara-āϰ step counter āĻĻāĻŋāύ⧇ āĻāĻ•āϟāĻž āĻ•āϰ⧇ āϏāĻ‚āĻ–ā§āϝāĻž āϰāĻžāϖ⧇, āφāϰ āĻ“āϰ goal āĻšāϞ⧋ 8000 stepāĨ¤ āĻ“ āϏāĻĒā§āϤāĻžāĻšā§‡āϰ āĻĒā§āϰāϤāĻŋāϟāĻž āĻĻāĻŋāύ⧇āϰ āϜāĻ¨ā§āϝ āĻāĻ•āϟāĻž āϞāĻžāχāύ āϚāĻžāϝāĻŧ: goal āĻšāϞ⧋, āύāĻžāĻ•āĻŋ āĻ•āĻŽ āĻĒāĻĄāĻŧāϞāĨ¤ āĻ“āϰ āĻĒā§āϰāĻĨāĻŽ program day 1 check āĻ•āϰ⧇, āϤāĻžāϰāĻĒāϰ āĻ“ check-āϟāĻž copy āĻ•āϰ⧇ day 2-āĻāϰ āϜāĻ¨ā§āϝ, āϤāĻžāϰāĻĒāϰ day 3-āĻāϰ āϜāĻ¨ā§āϝāĨ¤ āϏāĻĒā§āϤāĻžāĻš āĻŽāĻžāύ⧇ āϏāĻžāϤāϟāĻž copy, āĻŽāĻžāϏ āĻŽāĻžāύ⧇ āϤāĻŋāϰāĻŋāĻļāϟāĻž, āφāϰ day 23-āĻāϰ copy-āϤ⧇ āϤāĻ–āύ⧋ āϞ⧇āĻ–āĻž day 22āĨ¤ āĻāχ lesson āĻĒā§āϰāϤāĻŋāϟāĻž copy āϏāϰāĻŋāϝāĻŧ⧇ āĻĻ⧇āϝāĻŧ āĻāĻ•āϟāĻž āϏāĻŋāĻĻā§āϧāĻžāĻ¨ā§āϤ āφāϰ āĻāĻ•āϟāĻž loop āĻĻāĻŋāϝāĻŧ⧇āĨ¤

Zara-āϰ copy āĻ•āϰāĻž check

āĻāϟāĻž Zara-āϰ āĻĒā§āϰāĻĨāĻŽ program, āϤāĻŋāύ āĻĻāĻŋāύ⧇āϰ āϜāĻ¨ā§āϝāĨ¤ āĻĒā§āϰāϤāĻŋāϟāĻž check āĻāĻ•āχ āĻĒāĻžāρāϚāϟāĻž āϞāĻžāχāύ, āĻļ⧁āϧ⧁ āĻĻāĻŋāύāϟāĻž āφāϞāĻžāĻĻāĻžāĨ¤

const day1 = 7500;
const day2 = 8000;
const day3 = 12030;
const goal = 8000;

if (day1 >= goal) {
  console.log("day 1: met");
} else {
  console.log("day 1: short");
}
if (day2 >= goal) {
  console.log("day 2: met");
} else {
  console.log("day 2: short");
}
if (day3 >= goal) {
  console.log("day 3: met");
} else {
  console.log("day 3: short");
}
day 1: short
day 2: met
day 3: met

Program āĻ•āĻžāϜ āĻ•āϰ⧇, āĻ•āĻŋāĻ¨ā§āϤ⧁ āĻĻāĻŋāύ āĻŦāĻžāĻĄāĻŧāϞ⧇ āĻāĻ­āĻžāĻŦ⧇ āφāϰ āϚāϞ⧇ āύāĻžāĨ¤ āĻĻ⧁āĻŸā§‹ āϜāĻŋāύāĻŋāϏ āĻĻāĻŋāϝāĻŧ⧇ āĻāϟāĻž āϏāĻžāϰāĻžāύ⧋ āϝāĻžāϝāĻŧāĨ¤ āĻāĻ•āϟāĻž āϏāĻŋāĻĻā§āϧāĻžāĻ¨ā§āϤ (decision) āĻ•āĻŋāϛ⧁ āϞāĻžāχāύ āϚāĻžāϞāĻžāϝāĻŧ āĻļ⧁āϧ⧁ āϤāĻ–āύ, āϝāĻ–āύ āĻāĻ•āϟāĻž āĻļāĻ°ā§āϤ āĻŽā§‡āϞ⧇: āĻāϟāĻžāχ ifāĨ¤ āĻāĻ•āϟāĻž loop āĻāĻ•āχ āϞāĻžāχāύāϗ⧁āϞ⧋ āĻŦāĻžāϰāĻŦāĻžāϰ āϚāĻžāϞāĻžāϝāĻŧ, āĻĻāĻŋāύ⧇ āĻāĻ•āĻŦāĻžāϰ āĻ•āϰ⧇: āĻāϟāĻžāχ forāĨ¤ āĻĻ⧁āĻŸā§‹ āĻŽāĻŋāϞ⧇ āϝāϤ āĻĻāĻŋāύāχ āĻšā§‹āĻ•, āϏāĻžāĻŽāϞ⧇ āύ⧇āϝāĻŧāĨ¤

const input = require("fs").readFileSync(0, "utf8");
const tokens = input.split(/\s+/).filter(Boolean);
let at = 0;
const next = () => tokens[at++];
const nextInt = () => Number(next());
const out = [];

const GOAL = 8000;
const n = nextInt();
for (let day = 1; day <= n; day++) {
  const steps = nextInt();
  if (steps >= GOAL) {
    out.push("day " + day + ": met");
  } else {
    out.push("day " + day + ": short");
  }
}

console.log(out.join("\n"));
day 1: short
day 2: met
day 3: met
day 4: short
day 5: met
day 6: short
day 7: met

āĻāχ output input 7, āϤāĻžāϰāĻĒāϰ 7500 8000 12030 0 9100 4200 15000-āĻāϰ āϜāĻ¨ā§āϝāĨ¤ Check āϞ⧇āĻ–āĻž āĻšāϝāĻŧ⧇āϛ⧇ āĻāĻ•āĻŦāĻžāϰāχāĨ¤ Loop āĻ“āϟāĻž āϏāĻžāϤāĻŦāĻžāϰ āϚāĻžāϞāĻžāϝāĻŧ, āφāϰ āĻāĻ• āĻŦāĻ›āϰ⧇āϰ āϜāĻ¨ā§āϝ āĻāĻ•āϟāĻž āĻŦāĻžāĻĄāĻŧāϤāĻŋ āϞāĻžāχāύ āĻ›āĻžāĻĄāĻŧāĻžāχ 365 āĻŦāĻžāϰ āϚāĻžāϞāĻžāϤāĨ¤ āĻŽāĻžāύ⧇ loop āϞāĻžāχāύāϗ⧁āϞ⧋ āĻŦāĻžāϰāĻŦāĻžāϰ āϚāĻžāϞāĻžāϝāĻŧ, āφāϰ āϭ⧇āϤāϰ⧇āϰ if āĻ āĻŋāĻ• āĻ•āϰ⧇ āĻĒā§āϰāϤāĻŋāĻŦāĻžāϰ āϕ⧀ āĻšāĻŦ⧇āĨ¤

if: āϝ⧇ āϞāĻžāχāύ āϚāϞ⧇ āĻļ⧁āϧ⧁ āĻļāĻ°ā§āϤ āĻŽāĻŋāϞāϞ⧇

āĻāĻ•āϟāĻž if statement-āĻāϰ āĻĨāĻžāϕ⧇ āĻ—ā§‹āϞ bracket-āĻāϰ āϭ⧇āϤāϰ⧇ āĻāĻ•āϟāĻž āĻļāĻ°ā§āϤ (condition), āφāϰ curly brace-āĻāϰ āϭ⧇āϤāϰ⧇ āĻāĻ•āϟāĻž blockāĨ¤ Block āĻšāϞ⧋ āĻ•āϝāĻŧ⧇āĻ•āϟāĻž āϞāĻžāχāύ, āϝ⧇āϗ⧁āϞ⧋ āĻāĻ•āϏāĻžāĻĨ⧇ āϚāϞ⧇āĨ¤ āĻļāĻ°ā§āϤ āĻŽāĻŋāϞāϞ⧇ block āϚāϞ⧇āĨ¤ āύāĻž āĻŽāĻŋāϞāϞ⧇ program block-āϟāĻž āϟāĻĒāϕ⧇ āϤāĻžāϰ āĻĒāϰ⧇āϰ āϞāĻžāχāύ āĻĨ⧇āϕ⧇ āϚāϞāϤ⧇ āĻĨāĻžāϕ⧇āĨ¤

const steps = 9100;
if (steps >= 8000) {
  console.log("Goal met. Well walked.");
}
console.log("Done for today.");
Goal met. Well walked.
Done for today.

steps-āϕ⧇ 500 āĻ•āϰ⧇ āĻĻāĻžāĻ“, āϤāĻ–āύ āĻļ⧁āϧ⧁ āĻļ⧇āώ āϞāĻžāχāύāϟāĻž print āĻšāĻŦ⧇āĨ¤ if-āĻāϰ āĻĒāϰ⧇ āĻāĻ•āϟāĻž else block āĻĻāĻŋāϞ⧇ āϏ⧇āϟāĻž āϚāϞ⧇ āĻ āĻŋāĻ• āωāĻ˛ā§āĻŸā§‹ āĻ•ā§āώ⧇āĻ¤ā§āϰ⧇, āϤāĻžāχ āĻĻ⧁āĻŸā§‹ block-āĻāϰ āĻāĻ•āϟāĻž āϏāĻŦāϏāĻŽāϝāĻŧ āϚāϞ⧇, āĻĻ⧁āĻŸā§‹ āĻāĻ•āϏāĻžāĻĨ⧇ āĻ•āĻ–āύ⧋ āύāĻžāĨ¤

āĻļāĻ°ā§āϤāϟāĻž āϝ⧇ āϤ⧁āϞāύāĻžāχ āĻšāϤ⧇ āĻšāĻŦ⧇, āĻāĻŽāύ āύāĻžāĨ¤ JavaScript āϝ⧇āϕ⧋āύ⧋ value-āϕ⧇ truthy āĻŦāĻž falsy āĻšāĻŋāϏ⧇āĻŦ⧇ āĻĒāĻĄāĻŧ⧇, Module 2-āĻāϰ āύāĻŋāϝāĻŧāĻŽāĨ¤ Falsy value āĻšāϞ⧋ false, 0 (āϏāĻžāĻĨ⧇ -0 āφāϰ 0n), "", null, undefined āφāϰ NaN, āĻŦāĻžāĻ•āĻŋ āϏāĻŦ truthyāĨ¤

const name = "";
if (name) {
  console.log("Hello, " + name);
} else {
  console.log("Hello, stranger");
}

const unread = 3;
if (unread) {
  console.log(unread + " new messages");
}
Hello, stranger
3 new messages

āĻ–āĻžāϞāĻŋ string falsy, āϤāĻžāχ else block āϚāϞ⧇āϛ⧇āĨ¤ āϏāĻ‚āĻ–ā§āϝāĻž 3 truthy, āϤāĻžāχ āĻ“āϰ block āϚāϞ⧇āϛ⧇āĨ¤ āĻŽāĻžāύ⧇ if (value) āĻāĻ•āϟāĻžāχ āĻĒā§āϰāĻļā§āύ āĻ•āϰ⧇: āĻāχ value āĻ•āĻŋ truthy? steps >= 8000-āĻāϰ āĻŽāϤ⧋ āĻāĻ•āϟāĻž āϤ⧁āϞāύāĻžāĻ“ āφāϏāϞ⧇ āĻāĻ•āϟāĻž value, āϝ⧇āϟāĻž āϏāĻŦāϏāĻŽāϝāĻŧ true āύāϝāĻŧāϤ⧋ falseāĨ¤

āĻāχ track brace āϏāĻŦāϏāĻŽāϝāĻŧ āϞ⧇āϖ⧇, āĻāĻ• āϞāĻžāχāύ⧇āϰ block-āĻāĻ“āĨ¤ Brace āύāĻž āĻĻāĻŋāϞ⧇ āϕ⧀ āĻšāϝāĻŧ, āĻļ⧇āώ⧇āϰ āĻĻāĻŋāϕ⧇ "āϝ⧇ āϭ⧁āϞāϗ⧁āϞ⧋ āϏāĻŦāĻžāχ āĻ•āϰ⧇"-āĻāϰ ⧍ āύāĻŽā§āĻŦāϰ⧇ āĻĻ⧇āĻ–āĻŦ⧇āĨ¤

for: āϤāĻŋāύāϟāĻž āĻ…āĻ‚āĻļ, āφāϰ āϕ⧋āύāϟāĻž āĻ•āĻ–āύ āϚāϞ⧇

āĻāĻ•āϟāĻž for loop-āĻāϰ āĻ—ā§‹āϞ bracket-āĻ āĻĨāĻžāϕ⧇ āϤāĻŋāύāϟāĻž āĻ…āĻ‚āĻļ, semicolon āĻĻāĻŋāϝāĻŧ⧇ āφāϞāĻžāĻĻāĻž āĻ•āϰāĻžāĨ¤

  • āĻļ⧁āϰ⧁ (start), let i = 1, āϚāϞ⧇ āĻāĻ•āĻŦāĻžāϰāχ, āϏāĻŦāĻ•āĻŋāϛ⧁āϰ āφāϗ⧇āĨ¤
  • āĻĒāϰ⧀āĻ•ā§āώāĻž (test), i <= 3, āϚāϞ⧇ āĻĒā§āϰāϤāĻŋāϟāĻž pass-āĻāϰ āφāϗ⧇āĨ¤ Truthy āĻšāϞ⧇ body āϚāϞ⧇āĨ¤ Falsy āĻšāϞ⧇ loop āĻļ⧇āώāĨ¤
  • āϧāĻžāĻĒ (step), i++, āϚāϞ⧇ body-āϰ āĻĒā§āϰāϤāĻŋāϟāĻž pass-āĻāϰ āĻĒāϰ⧇āĨ¤ āĻāϟāĻž i-āϤ⧇ 1 āϝ⧋āĻ— āĻ•āϰ⧇āĨ¤

Brace-āĻāϰ āϭ⧇āϤāϰ⧇āϰ block-āϟāĻž āĻšāϞ⧋ body, āφāϰ body āĻāĻ•āĻŦāĻžāϰ āϚāϞāĻž āĻŽāĻžāύ⧇ āĻāĻ•āϟāĻž passāĨ¤ āĻ•ā§āϰāĻŽāϟāĻž āϖ⧇āϝāĻŧāĻžāϞ āĻ•āϰ⧋āĨ¤ āύāĻŋāĻšā§‡āϰ loop-āϟāĻž āĻāĻ• āϧāĻžāĻĒ āĻāĻ• āϧāĻžāĻĒ āĻ•āϰ⧇ āϚāĻžāϞāĻžāĻ“, āφāϰ test-āĻāϰ column-āĻ āĻšā§‹āĻ– āϰāĻžāĻ–ā§‹: āĻĒā§āϰāϤāĻŋāϟāĻž pass-āĻāϰ āφāϗ⧇ āĻ“āϟāĻž check āĻšāϝāĻŧāĨ¤

āĻļ⧁āϰ⧁āϤ⧇ i āĻšāϝāĻŧ 1āĨ¤ Test āϚāϞ⧇ āĻĒā§āϰāϤāĻŋāϟāĻž pass-āĻāϰ āφāϗ⧇, āφāϰ step i++ āϚāϞ⧇ āĻĒāϰ⧇āĨ¤ āϤāĻŋāύāϟāĻž pass total-āĻ āϝ⧋āĻ— āĻ•āϰ⧇ 1, 2 āφāϰ 3āĨ¤ āϤāĻžāϰāĻĒāϰ i āĻšāϝāĻŧ 4, test 4 <= 3 false, āφāϰ loop āĻļ⧇āώ: āϤāĻŋāύāϟāĻž pass-āĻāϰ āϜāĻ¨ā§āϝ test āϚāϞāϞ āϚāĻžāϰāĻŦāĻžāϰāĨ¤

Passitest i <= 3body-āϰ āĻĒāϰ⧇ total
11true, āϤāĻžāχ body āϚāϞ⧇1
22true, āϤāĻžāχ body āϚāϞ⧇3
33true, āϤāĻžāχ body āϚāϞ⧇6
āύ⧇āχ4false, āϤāĻžāχ loop āĻļ⧇āώ6

āĻāĻŦāĻžāϰ āĻāĻ•āχ loop, āĻĒ⧁āϰ⧋ program āĻšāĻŋāϏ⧇āĻŦ⧇āĨ¤ āĻĒā§āϰāϤāĻŋāϟāĻž pass āϝ⧇ i āĻĻ⧇āϖ⧇āϛ⧇, āϏ⧇āϟāĻž print āĻ•āϰ⧇āĨ¤

let total = 0;
for (let i = 1; i <= 3; i++) {
  console.log("pass with i = " + i);
  total += i;
}
console.log("total " + total);
pass with i = 1
pass with i = 2
pass with i = 3
total 6

Test āϚāϞ⧇āϛ⧇ āϚāĻžāϰāĻŦāĻžāϰ: āϤāĻŋāύāĻŦāĻžāϰ āĻŦāϞ⧇āϛ⧇ āĻšā§āϝāĻžāρ, āφāϰ āϚāϤ⧁āĻ°ā§āĻĨāĻŦāĻžāϰ, i āϝāĻ–āύ 4, āĻŦāϞ⧇āϛ⧇ āύāĻžāĨ¤ āύāĻŋāĻšā§‡āϰ āĻĻ⧁āĻŸā§‹ āĻ›āĻŦāĻŋāϤ⧇ if āφāϰ for āĻĒāĻžāĻļāĻžāĻĒāĻžāĻļāĻŋ āφāϛ⧇āĨ¤ for āφāϏāϞ⧇ āĻāĻ•āϟāĻž if, āϝāĻžāϰ āĻĨ⧇āϕ⧇ āĻāĻ•āϟāĻž āϤ⧀āϰ āφāĻŦāĻžāϰ āĻ“āĻĒāϰ⧇ āĻĢāĻŋāϰ⧇ āϝāĻžāϝāĻŧāĨ¤

if-āĻāϰ flowchart āφāϰ for loop-āĻāϰ flowchart āϏāĻŋāĻĻā§āϧāĻžāĻ¨ā§āϤ āĻāĻ•āϟāĻž āĻļāĻžāĻ–āĻž āĻāĻ•āĻŦāĻžāϰ āϚāĻžāϞāĻžāϝāĻŧ; loop body āϚāĻžāϞāĻžāϝāĻŧ āϝāϤāĻ•ā§āώāĻŖ āύāĻž test āύāĻž āĻŦāϞ⧇ if and else āφāϗ⧇āϰ āϞāĻžāχāύ āĻļāĻ°ā§āϤ āĻ•āĻŋ truthy? āĻšā§āϝāĻžāρ āύāĻž if block else block āĻĒāϰ⧇āϰ āϞāĻžāχāύ for (start; test; step) start: let i = 1 test: i <= 3 ? true body: total += i step: i++ āφāĻŦāĻžāϰ false loop-āĻāϰ āĻĒāϰ⧇ āĻļ⧁āϰ⧁ āϚāϞ⧇ āĻāĻ•āĻŦāĻžāϰāĨ¤ Test āϚāϞ⧇ āĻĒā§āϰāϤāĻŋāϟāĻž pass-āĻāϰ āφāϗ⧇, āφāϰ step āĻĒā§āϰāϤāĻŋāϟāĻž body-āϰ āĻĒāϰ⧇āĨ¤

āĻŽāĻžāύ⧇ for loop-āĻ āĻļ⧁āϰ⧁ āϚāϞ⧇ āĻāĻ•āĻŦāĻžāϰ, test āϚāϞ⧇ āĻĒā§āϰāϤāĻŋāϟāĻž pass-āĻāϰ āφāϗ⧇, āφāϰ step āϚāϞ⧇ āĻĒā§āϰāϤāĻŋāϟāĻž pass-āĻāϰ āĻĒāϰ⧇āĨ¤ Test āĻĒā§āϰāĻĨāĻŽ āϝ⧇āĻŦāĻžāϰ falsy āĻšāϝāĻŧ, loop āϏ⧇āĻ–āĻžāύ⧇āχ āĻļ⧇āώāĨ¤

Loop-āĻāϰ i āϕ⧋āĻĨāĻžāϝāĻŧ āĻĨāĻžāϕ⧇

for-āĻāϰ āĻļ⧁āϰ⧁āϤ⧇ let āĻĻāĻŋāϝāĻŧ⧇ declare āĻ•āϰāĻž āύāĻžāĻŽāϟāĻž loop-āĻāϰ āύāĻŋāĻœā§‡āϰāĨ¤ āĻ“āϟāĻž āĻĨāĻžāϕ⧇ āĻ—ā§‹āϞ bracket āφāϰ body-āϰ āϭ⧇āϤāϰ⧇, āφāϰ āϕ⧋āĻĨāĻžāĻ“ āύāĻžāĨ¤ āϤāĻžāχ āĻĻ⧁āĻŸā§‹ loop-āĻāϰ āĻĻ⧁āϜāύ⧇āϰāχ āύāĻŋāĻœā§‡āϰ āύāĻŋāĻœā§‡āϰ i āĻĨāĻžāĻ•āϤ⧇ āĻĒāĻžāϰ⧇, āϕ⧇āω āĻ•āĻžāϰ⧋āϟāĻž āĻĻ⧇āϖ⧇ āύāĻžāĨ¤

for (let i = 0; i < 2; i++) {
  console.log("first loop", i);
}
for (let i = 5; i < 7; i++) {
  console.log("second loop", i);
}
first loop 0
first loop 1
second loop 5
second loop 6

Loop āĻļ⧇āώ āĻšāϞ⧇ i-āĻ“ āĻļ⧇āώ, āϤāĻ–āύ āĻ“āϟāĻž āĻĒāĻĄāĻŧāϤ⧇ āϗ⧇āϞ⧇ error ("āϝ⧇ āϭ⧁āϞāϗ⧁āϞ⧋ āϏāĻŦāĻžāχ āĻ•āϰ⧇"-āĻāϰ ā§Ē)āĨ¤ āĻĒāϰ⧇ āϝ⧇ value āϞāĻžāĻ—āĻŦ⧇, āϏ⧇āϟāĻž āϰāĻžāĻ–ā§‹ loop-āĻāϰ āφāϗ⧇ declare āĻ•āϰāĻž āĻāĻ•āϟāĻž variable-āĻ, āϝ⧇āĻŽāύ āϰāĻžāĻ–āĻž āĻšāϝāĻŧ⧇āĻ›āĻŋāϞ totalāĨ¤ āĻŽāĻžāύ⧇ counter declare āĻ•āϰ⧋ loop-āĻāϰ āĻļ⧁āϰ⧁āϤ⧇, āφāϰ āĻĢāϞāĻžāĻĢāϞ loop-āĻāϰ āφāϗ⧇āĨ¤

for...of: āĻĒā§āϰāϤāĻŋāϟāĻž value-āϰ āϜāĻ¨ā§āϝ āĻāĻ•āϟāĻž pass

āĻ…āύ⧇āĻ• āϏāĻŽāϝāĻŧ āĻ•āĻžāϜāϟāĻž "n āĻĒāĻ°ā§āϝāĻ¨ā§āϤ āĻ—ā§‹āύ⧋" āύāĻž, āĻ•āĻžāϜāϟāĻž āĻšāϞ⧋ "āĻāχ list-āĻāϰ āĻĒā§āϰāϤāĻŋāϟāĻž value āĻĻ⧇āĻ–ā§‹"āĨ¤ JavaScript value-āĻāϰ list āϰāĻžāϖ⧇ āĻāĻ•āϟāĻž array-āϤ⧇, square bracket-āĻ āϞāĻŋāϖ⧇: [4200, 9900, 8000]āĨ¤ Array āĻ āĻŋāĻ•āĻŽāϤ⧋ āĻļ⧇āĻ–āĻžāĻŦ⧇ Module 7āĨ¤ āĻāĻ–āĻžāύ⧇ āĻļ⧁āϧ⧁ āĻĻ⧁āĻŸā§‹ āĻ•āĻĨāĻž āϜāĻžāύāϞ⧇āχ āϚāϞāĻŦ⧇: array value-āϗ⧁āϞ⧋ āĻ•ā§āϰāĻŽ āϧāϰ⧇ āϰāĻžāϖ⧇, āφāϰ week.length āĻŦāϞ⧇ āĻ“āϤ⧇ āĻ•āϝāĻŧāϟāĻž āφāϛ⧇āĨ¤

āĻāĻ•āϟāĻž for...of loop value-āϗ⧁āϞ⧋ āϤ⧋āĻŽāĻžāϰ āĻšāĻžāϤ⧇ āĻĻ⧇āϝāĻŧ āĻāĻ•āϟāĻž āĻāĻ•āϟāĻž āĻ•āϰ⧇āĨ¤ āĻāĻ–āĻžāύ⧇ āĻļ⧁āϰ⧁ āĻ•āϰāĻž, test āĻ•āϰāĻž āĻŦāĻž step āĻĻ⧇āĻ“āϝāĻŧāĻžāϰ āĻŽāϤ⧋ āϕ⧋āύ⧋ counter āύ⧇āχ: āĻĒā§āϰāϤāĻŋāϟāĻž pass-āĻ loop āĻĒāϰ⧇āϰ value-āϟāĻž āύ⧇āϝāĻŧ, āφāϰ āĻļ⧇āώāϟāĻžāϰ āĻĒāϰ⧇ āĻĨ⧇āĻŽā§‡ āϝāĻžāϝāĻŧāĨ¤

Loop week-āĻāϰ āĻĒā§āϰāϤāĻŋāϟāĻž value āĻ•ā§āϰāĻŽ āϧāϰ⧇ āύ⧇āϝāĻŧ: 4200, 9900, 8000, 7999 āφāϰ 15000āĨ¤ āϝ⧇ āϤāĻŋāύāϟāĻž value āĻ•āĻŽāĻĒāĻ•ā§āώ⧇ 8000, āϏ⧇āϗ⧁āϞ⧋āϰ āϜāĻ¨ā§āϝ if count-āĻ 1 āϝ⧋āĻ— āĻ•āϰ⧇, āϤāĻžāχ āĻļ⧇āώ⧇ count āĻšāϝāĻŧ 3āĨ¤

Passstepssteps >= 8000pass-āĻāϰ āĻĒāϰ⧇ count
14200false0
29900true1
38000true2
47999false2
515000true3
const week = [4200, 9900, 8000, 7999, 15000];
let count = 0;
for (const steps of week) {
  if (steps >= 8000) {
    count++;
  }
}
console.log(count + " of " + week.length + " days met the goal");
3 of 5 days met the goal

steps āĻāĻ•āϟāĻž const, āφāϰ āϏ⧇āϟāĻž āϚāϞ⧇: āĻĒā§āϰāϤāĻŋāϟāĻž pass āĻĒāϰ⧇āϰ value āύāĻŋāϝāĻŧ⧇ āĻāĻ•āϟāĻž āύāϤ⧁āύ steps āĻĒāĻžāϝāĻŧ, āϤāĻžāχ āĻ•āĻŋāϛ⧁āχ āφāĻŦāĻžāϰ assign āĻšāϝāĻŧ āύāĻžāĨ¤ String-āĻ“ āĻāĻ•āχāĻ­āĻžāĻŦ⧇ āϚāϞ⧇, āĻĒā§āϰāϤāĻŋ pass-āĻ āĻāĻ•āϟāĻž characterāĨ¤ "āĻāĻ•āϟāĻž character" āϕ⧋āĻĨāĻžāϝāĻŧ āĻ—āĻŋāϝāĻŧ⧇ āϜāϟāĻŋāϞ āĻšāϝāĻŧ, Module 3 āĻĻ⧇āĻ–āĻžāĻŦ⧇āĨ¤

for (const letter of "Zara") {
  console.log(letter);
}
Z
a
r
a

āĻŽāĻžāύ⧇ "āĻāχ list-āĻāϰ āĻĒā§āϰāϤāĻŋāϟāĻž value"-āϰ āϜāĻ¨ā§āϝ for...of, āφāϰ "āĻāĻ–āĻžāύ āĻĨ⧇āϕ⧇ āĻ“āĻ–āĻžāύ āĻĒāĻ°ā§āϝāĻ¨ā§āϤ āĻ—ā§‹āύ⧋"-āϰ āϜāĻ¨ā§āϝ counter-āĻ“āϝāĻŧāĻžāϞāĻž forāĨ¤ Lesson 04 āĻāϟāĻžāϕ⧇ āĻāĻ•āϟāĻž flowchart āĻŦāĻžāύāĻžāĻŦ⧇āĨ¤

Loop āϕ⧇āύ āĻĨāĻžāĻŽā§‡, āφāϰ āĻ•āĻ–āύ āĻ•āĻ–āύ⧋āχ āĻĨāĻžāĻŽā§‡ āύāĻž

Loop āĻĨāĻžāĻŽā§‡, āĻ•āĻžāϰāĻŖ āĻļ⧇āώāĻŽā§‡āĻļ āĻ“āϰ test-āĻāϰ āωāĻ¤ā§āϤāϰ falsy āĻšāϝāĻŧāĨ¤ for loop-āĻ āĻĒā§āϰāϤāĻŋāϟāĻž pass-āĻ step i-āϕ⧇ āĻ“āχ āωāĻ¤ā§āϤāϰ⧇āϰ āĻĻāĻŋāϕ⧇ āĻāĻ—āĻŋāϝāĻŧ⧇ āύ⧇āϝāĻŧāĨ¤ āĻĒā§āϰāĻĨāĻŽ check-āĻāχ test falsy āĻšāϞ⧇ body āĻāĻ•āĻŦāĻžāϰāĻ“ āϚāϞ⧇ āύāĻž, āφāϰ āϏ⧇āϟāĻž āϕ⧋āύ⧋ error āύāĻžāĨ¤

const n = 0;
for (let i = 1; i <= n; i++) {
  console.log("never printed");
}
console.log("the loop ran 0 times");
the loop ran 0 times

Test-āϕ⧇ false-āĻāϰ āĻĻāĻŋāϕ⧇ āϕ⧇āω āύāĻž āĻāĻ—ā§‹āϞ⧇ loop āĻ•āĻ–āύ⧋ āĻĨāĻžāĻŽā§‡ āύāĻžāĨ¤ āĻāϟāĻžāϕ⧇āχ āĻŦāϞ⧇ infinite loopāĨ¤ āύāĻŋāĻšā§‡āϰ while loop-āϟāĻž (lesson 02-āĻ āĻļāĻŋāĻ–āĻŦ⧇) i-āϤ⧇ 1 āϝ⧋āĻ— āĻ•āϰāϤ⧇ āϭ⧁āϞ⧇ āϗ⧇āϛ⧇, āϤāĻžāχ i < 5 āϚāĻŋāϰāĻ•āĻžāϞ true āĻĨāĻžāϕ⧇āĨ¤

let i = 0;
let total = 0;
while (i < 5) {
  total += i;
}
console.log(total);

āĻ•āĻŋāϛ⧁āχ print āĻšāϝāĻŧ āύāĻžāĨ¤ Sign in āύāĻž āĻ•āϰ⧇ Playground-āĻ āĻāχ program āĻĒā§āϰāĻžāϝāĻŧ 10 āϏ⧇āϕ⧇āĻ¨ā§āĻĄ āϚāϞāϞ, āϤāĻžāϰāĻĒāϰ āĻĨāĻžāĻŽāϞ Time Limit Exceeded verdict āĻĻāĻŋāϝāĻŧ⧇ (2026-10-07-āĻāϰ āĻāĻ•āϟāĻž run)āĨ¤ Submit āĻ•āϰāĻž program-āĻāϰ āϏāĻžāĻĨ⧇ judge-āĻ“ āĻāĻ•āχ āĻ•āĻžāϜ āĻ•āϰ⧇āĨ¤ āϤāĻžāχ āĻĒā§āϰāϤāĻŋāϟāĻž loop-āĻāϰ āϭ⧇āϤāϰ⧇ āĻāĻŽāύ āĻ•āĻŋāϛ⧁ āĻĨāĻžāĻ•āĻž āϚāĻžāχ, āϝ⧇āϟāĻž āĻ“āϰ test-āϕ⧇ false-āĻāϰ āĻĻāĻŋāϕ⧇ āĻāĻ—āĻŋāϝāĻŧ⧇ āύ⧇āϝāĻŧāĨ¤

if, else āφāϰ āĻĻ⧁āχ āϰāĻ•āĻŽ for loop

if (condition) {
  // runs when condition is truthy
} else {
  // runs when condition is falsy (the else part is optional)
}

for (start; test; step) {
  // the body: runs while test is truthy
}

for (const value of list) {
  // one pass per value of the list, in order
}
  • condition āφāϰ test āϝ⧇āϕ⧋āύ⧋ expression āĻšāϤ⧇ āĻĒāĻžāϰ⧇, truthy āĻŦāĻž falsy āĻšāĻŋāϏ⧇āĻŦ⧇ āĻĒāĻĄāĻŧāĻž āĻšāϝāĻŧāĨ¤
  • start āϚāϞ⧇ āĻāĻ•āĻŦāĻžāϰ; test āϚāϞ⧇ āĻĒā§āϰāϤāĻŋāϟāĻž pass-āĻāϰ āφāϗ⧇; step āϚāϞ⧇ āĻĒā§āϰāϤāĻŋāϟāĻž pass-āĻāϰ āĻĒāϰ⧇āĨ¤
  • list āĻšāϞ⧋ āĻāĻ•āϟāĻž array āĻŦāĻž āĻāĻ•āϟāĻž string; āĻĒā§āϰāϤāĻŋāϟāĻž pass-āĻ value āĻĒāϰ⧇āϰ item-āϟāĻž āύ⧇āϝāĻŧāĨ¤
  • Brace āĻĻāĻŋāϝāĻŧ⧇ block āĻšā§‡āύāĻž āϝāĻžāϝāĻŧāĨ¤ āĻāχ track āĻ“āϗ⧁āϞ⧋ āϏāĻŦāϏāĻŽāϝāĻŧ āϞ⧇āϖ⧇āĨ¤
Example 1: āĻ—āϰāĻŽ, āύāĻžāĻ•āĻŋ āύāĻž

āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āϛ⧋āϟ āϏāĻŋāĻĻā§āϧāĻžāĻ¨ā§āϤ: āĻāĻ•āϟāĻž āϏāĻ‚āĻ–ā§āϝāĻž, āĻāĻ•āϟāĻž āĻļāĻ°ā§āϤ, āĻĻ⧁āĻŸā§‹ āϏāĻŽā§āĻ­āĻžāĻŦā§āϝ āϞāĻžāχāύāĨ¤

const celsius = 31;
if (celsius >= 30) {
  console.log("hot: carry water");
} else {
  console.log("not hot");
}
hot: carry water

31 āĻ•āĻŽāĻĒāĻ•ā§āώ⧇ 30, āϤāĻžāχ if block āϚāϞ⧇ āφāϰ else block āĻŦāĻžāĻĻ āϝāĻžāϝāĻŧāĨ¤ celsius-āϕ⧇ 30 āĻ•āϰ⧋, āĻāĻ•āχ āϞāĻžāχāύ print āĻšāĻŦ⧇, āĻ•āĻžāϰāĻŖ >= āĻ•āĻŋāύāĻžāϰāĻžāϰ āϏāĻ‚āĻ–ā§āϝāĻžāϟāĻžāĻ“ āϧāϰ⧇āĨ¤

Run in Compiler
Example 2: Bob-āĻāϰ āϟāĻžāĻ•āĻž āϜāĻŽāĻžāύ⧋āϰ āĻŦāϝāĻŧāĻžāĻŽ

Bob āĻŦāϝāĻŧāĻžāĻŽā§‡ day 1-āĻ āϰāĻžāϖ⧇ 10 āϟāĻžāĻ•āĻž, day 2-āĻ 20, day 3-āĻ 30, āĻāĻ­āĻžāĻŦ⧇ āĻāĻ• āϏāĻĒā§āϤāĻžāĻšāĨ¤ āĻāĻ•āϟāĻž for loop āĻĻāĻŋāύ āĻ—ā§‹āύ⧇ āφāϰ āϚāϞāϤāĻŋ āĻŽā§‹āϟāϟāĻž āϰāĻžāϖ⧇āĨ¤

let saved = 0;
for (let day = 1; day <= 7; day++) {
  saved += day * 10;
  console.log("day " + day + ": " + saved);
}
day 1: 10
day 2: 30
day 3: 60
day 4: 100
day 5: 150
day 6: 210
day 7: 280

saved declare āĻ•āϰāĻž āĻšāϝāĻŧ⧇āϛ⧇ loop-āĻāϰ āφāϗ⧇, āϤāĻžāχ pass-āĻāϰ āĻĒāϰ pass āĻ“āϟāĻž āĻŦāĻžāĻĄāĻŧāϤ⧇āχ āĻĨāĻžāϕ⧇āĨ¤ Body-āϰ āϭ⧇āϤāϰ⧇ declare āĻ•āϰāϞ⧇ āĻĒā§āϰāϤāĻŋāϟāĻž pass-āĻ āĻ“āϟāĻž āφāĻŦāĻžāϰ 0 āĻĨ⧇āϕ⧇ āĻļ⧁āϰ⧁ āĻšāϤ⧋āĨ¤

Run in Compiler
Example 3: Zara-āϰ āϏāĻžāĻĒā§āϤāĻžāĻšāĻŋāĻ• report

āĻāχ program-āϟāĻžāχ Zara āφāϏāϞ⧇ āϰ⧇āϖ⧇ āĻĻ⧇āϝāĻŧāĨ¤ āĻāϟāĻž āĻĒāĻĄāĻŧ⧇ n, āϤāĻžāϰāĻĒāϰ n āĻĻāĻŋāύ⧇āϰ stepāĨ¤ āϤāĻžāϰāĻĒāϰ āĻŦāϞ⧇ āϏāĻĒā§āϤāĻžāĻšā§‡āϰ āĻŽā§‹āϟ step, āφāϰ āĻ•āϝāĻŧāĻĻāĻŋāύ āĻ“ āĻŦāĻŋāĻļā§āϰāĻžāĻŽ āύāĻŋāϝāĻŧ⧇āϛ⧇, āĻŽāĻžāύ⧇ 1000-āĻāϰ āĻ•āĻŽ stepāĨ¤

const input = require("fs").readFileSync(0, "utf8");
const tokens = input.split(/\s+/).filter(Boolean);
let at = 0;
const next = () => tokens[at++];
const nextInt = () => Number(next());
const out = [];

const n = nextInt();
let total = 0;
let restDays = 0;
for (let day = 1; day <= n; day++) {
  const steps = nextInt();
  total += steps;
  if (steps < 1000) {
    restDays++;
  }
}
out.push("total " + total);
out.push("rest days " + restDays);

console.log(out.join("\n"));
total 52230
rest days 2

āĻāχ output input 7, āϤāĻžāϰāĻĒāϰ 7500 8000 12030 0 9100 600 15000-āĻāϰ āϜāĻ¨ā§āϝāĨ¤ Loop āĻĒā§āϰāϤāĻŋāϟāĻž pass-āĻ nextInt() āĻĻāĻŋāϝāĻŧ⧇ āĻāĻ•āϟāĻž āĻ•āϰ⧇ āϏāĻ‚āĻ–ā§āϝāĻž āĻĒāĻĄāĻŧ⧇, āϤāĻžāχ āĻ āĻŋāĻ• n-āϟāĻžāχ āĻĒāĻĄāĻŧ⧇āĨ¤ āϕ⧋āύ pass restDays-āĻ āϝ⧋āĻ— āĻ•āϰāĻŦ⧇, āϏ⧇āϟāĻž āĻ āĻŋāĻ• āĻ•āϰ⧇ ifāĨ¤

Run in Compiler

āĻāϟāĻž āϕ⧋āĻĨāĻžāϝāĻŧ āĻ•āĻžāĻœā§‡ āϞāĻžāϗ⧇

  • āĻ­āĻžāώāĻžāϰ standard āύāĻŋāĻœā§‡āχāĨ¤ Array.prototype.includes āϜāĻŋāĻœā§āĻžā§‡āϏ āĻ•āϰ⧇ āĻāĻ•āϟāĻž array-āϤ⧇ āϕ⧋āύ⧋ value āφāϛ⧇ āĻ•āĻŋ āύāĻžāĨ¤ ECMA-262 āĻāϟāĻžāϕ⧇ āϞāĻŋāϖ⧇āϛ⧇ āĻāĻ•āϟāĻž loop āĻšāĻŋāϏ⧇āĻŦ⧇, "Repeat, while k < len", āφāϰ āϭ⧇āϤāϰ⧇ āĻāĻ•āϟāĻž if, āĻŽāĻŋāϞ āĻĒ⧇āϞ⧇āχ true āĻĢ⧇āϰāϤ āĻĻ⧇āϝāĻŧāĨ¤
  • Express, Node-āĻāϰ web frameworkāĨ¤ Express 4-āĻāϰ router āĻāĻ•āϟāĻž app-āĻāϰ middleware āϰāĻžāϖ⧇ āĻāĻ•āϟāĻž list-āĻāĨ¤ āĻāĻ•āϟāĻž while loop āĻĻāĻŋāϝāĻŧ⧇ list-āϟāĻž āϧāϰ⧇ āĻāĻ—ā§‹āϝāĻŧ, āφāϰ āĻĒā§āϰāϤāĻŋāϟāĻž layer āϚāĻžāϞāĻžāύ⧋āϰ āφāϗ⧇ request-āĻāϰ path-āĻāϰ āϏāĻžāĻĨ⧇ āĻŽāĻŋāϞāĻŋāϝāĻŧ⧇ āĻĻ⧇āϖ⧇āĨ¤
  • Node-āĻāϰ event loopāĨ¤ Node-āĻāϰ āύāĻŋāĻšā§‡āϰ C library libuv āĻāϟāĻž āϚāĻžāϞāĻžāϝāĻŧ āĻ“āϰ uv_run function-āĻāϰ āĻāĻ•āϟāĻž while loop āĻšāĻŋāϏ⧇āĻŦ⧇āĨ¤ āĻĒā§āϰāϤāĻŋāϟāĻž āϘ⧁āϰ⧇ āĻāĻ• āĻĻāĻĢāĻž event āϏāĻžāĻŽāϞāĻžāϝāĻŧ, āϝāϤāĻ•ā§āώāĻŖ āύāĻž āĻ…āĻĒ⧇āĻ•ā§āώāĻž āĻ•āϰāĻžāϰ āĻŽāϤ⧋ āĻ•āĻŋāϛ⧁ āĻŦāĻžāĻ•āĻŋ āĻĨāĻžāϕ⧇ (Module 12)āĨ¤
  • Browser-āĻāϰ gameāĨ¤ āĻāĻ•āϟāĻž game āĻāĻ•āϟāĻž frame āφāρāϕ⧇, āϤāĻžāϰāĻĒāϰ requestAnimationFrame-āϕ⧇ āĻŦāϞ⧇ āĻĒāϰ⧇āϰ āĻŦāĻžāϰ screen refresh-āĻāϰ āφāϗ⧇ āφāĻŦāĻžāϰ call āĻ•āϰāϤ⧇, āϏāĻžāϧāĻžāϰāĻŖāϤ āϏ⧇āϕ⧇āĻ¨ā§āĻĄā§‡ 60 āĻŦāĻžāϰ⧇āϰ āĻŽāϤ⧋āĨ¤ āĻĒā§āϰāϤāĻŋāϟāĻž frame āĻāĻ•āϟāĻž loop-āĻāϰ āĻāĻ•āϟāĻž pass, āφāϰ player āϝ⧇ key āĻšā§‡āĻĒ⧇ āφāϛ⧇ āϤāĻžāϰ āĻĒā§āϰāϤāĻŋāϟāĻžāϰ āϜāĻ¨ā§āϝ āĻāĻ•āϟāĻž if (Module 14)āĨ¤

āϝ⧇ āϭ⧁āϞāϗ⧁āϞ⧋ āϏāĻŦāĻžāχ āĻ•āϰ⧇

ā§§. āĻļāĻ°ā§āϤ⧇āϰ āĻĒāϰ⧇ semicolonāĨ¤

const steps = 500;
if (steps >= 8000); {
  console.log("Goal met");
}
Goal met

āϕ⧋āύ⧋ error āύ⧇āχ, āωāĻ¤ā§āϤāϰāϟāĻž āϭ⧁āϞ: 500 step-āĻ āύāĻžāĻ•āĻŋ goal āĻšāϝāĻŧ⧇ āϗ⧇āϛ⧇āĨ¤ Semicolon if-āϟāĻžāϕ⧇ āĻāĻ•āϟāĻž āĻ–āĻžāϞāĻŋ statement āĻĻāĻŋāϝāĻŧ⧇ āĻļ⧇āώ āĻ•āϰ⧇ āĻĻ⧇āϝāĻŧ, āφāϰ āϤāĻžāϰ āĻĒāϰ⧇āϰ brace-āϗ⧁āϞ⧋ āφāϞāĻžāĻĻāĻž āĻāĻ•āϟāĻž block, āϝ⧇āϟāĻž āϏāĻŦāϏāĻŽāϝāĻŧ āϚāϞ⧇āĨ¤ Semicolon-āϟāĻž āĻŽā§āϛ⧇ āĻĻāĻžāĻ“āĨ¤ āϤ⧁āĻŽāĻŋ āĻāϟāĻž āϞāĻŋāĻ–āĻŦ⧇, āĻ•āĻžāϰāĻŖ āĻĒā§āϰāĻžāϝāĻŧ āĻŦāĻžāĻ•āĻŋ āϏāĻŦ āϞāĻžāχāύ semicolon āĻĻāĻŋāϝāĻŧ⧇āχ āĻļ⧇āώ āĻšāϝāĻŧāĨ¤

⧍. Brace āĻ›āĻžāĻĄāĻŧāĻž āĻāĻ•āϟāĻž if-āĻāϰ āύāĻŋāĻšā§‡ āĻĻ⧁āĻŸā§‹ āϞāĻžāχāύāĨ¤

const steps = 500;
if (steps >= 8000)
  console.log("Goal met");
  console.log("Badge unlocked");
Badge unlocked

Brace āύāĻž āĻĨāĻžāĻ•āϞ⧇ if-āĻāϰ āĻ­āĻžāϗ⧇ āĻĒāĻĄāĻŧ⧇ āĻļ⧁āϧ⧁ āĻ āĻŋāĻ• āĻĒāϰ⧇āϰ āĻāĻ•āϟāĻž statementāĨ¤ Indentation āĻĻ⧇āϖ⧇ āĻŽāύ⧇ āĻšāϝāĻŧ badge-āĻāϰ āϞāĻžāχāύāϟāĻžāĻ“ if-āĻāϰ, āĻ•āĻŋāĻ¨ā§āϤ⧁ JavaScript indentation āĻĒāĻžāĻ¤ā§āϤāĻžāχ āĻĻ⧇āϝāĻŧ āύāĻžāĨ¤ āĻĒā§āϰāϤāĻŋāĻŦāĻžāϰ brace āϞ⧇āĻ–ā§‹āĨ¤ āϤ⧁āĻŽāĻŋ āĻŦāĻžāĻĻ āĻĻ⧇āĻŦ⧇, āĻ•āĻžāϰāĻŖ āĻĒā§āϰāĻĨāĻŽ version-āĻ āϞāĻžāχāύ āĻ›āĻŋāϞ āĻāĻ•āϟāĻžāχ, āĻĻā§āĻŦāĻŋāϤ⧀āϝāĻŧ āϞāĻžāχāύāϟāĻž āφāϏ⧇ āĻāĻ• āϏāĻĒā§āϤāĻžāĻš āĻĒāϰ⧇āĨ¤

ā§Š. for loop-āĻāϰ counter āĻšāĻŋāϏ⧇āĻŦ⧇ constāĨ¤

for (const i = 0; i < 3; i++) {
  console.log(i);
}
0
TypeError: Assignment to constant variable.

āĻĒā§āϰāĻĨāĻŽ pass āϚāϞ⧇, āϤāĻžāϰāĻĒāϰ step i++ āĻāĻ•āϟāĻž constant āĻŦāĻĻāϞāĻžāϤ⧇ āϝāĻžāϝāĻŧ, āφāϰ Node 22 program āĻĨāĻžāĻŽāĻŋāϝāĻŧ⧇ āĻĻ⧇āϝāĻŧāĨ¤ Counter āĻŦāĻĻāϞāĻžāϝāĻŧ, āϤāĻžāχ āĻ“āϟāĻž letāĨ¤ āϤ⧁āĻŽāĻŋ const āϞāĻŋāĻ–āĻŦ⧇, āĻ•āĻžāϰāĻŖ for...of āĻ“āϟāĻž āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧇, āφāϰ āϏ⧇āĻ–āĻžāύ⧇ āĻĒā§āϰāϤāĻŋāϟāĻž pass āĻĒ⧁āϰ⧋āύ⧋āϟāĻž āύāĻž āĻŦāĻĻāϞ⧇ āύāϤ⧁āύ āĻāĻ•āϟāĻž āύāĻžāĻŽ āĻĒāĻžāϝāĻŧāĨ¤

ā§Ē. Loop āĻļ⧇āώ āĻšāĻ“āϝāĻŧāĻžāϰ āĻĒāϰ⧇ counter āĻĒāĻĄāĻŧāĻžāĨ¤

for (let i = 0; i < 3; i++) {
  console.log(i);
}
console.log("finished at " + i);
0
1
2
ReferenceError: i is not defined

Loop-āĻāϰ i loop-āĻāϰ āϏāĻžāĻĨ⧇āχ āĻļ⧇āώ āĻšāϝāĻŧ⧇ āϗ⧇āϛ⧇āĨ¤ āĻĒāϰ⧇ āϕ⧋āύ⧋ value āϞāĻžāĻ—āϞ⧇ loop-āĻāϰ āφāϗ⧇ āĻāĻ•āϟāĻž variable declare āĻ•āϰ⧋, āφāϰ āϭ⧇āϤāϰ⧇ āϏ⧇āϟāĻžāϝāĻŧ value āϰāĻžāĻ–ā§‹āĨ¤ āϤ⧁āĻŽāĻŋ āĻāϟāĻž āĻ•āϰāϤ⧇ āϝāĻžāĻŦ⧇, āĻ•āĻžāϰāĻŖ āĻŽāύ⧇ āĻšāϝāĻŧ i-āĻāϰ āĻļ⧇āώ value-āϟāĻž āϤ⧋ āϕ⧋āĻĨāĻžāĻ“ āĻĒāĻĄāĻŧ⧇ āĻĨāĻžāĻ•āĻžāϰ āĻ•āĻĨāĻžāĨ¤

āĻŽāĻžāĻĨāĻž āĻ–āĻžāϟāĻžāĻ“

Bob āĻŦāϞ⧇ āĻāχ loop āϤāĻŋāύāĻŦāĻžāϰ āϚāϞāĻŦ⧇, āĻ•āĻžāϰāĻŖ 10-āϕ⧇ 3 āĻĻāĻŋāϝāĻŧ⧇ āĻ­āĻžāĻ— āĻ•āϰāϞ⧇ āĻŽā§‹āϟāĻžāĻŽā§āϟāĻŋ 3āĨ¤

for (let i = 10; i > 0; i -= 3) {
  console.log(i);
}

āĻ•āϝāĻŧāϟāĻž āϞāĻžāχāύ print āĻšāĻŦ⧇, āϕ⧋āύ āϕ⧋āύ āϏāĻ‚āĻ–ā§āϝāĻž, āφāϰ test āϝāĻ–āύ āĻļ⧇āώāĻŽā§‡āĻļ āύāĻž āĻŦāϞ⧇, āϤāĻ–āύ i-āĻāϰ value āĻ•āϤ?

āĻ•āĻžāĻ—āĻœā§‡ āĻĻ⧁āĻŸā§‹ column āĻŦāĻžāύāĻžāĻ“, i āφāϰ test i > 0, āφāϰ āĻĒā§āϰāϤāĻŋāϟāĻž pass-āĻāϰ āφāϗ⧇ āĻāĻ•āϟāĻž āĻ•āϰ⧇ row āĻ­āϰ⧋āĨ¤ āĻ­āĻžāĻ— āϕ⧋āϰ⧋ āύāĻž, āĻāĻ• āϧāĻžāĻĒ āĻāĻ• āϧāĻžāĻĒ āĻ•āϰ⧇ āĻāĻ—ā§‹āĻ“āĨ¤

āĻ…āύ⧁āĻļā§€āϞāύ ā§§āϏāĻšāϜ

David-āĻāϰ rocket game āĻļ⧁āϰ⧁ āĻšāϝāĻŧ āωāĻ˛ā§āĻŸā§‹ āĻ—ā§‹āύāĻž āĻĻāĻŋāϝāĻŧ⧇āĨ¤ n āĻĨ⧇āϕ⧇ 1 āĻĒāĻ°ā§āϝāĻ¨ā§āϤ āϏāĻ‚āĻ–ā§āϝāĻžāϗ⧁āϞ⧋ print āĻ•āϰ⧋, āϤāĻžāϰāĻĒāϰ āϏ⧇āχ āĻļāĻŦā§āĻĻāϟāĻž, āϝ⧇āϟāĻž rocket āĻ›āĻžāĻĄāĻŧ⧇āĨ¤

Input. āĻāĻ•āϟāĻž āĻĒā§‚āĻ°ā§āĻŖāϏāĻ‚āĻ–ā§āϝāĻž nāĨ¤

Output. n-āϟāĻž āϞāĻžāχāύ⧇ n, n - 1, āĻāĻ­āĻžāĻŦ⧇ 1 āĻĒāĻ°ā§āϝāĻ¨ā§āϤ, āϤāĻžāϰāĻĒāϰ āĻāĻ•āϟāĻž āϞāĻžāχāύ⧇ Go!āĨ¤

Constraints. 1 <= n <= 1000āĨ¤

Sample. Input 3 āĻĻāĻŋāϞ⧇ āϚāĻžāϰ āϞāĻžāχāύ⧇ āφāϏ⧇ 3, 2, 1 āφāϰ Go!āĨ¤

const input = require("fs").readFileSync(0, "utf8");
const tokens = input.split(/\s+/).filter(Boolean);
let at = 0;
const next = () => tokens[at++];
const nextInt = () => Number(next());
const out = [];

// your code: read with next() and nextInt(), push every line of output to out

console.log(out.join("\n"));

āφāϞāĻžāĻĻāĻž āĻ•āϰ⧇ grade āĻšāϝāĻŧ āύāĻžāĨ¤ for loop āωāĻ˛ā§āĻŸā§‹ āĻĻāĻŋāϕ⧇āĻ“ āϗ⧁āύāϤ⧇ āĻĒāĻžāϰ⧇: n āĻĨ⧇āϕ⧇ āĻļ⧁āϰ⧁ āĻ•āϰ⧋, test āĻĻāĻžāĻ“ i >= 1, āφāϰ step āĻĻāĻžāĻ“ i--āĨ¤

Run in Compiler
āĻ…āύ⧁āĻļā§€āϞāύ ⧍āϏāĻšāϜ

Zara-āϰ step counter, āĻāĻŦāĻžāϰ āĻ āĻŋāĻ•āĻ āĻžāĻ•āĨ¤ āĻĒā§āϰāϤāĻŋāϟāĻž āĻĻāĻŋāύ⧇āϰ āϜāĻ¨ā§āϝ āĻŦāϞ⧋ āĻ“āϰ goal āĻšāϝāĻŧ⧇āϛ⧇ āĻ•āĻŋ āύāĻž, āϤāĻžāϰāĻĒāϰ āĻŦāϞ⧋ āĻ•āϝāĻŧāĻĻāĻŋāύ goal āĻšāϝāĻŧ⧇āϛ⧇āĨ¤

Input. āĻĒā§āϰāĻĨāĻŽ āϞāĻžāχāύ⧇ n āφāϰ goal gāĨ¤ āĻĻā§āĻŦāĻŋāϤ⧀āϝāĻŧ āϞāĻžāχāύ⧇ n-āϟāĻž āĻĒā§‚āĻ°ā§āĻŖāϏāĻ‚āĻ–ā§āϝāĻž, āĻĒā§āϰāϤāĻŋāĻĻāĻŋāύ⧇āϰ stepāĨ¤

Output. n + 1-āϟāĻž āϞāĻžāχāύ: āĻ•ā§āϰāĻŽ āϧāϰ⧇ āĻĒā§āϰāϤāĻŋāϟāĻž āĻĻāĻŋāύ⧇āϰ āϜāĻ¨ā§āϝ, step āĻ•āĻŽāĻĒāĻ•ā§āώ⧇ g āĻšāϞ⧇ met, āύāĻžāĻšāϞ⧇ short; āϤāĻžāϰāĻĒāϰ āĻ•āϝāĻŧāĻĻāĻŋāύ goal āĻšāϝāĻŧ⧇āϛ⧇ āϏ⧇āχ āϏāĻ‚āĻ–ā§āϝāĻžāĨ¤

Constraints. 1 <= n <= 100000āĨ¤ 0 <= g <= 100000āĨ¤ 0 <= steps <= 100000āĨ¤

Sample. Input 5 8000 āφāϰ 7500 8000 12030 0 9100 āĻĻāĻŋāϞ⧇ āĻ›āϝāĻŧ āϞāĻžāχāύ⧇ āφāϏ⧇ short, met, met, short, met āφāϰ 3āĨ¤

const input = require("fs").readFileSync(0, "utf8");
const tokens = input.split(/\s+/).filter(Boolean);
let at = 0;
const next = () => tokens[at++];
const nextInt = () => Number(next());
const out = [];

// your code: read with next() and nextInt(), push every line of output to out

console.log(out.join("\n"));

Grade āĻšāĻŦ⧇ steps-goal āĻšāĻŋāϏ⧇āĻŦ⧇āĨ¤ Hidden test-āĻ āφāϛ⧇ āĻāĻŽāύ āĻĻāĻŋāύ āϝ⧇āϟāĻž āĻ āĻŋāĻ• goal-āĻāϰ āϏāĻŽāĻžāύ, goal 0, āφāϰ āĻŽāĻžāĻ¤ā§āϰ āĻāĻ•āϟāĻž āĻĻāĻŋāύ, āϤāĻžāχ "āĻ•āĻŽāĻĒāĻ•ā§āώ⧇" āĻ•āĻĨāĻžāϟāĻž āϖ⧇āϝāĻŧāĻžāϞ āĻ•āϰ⧇ āĻĒāĻĄāĻŧā§‹āĨ¤

Run in Compiler
āĻ…āύ⧁āĻļā§€āϞāύ ā§ŠāĻŽāĻžāĻāĻžāϰāĻŋ

Zara āϜāĻžāύāϤ⧇ āϚāĻžāϝāĻŧ āĻ•āϝāĻŧāĻĻāĻŋāύ āĻ“ āφāϗ⧇āϰ āĻĻāĻŋāύāϕ⧇ āĻšāĻžāϰāĻŋāϝāĻŧ⧇āϛ⧇āĨ¤ āϝ⧇āϏāĻŦ āĻĻāĻŋāύ⧇ step āφāϗ⧇āϰ āĻĻāĻŋāύ⧇āϰ āĻšā§‡āϝāĻŧ⧇ āĻŦ⧇āĻļāĻŋ, āϏ⧇āϗ⧁āϞ⧋ āĻ—ā§‹āύ⧋āĨ¤ Day 1-āĻāϰ āφāϗ⧇āϰ āĻĻāĻŋāύ āύ⧇āχ, āϤāĻžāχ āĻ“āϟāĻž āĻ•āĻ–āύ⧋ āĻ—ā§‹āύāĻž āĻšāϝāĻŧ āύāĻžāĨ¤

Input. n, āϤāĻžāϰāĻĒāϰ n-āϟāĻž āĻĒā§‚āĻ°ā§āĻŖāϏāĻ‚āĻ–ā§āϝāĻž, āĻĒā§āϰāϤāĻŋāĻĻāĻŋāύ⧇āϰ stepāĨ¤

Output. āĻāĻ•āϟāĻž āϏāĻ‚āĻ–ā§āϝāĻž: āĻ•āϝāĻŧāĻĻāĻŋāύ āφāϗ⧇āϰ āĻĻāĻŋāύ⧇āϰ āĻšā§‡āϝāĻŧ⧇ āĻŦ⧇āĻļāĻŋ step āĻšāϝāĻŧ⧇āϛ⧇āĨ¤

Constraints. 1 <= n <= 100000āĨ¤ 0 <= steps <= 100000āĨ¤

Sample. Input 5 āφāϰ 4200 9900 8000 8100 15000 āĻĻāĻŋāϞ⧇ āφāϏ⧇ 3: 9900 āĻšāĻžāϰāĻŋāϝāĻŧ⧇āϛ⧇ 4200-āϕ⧇, 8100 āĻšāĻžāϰāĻŋāϝāĻŧ⧇āϛ⧇ 8000-āϕ⧇, āφāϰ 15000 āĻšāĻžāϰāĻŋāϝāĻŧ⧇āϛ⧇ 8100-āϕ⧇āĨ¤

const input = require("fs").readFileSync(0, "utf8");
const tokens = input.split(/\s+/).filter(Boolean);
let at = 0;
const next = () => tokens[at++];
const nextInt = () => Number(next());
const out = [];

// your code: read with next() and nextInt(), push every line of output to out

console.log(out.join("\n"));

āφāϞāĻžāĻĻāĻž āĻ•āϰ⧇ grade āĻšāϝāĻŧ āύāĻžāĨ¤ āĻ—āϤāĻ•āĻžāϞ⧇āϰ value āϰāĻžāĻ–ā§‹ loop-āĻāϰ āφāϗ⧇ declare āĻ•āϰāĻž āĻāĻ•āϟāĻž let-āĻ, āφāϰ āĻĒā§āϰāϤāĻŋāϟāĻž pass-āĻāϰ āĻļ⧇āώ⧇ āϏ⧇āϟāĻž update āĻ•āϰ⧋āĨ¤ āϤāĻžāϰāĻĒāϰ n = 1 āĻĻāĻŋāϝāĻŧ⧇, āφāϰ āĻĒāϰāĻĒāϰ āĻĻ⧁āĻŸā§‹ āϏāĻŽāĻžāύ āĻĻāĻŋāύ āĻĻāĻŋāϝāĻŧ⧇ āϚāĻžāϞāĻŋāϝāĻŧ⧇ āĻĻ⧇āĻ–ā§‹āĨ¤

Run in Compiler
āĻ…āύ⧁āĻļā§€āϞāύ ā§ĒāĻ•āĻ āĻŋāύ

Zara-āϰ app āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āϞāĻŽā§āĻŦāĻž streak-āĻāϰ āϜāĻ¨ā§āϝ āĻāĻ•āϟāĻž badge āĻĻ⧇āϝāĻŧ: āĻĒāϰāĻĒāϰ āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āĻŦ⧇āĻļāĻŋ āĻ•āϝāĻŧāĻĻāĻŋāύ goal āĻšāϝāĻŧ⧇āϛ⧇āĨ¤ āĻ“āϰ āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āϞāĻŽā§āĻŦāĻž streak āĻ•āϤ āĻĻāĻŋāύ⧇āϰ, āĻŦ⧇āϰ āĻ•āϰ⧋āĨ¤

Input. āĻĒā§āϰāĻĨāĻŽ āϞāĻžāχāύ⧇ n āφāϰ goal gāĨ¤ āĻĻā§āĻŦāĻŋāϤ⧀āϝāĻŧ āϞāĻžāχāύ⧇ n-āϟāĻž āĻĒā§‚āĻ°ā§āĻŖāϏāĻ‚āĻ–ā§āϝāĻž, āĻĒā§āϰāϤāĻŋāĻĻāĻŋāύ⧇āϰ stepāĨ¤

Output. āĻāĻ•āϟāĻž āϏāĻ‚āĻ–ā§āϝāĻž: āĻĒāϰāĻĒāϰ āϝāϤāĻĻāĻŋāύ step āĻ•āĻŽāĻĒāĻ•ā§āώ⧇ g āĻšāϝāĻŧ⧇āϛ⧇, āϤāĻžāϰ āĻŽāĻ§ā§āϝ⧇ āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āϞāĻŽā§āĻŦāĻž āϟāĻžāύāĻž āĻĻāĻŋāύ⧇āϰ āϏāĻ‚āĻ–ā§āϝāĻž, āφāϰ āϕ⧋āύ⧋ āĻĻāĻŋāύāχ goal āύāĻž āĻšāϞ⧇ 0āĨ¤

Constraints. 1 <= n <= 100000āĨ¤ 0 <= g <= 100000āĨ¤ 0 <= steps <= 100000āĨ¤

Sample. Input 7 8000 āφāϰ 9000 8000 100 8500 9100 12000 50 āĻĻāĻŋāϞ⧇ āφāϏ⧇ 3: day 4, 5 āφāϰ 6āĨ¤

const input = require("fs").readFileSync(0, "utf8");
const tokens = input.split(/\s+/).filter(Boolean);
let at = 0;
const next = () => tokens[at++];
const nextInt = () => Number(next());
const out = [];

// your code: read with next() and nextInt(), push every line of output to out

console.log(out.join("\n"));

āφāϞāĻžāĻĻāĻž āĻ•āϰ⧇ grade āĻšāϝāĻŧ āύāĻžāĨ¤ āĻĻ⧁āĻŸā§‹ counter āϞāĻžāĻ—āĻŦ⧇: āĻāĻ–āύ āϝ⧇ streak āϚāϞāϛ⧇, āφāϰ āĻāĻ–āύ āĻĒāĻ°ā§āϝāĻ¨ā§āϤ āϏ⧇āϰāĻžāϟāĻžāĨ¤ āϝ⧇āĻĻāĻŋāύ goal āĻšāϝāĻŧ āύāĻž, āϏ⧇āĻĻāĻŋāύ āϕ⧋āύāϟāĻž āϕ⧀ āĻ•āϰāĻŦ⧇ āĻ āĻŋāĻ• āĻ•āϰ⧋, āφāϰ āĻāĻŽāύ āĻāĻ•āϟāĻž āϏāĻĒā§āϤāĻžāĻš āĻĻāĻŋāϝāĻŧ⧇ āϚāĻžāϞāĻžāĻ“ āϝ⧇āĻ–āĻžāύ⧇ āϏ⧇āϰāĻž streak-āϟāĻž āĻāĻ•āĻĻāĻŽ āĻļ⧇āώ⧇āĨ¤

Run in Compiler

āϏāϚāϰāĻžāϚāϰ āϝ⧇ āĻĒā§āϰāĻļā§āύāϗ⧁āϞ⧋ āφāϏ⧇

  • Block-āĻ āĻāĻ• āϞāĻžāχāύ āĻĨāĻžāĻ•āϞ⧇āĻ“ āĻ•āĻŋ brace āϞāĻžāĻ—āĻŦ⧇āχ?

    āĻāĻ•āϟāĻž statement āĻšāϞ⧇ āĻ­āĻžāώāĻž āϤ⧋āĻŽāĻžāϕ⧇ brace āĻŦāĻžāĻĻ āĻĻāĻŋāϤ⧇ āĻĻ⧇āϝāĻŧāĨ¤ āĻāχ track āϤāĻŦ⧁ āϏāĻŦāϏāĻŽāϝāĻŧ āϞ⧇āϖ⧇āĨ¤ Google JavaScript Style Guide-āĻ“ āϞ⧇āϖ⧇, āĻ“āϰāĻž āĻĒā§āϰāϤāĻŋāϟāĻž control structure-āĻ brace āϚāĻžāϝāĻŧ, āφāϰ ESLint-āĻāϰ curly rule āĻāϟāĻž āĻœā§‹āϰ āĻ•āϰ⧇ āĻŽāĻžāύāĻžāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤ āĻ•āĻžāϰāĻŖāϟāĻž "āϝ⧇ āϭ⧁āϞāϗ⧁āϞ⧋ āϏāĻŦāĻžāχ āĻ•āϰ⧇"-āĻāϰ ⧍: āĻĻā§āĻŦāĻŋāϤ⧀āϝāĻŧ āϞāĻžāχāύāϟāĻž āϏāĻŦāϏāĻŽāϝāĻŧ āĻĒāϰ⧇ āφāϏ⧇āĨ¤

  • āĻ•āĻŋāϛ⧁ loop 0 āĻĨ⧇āϕ⧇ āĻļ⧁āϰ⧁ āĻšāϝāĻŧ, āĻ•āĻŋāϛ⧁ 1 āĻĨ⧇āϕ⧇, āϕ⧇āύ?

    Test āĻļ⧁āϰ⧁āϰ āϏāĻžāĻĨ⧇ āĻŽāĻŋāϞāϞ⧇ āĻĻ⧁āĻŸā§‹āχ n-āϟāĻž pass āϚāϞ⧇āĨ¤ for (let i = 0; i < n; i++) āĻ—ā§‹āύ⧇ 0 āĻĨ⧇āϕ⧇ n - 1, āϝ⧇āϟāĻž array-āϰ position-āĻāϰ āϏāĻžāĻĨ⧇ āĻŽā§‡āϞ⧇ (Module 7)āĨ¤ for (let day = 1; day <= n; day++) āĻ—ā§‹āύ⧇ 1 āĻĨ⧇āϕ⧇ n, āĻŽāĻžāύ⧁āώ āϝ⧇āĻ­āĻžāĻŦ⧇ āĻĻāĻŋāύ āĻ—ā§‹āύ⧇āĨ¤ āϝ⧇ āϏāĻ‚āĻ–ā§āϝāĻžāϗ⧁āϞ⧋ print āĻ•āϰāĻŦ⧇, āϏ⧇āχ āĻ…āύ⧁āϝāĻžāϝāĻŧā§€ āĻŦ⧇āϛ⧇ āύāĻžāĻ“āĨ¤

  • Step āĻšāĻŋāϏ⧇āĻŦ⧇ i++ āφāϰ i += 1-āĻ āĻ•āĻŋ āϕ⧋āύ⧋ āϤāĻĢāĻžāϤ āφāϛ⧇?

    Step āĻšāĻŋāϏ⧇āĻŦ⧇ āύāĻžāĨ¤ Step-āĻāϰ āύāĻŋāĻœā§‡āϰ value āĻĢ⧇āϞ⧇ āĻĻ⧇āĻ“āϝāĻŧāĻž āĻšāϝāĻŧ, āϤāĻžāχ āĻĻ⧁āĻŸā§‹āχ āĻļ⧁āϧ⧁ 1 āϝ⧋āĻ— āĻ•āϰ⧇āĨ¤ i++ āφāϰ ++i āϕ⧋āĻĨāĻžāϝāĻŧ āφāϞāĻžāĻĻāĻž, Module 2-āĻāϰ lesson 02 āĻĻ⧇āĻ–āĻŋāϝāĻŧ⧇āϛ⧇, āφāϰ āϏ⧇āϟāĻž āĻļ⧁āϧ⧁ āϤāĻ–āύāχ, āϝāĻ–āύ āϤ⧁āĻŽāĻŋ value-āϟāĻž āĻ•āĻžāĻœā§‡ āϞāĻžāĻ—āĻžāĻ“āĨ¤

  • n āϝāĻĻāĻŋ 0 āĻšāϝāĻŧ, āϤāĻ–āύ āϕ⧀ āĻšāϝāĻŧ?

    āĻĒā§āϰāĻĨāĻŽ check-āĻāχ test fail āĻ•āϰ⧇, āφāϰ body āĻāĻ•āĻŦāĻžāϰāĻ“ āϚāϞ⧇ āύāĻžāĨ¤ āĻāϟāĻžāχ āĻ āĻŋāĻ• āφāϚāϰāĻŖ, error āύāĻžāĨ¤ āϤāĻŦ⧁ āĻ–āĻžāϞāĻŋ input-āĻ āϝāĻž print āĻ•āϰāĻžāϰ āĻ•āĻĨāĻž, program-āϕ⧇ āϏ⧇āϟāĻž print āĻ•āϰāϤ⧇āχ āĻšāĻŦ⧇, āφāϰ Zara āϏāĻŦāĻžāϰ āφāϗ⧇ āĻāϟāĻžāχ check āĻ•āϰāϤāĨ¤

  • for...of āφāϰ for...in āĻ•āĻŋ āĻāĻ•āχ loop?

    āύāĻžāĨ¤ for...of āϤ⧋āĻŽāĻžāϰ āĻšāĻžāϤ⧇ āĻĻ⧇āϝāĻŧ valueāĨ¤ for...in āĻĻ⧇āϝāĻŧ āĻāĻ•āϟāĻž object-āĻāϰ property-āϗ⧁āϞ⧋āϰ āύāĻžāĻŽ, āφāϰ array-āϤ⧇ āĻĻ⧇āϝāĻŧ position-āϗ⧁āϞ⧋, string āĻšāĻŋāϏ⧇āĻŦ⧇āĨ¤ āĻĻ⧁āĻŸā§‹āχ, āφāϰ āĻĻ⧁āĻŸā§‹āϰ āĻŽāĻžāĻā§‡āϰ āĻĢāĻžāρāĻĻāϟāĻž, lesson 02 āĻĻ⧇āĻ–āĻžāĻŦ⧇āĨ¤

āĻŽā§‚āϞ āĻ•āĻĨāĻž

  • āĻļāĻ°ā§āϤ truthy āĻšāϞ⧇ if-āĻāϰ block āϚāϞ⧇, falsy āĻšāϞ⧇ else-āĻāϰ block; āĻāχ track brace āϏāĻŦāϏāĻŽāϝāĻŧ āϞ⧇āϖ⧇āĨ¤
  • āĻāĻ•āϟāĻž for loop āĻļ⧁āϰ⧁āϟāĻž āϚāĻžāϞāĻžāϝāĻŧ āĻāĻ•āĻŦāĻžāϰ, test āĻĒā§āϰāϤāĻŋāϟāĻž pass-āĻāϰ āφāϗ⧇, āφāϰ step āĻĒā§āϰāϤāĻŋāϟāĻž pass-āĻāϰ āĻĒāϰ⧇āĨ¤
  • Test āĻĒā§āϰāĻĨāĻŽ āϝ⧇āĻŦāĻžāϰ falsy āĻšāϝāĻŧ, loop āϏ⧇āĻ–āĻžāύ⧇āχ āĻļ⧇āώ; āĻļ⧁āϰ⧁āϤ⧇āχ falsy āĻšāϞ⧇ āĻāĻ•āϟāĻžāĻ“ pass āĻšāϝāĻŧ āύāĻžāĨ¤
  • Loop-āĻāϰ āĻļ⧁āϰ⧁āϤ⧇ declare āĻ•āϰāĻž let āĻĨāĻžāϕ⧇ āĻļ⧁āϧ⧁ āĻ“āχ loop-āĻāϰ āϭ⧇āϤāϰ⧇; āĻĢāϞāĻžāĻĢāϞ āϰāĻžāĻ–ā§‹ loop-āĻāϰ āφāϗ⧇ declare āĻ•āϰāĻž variable-āĻāĨ¤
  • for...of āĻāĻ•āϟāĻž array āĻŦāĻž string āĻĨ⧇āϕ⧇ āĻĒā§āϰāϤāĻŋ pass-āĻ āĻāĻ•āϟāĻž āĻ•āϰ⧇ value āύ⧇āϝāĻŧ, āϕ⧋āύ⧋ counter āϏāĻžāĻŽāϞāĻžāϤ⧇ āĻšāϝāĻŧ āύāĻžāĨ¤
  • āφāϰāĻ“ āĻ—āĻ­ā§€āϰ⧇: Under the Hood, jump āĻĻāĻŋāϝāĻŧ⧇ loop, iterator protocol āφāϰ āĻāĻ•āϟāĻž loop lab (Pro)āĨ¤

āĻāϰāĻĒāϰ lesson 02 āĻĒā§āϰāϤāĻŋāϟāĻž statement āĻāĻ•āϟāĻž āĻāĻ•āϟāĻž āĻ•āϰ⧇ āϧāϰāĻŦ⧇: else if, switch, while, do...while, for...in, break āφāϰ continueāĨ¤

lesson ā§§ āĻļ⧇āώ

āĻļ⧇āώ āĻšāϞ⧇ āϚāĻŋāĻšā§āύ āĻĻāĻŋāύ, āĻ…āĻ—ā§āϰāĻ—āϤāĻŋ āφāĻĒāύāĻžāϰ āϏāĻžāĻĨ⧇ āĻĨāĻžāĻ•āĻŦ⧇āĨ¤

āĻĒāϰ⧇āϰāϟāĻž: āĻĒā§āϰāϤāĻŋāϟāĻž statement, āĻāĻ•āϟāĻž āĻāĻ•āϟāĻž āĻ•āϰ⧇

āϏāĻŋāĻĻā§āϧāĻžāĻ¨ā§āϤ āφāϰ loop: āĻĒ⧁āϰ⧋ āĻ›āĻŦāĻŋāϟāĻž | Learn JavaScript | Progsity