Control flow
કોમ્પ્યુટર વિજ્ઞાનમાં, નિયંત્રણ પ્રવાહ (અથવા નિયંત્રણનો પ્રવાહ) એ ક્રમ છે જેમાં અનિવાર્ય પ્રોગ્રામના વ્યક્તિગત નિવેદનો, સૂચનાઓ અથવા કાર્ય કૉલ્સને અમલમાં મૂકવામાં આવે છે અથવા તેનું મૂલ્યાંકન કરવામાં આવે છે. સ્પષ્ટ નિયંત્રણ પ્રવાહ પર ભાર મૂકવાથી અનિવાર્ય પ્રોગ્રામિંગ ભાષાને ઘોષણાત્મક પ્રોગ્રામિંગ ભાષાથી અલગ પડે છે. અનિવાર્ય પ્રોગ્રામિંગ ભાષામાં, નિયંત્રણ પ્રવાહ નિવેદન એ એક નિવેદન છે જે બે અથવા વધુ માર્ગોમાંથી કયા માર્ગને અનુસરવો તે પસંદ કરવામાં પરિણમે છે. બિન-કડક કાર્યાત્મક ભાષાઓ માટે, સમાન પરિણામ પ્રાપ્ત કરવા માટે કાર્યો અને ભાષાની રચનાઓ અસ્તિત્વમાં છે, પરંતુ તેમને સામાન્ય રીતે નિયંત્રણ પ્રવાહ નિવેદનો તરીકે ઓળખવામાં આવતા નથી. નિવેદનોના સમૂહને સામાન્ય રીતે બ્લોક તરીકે રચવામાં આવે છે, જે જૂથ ઉપરાંત, લેક્સિકલ અવકાશને પણ વ્યાખ્યાયિત કરે છે. વિક્ષેપો અને સંકેતો એ નિમ્ન-સ્તરની પદ્ધતિઓ છે જે સબરૂટીન જેવી જ રીતે નિયંત્રણના પ્રવાહમાં ફેરફાર કરી શકે છે, પરંતુ સામાન્ય રીતે ઇન-લાઇન કંટ્રોલ ફ્લો સ્ટેટમેન્ટના અમલને બદલે કેટલાક બાહ્ય ઉત્તેજના અથવા ઘટના (જે અસુમેળ રીતે થઈ શકે છે) ના પ્રતિભાવ તરીકે થાય છે. મશીન લેંગ્વેજ અથવા એસેમ્બલી લેંગ્વેજના સ્તરે, નિયંત્રણ પ્રવાહ સૂચનાઓ સામાન્ય રીતે પ્રોગ્રામ કાઉન્ટરમાં ફેરફાર કરીને કામ કરે છે. કેટલાક કેન્દ્રીય પ્રક્રિયા એકમો (CPU) માટે, એકમાત્ર ઉપલબ્ધ નિયંત્રણ પ્રવાહ સૂચનાઓ શરતી અથવા બિનશરતી શાખા સૂચનાઓ છે, જેને જમ્પ્સ પણ કહેવાય છે. શ્રેણીઓ વિવિધ ભાષાઓ દ્વારા સમર્થિત નિયંત્રણ પ્રવાહ નિવેદનોના પ્રકારો અલગ અલગ હોય છે, પરંતુ તેમની અસર દ્વારા વર્ગીકૃત કરી શકાય છેઃ અલગ નિવેદન પર ચાલુ રાખવું (બિનશરતી શાખા અથવા કૂદકો) નિવેદનોના સમૂહને ત્યારે જ અમલમાં મૂકવો જ્યારે કેટલીક શરતો પૂરી થાય (પસંદગી-એટલે કે, શરતી શાખા) નિવેદનોના સમૂહને શૂન્ય અથવા વધુ વખત અમલમાં મૂકવો, જ્યાં સુધી કેટલીક શરતો પૂરી ન થાય (એટલે કે, લૂપ-શરતી શાખા જેવું જ) દૂરના નિવેદનોના સમૂહને અમલમાં મૂકવો, જેના પછી નિયંત્રણનો પ્રવાહ સામાન્ય રીતે પાછો આવે છે (સબરૂટિન, કોરોટિન અને સાતત્ય) કાર્યક્રમને અટકાવવો, આગળના કોઈપણ અમલને અટકાવવો (બિનશરતી વિરામ) પ્રિમિટિવ્સ લેબલ્સ એક લેબલ એ સ્પષ્ટ નામ અથવા સંખ્યા છે જે નિશ્ચિત સ્થાનને સોંપવામાં આવે છે. લેબલ સ્રોત કોડની અંદરની સ્થિતિને ચિહ્નિત કરે છે અને તેની અન્ય કોઈ અસર નથી. રેખા સંખ્યાઓ કેટલીક ભાષાઓમાં (જેમ કે બેઝિક) ઉપયોગમાં લેવાતા નામના લેબલનો વિકલ્પ છે. તેઓ સ્રોત કોડમાં લખાણની દરેક લીટીની શરૂઆતમાં મૂકવામાં આવેલી સંપૂર્ણ સંખ્યાઓ છે. જે ભાષાઓ આનો ઉપયોગ કરે છે તે ઘણીવાર અવરોધ લાદતી હોય છે કે રેખા સંખ્યાઓ નીચેની દરેક રેખામાં મૂલ્યમાં વધારો થવો જોઈએ, પરંતુ તે જરૂરી નથી કે તેઓ સતત હોય. ઉદાહરણ તરીકે, બેઝિકમાંઃ 10 લેટ X = 3 20 પ્રિન્ટ X સી અને અદા જેવી અન્ય ભાષાઓમાં, લેબલ એક ઓળખકર્તા છે, જે સામાન્ય રીતે લીટીની શરૂઆતમાં દેખાય છે અને તરત જ કોલોન દ્વારા અનુસરવામાં આવે છે. ઉદાહરણ તરીકે, સીઃ સક્સેસઃ પ્રિન્ટએફ ("ઓપરેશન સફળ રહ્યું હતું. \n"); ALGOL 60 ભાષાએ સંપૂર્ણ સંખ્યાઓ અને ઓળખકર્તાઓ બંનેને લેબલ તરીકે મંજૂરી આપી હતી (બંને કોલોન દ્વારા નીચેના સ્ટેટમેન્ટ સાથે જોડાયેલા છે), પરંતુ જો કોઈ અન્ય ALGOL પ્રકારો સંપૂર્ણ સંખ્યાઓને મંજૂરી આપે તો થોડા. પ્રારંભિક ફોરટ્રાન સંકલનકારોએ માત્ર સંપૂર્ણ સંખ્યાઓને લેબલ તરીકે મંજૂરી આપી હતી. ફોરટ્રાન-90 થી શરૂ કરીને, આલ્ફાન્યૂમેરિક લેબલોને પણ મંજૂરી આપવામાં આવી છે. ગોટો નિવેદન (અંગ્રેજી શબ્દો ગો એન્ડ ટુ, અને તે મુજબ ઉચ્ચારવામાં આવે છે) એ નિયંત્રણના બિનશરતી હસ્તાંતરણનું સૌથી મૂળભૂત સ્વરૂપ છે. જો કે મુખ્ય શબ્દ ભાષાના આધારે ઉપલા અથવા નીચલા કેસમાં હોઈ શકે છે, તે સામાન્ય રીતે આ રીતે લખવામાં આવે છેઃ ગોટો લેબલ ગોટો નિવેદનની અસર એ છે કે આગામી નિવેદનને સૂચિત લેબલ પર (અથવા તરત પછી) દેખાતા નિવેદન તરીકે ચલાવવામાં આવે. ઘણા કોમ્પ્યુટર વૈજ્ઞાનિકો, ખાસ કરીને ડિજ્ક્સ્ટ્રા દ્વારા ગોટોના નિવેદનોને હાનિકારક માનવામાં આવ્યા છે. સબરૂટિન માટેની પરિભાષાઓ બદલાય છે; તેઓ વૈકલ્પિક રીતે દિનચર્યાઓ, પ્રક્રિયાઓ, કાર્યો (ખાસ કરીને જો તેઓ પરિણામો આપે તો) અથવા પદ્ધતિઓ (ખાસ કરીને જો તેઓ વર્ગો અથવા પ્રકાર વર્ગો સાથે સંબંધિત હોય તો) તરીકે ઓળખાય છે. 1950 ના દાયકામાં, વર્તમાન ધોરણો દ્વારા કમ્પ્યુટર મેમરી ખૂબ જ નાની હતી તેથી સબરૂટિનનો ઉપયોગ મુખ્યત્વે પ્રોગ્રામના કદને ઘટાડવા માટે કરવામાં આવતો હતો. કોડનો એક ભાગ એકવાર લખવામાં આવ્યો હતો અને પછી પ્રોગ્રામમાં અન્ય વિવિધ સ્થળોએથી ઘણી વખત તેનો ઉપયોગ કરવામાં આવ્યો હતો. આજે, સબરૂટિનનો ઉપયોગ પ્રોગ્રામને વધુ સંરચિત બનાવવામાં મદદ કરવા માટે થાય છે, દા. ત., કેટલાક અલ્ગોરિધમને અલગ કરીને અથવા કેટલીક ડેટા એક્સેસ પદ્ધતિને છુપાવીને. જો ઘણા પ્રોગ્રામરો એક પ્રોગ્રામ પર કામ કરી રહ્યા હોય, તો સબરૂટિન એક પ્રકારની મોડ્યુલરિટી છે જે કાર્યને વિભાજિત કરવામાં મદદ કરી શકે છે. ક્રમ સંરચિત પ્રોગ્રામિંગમાં, ક્રમિક આદેશોના ક્રમબદ્ધ ક્રમને મૂળભૂત નિયંત્રણ માળખામાંનું એક માનવામાં આવે છે, જેનો ઉપયોગ પુનરાવર્તન, પુનરાવર્તન અને પસંદગીની સાથે કાર્યક્રમો માટે બિલ્ડિંગ બ્લોક તરીકે થાય છે. ન્યૂનતમ સંરચિત નિયંત્રણ પ્રવાહ મે 1966માં, બોહમ અને જેકોપિનીએ કોમ્યુનિકેશન્સ ઓફ ધ એસીએમમાં એક લેખ પ્રકાશિત કર્યો હતો જેમાં દર્શાવવામાં આવ્યું હતું કે ગોટોસ સાથેના કોઈપણ પ્રોગ્રામને ગોટો-ફ્રી સ્વરૂપમાં રૂપાંતરિત કરી શકાય છે જેમાં માત્ર પસંદગી (જો પછી અન્ય) અને લૂપ્સ (WHILE શરત ડીઓ XXX) નો સમાવેશ થાય છે, સંભવતઃ ડુપ્લિકેટ કોડ અને/અથવા બુલિયન ચલો (સાચા/ખોટા ફ્લેગ્સ) ના ઉમેરા સાથે. પછીના લેખકોએ દર્શાવ્યું કે પસંદગીને લૂપ્સ (અને હજુ સુધી વધુ બુલિયન ચલ) દ્વારા બદલી શકાય છે. આવા લઘુતમ શક્ય છે તેનો અર્થ એ નથી કે તે જરૂરી ઇચ્છનીય છે; છેવટે, કોમ્પ્યુટર્સને સૈદ્ધાંતિક રીતે માત્ર એક જ મશીન સૂચનાની જરૂર છે (પરિણામ નકારાત્મક હોય તો એક નંબરને બીજામાંથી બાદ કરો અને શાખા કરો), પરંતુ વ્યવહારુ કમ્પ્યુટર્સમાં ડઝનેક અથવા તો સેંકડો મશીન સૂચનો પણ હોય છે. બોહમ અને જેકોપિનીના લેખમાં જે બતાવવામાં આવ્યું હતું તે એ હતું કે તમામ કાર્યક્રમો ગોટો-ફ્રી હોઈ શકે છે. અન્ય સંશોધનોએ દર્શાવ્યું હતું કે એક એન્ટ્રી અને એક એક્ઝિટ સાથે નિયંત્રણ માળખાં અન્ય કોઈપણ સ્વરૂપ કરતાં સમજવા માટે ખૂબ સરળ હતા, મુખ્યત્વે કારણ કે તેઓ નિયંત્રણ પ્રવાહને વિક્ષેપિત કર્યા વિના નિવેદન તરીકે ગમે ત્યાં ઉપયોગ કરી શકાય છે. બીજા શબ્દોમાં કહીએ તો, તેઓ શાંત હતા. (પછીના વિકાસ, જેમ કે બિન-કડક પ્રોગ્રામિંગ ભાષાઓ-અને તાજેતરમાં, કમ્પોઝેબલ સોફ્ટવેર વ્યવહારો-એ આ વ્યૂહરચના ચાલુ રાખી છે, જે પ્રોગ્રામના ઘટકોને વધુ મુક્ત રીતે કમ્પોઝેબલ બનાવે છે.) કેટલાક વિદ્વાનોએ બોહમ-જાકોપિની પરિણામ માટે શુદ્ધ અભિગમ અપનાવ્યો હતો અને દલીલ કરી હતી કે લૂપ્સની વચ્ચેથી વિરામ અને પરત ફરવા જેવી સૂચનાઓ પણ ખરાબ પ્રથા છે કારણ કે બોહમ-જાકોપિની સાબિતીમાં તેમની જરૂર નથી, અને આમ તેઓએ હિમાયત કરી હતી કે તમામ લૂપ્સમાં એક જ નિકાસ બિંદુ હોવું જોઈએ. આ શુદ્ધતાવાદી અભિગમ પાસ્કલ (1968-1969 માં રચાયેલ) ભાષામાં અંકિત છે, જે 1990 ના દાયકાના મધ્ય સુધી શિક્ષણવિદ્યામાં પ્રારંભિક પ્રોગ્રામિંગ શીખવવા માટે પસંદગીનું સાધન હતું. બોહમ-જેકોપિની પ્રમેયનો સીધો ઉપયોગ માળખાગત ચાર્ટમાં વધારાના સ્થાનિક ચલ રજૂ કરવામાં પરિણમી શકે છે, અને કેટલાક કોડ ડુપ્લિકેશનમાં પણ પરિણમી શકે છે. પાસ્કલ આ બંને સમસ્યાઓથી પ્રભાવિત છે અને એરિક એસ. રોબર્ટ્સ દ્વારા ટાંકવામાં આવેલા પ્રયોગમૂલક અભ્યાસો અનુસાર, વિદ્યાર્થી પ્રોગ્રામરોને પાસ્કલમાં કેટલીક સરળ સમસ્યાઓ માટે સાચા ઉકેલો ઘડવામાં મુશ્કેલી પડતી હતી, જેમાં એરેમાં તત્વ શોધવા માટે કાર્ય લખવાનો સમાવેશ થાય છે. રોબર્ટ્સ દ્વારા ટાંકવામાં આવેલા હેનરી શાપિરો દ્વારા 1980ના એક અભ્યાસમાં જાણવા મળ્યું હતું કે માત્ર પાસ્કલ દ્વારા પૂરી પાડવામાં આવેલ નિયંત્રણ માળખાનો ઉપયોગ કરીને, માત્ર 20 ટકા વિષયો દ્વારા સાચો ઉકેલ આપવામાં આવ્યો હતો, જ્યારે કોઈ પણ વિષય આ સમસ્યા માટે ખોટો કોડ લખતો ન હતો જો તેને લૂપની મધ્યમાંથી વળતર લખવાની મંજૂરી આપવામાં આવે. વ્યવહારમાં નિયંત્રણ માળખાં નિયંત્રણ માળખાં ધરાવતી મોટાભાગની પ્રોગ્રામિંગ ભાષાઓમાં પ્રારંભિક મુખ્ય શબ્દ હોય છે જે સામેલ નિયંત્રણ માળખાના પ્રકારને સૂચવે છે. ભાષાઓ પછી વિભાજિત થાય છે કે નિયંત્રણ માળખામાં અંતિમ મુખ્ય શબ્દ છે કે નહીં. કોઈ અંતિમ મુખ્ય શબ્દઃ એએલજીઓએલ 60, સી, સી + +, હાસ્કેલ, જાવા, પાસ્કલ, પર્લ, પીએચપી, પીએલ/આઈ, પાયથોન, પાવરશેલ. આવી ભાષાઓને નિવેદનોને એકસાથે જૂથબદ્ધ કરવાની કેટલીક રીતની જરૂર છેઃ ALGOL 60 અને પાસ્કલઃ પ્રારંભ. અંત C, C + +, જાવા, પર્લ, PHP, અને પાવરશેલઃ કર્લી કૌંસ {.} PL/I: Do. અંત પાયથોનઃ ઇન્ડેન્ટ સ્તરનો ઉપયોગ કરે છે (જુઓ ઓફ-સાઇડ નિયમ) હાસ્કેલઃ ક્યાં તો ઇન્ડેન્ટ સ્તર અથવા કર્લી કૌંસનો ઉપયોગ કરી શકાય છે, અને તેઓ મુક્તપણે મિશ્રિત થઈ શકે છે લુઆઃ ઉપયોગ કરે છે. અંતિમ મુખ્ય શબ્દઃ અદા, APL, ALGOL 68, મોડ્યુલા-2, ફોરટ્રાન 77, માઇથ્રિલ, વિઝ્યુઅલ બેઝિક. અંતિમ મુખ્ય શબ્દના સ્વરૂપો અલગ અલગ હોય છેઃ અદાઃ અંતિમ મુખ્ય શબ્દ છે અંત + જગ્યા + પ્રારંભિક મુખ્ય શબ્દ દા. ત., જો. અંત હોય તો, લૂપ. અંત લૂપ APL: અંતિમ મુખ્ય શબ્દ છેઃ વૈકલ્પિક રીતે અંત + પ્રારંભિક મુખ્ય શબ્દ, દા. ત.,: જો.: અંત અથવાઃ જો.: અંત કરો, પસંદ કરો.: અંત અથવાઃ પસંદ કરો.: અંત પસંદ કરો, જો કે, જો અંતિમ શરત ઉમેરવામાં આવે તો, અંતિમ મુખ્ય શબ્દ બની જાય છેઃ ALGOL 68 સુધી, મિથ્રિલઃ પ્રારંભિક મુખ્ય શબ્દની જોડણી પાછળની બાજુ, દા. ત., જો. ફાઈ, કેસ. ઇસાક ફોરટ્રાન 77: અંતિમ મુખ્ય શબ્દ છે END + પ્રારંભિક મુખ્ય શબ્દ દા. ત., IF., ENDIF, Do. અંત. જો. જો સમાપ્ત કરો; માટે. આગળ; કરો. લૂપ; જ્યારે. વેન્ડ ચોઇસ જો-તો-(અન્યથા) નિવેદનો શરતી અભિવ્યક્તિઓ અને શરતી રચનાઓ એ પ્રોગ્રામિંગ ભાષાની લાક્ષણિકતાઓ છે જે પ્રોગ્રામર-નિર્દિષ્ટ બુલિયન શરત સાચું કે ખોટું મૂલ્યાંકન કરે છે તેના આધારે વિવિધ ગણતરીઓ અથવા ક્રિયાઓ કરે છે. IF.GOTO. બિનસંરચિત ભાષાઓમાં જોવા મળતું ફોર્મ, લાક્ષણિક મશીન કોડ સૂચનાની નકલ કરીને, જ્યારે શરત પૂરી થાય ત્યારે લેબલ અથવા લાઇન નંબર (જીઓટીઓ) પર કૂદી જાય છે. IF.THEN. (ENDIF). કૂદકા સુધી મર્યાદિત રહેવાને બદલે, કોઈપણ સરળ નિવેદન અથવા નેસ્ટેડ બ્લોક, પછીના મુખ્ય શબ્દને અનુસરી શકે છે. આ એક સંરચિત સ્વરૂપ છે. IF.THEN.ELSE. (ENDIF). ઉપરની જેમ, પરંતુ જો શરત ખોટી હોય તો બીજી ક્રિયા સાથે. આ સૌથી સામાન્ય સ્વરૂપોમાંનું એક છે, જેમાં ઘણી વિવિધતાઓ છે. કેટલાકને ટર્મિનલ ENDIFની જરૂર પડે છે, અન્યને નહીં. સી અને સંબંધિત ભાષાઓને અંતિમ મુખ્ય શબ્દ અથવા 'પછી' ની જરૂર નથી, પરંતુ શરતની આસપાસ કૌંસની જરૂર પડે છે. શરતી નિવેદનો હોઈ શકે છે અને ઘણીવાર અન્ય શરતી નિવેદનોમાં સમાવિષ્ટ થઈ શકે છે. કેટલીક ભાષાઓ ELSE અને IF ને ELSEIF માં જોડવાની મંજૂરી આપે છે, સંયોજન નિવેદનના અંતે ENDIF અથવા અન્ય અંતિમ નિવેદનોની શ્રેણીની જરૂરિયાતને ટાળે છે. ઓછી સામાન્ય વિવિધતાઓમાં નીચેનાનો સમાવેશ થાય છેઃ કેટલીક ભાષાઓ, જેમ કે ફોરટ્રાન, ત્રિકોણીય અથવા અંકગણિત ધરાવે છે, જો આંકડાકીય મૂલ્ય હકારાત્મક, નકારાત્મક અથવા શૂન્ય છે કે કેમ તે ચકાસવામાં આવે. કેટલીક ભાષાઓમાં આઇએફ સ્ટેટમેન્ટનું કાર્યાત્મક સ્વરૂપ હોય છે, ઉદાહરણ તરીકે લિસ્પનું કોન્ડ. કેટલીક ભાષાઓમાં આઇએફ સ્ટેટમેન્ટનું ઓપરેટર સ્વરૂપ હોય છે, જેમ કે સીનું ત્રિમાસિક ઓપરેટર. પર્લ સી-શૈલીને પૂરક બનાવે છે જો ક્યારે અને જ્યાં સુધી નહીં. સ્મોલટૉક કોઈપણ મૂળભૂત ભાષા રચનાને બદલે શરતી અમલીકરણ માટે આઇએફ ટ્રુ અને આઇએફ ફોલ્સ સંદેશાનો ઉપયોગ કરે છે. કેસ અને સ્વિચ સ્ટેટમેન્ટ સ્વિચ સ્ટેટમેન્ટ (અથવા કેસ સ્ટેટમેન્ટ, અથવા મલ્ટીવે શાખાઓ) આપેલ મૂલ્યની ચોક્કસ અચળાંકો સાથે સરખામણી કરે છે અને મેળ ખાતા પ્રથમ અચળાંકો અનુસાર પગલાં લે છે. જો કોઈ મેચ સફળ ન થાય તો સામાન્ય રીતે ડિફોલ્ટ એક્શન ("અન્યથા", "અન્યથા") લેવાની જોગવાઈ હોય છે. સ્વિચ સ્ટેટમેન્ટ કમ્પાઇલર ઓપ્ટિમાઇઝેશનને મંજૂરી આપી શકે છે, જેમ કે લુકઅપ કોષ્ટકો. ગતિશીલ ભાષાઓમાં, કિસ્સાઓ સતત અભિવ્યક્તિઓ સુધી મર્યાદિત ન હોઈ શકે, અને જમણી બાજુના શેલ સ્ક્રિપ્ટના ઉદાહરણની જેમ પેટર્ન મેચિંગ સુધી વિસ્તરી શકે છે, જ્યાં *) ડિફોલ્ટ કેસને કોઈપણ સ્ટ્રિંગ સાથે મેળ ખાતા ગ્લોબ તરીકે લાગુ કરે છે. એસક્યુએલના ડીકોડ સ્ટેટમેન્ટની જેમ કેસ લોજિકને કાર્યાત્મક સ્વરૂપમાં પણ લાગુ કરી શકાય છે. લૂપ એ નિવેદનોની શ્રેણી છે જે એકવાર નિર્દિષ્ટ કરવામાં આવે છે પરંતુ જે એક પછી એક ઘણી વખત હાથ ધરવામાં આવી શકે છે. લૂપની અંદરનો કોડ (લૂપનો મુખ્ય ભાગ, નીચે XXX તરીકે દર્શાવવામાં આવ્યો છે) ચોક્કસ સંખ્યામાં, અથવા વસ્તુઓના દરેક સંગ્રહ માટે એક વાર, અથવા કોઈ શરત પૂરી ન થાય ત્યાં સુધી, અથવા અનિશ્ચિત સમય સુધી પાલન કરવામાં આવે છે. હાસ્કેલ અને સ્કીમ જેવી કાર્યાત્મક પ્રોગ્રામિંગ ભાષાઓમાં, પુનરાવર્તિત અને પુનરાવર્તિત બંને પ્રક્રિયાઓ વાક્યરચનાત્મક લૂપિંગ રચનાઓને બદલે પૂંછડી પુનરાવર્તિત પ્રક્રિયાઓ સાથે વ્યક્ત કરવામાં આવે છે. ગણતરી-નિયંત્રિત લૂપ્સ મોટાભાગની પ્રોગ્રામિંગ ભાષાઓમાં લૂપને ચોક્કસ સંખ્યામાં પુનરાવર્તન કરવા માટેની રચનાઓ હોય છે. મોટાભાગના કિસ્સાઓમાં ગણતરી ઉપરની તરફ જવાને બદલે નીચે તરફ જઈ શકે છે અને 1 સિવાયના પગલાના કદનો ઉપયોગ કરી શકાય છે. આ ઉદાહરણોમાં, જો N <1 હોય તો લૂપનો મુખ્ય ભાગ પ્રોગ્રામિંગ ભાષાના આધારે એકવાર (I ની કિંમત 1 સાથે) ચલાવી શકે છે અથવા બિલકુલ નહીં. ઘણી પ્રોગ્રામિંગ ભાષાઓમાં, ગણતરી-નિયંત્રિત લૂપમાં માત્ર પૂર્ણાંકોનો વિશ્વસનીય રીતે ઉપયોગ કરી શકાય છે. ફ્લોટિંગ-પોઇન્ટ નંબરો હાર્ડવેરની મર્યાદાઓને કારણે અચોક્કસ રીતે રજૂ કરવામાં આવે છે, તેથી X: = 0.1 પગલું 0.1 થી 1.0 ડૂ જેવા લૂપને ગોળાકાર ભૂલો અને/અથવા હાર્ડવેર અને/અથવા કમ્પાઇલર સંસ્કરણના આધારે 9 અથવા 10 વખત પુનરાવર્તિત કરી શકાય છે. વધુમાં, જો X નો વધારો પુનરાવર્તિત ઉમેરા દ્વારા થાય છે, તો સંચિત ગોળાકાર ભૂલોનો અર્થ એ થઈ શકે છે કે દરેક પુનરાવર્તનમાં X નું મૂલ્ય અપેક્ષિત ક્રમ 0.1,2,0.3,0.0 થી નોંધપાત્ર રીતે અલગ હોઈ શકે છે. શરતી-નિયંત્રિત લૂપ્સ મોટાભાગની પ્રોગ્રામિંગ ભાષાઓમાં કેટલીક શરતો બદલાય ત્યાં સુધી લૂપનું પુનરાવર્તન કરવા માટેની રચનાઓ હોય છે. કેટલાક ફેરફારો લૂપની શરૂઆતમાં સ્થિતિનું પરીક્ષણ કરે છે; અન્ય લોકો અંતે તેનું પરીક્ષણ કરે છે. જો પરીક્ષણ શરૂઆતમાં હોય, તો શરીર સંપૂર્ણપણે છોડી શકાય છે; જો તે અંતે હોય, તો શરીર હંમેશા ઓછામાં ઓછું એક વાર ચલાવવામાં આવે છે. નિયંત્રણ વિરામ એ મૂલ્યોના જૂથો માટે પ્રક્રિયાને ટ્રિગર કરવા માટે સામાન્ય લૂપ્સમાં ઉપયોગમાં લેવાતી મૂલ્ય પરિવર્તન શોધ પદ્ધતિ છે. લૂપની અંદર મૂલ્યોની દેખરેખ રાખવામાં આવે છે અને ફેરફાર તેમની સાથે સંકળાયેલ જૂથ ઇવેન્ટના સંચાલન માટે પ્રોગ્રામના પ્રવાહને ડાયવર્ટ કરે છે. (ફાઇલનો અંત) જો નવો-ઝિપકોડ <> વર્તમાન-ઝિપકોડ ડિસ્પ્લે _ ટેલી (વર્તમાન-ઝિપકોડ, ઝિપકાઉન્ટ) વર્તમાન-ઝિપકોડ = નવા-ઝિપકોડ ઝિપકાઉન્ટ = 0 ENDIF ઝિપકાઉન્ટ + + લૂપ સંગ્રહ-નિયંત્રિત લૂપ્સ હોય તો કેટલીક પ્રોગ્રામિંગ ભાષાઓ (દા. ત., અદા, ડી, સી + + 11, સ્મોલટૉક, PHP, પર્લ, ઓબ્જેક્ટ પાસ્કલ, જાવા, સી #, MATLAB, વિઝ્યુઅલ બેઝિક, રૂબી, પાયથોન, જાવાસ્ક્રિપ્ટ, ફોરટ્રાન 95 અને પછીની) માં વિશેષ રચનાઓ હોય છે જે એરેના તમામ ઘટકો અથવા બધા દ્વારા ગર્ભિત લૂપિંગને મંજૂરી આપે છે. કેટલાક સંગ્રહોઃ [: eachElement |xxx]. સંગ્રહમાં આઇટમ માટે XXX અંત શરૂ કરો; ફોરએચ (આઇટમ; માયકોલેક્શન) {XXX} કેટલાક એરે ફોરચ ($કેટલાક એરે તરીકે $k => $v) {XXX} સંગ્રહ <સ્ટ્રિંગ> કોલ; માટે (સ્ટ્રિંગ s: કોલ) {} ફોરચ (સ્ટ્રિંગ s ઇન માયસ્ટ્રિંગકોલેક્શન) {XXX} કેટલાક સંગ્રહ | દરેક-ઑબ્જેક્ટ માટે {$_} ફોરલ (અનુક્રમણિકા = પ્રથમઃ છેલ્લુંઃ પગલું.) સ્કાલામાં અભિવ્યક્તિઓ છે, જે સંગ્રહ-નિયંત્રિત લૂપ્સને સામાન્ય બનાવે છે, અને અન્ય ઉપયોગોને પણ સમર્થન આપે છે, જેમ કે એસિંક્રોનસ પ્રોગ્રામિંગ. હાસ્કેલ પાસે કરો-અભિવ્યક્તિઓ અને સમજણ છે, જે એકસાથે સ્કાલામાં અભિવ્યક્તિઓ માટે સમાન કાર્ય પ્રદાન કરે છે. સામાન્ય પુનરાવર્તન સામાન્ય પુનરાવર્તન રચનાઓ જેમ કે C 's for સ્ટેટમેન્ટ અને કોમન લિસ્પના ડુ ફોર્મનો ઉપયોગ ઉપરોક્ત કોઈપણ પ્રકારની લૂપ્સને વ્યક્ત કરવા માટે કરી શકાય છે, અને અન્ય, જેમ કે સમાંતર કેટલાક સંગ્રહો પર લૂપિંગ. જ્યાં વધુ ચોક્કસ લૂપિંગ રચનાનો ઉપયોગ કરી શકાય છે, તે સામાન્ય રીતે સામાન્ય પુનરાવર્તન રચના કરતાં પસંદ કરવામાં આવે છે, કારણ કે તે ઘણીવાર અભિવ્યક્તિનો હેતુ સ્પષ્ટ કરે છે. અનંત લૂપ્સ અનંત લૂપ્સનો ઉપયોગ પ્રોગ્રામ સેગમેન્ટ લૂપ્સને કાયમ માટે અથવા જ્યાં સુધી કોઈ અપવાદરૂપ સ્થિતિ ઊભી ન થાય ત્યાં સુધી ખાતરી આપવા માટે થાય છે, જેમ કે ભૂલ. દાખલા તરીકે, ઇવેન્ટ-સંચાલિત પ્રોગ્રામ (જેમ કે સર્વર) એ કાયમ માટે લૂપ કરવો જોઈએ, ઇવેન્ટ્સ જેમ થાય તેમ તેનું સંચાલન કરવું જોઈએ, જ્યારે ઓપરેટર દ્વારા પ્રક્રિયા સમાપ્ત થાય ત્યારે જ બંધ થવું જોઈએ. અનંત લૂપ્સ અન્ય નિયંત્રણ પ્રવાહ રચનાઓનો ઉપયોગ કરીને અમલમાં મૂકી શકાય છે. સૌથી સામાન્ય રીતે, અનસ્ટ્રક્ચર્ડ પ્રોગ્રામિંગમાં આ જમ્પ બેક અપ (ગોટો) છે, જ્યારે સ્ટ્રક્ચર્ડ પ્રોગ્રામિંગમાં આ અનિશ્ચિત લૂપ (વાઇલ લૂપ) છે જે ક્યારેય સમાપ્ત થતું નથી, ક્યાં તો શરતને બાદ કરીને અથવા સ્પષ્ટ રીતે તેને વાઇલ (સાચું) તરીકે સાચવીને. કેટલીક ભાષાઓમાં અનંત લૂપ્સ માટે વિશેષ રચનાઓ હોય છે, સામાન્ય રીતે અનિશ્ચિત લૂપમાંથી શરતને દૂર કરીને. ઉદાહરણોમાં અદા (લૂપ. એન્ડ લૂપ), ફોરટ્રાન (ડીઓ. એન્ડ ડીઓ), ગો ({.} માટે) અને રૂબી (લૂપ ડુ. એન્ડ) નો સમાવેશ થાય છે. ઘણીવાર, અનંત લૂપ અજાણતાં સ્થિતિ-નિયંત્રિત લૂપમાં પ્રોગ્રામિંગ ભૂલ દ્વારા બનાવવામાં આવે છે, જેમાં લૂપની સ્થિતિ એવા ચલોનો ઉપયોગ કરે છે જે લૂપની અંદર ક્યારેય બદલાતા નથી. આગામી પુનરાવર્તન સાથે સાતત્ય કેટલીકવાર લૂપના મુખ્ય ભાગની અંદર લૂપ બોડીના બાકીના ભાગને છોડવાની અને લૂપના આગામી પુનરાવર્તન સાથે ચાલુ રાખવાની ઇચ્છા હોય છે. કેટલીક ભાષાઓ નિવેદન પૂરું પાડે છે જેમ કે ચાલુ રાખો (મોટાભાગની ભાષાઓ), અવગણો, ચક્ર (ફોરટ્રાન), અથવા આગામી (પર્લ અને રૂબી), જે આ કરશે. અસર એ છે કે સૌથી અંદરની લૂપ બોડીને અકાળે સમાપ્ત કરવી અને પછી આગામી પુનરાવર્તન સાથે સામાન્ય રીતે ફરી શરૂ કરવી. જો પુનરાવર્તન લૂપમાં છેલ્લું હોય, તો અસર એ છે કે સમગ્ર લૂપને વહેલી તકે સમાપ્ત કરવું. વર્તમાન પુનરાવર્તન ફરીથી કરો કેટલીક ભાષાઓ, જેમ કે પર્લ અને રૂબીમાં ફરીથી નિવેદન હોય છે જે શરૂઆતથી વર્તમાન પુનરાવર્તનને ફરીથી શરૂ કરે છે. રીસ્ટાર્ટ લૂપ રુબી પાસે રીટ્રી સ્ટેટમેન્ટ છે જે પ્રારંભિક પુનરાવર્તનથી સમગ્ર લૂપને પુનઃપ્રારંભ કરે છે. લૂપમાંથી વહેલા બહાર નીકળો ટેબલમાં શોધવા માટે ગણતરી-નિયંત્રિત લૂપનો ઉપયોગ કરતી વખતે, જરૂરી વસ્તુ મળતાની સાથે જ શોધ કરવાનું બંધ કરવું ઇચ્છનીય હોઈ શકે છે. કેટલીક પ્રોગ્રામિંગ ભાષાઓ વિરામ (મોટાભાગની ભાષાઓ), બહાર નીકળો (વિઝ્યુઅલ બેઝિક), અથવા છેલ્લું (પર્લ) જેવા નિવેદન પ્રદાન કરે છે, જેની અસર વર્તમાન લૂપને તરત જ સમાપ્ત કરવાની હોય છે, અને તે લૂપ પછી તરત જ નિવેદનમાં નિયંત્રણ સ્થાનાંતરિત કરવાની હોય છે. અર્લી-એક્ઝિટ લૂપ્સ માટેનો બીજો શબ્દ લૂપ-એન્ડ-એ-હાફ છે. નીચેનું ઉદાહરણ એડામાં કરવામાં આવ્યું છે જે મધ્યમાં પરીક્ષણ સાથે લૂપ્સ અને લૂપ્સમાંથી વહેલી બહાર નીકળવાનું સમર્થન કરે છે. બંને સુવિધાઓ ખૂબ સમાન છે અને બંને કોડ સ્નિપેટ્સની સરખામણી કરવાથી તફાવત દેખાશેઃ પ્રારંભિક બહાર નીકળવાને આઇએફ સ્ટેટમેન્ટ સાથે જોડવું આવશ્યક છે જ્યારે મધ્યમાં શરત એ સ્વ-સમાવિષ્ટ રચના છે. Ada.Text IO સાથે; Ada.Integer ટેક્સ્ટ IO સાથે; પ્રક્રિયા પ્રિન્ટ _ સ્ક્વેર્સ એ X: પૂર્ણાંક છે; શરૂ કરો રીડ _ ડેટાઃ લૂપ Ada.Integer ટેક્સ્ટ IO.Get (X); બહાર નીકળો રીડ _ ડેટા જ્યારે X = 0; Ada.Text IO.Put (X * X); Ada.Text IO.New_Line; એન્ડ લૂપ રીડ _ ડેટા; એન્ડ પ્રિન્ટ _ સ્ક્વેર્સ; પાયથોન કોડના શરતી અમલને ટેકો આપે છે, તેના આધારે કે લૂપ વહેલા બહાર નીકળી ગયું હતું (બ્રેક સ્ટેટમેન્ટ સાથે) કે નહીં. ઉદાહરણ તરીકે, સેટ _ ઓફ _ નંબર્સમાં n માટેઃ જો પ્રાઇમ (n) હોય તો પ્રિન્ટ કરો ("સેટમાં પ્રાઇમ નંબર હોય છે") અન્યને તોડોઃ પ્રિન્ટ કરો ("સેટમાં કોઈ પ્રાઇમ નંબર ન હોય") ઉપરોક્ત ઉદાહરણમાં અન્ય કલમ ફોર સ્ટેટમેન્ટ સાથે જોડાયેલી છે, અને આંતરિક ઇફ્ સ્ટેટમેન્ટ સાથે નહીં. પાયથોનના ફોર અને વાઇલ લૂપ્સ બંને આવા અન્ય કલમને ટેકો આપે છે, જે લૂપની વહેલી બહાર ન નીકળ્યા હોય તો જ ચલાવવામાં આવે છે. કેટલીક ભાષાઓ નેસ્ટેડ લૂપ્સમાંથી બહાર નીકળવાનું સમર્થન કરે છે; સિદ્ધાંત વર્તુળોમાં, આને બહુ-સ્તરના વિરામ કહેવામાં આવે છે. એક સામાન્ય ઉપયોગનું ઉદાહરણ બહુ-પરિમાણીય કોષ્ટક શોધવાનું છે. આ ક્યાં તો બહુસ્તરીય વિરામ (એન સ્તરોમાંથી બહાર નીકળો) દ્વારા કરી શકાય છે, જેમ કે બાશ અને પીએચપીમાં, અથવા જાવા અને પર્લની જેમ લેબલ બ્રેક (બ્રેક આઉટ અને આપેલ લેબલ પર ચાલુ રાખો) દ્વારા કરી શકાય છે. બહુસ્તરીય વિરામના વિકલ્પોમાં સિંગલ બ્રેકનો સમાવેશ થાય છે, જેમાં સ્ટેટ વેરિયેબલનો સમાવેશ થાય છે, જેનું પરીક્ષણ બીજા સ્તરને તોડવા માટે કરવામાં આવે છે; અપવાદો, જે વિભાજિત કરવામાં આવતા સ્તર પર પકડાય છે; કાર્યમાં નેસ્ટેડ લૂપ્સ મૂકવા અને સમગ્ર નેસ્ટેડ લૂપની અસર સમાપ્તિ પર વળતરનો ઉપયોગ કરવો; અથવા લેબલ અને ગોટો સ્ટેટમેન્ટનો ઉપયોગ કરવો. સીમાં બહુસ્તરીય વિરામનો સમાવેશ થતો નથી, અને સામાન્ય વિકલ્પ લેબલ થયેલ વિરામને અમલમાં મૂકવા માટે ગોટો નો ઉપયોગ કરવાનો છે. પાયથોનમાં બહુસ્તરીય વિરામ અથવા સાતત્ય નથી-આની દરખાસ્ત પી. ઈ. પી. 3136માં કરવામાં આવી હતી, અને ઉમેરવામાં આવેલી જટિલતા દુર્લભ કાયદેસર ઉપયોગ માટે યોગ્ય ન હતી તેના આધારે તેને નકારી કાઢવામાં આવી હતી. બહુ-સ્તરના વિરામની કલ્પનાને સૈદ્ધાંતિક કોમ્પ્યુટર વિજ્ઞાનમાં થોડો રસ છે, કારણ કે તે આજે જેને કોસરાજુ પદાનુક્રમ કહેવામાં આવે છે તેને જન્મ આપે છે. 1973માં એસ. રાવ કોસરાજુએ સ્ટ્રક્ચર્ડ પ્રોગ્રામ થીયરમને સુધારીને સાબિત કર્યું કે સ્ટ્રક્ચર્ડ પ્રોગ્રામિંગમાં વધારાના ચલ ઉમેરવાનું ટાળવું શક્ય છે, જ્યાં સુધી લૂપ્સમાંથી મનસ્વી-ઊંડાણ, બહુ-સ્તરના વિરામની મંજૂરી છે. વધુમાં, કોસરાજુએ સાબિત કર્યું કે પ્રોગ્રામ્સનું કડક પદાનુક્રમ અસ્તિત્વમાં છેઃ દરેક પૂર્ણાંક n માટે, ઊંડાઈ n નો બહુ-સ્તર વિરામ ધરાવતો એક પ્રોગ્રામ અસ્તિત્વમાં છે જેને વધારાના ચલ રજૂ કર્યા વિના n કરતા ઓછી ઊંડાઈના બહુ-સ્તરના વિરામ સાથે પ્રોગ્રામ તરીકે ફરીથી લખી શકાતો નથી. નેસ્ટેડ લૂપ અને સબરૂટિન બંનેમાંથી બહાર નીકળીને, લૂપ કરેલા નિવેદનોને ચલાવતી સબરૂટિનમાંથી પણ બહાર આવી શકે છે. બહુવિધ વિરામ માટે અન્ય સૂચિત નિયંત્રણ માળખાં છે, પરંતુ આ સામાન્ય રીતે તેના બદલે અપવાદ તરીકે લાગુ કરવામાં આવે છે. તેમના 2004 ના પાઠ્યપુસ્તકમાં, ડેવિડ વોટ્ટે બહુ-સ્તરના વિરામ અને વળતરના નિવેદનો વચ્ચેની સમાનતાને સમજાવવા માટે ટેનેન્ટની સિક્વેન્સરની કલ્પનાનો ઉપયોગ કર્યો છે. વોટ નોંધે છે કે એસ્કેપ સિક્વન્સર્સ તરીકે ઓળખાતા સિક્વન્સર્સનો એક વર્ગ, જેને "સિક્વન્સર્સ કે જે લખાણને સંલગ્ન આદેશ અથવા પ્રક્રિયાના અમલને સમાપ્ત કરે છે" તરીકે વ્યાખ્યાયિત કરવામાં આવે છે, તેમાં લૂપ્સના વિરામ (બહુ-સ્તરના વિરામ સહિત) અને વળતર નિવેદનો બંનેનો સમાવેશ થાય છે. સામાન્ય રીતે અમલમાં મુકવામાં આવે છે તેમ, વળતર અનુક્રમણિકાઓ પણ (વળતર) મૂલ્ય ધરાવે છે, જ્યારે સમકાલીન ભાષાઓમાં અમલમાં મુકવામાં આવેલ વિરામ અનુક્રમણિકા સામાન્ય રીતે કરી શકાતી નથી. લૂપ વેરિઅન્ટ અને અપરિવર્તનશીલ લૂપ વેરિઅન્ટ અને લૂપ અપરિવર્તનશીલનો ઉપયોગ લૂપની શુદ્ધતા વ્યક્ત કરવા માટે થાય છે. વ્યવહારુ દ્રષ્ટિએ, લૂપ વેરિઅન્ટ એ એક પૂર્ણાંક અભિવ્યક્તિ છે જે પ્રારંભિક બિન-નકારાત્મક મૂલ્ય ધરાવે છે. દરેક લૂપ પુનરાવર્તન દરમિયાન વેરિઅન્ટનું મૂલ્ય ઘટવું આવશ્યક છે પરંતુ લૂપના યોગ્ય અમલ દરમિયાન તે ક્યારેય નકારાત્મક ન બનવું જોઈએ. લૂપના પ્રકારોનો ઉપયોગ લૂપ્સ સમાપ્ત થશે તેની ખાતરી કરવા માટે થાય છે. લૂપ ઇનવેરિયન્ટ એ એક એવો દાવો છે જે પ્રથમ લૂપ પુનરાવર્તન પહેલાં સાચો હોવો જોઈએ અને દરેક પુનરાવર્તન પછી સાચો રહેવો જોઈએ. આ સૂચવે છે કે જ્યારે લૂપ યોગ્ય રીતે સમાપ્ત થાય છે, ત્યારે બહાર નીકળવાની સ્થિતિ અને લૂપ અપરિવર્તન બંને સંતુષ્ટ થાય છે. લૂપ અપરિવર્તનોનો ઉપયોગ ક્રમિક પુનરાવર્તનો દરમિયાન લૂપના ચોક્કસ ગુણધર્મોનું નિરીક્ષણ કરવા માટે થાય છે. કેટલીક પ્રોગ્રામિંગ ભાષાઓ, જેમ કે એફિલ લૂપ સ્વરૂપો અને અપરિવર્તન માટે મૂળ આધાર ધરાવે છે. અન્ય કિસ્સાઓમાં, સપોર્ટ એ એડ-ઓન છે, જેમ કે જાવામાં લૂપ સ્ટેટમેન્ટ માટે જાવા મોડેલિંગ લેંગ્વેજનું સ્પષ્ટીકરણ. લૂપ ઉપભાષા કેટલીક લિસ્પ બોલીઓ લૂપનું વર્ણન કરવા માટે વ્યાપક ઉપભાષા પ્રદાન કરે છે. પ્રારંભિક ઉદાહરણ ઇન્ટરલિસ્પના કન્વર્ઝનલ લિસ્પમાં મળી શકે છે. કોમન લિસ્પ લૂપ મેક્રો પ્રદાન કરે છે જે આવી ઉપભાષાનો અમલ કરે છે. લૂપ સિસ્ટમ ક્રોસ-રેફરન્સ ટેબલ જ્યારે (સાચું) આ હેતુ માટે અનંત લૂપ તરીકે ગણવામાં આવતું નથી, કારણ કે તે સમર્પિત ભાષાનું માળખું નથી. C 's for (init; પરીક્ષણ; વૃદ્ધિ) લૂપ એ એક સામાન્ય લૂપ રચના છે, ખાસ કરીને ગણતરી માટે નહીં, જો કે તે ઘણીવાર તેના માટે વપરાય છે. લેબલ અને ગોટોના ઉપયોગ દ્વારા એપીએલ, સી, સી + + અને સી #માં ઊંડા વિરામ પૂર્ણ કરી શકાય છે. પદાર્થો પર પુનરાવર્તન PHP 5 માં ઉમેરવામાં આવ્યું હતું. ગણતરી લૂપને વૃદ્ધિ સૂચિ અથવા જનરેટર પર પુનરાવર્તન કરીને અનુકરણ કરી શકાય છે, ઉદાહરણ તરીકે, પાયથોનની શ્રેણી (). ઊંડા વિરામ અપવાદ હેન્ડલિંગના ઉપયોગ દ્વારા પૂર્ણ કરી શકાય છે. ત્યાં કોઈ વિશેષ રચના નથી, કારણ કે આ માટે વાઇલ ફંક્શનનો ઉપયોગ કરી શકાય છે. ત્યાં કોઈ વિશેષ રચના નથી, પરંતુ વપરાશકર્તાઓ સામાન્ય લૂપ કાર્યોને વ્યાખ્યાયિત કરી શકે છે. સી + + 11 સ્ટાન્ડર્ડ માટે શ્રેણી-આધારિત રજૂ કરે છે. એસટીએલમાં, દરેક નમૂના કાર્ય માટે એક એસટીડીઃ: છે જે એસટીએલ કન્ટેનર પર પુનરાવર્તન કરી શકે છે અને દરેક તત્વ માટે યુનરી કાર્યને કૉલ કરી શકે છે. આ કન્ટેનર પર કાર્યક્ષમતાને મેક્રો તરીકે પણ બનાવી શકાય છે. ગણતરી-નિયંત્રિત લૂપિંગ પૂર્ણાંક અંતરાલમાં પુનરાવર્તન દ્વારા પ્રભાવિત થાય છે; બહાર નીકળવા માટેની વધારાની શરતનો સમાવેશ કરીને વહેલા બહાર નીકળો. એફિલ આરક્ષિત શબ્દ પુનઃપ્રયાસને ટેકો આપે છે, જો કે તેનો ઉપયોગ લૂપ નિયંત્રણમાં નહીં પણ અપવાદ સંચાલનમાં થાય છે. જાવા મોડેલિંગ લેંગ્વેજ (જે. એમ. એલ.) વર્તણૂકીય ઇન્ટરફેસ સ્પષ્ટીકરણ ભાષાની જરૂર છે. લૂપ સ્વરૂપો પૂર્ણાંકો હોવા જરૂરી છે; ટ્રાન્સફાઇનાઇટ સ્વરૂપો આધારભૂત નથી. ડી અનંત સંગ્રહો અને તે સંગ્રહો પર પુનરાવર્તન કરવાની ક્ષમતાને ટેકો આપે છે. આ માટે કોઈ ખાસ બાંધકામની જરૂર નથી. ગો ટુ અને પ્રક્રિયાઓનો ઉપયોગ કરીને ઊંડા વિરામ પ્રાપ્ત કરી શકાય છે. કોમન લિસ્પ સામાન્ય સંગ્રહ પ્રકારનો ખ્યાલ રજૂ કરે છે. માળખાગત બિન-સ્થાનિક નિયંત્રણ પ્રવાહ ઘણી પ્રોગ્રામિંગ ભાષાઓ, ખાસ કરીને પ્રોગ્રામિંગની વધુ ગતિશીલ શૈલીઓની તરફેણ કરતી, બિન-સ્થાનિક નિયંત્રણ પ્રવાહ માટે રચનાઓ પ્રદાન કરે છે. આ કારણે અમલનો પ્રવાહ આપેલ સંદર્ભમાંથી બહાર નીકળી જાય છે અને અમુક પૂર્વઘોષિત બિંદુ પર ફરી શરૂ થાય છે. શરતો, અપવાદો અને સાતત્ય એ બિન-સ્થાનિક નિયંત્રણ રચનાઓના ત્રણ સામાન્ય પ્રકારો છે; વધુ વિચિત્ર રચનાઓ પણ અસ્તિત્વમાં છે, જેમ કે જનરેટર, કોરોટીન્સ અને એસિંક મુખ્ય શબ્દ. શરતો પી. એલ./આઈ. માં કેટલીક 22 પ્રમાણભૂત શરતો છે (દા. ત., ઝીરોડીવીડ સબસ્ક્રીપ્ટ્રેન્જ એન્ડીફાઇલ) જેને વધારી શકાય છે અને જેને નીચેની શરતોની ક્રિયા દ્વારા અટકાવી શકાય છે; પ્રોગ્રામરો તેમની પોતાની નામવાળી શરતોને વ્યાખ્યાયિત કરી શકે છે અને તેનો ઉપયોગ પણ કરી શકે છે. અનસ્ટ્રક્ચર્ડ ઇફની જેમ, માત્ર એક જ નિવેદન નિર્દિષ્ટ કરી શકાય છે તેથી ઘણા કિસ્સાઓમાં નિયંત્રણનો પ્રવાહ ક્યાં ફરી શરૂ થવો જોઈએ તે નક્કી કરવા માટે જીઓટીઓની જરૂર પડે છે. કમનસીબે, કેટલાક અમલીકરણમાં જગ્યા અને સમય બંનેમાં નોંધપાત્ર ઓવરહેડ હતું (ખાસ કરીને સબ્સ્ક્રિપ્ટરેન્જ), તેથી ઘણા પ્રોગ્રામરોએ શરતોનો ઉપયોગ કરવાનું ટાળવાનો પ્રયાસ કર્યો. સામાન્ય વાક્યરચના ઉદાહરણોઃ ON શરત જીઓટીઓ લેબલ અપવાદો આધુનિક ભાષાઓમાં અપવાદના સંચાલન માટે વિશિષ્ટ સંરચિત રચના હોય છે જે જીઓટીઓ અથવા (બહુ-સ્તર) વિરામ અથવા વળતરના ઉપયોગ પર આધાર રાખતી નથી. ઉદાહરણ તરીકે, C + + માં કોઈ વ્યક્તિ લખી શકે છેઃ અહીં ક્યાંય પણ "ફેંક" નો પ્રયાસ કરો, અમુક મૂલ્ય; XXX3} કેચ (અમુક વર્ગ અને અમુકId) {// અમુક વર્ગની ક્રિયાનું કેચ મૂલ્ય, અમુક વર્ગ માટે કેચ (અમુક પ્રકાર અને અન્યId) {// અમુક પ્રકારની ક્રિયાનું કેચ મૂલ્ય, અમુક પ્રકાર માટે કેચ (.) (.) (.) (.) (.) (.) (.) (.) (.) (.) (.) (.) (.) (.) (.) (.) (.) (.) (.) (.) (.) (.) (.) (.) (.) (.) (.) (.) (.) (.) (.) (.) (.) (.) (.) (.) (.) (.) (.) (.) (.) જો કોઈ ચોક્કસ થ્રો સાથે મેળ ખાતો કોઈ કેચ ન હોય, તો જ્યાં સુધી મેળ ખાતો કેચ ન મળે ત્યાં સુધી અથવા મુખ્ય પ્રોગ્રામના અંત સુધી ન પહોંચે ત્યાં સુધી સબરૂટિન કૉલ્સ અને/અથવા નેસ્ટેડ બ્લોક્સ દ્વારા પાછા ફરતા નિયંત્રણ કરો, જે સમયે પ્રોગ્રામને યોગ્ય ભૂલ સંદેશ સાથે બળજબરીથી બંધ કરવામાં આવે છે. C + + ના પ્રભાવ દ્વારા, કેચ એ જાવા અથવા C #જેવી આજે લોકપ્રિય અન્ય ભાષાઓમાં પેટર્ન-મેળ ખાતા અપવાદ હેન્ડલરને જાહેર કરવા માટે અનામત મુખ્ય શબ્દ છે. અદા જેવી કેટલીક અન્ય ભાષાઓ અપવાદ હેન્ડલર રજૂ કરવા માટે મુખ્ય શબ્દ અપવાદનો ઉપયોગ કરે છે અને પછી પેટર્ન મેચિંગ માટે અલગ મુખ્ય શબ્દ (જ્યારે અદા માં હોય) નો પણ ઉપયોગ કરી શકે છે. એપલસ્ક્રિપ્ટ જેવી કેટલીક ભાષાઓ અપવાદ હોય ત્યારે આપમેળે માહિતીના કેટલાક ટુકડાઓ બહાર કાઢવા માટે અપવાદ હેન્ડલર વાક્યરચનામાં પ્લેસહોલ્ડર્સનો સમાવેશ કરે છે. આ અભિગમ એપલસ્ક્રિપ્ટમાંથી ઓન એરર કન્સ્ટ્રક્ટ દ્વારા નીચે દર્શાવવામાં આવ્યો છેઃ ભૂલ પર માય નંબરને માય નંબર/0 પર સેટ કરવાનો પ્રયાસ કરો e નંબર n ને f થી t આંશિક પરિણામ pr પર સેટ કરો જો (e = "શૂન્ય દ્વારા વિભાજિત કરી શકાતું નથી") તો પછી સંવાદ પ્રદર્શિત કરો "તમારે તે ન કરવું જોઈએ" અંત પ્રયાસ કરો ડેવિડ વોટની 2004 ની પાઠ્યપુસ્તક પણ સિક્વેન્સર્સના માળખામાં અપવાદ સંચાલનનું વિશ્લેષણ કરે છે (લૂપ્સમાંથી પ્રારંભિક બહાર નીકળવાના વિભાગમાં આ લેખમાં રજૂ કરાયેલ). વોટ નોંધે છે કે અસામાન્ય પરિસ્થિતિ, સામાન્ય રીતે અંકગણિત ઓવરફ્લો અથવા ઇનપુટ/આઉટપુટ નિષ્ફળતાઓ જેવી કે ફાઇલ મળી નથી, તે એક પ્રકારની ભૂલ છે જે "કેટલાક નિમ્ન-સ્તરના પ્રોગ્રામ એકમમાં શોધાય છે, પરંતુ [જેના માટે] હેન્ડલર વધુ કુદરતી રીતે ઉચ્ચ-સ્તરના પ્રોગ્રામ એકમમાં સ્થિત છે". ઉદાહરણ તરીકે, પ્રોગ્રામમાં ફાઇલો વાંચવા માટે ઘણા કૉલ્સ હોઈ શકે છે, પરંતુ જ્યારે ફાઇલ ન મળે ત્યારે કરવાની ક્રિયા પ્રોગ્રામના પ્રશ્નમાં ફાઇલના અર્થ (હેતુ) પર આધારિત હોય છે અને આમ આ અસામાન્ય પરિસ્થિતિ માટે હેન્ડલિંગ રૂટિન નિમ્ન-સ્તરના સિસ્ટમ કોડમાં સ્થિત કરી શકાતી નથી. વોટ્સ આગળ નોંધે છે કે કોલ કરનારમાં સ્થિતિ ફ્લેગ પરીક્ષણની શરૂઆત, સિંગલ-એક્ઝિટ સ્ટ્રક્ચર્ડ પ્રોગ્રામિંગ અથવા તો (મલ્ટી-એક્ઝિટ) રીટર્ન સિક્વેન્સર્સ તરીકે, એવી પરિસ્થિતિમાં પરિણમે છે કે જ્યાં "એપ્લિકેશન કોડ સ્થિતિ ફ્લેગના પરીક્ષણો દ્વારા અવ્યવસ્થિત થઈ જાય છે" અને "પ્રોગ્રામર સ્થિતિ ફ્લેગને ચકાસવા માટે ભૂલી શકે છે અથવા આળસથી છોડી શકે છે. હકીકતમાં, સ્થિતિ ધ્વજ દ્વારા રજૂ થતી અસામાન્ય પરિસ્થિતિઓને મૂળભૂત રીતે અવગણવામાં આવે છે! " વોટ નોંધે છે કે સ્થિતિ ફ્લેગ પરીક્ષણથી વિપરીત, અપવાદોમાં વિપરીત મૂળભૂત વર્તણૂક હોય છે, જે પ્રોગ્રામને સમાપ્ત કરવા માટેનું કારણ બને છે, સિવાય કે પ્રોગ્રામર સ્પષ્ટપણે કોઈ રીતે અપવાદ સાથે વ્યવહાર કરે, કદાચ તેને અવગણવા માટે સ્પષ્ટ કોડ ઉમેરીને. આ દલીલોના આધારે, વોટ નિષ્કર્ષ કાઢે છે કે જમ્પ સિક્વન્સર્સ અથવા એસ્કેપ સિક્વન્સર્સ ઉપર ચર્ચા કરાયેલા સિમેન્ટિક્સ સાથે સમર્પિત અપવાદ સિક્વન્સર્સ જેટલા યોગ્ય નથી. ઓબ્જેક્ટ પાસ્કલ, ડી, જાવા, સી #અને પાયથોનમાં ટ્રાય કન્સ્ટ્રક્ટમાં આખરે કલમ ઉમેરી શકાય છે. નિયંત્રણ ગમે તે રીતે છોડી દે, આખરે કલમની અંદર કોડને અમલમાં મૂકવાની ખાતરી આપવામાં આવે છે. આ કોડ લખતી વખતે ઉપયોગી છે જે પ્રક્રિયા પૂર્ણ થાય ત્યારે ખર્ચાળ સ્રોત (જેમ કે ખુલ્લી ફાઇલ અથવા ડેટાબેઝ જોડાણ) ને છોડવો જ જોઇએઃ ફાઇલસ્ટ્રીમ એસટીએમ = નલ;// સી #ઉદાહરણ તરીકે અજમાવો {એસટીએમ = નવી ફાઇલસ્ટ્રીમ ("logfile.txt", FileMode.Create); રીટર્ન પ્રોસેસસ્ટફ (એસટીએમ);// એક અપવાદ ફેંકી શકે છે} આખરે {જો (એસટીએમ! = નલ) stm.Close ();} આ પેટર્ન એકદમ સામાન્ય હોવાથી, સી #પાસે એક વિશેષ વાક્યરચના છેઃ ઉપયોગ (વાર એસટીએમ = નવી ફાઇલસ્ટ્રીમ ("logfile.txt", FileMode.Create)) {રીટર્ન પ્રોસેસસ્ટફ (એસટીએમ);// છોડી દેવા પર એક અપવાદ ફેંકી શકે છે] નિવેદન સાથે પાયથોન અને File.open માટે રૂબીની બ્લોક દલીલ સમાન અસર માટે વપરાય છે. ઉપર ઉલ્લેખિત તમામ ભાષાઓ પ્રમાણભૂત અપવાદો અને જે સંજોગોમાં તેમને ફેંકવામાં આવે છે તેની વ્યાખ્યા આપે છે. વપરાશકર્તાઓ તેમના પોતાના અપવાદો ફેંકી શકે છે; હકીકતમાં સી + + વપરાશકર્તાઓને લગભગ કોઈપણ પ્રકારને ફેંકવા અને પકડવાની મંજૂરી આપે છે, જેમાં ઇન્ટ જેવા મૂળભૂત પ્રકારોનો સમાવેશ થાય છે, જ્યારે જાવા જેવી અન્ય ભાષાઓ એટલી અનુકૂળ નથી. સાતત્યતા એસિંક સી #5.0 એ "સીધી શૈલી" માં એસિંક્રોનસ I/O ને ટેકો આપવા માટે એસિંક કીવર્ડની રજૂઆત કરી. જનરેટર જનરેટર, જેને સેમિકોરોટિન તરીકે પણ ઓળખવામાં આવે છે, તે સામાન્ય રીતે મુખ્ય શબ્દ (ઉપજ વર્ણન) નો ઉપયોગ કરીને અસ્થાયી રૂપે ગ્રાહક પદ્ધતિ પર નિયંત્રણ મેળવવાની મંજૂરી આપે છે. એસિંક કીવર્ડની જેમ, આ "સીધી શૈલી" માં પ્રોગ્રામિંગને સપોર્ટ કરે છે. કોરોટિન એવા કાર્યો છે જે એકબીજાને નિયંત્રણ આપી શકે છે-થ્રેડો વિના સહકારી મલ્ટીટાસ્કીંગનું એક સ્વરૂપ. કોરોટાઇન્સને પુસ્તકાલય તરીકે લાગુ કરી શકાય છે જો પ્રોગ્રામિંગ ભાષા કાં તો સાતત્ય અથવા જનરેટર પ્રદાન કરે છે-તેથી વ્યવહારમાં કોરોટાઇન્સ અને જનરેટર વચ્ચેનો તફાવત એ તકનીકી વિગત છે. નોન-લોકલ કંટ્રોલ ફ્લો ક્રોસ રેફરન્સ પ્રપોઝ્ડ કંટ્રોલ સ્ટ્રક્ચર્સ 1973માં એક સ્પૂફ ડેટામેશન લેખમાં, આર. લોરેન્સ ક્લાર્કે સૂચવ્યું હતું કે જીઓટીઓ સ્ટેટમેન્ટને કોમેફ્રોમ સ્ટેટમેન્ટ દ્વારા બદલી શકાય છે, અને કેટલાક મનોરંજક ઉદાહરણો પૂરા પાડે છે. કોમેફ્રોમ ઇન્ટરકલ નામની એક વિશિષ્ટ પ્રોગ્રામિંગ ભાષામાં લાગુ કરવામાં આવી હતી. ડોનાલ્ડ ક્નુથના 1974 ના લેખ "સ્ટ્રક્ચર્ડ પ્રોગ્રામિંગ વિથ ગો ટુ સ્ટેટમેન્ટ્સ", બે પરિસ્થિતિઓને ઓળખે છે જે ઉપર સૂચિબદ્ધ નિયંત્રણ માળખા દ્વારા આવરી લેવામાં આવી ન હતી, અને નિયંત્રણ માળખાના ઉદાહરણો આપ્યા હતા જે આ પરિસ્થિતિઓને સંભાળી શકે છે. તેમની ઉપયોગિતા હોવા છતાં, આ રચનાઓ હજુ સુધી મુખ્ય પ્રવાહની પ્રોગ્રામિંગ ભાષાઓમાં તેમનો માર્ગ શોધી શકી નથી. મધ્યમાં પરીક્ષણ સાથે લૂપ ડહલ દ્વારા 1972 માં નીચેની દરખાસ્ત કરવામાં આવી હતીઃ લૂપ લૂપ XXX1 રીડ (ચાર); જ્યારે પરીક્ષણ; જ્યારે એન્ડઓફફાઇલ પર નહીં; XXX2 લખો (ચાર); પુનરાવર્તન કરો; પુનરાવર્તન કરો; જો XXX1 અવગણવામાં આવે, તો આપણને ટોચ પર પરીક્ષણ સાથે લૂપ મળે છે (એક પરંપરાગત વાઇલ લૂપ). જો XXX2 અવગણવામાં આવે, તો આપણને નીચે પરીક્ષણ સાથે લૂપ મળે છે, જે ઘણી ભાષાઓમાં ડુ વાઇલ લૂપની સમકક્ષ હોય છે. જો વાઇલ અવગણવામાં આવે, તો આપણને અનંત લૂપ મળે છે. અહીંના બાંધકામને મધ્યમાં વાઇલ ચેક સાથે ડૂ લૂપ તરીકે વિચારી શકાય છે. તેથી આ એક જ રચના મોટાભાગની પ્રોગ્રામિંગ ભાષાઓમાં અનેક રચનાઓને બદલી શકે છે. આ રચનાનો અભાવ ધરાવતી ભાષાઓ સામાન્ય રીતે સમાન અનંત-લૂપ-વિથ-બ્રેક રૂઢિપ્રયોગનો ઉપયોગ કરીને તેનું અનુકરણ કરે છેઃ જ્યારે (સાચું) {XXX1 જો (પરીક્ષણ ન હોય તો) બ્રેક XXX2} એક સંભવિત પ્રકાર એ છે કે પરીક્ષણ દરમિયાન એક કરતાં વધુને મંજૂરી આપવી; લૂપની અંદર, પરંતુ એક્ઝિટનો ઉપયોગ જ્યારે આ કેસને વધુ સારી રીતે આવરી લે તેવું લાગે છે (આગામી વિભાગ જુઓ). એડામાં, ઉપરોક્ત લૂપ કન્સ્ટ્રક્ટ (લૂપ-વાઇલ-રિપીટ) ને પ્રમાણભૂત અનંત લૂપ (લૂપ-એન્ડ લૂપ) નો ઉપયોગ કરીને રજૂ કરી શકાય છે, જે મધ્યમાં ક્લોઝ હોય ત્યારે બહાર નીકળે છે (નીચેના વિભાગમાં એક્ઝિટ-વ્હેન સ્ટેટમેન્ટ સાથે મૂંઝવણ ન કરવી). Ada.Text _ IO સાથે; Ada.Integer_Text_IO સાથે; પ્રક્રિયા પ્રિન્ટ _ સ્ક્વેર્સ એ X: પૂર્ણાંક છે; શરૂ કરો રીડ _ ડેટાઃ લૂપ Ada.Integer_Text_IO. મેળવો (X); બહાર નીકળો રીડ _ ડેટા જ્યારે X = 0; Ada.Text IO.Put (X * X); Ada.Text IO.New_Line; એન્ડ લૂપ રીડ _ ડેટા; એન્ડ પ્રિન્ટ _ સ્ક્વેર્સ; લૂપનું નામકરણ (જેમ કે આ ઉદાહરણમાં રીડ _ ડેટા) વૈકલ્પિક છે પરંતુ કેટલાક નેસ્ટેડ લૂપ્સના બાહ્ય લૂપને છોડવાની મંજૂરી આપે છે. નેસ્ટેડ લૂપ્સમાંથી બહુવિધ પ્રારંભિક બહાર નીકળો/બહાર નીકળો આ રચનાની દરખાસ્ત ઝાન દ્વારા 1974માં કરવામાં આવી હતી. સંશોધિત સંસ્કરણ અહીં રજૂ કરવામાં આવ્યું છે. બહાર નીકળો જ્યારે EventA અથવા EventB અથવા EventC; XXX EventA માંથી બહાર નીકળે છેઃ ક્રિયા A EventB: ક્રિયા B EventC: ક્રિયા C સમાપ્ત થાય છે; બહાર નીકળો જ્યારે XXX ની અંદર આવી શકે તેવી ઘટનાઓને સ્પષ્ટ કરવા માટે વપરાય છે, ત્યારે તેમની ઘટનાને નિવેદન તરીકે ઘટનાના નામનો ઉપયોગ કરીને સૂચવવામાં આવે છે. જ્યારે કોઈ ઘટના બને છે, ત્યારે સંબંધિત કાર્યવાહી હાથ ધરવામાં આવે છે, અને પછી બહાર નીકળ્યા પછી તરત જ નિયંત્રણ પસાર થાય છે. આ રચના અમુક પરિસ્થિતિ લાગુ પડે છે તે નક્કી કરવા અને તે પરિસ્થિતિ માટે લેવામાં આવતી કાર્યવાહી વચ્ચે ખૂબ જ સ્પષ્ટ વિભાજન પ્રદાન કરે છે. જ્યારે તે વિભાવનાત્મક રીતે અપવાદ સંચાલન જેવું જ હોય છે, અને ઘણી ભાષાઓમાં આ હેતુ માટે અપવાદો અથવા સમાન રચનાઓનો ઉપયોગ કરવામાં આવે છે. નીચેના સરળ ઉદાહરણમાં કોઈ ચોક્કસ વસ્તુ માટે દ્વિ-પરિમાણીય કોષ્ટક શોધવાનો સમાવેશ થાય છે. બહાર નીકળો જ્યારે મળે અથવા ગુમ થાય; I: = 1 થી N માટે J: = 1 માટે M કરો જો કોષ્ટક [I, J] = લક્ષ્ય પછી મળે; ગુમ થયેલ; બહાર નીકળે છેઃ પ્રિન્ટ ("આઇટમ ટેબલમાં છે"); ગુમ થયેલઃ પ્રિન્ટ ("આઇટમ ટેબલમાં નથી"); એન્ડએક્સિટ; સુરક્ષા સોફ્ટવેરના ભાગ પર હુમલો કરવાની એક રીત પ્રોગ્રામના અમલના પ્રવાહને રીડાયરેક્ટ કરવાની છે. આ હુમલાઓ સામે રક્ષણ આપવા માટે સ્ટૅક કેનરીઝ, બફર ઓવરફ્લો પ્રોટેક્શન, શેડો સ્ટેક્સ અને વીટેબલ પોઇન્ટર વેરિફિકેશન સહિત વિવિધ નિયંત્રણ-પ્રવાહ અખંડિતતા તકનીકોનો ઉપયોગ કરવામાં આવે છે. આ પણ જુઓ શાખા (કોમ્પ્યુટર વિજ્ઞાન) નિયંત્રણ-પ્રવાહ વિશ્લેષણ નિયંત્રણ-પ્રવાહ આકૃતિ નિયંત્રણ-પ્રવાહ આલેખ નિયંત્રણ કોષ્ટક કોરોટીન ચક્રીય જટિલતા ડ્રેકોન-ચાર્ટ ફ્લોચાર્ટ ગોટો જેરૂ, નિયંત્રણ માળખાં શીખવામાં મદદ કરે છે મુખ્ય લૂપ રિકર્શન શેડ્યુલિંગ (કમ્પ્યુટિંગ) સ્પેગેટી કોડ સ્ટ્રક્ચર્ડ પ્રોગ્રામિંગ સબરૂટીન સ્વિચ સ્ટેટમેન્ટ, નિયંત્રણ પ્રવાહને શરતી રીતે બદલે છે. કોમ. ACM 4,321-322,1961. બાહ્ય લિંક્સ એ. ડી. એ. કોડના ઉદાહરણ સાથે જીઓટીઓ-ઓછા પ્રોગ્રામિંગ લેખોના ભાષાકીય યોગદાનને હાનિકારક માનવામાં આવતા નિવેદન પર જાઓ