PHP handles a lot of repetitive work on the server side. A single request might need to scan a folder full of images, po

PHP சர்வர் பக்கத்தில் (server side) பல மீண்டும் மீண்டும் செய்யப்படும் வேலைகளைக் கையாள்கிறது. ஒரு ஒற்றை கோரிக்கை (request) படங்களால் நிறைந்த ஒரு கோப்புறையை ஸ்கேன் செய்ய வேண்டியிருக்கலாம், நிலை (status) மாறும் வரை ஒரு தரவுத்தளத்தை (database) கண்காணிக்க வேண்டியிருக்கலாம், அல்லது உங்கள் விதிகளுக்குப் பொருந்தும் வரை பயனரிடம் தொடர்ந்து உள்ளீட்டை (input) கேட்க வேண்டியிருக்கலாம். இதையெல்லாம் ஒரே குறியீட்டுத் தொகுதியை (code block) நகலெடுத்து ஒட்டுவதன் மூலம் செய்வது மிகவும் பலவீனமானதாகவும், பராமரிப்பது கிட்டத்தட்ட சாத்தியமற்றதாகவும் இருக்கும். இந்தத் துல்லியமான சிக்கலைத் தீர்ப்பதற்காகவே லூப்கள் (Loops) உள்ளன. அவை தர்க்கத்தை (logic) மீண்டும் பயன்படுத்தக்கூடிய ஒரு தொகுப்பாகச் சுருக்குகின்றன, பிழைகளைக் குறைக்கின்றன மற்றும் உங்கள் பயன்பாட்டை (application) சுருக்கமாகவும் நேர்த்தியாகவும் வைத்திருக்க உதவுகின்றன.

பெரும்பாலான PHP டெவலப்பர்கள் எத்தனை முறை சுழற்சி (iterations) தேவை என்பதைத் தெரிந்தால் இயல்பாகவே for லூப்பைப் பயன்படுத்துவார்கள், அல்லது எண்ணிக்கை ஒரு மாறும் நிபந்தனையை (dynamic condition) பொறுத்து இருந்தால் while லூப்பைப் பயன்படுத்துவார்கள். இருப்பினும், மூன்றாவது விருப்பமும் உள்ளது, அது போதுமான அளவு வித்தியாசமாகச் செயல்படுகிறது, எனவே சரியான நேரத்தில் அதைத் தேர்ந்தெடுப்பது உங்கள் குறியீட்டை கணிசமாகத் தெளிவாக்கும். do-while லூப் அதன் உள்ளே இருக்கும் குறியீட்டை முதலில் இயக்கிவிட்டு, பின்னர் மீண்டும் இயங்க வேண்டுமா என்று சரிபார்க்கிறது.

do-while லூப்பை வேறுபடுத்துவது எது

ஒரு சாதாரண while லூப்பில், PHP குறியீட்டுத் தொகுப்பிற்குள் நுழைவதற்கு முன்பே நிபந்தனையைச் சரிபார்க்கிறது. நிபந்தனை ஆரம்பத்திலேயே தவறாக இருந்தால், அந்தத் தொகுப்பு முற்றிலும் தவிர்க்கப்படும். ஒரு do-while லூப் அந்த வரிசையைத் தலைகீழாக மாற்றுகிறது. இது குறியீட்டை ஒருமுறை இயக்கி, முடிவை எட்டிய பிறகு, மீண்டும் சுழல வேண்டுமா என்பதைத் தீர்மானிக்க நிபந்தனையைச் சரிபார்க்கிறது.

இதன் தொடரியல் (syntax) இவ்வாறு இருக்கும்:

do {
    // statements
} while ($condition);

while பகுதிக்குப் பிறகு வரும் செமிகோலன் (semicolon) ஆகியவற்றைக் கவனியுங்கள். அந்த செமிகோலன் கட்டாயம் தேவை, அதை மறந்தால் தொடரியல் பிழை (syntax error) ஏற்படும். do மற்றும் while ஆகியவற்றிற்கு இடையில் உள்ள தொகுப்பு, நிபந்தனை ஆரம்பத்திலிருந்தே தவறாக இருந்தாலும் எப்போதும் குறைந்தது ஒரு முறையாவது இயங்கும். இந்த 'post-test' நடத்தை வெறும் விசித்திரம் மட்டுமல்ல; லூப் இருப்பதற்கே இதுதான் முழுமையான காரணம்.

எப்போது do-while-ஐப் பயன்படுத்த வேண்டும்

இந்த அமைப்பு சிறப்பாகச் செயல்படும் மூன்று பொதுவான சூழல்கள் உள்ளன: ஒரு மெனுவைக் காண்பித்தல் (displaying a menu), உள்ளீட்டைச் சரிபார்த்தல் (validating input), மற்றும் தோல்வியடையக்கூடிய ஒரு பணியை மீண்டும் முயற்சித்தல் (retrying a task). ஒவ்வொரு சூழலிலும், தொடரலாமா என்பதைத் தீர்மானிப்பதற்கு முன்பே அந்தச் செயல் நடக்க வேண்டும் என்று தர்க்கம் கோருகிறது.

மெனுவைக் காண்பித்தல்

ஒரு கமாண்ட்-லைன் கருவி அல்லது உரை அடிப்படையிலான (text-based) அட்மின் பேனலை கற்பனை செய்து பாருங்கள். நீங்கள் விருப்பங்களின் பட்டியலை அச்சிட வேண்டும், பயனர் ஒன்றைத் தேர்ந்தெடுக்கும் வரை காத்திருக்க வேண்டும், பின்னர் மெனுவை மீண்டும் காட்ட வேண்டுமா என்று தீர்மானிக்க வேண்டும். திரையில் மெனு தோன்றிய பிறகே பயனர் வெளியேறத் (exit) தேர்ந்தெடுத்தாரா என்பதை உங்களால் சரிபார்க்க முடியும்.

$choice = 0;

do {
    echo "1. View Reports\n";
    echo "2. Export Data\n";
    echo "3. Exit\n";
    
    $choice = (int) readline("Select an option: ");
    
    if ($choice === 1) {
        // fetch and display reports
    } elseif ($choice === 2) {
        // run export logic
    }
} while ($choice !== 3);

ஒரு சாதாரண while லூப் தொழில்நுட்ப ரீதியாக இதைச் செய்ய முடியும், ஆனால் லூப் தொடங்குவதற்கு முன்பே மெனு வெளியீட்டை ஒருமுறை மீண்டும் செய்யவோ அல்லது ஆரம்ப நிபந்தனையைப் பூர்த்தி செய்ய $choice-ஐ ஒரு போலி மதிப்பிற்கு (phony value) மாற்றவோ அது உங்களைக் கட்டாயப்படுத்தும். இது தொடர்புடைய தர்க்கத்தை இரண்டு இடங்களில் சிதறடிக்கும். do-while பதிப்பு காண்பித்தல், வாசித்தல் மற்றும் சரிபார்த்தல் ஆகியவற்றை ஒரே நேர்த்தியான தொகுப்பிற்குள் வைத்திருக்கிறது.

உள்ளீட்டைச் சரிபார்த்தல்

உள்ளீடு சரிபார்ப்பு பெரும்பாலும் இதே முறையைப் பின்பற்றுகிறது. நீங்கள் பயனரிடம் கேட்க வேண்டும், அவர்கள் கொடுத்ததை ஆய்வு செய்ய வேண்டும், மேலும் அது உங்கள் விதிகளுக்குப் பொருந்தவில்லை என்றால் மீண்டும் செய்ய வேண்டும். ஆய்வு செய்வதற்கு முன்பே பயனரிடம் கேட்க வேண்டும் என்பதால், do-while லூப் இயற்கையாகப் பொருந்துகிறது.

do {
    $username = readline("Choose a username (min 3 chars): ");
    $isValid = strlen($username) >= 3;
    
    if (!$isValid) {
        echo "That username is too short.\n";
    }
} while (!$isValid);

ஒரு சாதாரண while லூப்பைப் பயன்படுத்தினால், நிபந்தனை எதற்காவது மதிப்பைக் கொண்டிருக்க வேண்டும் என்பதால், நீங்கள் $username-ஐ ஒரு வெற்று சரமாக (empty string) அமைக்க வேண்டும் மற்றும் லூப்பிற்கு மேலே உள்ள தூண்டுதல் (prompt) வரியைத் திரும்பத் திரும்ப எழுத வேண்டும். இந்தத் திரும்பத் திரும்பச் செய்யும் செயல் பிழைகளை (bugs) உண்டாக்கும். நீங்கள் பின்னர் தூண்டுதல் செய்தியை மாற்றினால், லூப்பிற்குள் அதைத் திருத்த நினைப்பீர்கள் ஆனால் அதற்கு மேலே உள்ள நகலைத் திருத்த மறந்துவிடலாம். எந்தவொரு நிபந்தனையும் சோதிக்கப்படுவதற்கு முன்பே தூண்டுதல் தொகுப்பிற்குள் இயங்குவதை உறுதி செய்வதன் மூலம் do-while அமைப்பு அந்த அபாயத்தை நீக்குகிறது.

தோல்வியடைந்த பணியை மீண்டும் முயற்சித்தல்

நெட்வொர்க் கோரிக்கைகள் (Network requests), கோப்புப் பூட்டுகள் (file locks) மற்றும் தரவுத்தளப் பதிவுகள் (database writes) சில சமயங்களில் முதல் முயற்சியில் தோல்வியடையலாம், ஆனால் சிறிது நேரத்திற்குப் பிறகு வெற்றிபெறலாம். நீங்கள் பொதுவாகக் குறைந்தது ஒருமுறை முயற்சி செய்ய விரும்புகிறீர்கள், பின்னர் தோல்வி தொடரும் வரை மற்றும் உங்களிடம் பொறுமை இருக்கும் வரை தொடர்ந்து முயற்சிப்பீர்கள்.

$attempts = 0;
$maxRetries = 3;
$success = false;

do {
    $attempts++;
    $response = @file_get_contents('https://api.example.com/status');
    
    if ($response !== false) {
        $success = true;
    } elseif ($attempts < $maxRetries) {
        sleep(1);
    }
} while (!$success && $attempts < $maxRetries);

if (!$success) {
    // log the permanent failure
}

இங்கே முக்கியமான விஷயம் என்னவென்றால், "இது வேலை செய்ததா?" என்று PHP கேட்பதற்கு முன்பே கோரிக்கை அனுப்பப்படுகிறது. ஒரு while லூப் லூப்பிற்குள் நுழைவதற்கு முன்பு ஒரு போலி கோரிக்கையைச் செய்ய வேண்டும் அல்லது ஒரு போலி வெற்றித் குறியீட்டை (fake success flag) அமைக்க வேண்டும், இது உண்மையில் என்ன நடக்கிறது என்பதை மறைத்துவிடும். do-while பதிப்பு வரிசையை நேர்மையாக வைத்திருக்கிறது: முயற்சி, ஆய்வு மற்றும் முடிவு.

do-while மற்றும் while ஆகியவற்றை ஒப்பிடுதல்

இந்த இரண்டு லூப்களுக்கும் இடையிலான வேறுபாடு நேரத்தைப் (timing) பொறுத்தது. எந்தவொரு சோதனையிலும் தோல்வியடையும் நிலையில் தொடங்கும் ஒரு மாறியைக் (variable) கருத்தில் கொள்ளுங்கள்:

$x = 10;

while ($x < 5) {
    echo $x;        // Never runs
}

அதே தொடக்க மதிப்பிற்கு எதிராக, ஒரு do-while லூப் இவ்வாறு செயல்படும்:

$x = 10;

do {
    echo $x;        // Runs once, outputs 10
} while ($x < 5);

அந்த ஒற்றை உறுதி செய்யப்பட்ட இயக்கம் தான் தீர்மானிக்கும் காரணியாகும். உங்கள் தர்க்கத்திற்கு பூஜ்ஜியம் அல்லது அதற்கு மேற்பட்ட சுழற்சிகள் தேவைப்பட்டால், while பாதுகாப்பான கருவி. உங்கள் தர்க்கத்திற்கு ஒன்று அல்லது அதற்கு மேற்பட்ட சுழற்சிகள் தேவைப்பட்டால், do-while பொதுவாகத் தெளிவான கருவியாகும்.

சிக்கல்கள் மற்றும் சிறந்த நடைமுறைகள்

Because the do-while loop promises at least one execution, it can also promise an infinite loop if you are not careful. If the variables checked in the condition never change inside the block, PHP will spin forever or until it hits the maximum execution time.

Another common mistake is omitting the trailing semicolon. The following will fail:

do {
    // code
} while ($x < 5)    // syntax error

You should also avoid reaching for do-while out of habit when another loop is more expressive. If you are iterating over an array, foreach is almost always superior. If you are managing a simple numeric counter, a for loop keeps the initialization, condition, and increment in one line, which is easier to scan.

In terms of performance, do-while carries no meaningful overhead compared to while in PHP. The benefit is entirely structural. When another developer sees a do-while loop, they immediately understand that the block must run before any condition is evaluated. That single piece of information saves them from tracing dummy variables or duplicated setup code above a standard while loop.

Edge Cases and Alternate Patterns

Sometimes a do-while loop is useful even when no user interaction is involved. For example, when consuming a generator or cursor that yields at least one item, you can process the first item and then check whether the cursor has advanced to a valid next position. In legacy codebases that use raw database resources instead of modern result sets, you might see a pattern like this:

$row = $result->fetch();
do {
    // process $row
} while ($row = $result->fetch());

While modern PHP favors foreach with PDO, the pattern illustrates how do-while handles the first iteration as a special case without extra branching.

The Real Takeaway

The do-while loop is a narrow tool, but in the right spot it is the only tool that makes sense. It keeps your setup and validation logic in one place, guarantees that an action is attempted before it is judged, and communicates your intent directly to the next person reading the code. When the condition must come after the work, use do-while. In every other case, let the simpler while, for, or foreach do the job.