Skip to main content
Wave
GitHub

లూప్

పరిచయం​

Wave భాష ఒకే కోడ్‌ని అనేకసార్లు అమలు చేయాల్సిన పరిస్థితులను నిర్వహించడానికి లూప్ స్టేట్‌మెంట్‌లను అందిస్తుంది. లూప్ స్టేట్‌మెంట్‌లు నిర్దిష్ట షరతులు నెరవేరినప్పుడు కోడ్‌ని అమలు చేయడం కొనసాగించడానికి లేదా నిర్ణీత సంఖ్యలో పదే పదే అమలు చేయడానికి ఉపయోగించబడతాయి.

ఇది ఒకే లాజిక్‌ను పదే పదే వ్రాయాల్సిన అవసరం లేకుండా, పునరావృతమయ్యే పనులను సంక్షిప్త, స్పష్టమైన కోడ్‌లో వ్యక్తీకరించడానికి మిమ్మల్ని అనుమతిస్తుంది. Wave షరతు-ఆధారిత పునరావృతం మరియు గణన-ఆధారిత పునరావృతం రెండింటికి మద్దతు ఇస్తుంది మరియు పునరావృత సమయంలో అమలు ప్రవాహాన్ని నియంత్రించడానికి కీలక పదాలను కూడా అందిస్తుంది.

పునరావృత ప్రవాహాన్ని నియంత్రించడానికి while మరియు for స్టేట్‌మెంట్‌లను అలాగే break మరియు continue కీవర్డ్‌లను ఎలా ఉపయోగించాలో ఈ విభాగం వివరిస్తుంది.

ప్రకటన అయితే​

while స్టేట్‌మెంట్ ఇచ్చిన కండిషన్ ఎక్స్‌ప్రెషన్ నిజమైన (true)కి మూల్యాంకనం చేసేంత వరకు కోడ్ బ్లాక్‌ను పదేపదే అమలు చేస్తుంది. షరతు వ్యక్తీకరణ తప్పుగా మారిన క్షణం (false), పునరావృతం వెంటనే ముగుస్తుంది.

పునరావృతాల సంఖ్య స్పష్టంగా లేని పరిస్థితులకు ఈ పద్ధతి అనుకూలంగా ఉంటుంది మరియు నిర్దిష్ట షరతు నెరవేరే వరకు పునరావృతం చేయాలి.

ప్రాథమిక నిర్మాణం​

Waveలో కాసేపు ప్రకటన యొక్క ప్రాథమిక నిర్మాణం క్రింది విధంగా ఉంది:

while (condition) {
    // పునరావృతం చేయడానికి కోడ్
}

షరతులతో కూడిన వ్యక్తీకరణ తప్పనిసరిగా bool రకంగా మూల్యాంకనం చేయబడాలి. మీరు {} కర్లీ బ్రేస్‌లలో చేర్చబడిన కోడ్ బ్లాక్‌లో ఒకటి లేదా అంతకంటే ఎక్కువ స్టేట్‌మెంట్‌లను వ్రాయవచ్చు.

ఉదాహరణ: 0 నుండి 4 వరకు ముద్రించండి​

var i :i32 = 0;

while (i < 5) {
    println("నేను {}.", i);
    i = i + 1;
}

ఈ ఉదాహరణలో, వేరియబుల్ i 5 కంటే తక్కువగా ఉన్నప్పుడు పునరావృత్తులు నిర్వహించబడతాయి. ప్రతి పునరావృతం వద్ద, ఇది ప్రస్తుత విలువను ముద్రిస్తుంది మరియు i విలువను 1 ద్వారా పెంచుతుంది, తద్వారా పరిస్థితి చివరికి తప్పుగా మారుతుంది.

ప్రకటన కోసం​

for స్టేట్‌మెంట్ అనేది పునరావృతాల సంఖ్య సాపేక్షంగా స్పష్టంగా ఉన్నప్పుడు ఉపయోగించడానికి అనువైన లూప్ స్టేట్‌మెంట్. ప్రారంభ విలువ, షరతులతో కూడిన వ్యక్తీకరణ మరియు వ్యక్తీకరణను ఒకేసారి పెంచడం/తగ్గించడం ద్వారా మీరు పునరావృత ప్రవాహాన్ని స్పష్టంగా వ్యక్తీకరించవచ్చు.

పునరావృత నియంత్రణకు అవసరమైన మూలకాలు ఒకే చోట సేకరించబడినందున, పునరావృత నిర్మాణాన్ని ఒక చూపులో అర్థం చేసుకోవడం సులభం.

ప్రాథమిక నిర్మాణం​

for (init; condition; step) {
    // పునరావృతం చేయడానికి కోడ్
}

ప్రారంభించడం కోసం Wave అనేక రూపాలకు మద్దతు ఇస్తుంది.

  • అవ్యక్త var రకం ప్రారంభించడం
  • var / let mut / const డిక్లరేషన్ ప్రారంభించడం
  • సాధారణ వ్యక్తీకరణలను ప్రారంభించండి (ఇప్పటికే ఉన్న వేరియబుల్స్‌ని మళ్లీ ఉపయోగించండి)

ఉదాహరణ 1: అవ్యక్త రకం ప్రారంభించడం​

for (i :i32 = 1; i <= 5; i += 1) {
    println("i = {}", i);
}

ఉదాహరణ 2: var / let mut ప్రారంభించడం​

for (var i: i32 = 0; i < 3; i += 1) {
    println("var i = {}", i);
}

for (let mut j: i32 = 0; j < 3; j += 1) {
    println("let mut j = {}", j);
}

ఉదాహరణ 3: వ్యక్తీకరణ-ఆధారిత ప్రారంభీకరణ (ఇప్పటికే ఉన్న వేరియబుల్‌లను తిరిగి ఉపయోగించడం)​

var i: i32 = 99;

for (i = 3; i <= 5; i += 1) {
    println("i = {}", i);
}

println("after loop: {}", i); // 6

డిక్లరేటివ్ ప్రారంభాలు (var, let mut, i :i32 = ...) లూప్ స్కోప్ వేరియబుల్స్‌గా పనిచేస్తాయి, వ్యక్తీకరణ-ఆధారిత ప్రారంభీకరణ (i = ...) బాహ్య వేరియబుల్‌ను స్వయంగా నవీకరిస్తుంది.

సమూహ లూప్​

లూప్‌లను ఇతర లూప్‌ల లోపల వ్రాయవచ్చు, వీటిని నెస్టెడ్ లూప్‌లు అంటారు. టూ-డైమెన్షనల్ డేటా స్ట్రక్చర్‌లో ప్రయాణించేటప్పుడు లేదా బహుళ పరిస్థితుల కలయికను ప్రాసెస్ చేస్తున్నప్పుడు నెస్టెడ్ లూప్‌లు ఉపయోగపడతాయి.

ఉదాహరణ: డబుల్ అయితే స్టేట్‌మెంట్​

var i :i32 = 0;

while (i < 3) {
    var j :i32 = 0;

    while (j < 2) {
        println("i={}, j={}", i, j);
        j = j + 1;
    }

    i = i + 1;
}

ఈ ఉదాహరణలో, బయటి while స్టేట్‌మెంట్ అమలు చేయబడిన ప్రతిసారి, అంతర్గత while స్టేట్‌మెంట్‌లు అన్నీ అమలు చేయబడతాయి. ఇది ఫారమ్ (i, j) కలయికలను వరుసగా ప్రాసెస్ చేయడానికి అనుమతిస్తుంది.

విరామం ప్రకటన​

break స్టేట్‌మెంట్ వెంటనే లూప్‌ను రద్దు చేస్తుంది మరియు లూప్ నుండి ప్రవాహాన్ని బయటకు తరలిస్తుంది. తదుపరి పునరావృత్తులు చేయనవసరం లేనప్పుడు పునరావృత సమయంలో ఉపయోగించబడుతుంది.

ఉదాహరణ: నిర్దిష్ట విలువ వద్ద పునరావృతం ముగింపు​

var i :i32 = 0;

while (true) {
    if (i == 5) {
        break;
    }

    println(i);
    i = i + 1;
}

ఈ ఉదాహరణలో, అనంతమైన లూప్‌లో i 5గా మారినప్పుడు, break అమలు చేయబడుతుంది మరియు పునరావృతం ముగుస్తుంది. ఇలా, మీరు పునరావృత్తి స్థితి నుండి స్వతంత్రంగా పునరావృతం చేయడాన్ని నియంత్రించాలనుకున్నప్పుడు break ప్రకటన ఉపయోగకరంగా ఉంటుంది.

ప్రకటన కొనసాగించు​

continue స్టేట్‌మెంట్ ప్రస్తుత పునరావృతంలో మిగిలిన కోడ్‌ను దాటవేస్తుంది మరియు వెంటనే తదుపరి పునరావృతం ప్రారంభమవుతుంది. మీరు కొన్ని షరతులలో కొంత తర్కాన్ని వదిలివేయాలనుకున్నప్పుడు ఇది ఉపయోగించబడుతుంది.

ఉదాహరణ: సరి సంఖ్యలను మాత్రమే ముద్రించండి​

for (var i: i32 = 0; i <= 10; i = i + 1) {
    if (i % 2 == 1) {
        continue;
    }

    println(i);
}

ఈ కోడ్‌లో, i అనేది బేసి సంఖ్య అయితే, అవుట్‌పుట్ భాగాన్ని దాటవేస్తూ continue అమలు చేయబడుతుంది. ఫలితంగా, సమాన విలువలు మాత్రమే అవుట్‌పుట్ అవుతాయి.

సారాంశం​

Wave యొక్క లూప్ సహజంగా షరతు-ఆధారిత మరియు గణన-ఆధారిత పునరావృత్తులు రెండింటినీ వ్యక్తీకరించడానికి రూపొందించబడింది. while స్టేట్‌మెంట్ షరతులతో నడిచే పునరావృతానికి అనుకూలంగా ఉంటుంది మరియు పునరావృతాల సంఖ్య మరియు ప్రవాహం స్పష్టంగా ఉన్నప్పుడు for స్టేట్‌మెంట్ ఉపయోగపడుతుంది.

break మరియు continueలను కలిపి ఉపయోగించడం ద్వారా, మీరు పునరావృత సమయంలో కూడా అమలు ప్రక్రియను చక్కగా నియంత్రించవచ్చు. మీరు మరింత అధునాతనమైన మరియు సౌకర్యవంతమైన పునరావృత తర్కాన్ని నిర్మించవచ్చు.