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 ஆகியவற்றை ஒன்றாகப் பயன்படுத்துவதன் மூலம், மறு செய்கையின் போது கூட செயல்படுத்தும் ஓட்டத்தை நன்றாகக் கட்டுப்படுத்தலாம். நீங்கள் மிகவும் நுட்பமான மற்றும் நெகிழ்வான தர்க்கத்தை உருவாக்கலாம்.