ప్రధాన కంటెంట్‌కు వెళ్లండి
మాడ్యూల్ 5 · 4లో పాఠం 1కోర్సులో 17/32~10 min
మాడ్యూల్ పాఠాలు (1/4)

ఉచ్చులు: మరియు కొంతకాలం

లూప్‌లు కోడ్ బ్లాక్‌ని పునరావృతం చేయడానికి మిమ్మల్ని అనుమతిస్తాయి. JavaScript మూడు క్లాసిక్ రూపాలను కలిగి ఉంది: for, while, do…while. పునరావృతాల సంఖ్య మీకు తెలిసినప్పుడు (లేదా గణించగలిగినప్పుడు) మొదటిదాన్ని ఉపయోగించండి, మరొకటి మీకు నిష్క్రమణ పరిస్థితి అవసరమైనప్పుడు రెండు.

క్లాసిక్ for

మూడు భాగాలు ; ద్వారా వేరు చేయబడ్డాయి: ప్రారంభించడం, కొనసాగింపు పరిస్థితి, దశ.

JS
for (let i = 0; i < 4; i++) {
  console.log(i); // 0, 1, 2, 3
}

అదే శైలిలో సమానం:

JS
let i = 0;
while (i < 4) {
  console.log(i);
  i++;
}

while

ప్రతి పునరావృతానికి ముందు పరిస్థితిని తనిఖీ చేస్తుంది.

JS
let n = 10;
while (n > 0) {
  n = Math.floor(n / 2);
}
n; // 0

మొదటి రౌండ్‌లో పరిస్థితి ఇప్పటికే తప్పుగా ఉంటే, శరీరం ఎప్పటికీ అమలు చేయబడదు.

do…while

పరిస్థితిని తనిఖీ చేస్తుంది తర్వాత: శరీరం ఎల్లప్పుడూ కనీసం ఒక్కసారైనా అమలు చేయబడుతుంది.

JS
let tentativi = 0;
do {
  tentativi++;
} while (Math.random() < 0.0001); // pratica: provare almeno una volta

tentativi; // >= 1

దీనిని ప్రయత్నించండి

వ్యాయామం#js.m5.l1.e1
ప్రయత్నాలు: 0లోడ్ అవుతోంది...

1+2+...+n (పాజిటివ్ పూర్ణాంకం) మొత్తాన్ని అందించే `sumUpTo(n)` ఫంక్షన్‌ని నిర్వచించండి. కోసం ఒక క్లాసిక్ ఉపయోగించండి.

ఎడిటర్ లోడ్ అవుతోంది…
సూచనను చూపించు

టోటల్‌ను 0 వద్ద ప్రారంభించండి, ఆపై 1 నుండి n కలుపుకొని iని లూప్ చేయండి.

3 ప్రయత్నాల తర్వాత పరిష్కారం లభిస్తుంది

వ్యాయామం సమీక్షించండి

వ్యాయామం#js.m5.l1.e2
ప్రయత్నాలు: 0లోడ్ అవుతోంది...

`halveUntilOne(n)`ని నిర్వచించండి, అది ధనాత్మక పూర్ణాంకం ఇచ్చినట్లయితే, 1 లేదా అంతకంటే తక్కువకు చేరుకోవడానికి ముందు మీరు nని 2తో (Math.floorతో) భాగించాల్సిన అవసరం ఎన్నిసార్లు చూపుతుంది. కాసేపు ఉపయోగించండి.

ఎడిటర్ లోడ్ అవుతోంది…
సూచనను చూపించు

కౌంటర్ ఉంచండి మరియు n ను 2తో భాగించండి, అయితే n > 1.

3 ప్రయత్నాల తర్వాత పరిష్కారం లభిస్తుంది