PHP સર્વર સાઇડ પર ઘણું બધું પુનરાવર્તિત કામ સંભાળે છે. એક સિંગલ રિક્વેસ્ટમાં ઈમેજથી ભરેલા ફોલ્ડરને સ્કેન કરવું પડી શકે છે, સ્ટેટસ બદલાય ત્યાં સુધી ડેટાબેઝને પોલ (poll) કરવો પડી શકે છે, અથવા તમારા નિયમો મુજબ ઇનપુટ મળે ત્યાં સુધી યુઝર પાસેથી પૂછતા રહેવું પડી શકે છે. આમાંથી કોઈપણ કામ કરવા માટે એક જ કોડ બ્લોકને કોપી અને પેસ્ટ કરવાથી તે અસ્થિર (brittle) બનશે અને તેને મેન્ટેન કરવું લગભગ અશક્ય હશે. લૂપ્સ (Loops) બરાબર આ સમસ્યાનો ઉકેલ લાવવા માટે જ અસ્તિત્વ ધરાવે છે. તેઓ લોજિકને ફરીથી ઉપયોગમાં લઈ શકાય તેવા બ્લોકમાં લપેટી દે છે, ભૂલો ઘટાડે છે અને તમારા એપ્લિકેશનને કોમ્પેક્ટ રાખે છે.
મોટાભાગના PHP ડેવલપર્સ જ્યારે તેમને ખબર હોય કે તેમને કેટલા ઇટરેશન (iterations) ની જરૂર છે ત્યારે સહજ રીતે for લૂપનો ઉપયોગ કરે છે, અથવા જ્યારે કાઉન્ટ ડાયનેમિક કન્ડિશન પર આધારિત હોય ત્યારે while લૂપનો ઉપયોગ કરે છે. જોકે, ત્રીજો વિકલ્પ પણ છે, અને તે એટલી અલગ રીતે વર્તે છે કે યોગ્ય સમયે તેનો ઉપયોગ કરવાથી તમારો કોડ નોંધપાત્ર રીતે સ્પષ્ટ બની શકે છે. do-while લૂપ તેના બ્લોકની અંદરના કોડને પહેલા એક્ઝિક્યુટ કરે છે, અને પછી તપાસે છે કે તેને ફરીથી ચલાવવું જોઈએ કે નહીં.
do-while લૂપને શું અલગ બનાવે છે
એક સ્ટાન્ડર્ડ while લૂપમાં, PHP બ્લોકમાં પ્રવેશતા પહેલા જ કન્ડિશનનું મૂલ્યાંકન કરે છે. જો કન્ડિશન શરૂઆતમાં જ ખોટી (false) હોય, તો બ્લોક સંપૂર્ણપણે સ્કીપ થઈ જાય છે. do-while લૂપ આ ક્રમને ઉલટાવી દે છે. તે કોડને એકવાર ચલાવે છે, અંત સુધી પહોંચે છે, અને ત્યારપછી જ નક્કી કરવા માટે કન્ડિશન તપાસે છે કે લૂપ પાછું ચલાવવું કે નહીં.
તેની સિન્ટેક્સ (syntax) આ મુજબ દેખાય છે:
do {
// statements
} while ($condition);
while ક્લોઝ પછીના સેમીકોલન (semicolon) પર ધ્યાન આપો. તે સેમીકોલન જરૂરી છે, અને તેને ભૂલી જવાથી સિન્ટેક્સ એરર આવશે. do અને while વચ્ચેનો બ્લોક હંમેશા ઓછામાં ઓછી એક વાર એક્ઝિક્યુટ થાય છે, ભલે કન્ડિશન શરૂઆતથી જ ખોટી હોય. આ પોસ્ટ-ટેસ્ટ (post-test) વર્તણૂક માત્ર એક વિચિત્રતા નથી; તે આ લૂપના અસ્તિત્વનું મુખ્ય કારણ છે.
do-while નો ઉપયોગ ક્યારે કરવો
ત્રણ સામાન્ય પરિસ્થિતિઓ છે જ્યાં આ સ્ટ્રક્ચર ખૂબ ઉપયોગી સાબિત થાય છે: મેનૂ ડિસ્પ્લે કરવા માટે, ઇનપુટ વેલિડેટ કરવા માટે, અને નિષ્ફળ જઈ શકે તેવા કાર્યને ફરીથી પ્રયાસ (retry) કરવા માટે. દરેક કિસ્સામાં, લોજિક એવું માંગે છે કે તમે આગળ વધવું કે નહીં તે નક્કી કરતા પહેલા એક્શન થવી જોઈએ.
મેનૂ ડિસ્પ્લે કરવા માટે
કમાન્ડ-લાઇન ટૂલ અથવા ટેક્સ્ટ-આધારિત એડમિન પેનલની કલ્પના કરો. તમારે વિકલ્પોની યાદી પ્રિન્ટ કરવાની જરૂર છે, યુઝર એક વિકલ્પ પસંદ કરે તેની રાહ જોવી પડશે, અને પછી મેનૂ ફરીથી બતાવવું કે નહીં તે નક્કી કરવું પડશે. મેનૂ સ્ક્રીન પર દેખાય તે પહેલાં તમે યુઝરે '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) વેલ્યુ સાથે ઇનિશિયલાઇઝ કરવા માટે મજબૂર કરશે. આનાથી સંબંધિત લોજિક બે અલગ જગ્યાએ વિખરાઈ જાય છે. do-while વર્ઝન ડિસ્પ્લે, રીડ (read), અને ચેકને એક વ્યવસ્થિત બ્લોકની અંદર રાખે છે.
ઇનપુટ વેલિડેટ કરવા માટે
ઇનપુટ વેલિડેશન ઘણીવાર સમાન પેટર્ન અનુસરે છે. તમે યુઝરને પ્રોમ્પ્ટ (prompt) આપવા માંગો છો, તેમણે શું આપ્યું તેનું નિરીક્ષણ કરવા માંગો છો, અને જો તે તમારા નિયમોમાં નિષ્ફળ જાય તો તેને રિપીટ કરવા માંગો છો. કારણ કે નિરીક્ષણ કરતા પહેલા પ્રોમ્પ્ટ આવવો જ જોઈએ, તેથી 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 ને ખાલી સ્ટ્રિંગ સાથે સેટ કરવું પડશે અને કન્ડિશનને મૂલ્યાંકન કરવા માટે લૂપની ઉપર પ્રોમ્પ્ટ લાઇન ડુપ્લીકેટ કરવી પડશે. આ પુનરાવર્તન બગ્સ (bugs) ને આમંત્રણ આપે છે. જો તમે પાછળથી પ્રોમ્પ્ટ મેસેજ બદલો છો, તો તમે લૂપની અંદર તેને એડિટ કરવાનું યાદ રાખી શકો છો પરંતુ તેની ઉપરની કોપી ભૂલી શકો છો. do-while સ્ટ્રક્ચર કોઈપણ કન્ડિશન ટેસ્ટ કરતા પહેલા બ્લોકની અંદર પ્રોમ્પ્ટ ચાલે તેની ખાતરી કરીને તે જોખમ દૂર કરે છે.
નિષ્ફળ ગયેલા કાર્યને ફરીથી પ્રયાસ કરવા માટે
નેટવર્ક રિક્વેસ્ટ, ફાઇલ લોક્સ અને ડેટાબેઝ રાઇટ્સ ક્યારેક પ્રથમ પ્રયાસમાં નિષ્ફળ જાય છે પરંતુ થોડીવાર પછી સફળ થાય છે. તમે સામાન્ય રીતે ઓછામાં ઓછો એક પ્રયાસ કરવા માંગો છો, અને પછી જ્યાં સુધી નિષ્ફળતા ચાલુ રહે અને તમારી પાસે ધીરજ હોય ત્યાં સુધી પ્રયાસ ચાલુ રાખવા માંગો છો.
$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 લૂપને લૂપમાં પ્રવેશતા પહેલા એક ડમી (dummy) રિક્વેસ્ટ કરવી પડે અથવા ફેક સક્સેસ ફ્લેગ સેટ કરવો પડે, જે ખરેખર શું થઈ રહ્યું છે તેને અસ્પષ્ટ બનાવશે. do-while વર્ઝન ક્રમની પ્રમાણિકતા જાળવી રાખે છે: પ્રયાસ કરો, નિરીક્ષણ કરો અને નિર્ણય લો.
do-while અને while ની સરખામણી
આ બંને લૂપ્સ વચ્ચેનો તફાવત સમય (timing) નો છે. એવા વેરિયેબલનો વિચાર કરો જે એવી સ્થિતિમાં શરૂ થાય છે જે કોઈપણ ટેસ્ટમાં નિષ્ફળ જશે:
$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 સામાન્ય રીતે વધુ ક્લીન સાધન છે.
Pitfalls and Best Practices
કારણ કે do-while લૂપ ઓછામાં ઓછી એક વાર એક્ઝિક્યુશનની ખાતરી આપે છે, જો તમે સાવધ ન હોવ તો તે અનંત લૂપ (infinite loop) પણ બનાવી શકે છે. જો કન્ડિશનમાં તપાસવામાં આવતા વેરિયેબલ્સ બ્લોકની અંદર ક્યારેય બદલાતા નથી, તો PHP કાયમ માટે ચાલતું રહેશે અથવા જ્યાં સુધી તે મહત્તમ એક્ઝિક્યુશન સમય (maximum execution time) સુધી ન પહોંચી જાય ત્યાં સુધી ચાલશે.
બીજી સામાન્ય ભૂલ છે છેલ્લે સેમીકોલન (semicolon) ભૂલી જવું. નીચેનું ઉદાહરણ નિષ્ફળ જશે:
do {
// code
} while ($x < 5) // syntax error
જ્યારે અન્ય લૂપ વધુ સ્પષ્ટ હોય, ત્યારે માત્ર ટેવના કારણે do-while નો ઉપયોગ કરવાનું ટાળવું જોઈએ. જો તમે એરે (array) પર ઇટરેટ (iterate) કરી રહ્યા હોવ, તો foreach લગભગ હંમેશા શ્રેષ્ઠ છે. જો તમે સાદા ન્યુમેરિક કાઉન્ટર (numeric counter) ને મેનેજ કરી રહ્યા હોવ, તો for લૂપ ઇનિશિયલાઇઝેશન, કન્ડિશન અને ઇન્ક્રીમેન્ટને એક જ લાઇનમાં રાખે છે, જે વાંચવામાં સરળ છે.
પર્ફોર્મન્સની દ્રષ્ટિએ, PHP માં while ની સરખામણીમાં do-while માં કોઈ ખાસ ઓવરહેડ (overhead) નથી. તેનો ફાયદો સંપૂર્ણપણે સ્ટ્રક્ચરલ છે. જ્યારે અન્ય ડેવલપર do-while લૂપ જુએ છે, ત્યારે તેઓ તરત જ સમજી જાય છે કે કોઈપણ કન્ડિશન તપાસતા પહેલા બ્લોક ચલાવવો જ જોઈએ. આ એક માહિતી તેમને સ્ટાન્ડર્ડ while લૂપની ઉપર ડમી વેરિયેબલ્સ અથવા ડુપ્લીકેટ સેટઅપ કોડ ટ્રેસ કરવાથી બચાવે છે.
એજ કેસીસ (Edge Cases) અને વૈકલ્પિક પેટર્ન
ક્યારેક do-while લૂપ ત્યારે પણ ઉપયોગી હોય છે જ્યારે કોઈ યુઝર ઇન્ટરેક્શન સામેલ ન હોય. ઉદાહરણ તરીકે, જ્યારે તમે એવા જનરેટર (generator) અથવા કર્સર (cursor) નો ઉપયોગ કરી રહ્યા હોવ જે ઓછામાં ઓછી એક આઇટમ આપે છે, ત્યારે તમે પ્રથમ આઇટમ પ્રોસેસ કરી શકો છો અને પછી તપાસી શકો છો કે કર્સર યોગ્ય આગામી પોઝિશન પર આગળ વધ્યું છે કે નહીં. લેગસી કોડબેઝ (legacy codebases) માં જે આધુનિક રિઝલ્ટ સેટ્સને બદલે રો (raw) ડેટાબેઝ રિસોર્સિસનો ઉપયોગ કરે છે, ત્યાં તમે આ પ્રકારની પેટર્ન જોઈ શકો છો:
$row = $result->fetch();
do {
// process $row
} while ($row = $result->fetch());
જોકે આધુનિક PHP માં PDO સાથે foreach ને વધુ પસંદ કરવામાં આવે છે, પરંતુ આ પેટર્ન દર્શાવે છે કે કેવી રીતે do-while વધારાના બ્રાન્ચિંગ વગર પ્રથમ ઇટરેશનને એક વિશેષ કિસ્સા તરીકે હેન્ડલ કરે છે.
મુખ્ય સારાંશ
do-while લૂપ એક મર્યાદિત સાધન છે, પરંતુ યોગ્ય જગ્યાએ તે જ એકમાત્ર સાધન છે જે તર્કસંગત લાગે છે. તે તમારા સેટઅપ અને વેલિડેશન લોજિકને એક જ જગ્યાએ રાખે છે, ખાતરી આપે છે કે કોઈ પણ નિર્ણય લેતા પહેલા એક્શન લેવાનો પ્રયાસ કરવામાં આવે છે, અને કોડ વાંચનાર આગામી વ્યક્તિને તમારો હેતુ સીધો સમજાવે છે. જ્યારે કામ કર્યા પછી કન્ડિશન આવવી જરૂરી હોય, ત્યારે do-while નો ઉપયોગ કરો. અન્ય દરેક કિસ્સામાં, સરળ while, for, અથવા foreach ને કામ કરવા દો.