Control flow
ಗಣಕಯಂತ್ರ ವಿಜ್ಞಾನದಲ್ಲಿ, ನಿಯಂತ್ರಣ ಹರಿವು (ಅಥವಾ ನಿಯಂತ್ರಣದ ಹರಿವು) ಎಂಬುದು ಒಂದು ಅನಿವಾರ್ಯ ಪ್ರೋಗ್ರಾಂನ ಪ್ರತ್ಯೇಕ ಹೇಳಿಕೆಗಳು, ಸೂಚನೆಗಳು ಅಥವಾ ಕಾರ್ಯ ಕರೆಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವ ಅಥವಾ ಮೌಲ್ಯಮಾಪನ ಮಾಡುವ ಕ್ರಮವಾಗಿದೆ. ಸ್ಪಷ್ಟವಾದ ನಿಯಂತ್ರಣ ಹರಿವಿನ ಮೇಲೆ ಒತ್ತು ನೀಡುವುದು ಅನಿವಾರ್ಯ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಯನ್ನು ಘೋಷಣಾತ್ಮಕ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಯಿಂದ ಪ್ರತ್ಯೇಕಿಸುತ್ತದೆ. ಅನಿವಾರ್ಯ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಯೊಳಗೆ, ನಿಯಂತ್ರಣ ಹರಿವಿನ ಹೇಳಿಕೆಯು ಎರಡು ಅಥವಾ ಹೆಚ್ಚಿನ ಮಾರ್ಗಗಳಲ್ಲಿ ಯಾವುದನ್ನು ಅನುಸರಿಸಬೇಕು ಎಂಬುದರ ಆಯ್ಕೆಗೆ ಕಾರಣವಾಗುವ ಹೇಳಿಕೆಯಾಗಿದೆ. ಕಟ್ಟುನಿಟ್ಟಲ್ಲದ ಕ್ರಿಯಾತ್ಮಕ ಭಾಷೆಗಳಿಗೆ, ಅದೇ ಫಲಿತಾಂಶವನ್ನು ಸಾಧಿಸಲು ಕಾರ್ಯಗಳು ಮತ್ತು ಭಾಷಾ ರಚನೆಗಳು ಅಸ್ತಿತ್ವದಲ್ಲಿವೆ, ಆದರೆ ಅವುಗಳನ್ನು ಸಾಮಾನ್ಯವಾಗಿ ನಿಯಂತ್ರಣ ಹರಿವಿನ ಹೇಳಿಕೆಗಳು ಎಂದು ಕರೆಯಲಾಗುವುದಿಲ್ಲ. ಹೇಳಿಕೆಗಳ ಒಂದು ಗುಂಪನ್ನು ಸಾಮಾನ್ಯವಾಗಿ ಒಂದು ಬ್ಲಾಕ್ ಆಗಿ ರಚಿಸಲಾಗುತ್ತದೆ, ಇದು ಗುಂಪಿನ ಜೊತೆಗೆ, ಲೆಕ್ಸಿಕಲ್ ವ್ಯಾಪ್ತಿಯನ್ನು ಸಹ ವ್ಯಾಖ್ಯಾನಿಸುತ್ತದೆ. ಅಡೆತಡೆಗಳು ಮತ್ತು ಸಂಕೇತಗಳು ಕೆಳಮಟ್ಟದ ಕಾರ್ಯವಿಧಾನಗಳಾಗಿದ್ದು, ಅವು ನಿಯಂತ್ರಣದ ಹರಿವನ್ನು ಸಬ್ರುಟೈನ್ನಂತೆಯೇ ಬದಲಾಯಿಸಬಲ್ಲವು, ಆದರೆ ಸಾಮಾನ್ಯವಾಗಿ ಇನ್-ಲೈನ್ ನಿಯಂತ್ರಣ ಹರಿವಿನ ಹೇಳಿಕೆಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವ ಬದಲು ಕೆಲವು ಬಾಹ್ಯ ಪ್ರಚೋದನೆ ಅಥವಾ ಘಟನೆಗೆ (ಇದು ಅಸಿಂಕ್ರೊನಸ್ ಆಗಿ ಸಂಭವಿಸಬಹುದು) ಪ್ರತಿಕ್ರಿಯೆಯಾಗಿ ಸಂಭವಿಸುತ್ತದೆ. ಯಂತ್ರ ಭಾಷೆ ಅಥವಾ ಜೋಡಣೆ ಭಾಷೆಯ ಮಟ್ಟದಲ್ಲಿ, ನಿಯಂತ್ರಣ ಹರಿವಿನ ಸೂಚನೆಗಳು ಸಾಮಾನ್ಯವಾಗಿ ಪ್ರೋಗ್ರಾಂ ಕೌಂಟರ್ ಅನ್ನು ಬದಲಾಯಿಸುವ ಮೂಲಕ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ. ಕೆಲವು ಕೇಂದ್ರೀಯ ಸಂಸ್ಕರಣಾ ಘಟಕಗಳಿಗೆ (ಸಿಪಿಯು), ಲಭ್ಯವಿರುವ ನಿಯಂತ್ರಣ ಹರಿವಿನ ಸೂಚನೆಗಳು ಷರತ್ತುಬದ್ಧ ಅಥವಾ ಬೇಷರತ್ತಾದ ಶಾಖೆಯ ಸೂಚನೆಗಳಾಗಿವೆ, ಇದನ್ನು ಜಿಗಿತಗಳು ಎಂದೂ ಕರೆಯಲಾಗುತ್ತದೆ. ವರ್ಗಗಳು ವಿವಿಧ ಭಾಷೆಗಳು ಬೆಂಬಲಿಸುವ ನಿಯಂತ್ರಣ ಹರಿವಿನ ಹೇಳಿಕೆಗಳ ಪ್ರಕಾರಗಳು ಬದಲಾಗುತ್ತವೆ, ಆದರೆ ಅವುಗಳ ಪರಿಣಾಮದಿಂದ ವರ್ಗೀಕರಿಸಬಹುದುಃ ಬೇರೆ ಹೇಳಿಕೆಯಲ್ಲಿ ಮುಂದುವರಿಕೆ (ಬೇಷರತ್ತಾದ ಶಾಖೆ ಅಥವಾ ಜಿಗಿತ) ಕೆಲವು ಷರತ್ತುಗಳನ್ನು ಪೂರೈಸಿದರೆ ಮಾತ್ರ ಹೇಳಿಕೆಗಳ ಗುಂಪನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವುದು (ಆಯ್ಕೆ-ಅಂದರೆ, ಷರತ್ತುಬದ್ಧ ಶಾಖೆ) ಕೆಲವು ಷರತ್ತುಗಳನ್ನು ಪೂರೈಸುವವರೆಗೆ ಶೂನ್ಯ ಅಥವಾ ಹೆಚ್ಚಿನ ಬಾರಿ ಹೇಳಿಕೆಗಳ ಗುಂಪನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವುದು (ಅಂದರೆ, ಲೂಪ್-ಷರತ್ತುಬದ್ಧ ಶಾಖೆಯಂತೆಯೇ) ದೂರದ ಹೇಳಿಕೆಗಳ ಗುಂಪನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವುದು, ಅದರ ನಂತರ ನಿಯಂತ್ರಣದ ಹರಿವು ಸಾಮಾನ್ಯವಾಗಿ ಹಿಂತಿರುಗುತ್ತದೆ (ಉಪ-ರೂಢಿಗಳು, ಕೊರೌಟೈನ್ಗಳು ಮತ್ತು ನಿರಂತರತೆಗಳು) ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ನಿಲ್ಲಿಸುವುದು, ಯಾವುದೇ ಮುಂದಿನ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯನ್ನು ತಡೆಯುವುದು (ಬೇಷರತ್ತಾದ ನಿಲುಗಡೆ) ಪ್ರಾಚೀನ ಲೇಬಲ್ಗಳು ಒಂದು ಲೇಬಲ್ ಎಂಬುದು ನಿರ್ದಿಷ್ಟ ಸ್ಥಾನಕ್ಕೆ ನಿಗದಿಪಡಿಸಲಾದ ಸ್ಪಷ್ಟ ಹೆಸರು ಅಥವಾ ಸಂಖ್ಯೆಯಾಗಿದೆ. ಲೇಬಲ್ ಮೂಲ ಸಂಕೇತದೊಳಗೆ ಸ್ಥಾನವನ್ನು ಗುರುತಿಸುತ್ತದೆ ಮತ್ತು ಬೇರೆ ಯಾವುದೇ ಪರಿಣಾಮವನ್ನು ಹೊಂದಿರುವುದಿಲ್ಲ. ಸಾಲು ಸಂಖ್ಯೆಗಳು ಕೆಲವು ಭಾಷೆಗಳಲ್ಲಿ ಬಳಸುವ ಹೆಸರಿನ ಲೇಬಲ್ಗೆ ಪರ್ಯಾಯವಾಗಿವೆ (ಉದಾಹರಣೆಗೆ ಬೇಸಿಕ್). ಅವು ಮೂಲ ಸಂಕೇತದಲ್ಲಿರುವ ಪಠ್ಯದ ಪ್ರತಿ ಸಾಲಿನ ಆರಂಭದಲ್ಲಿ ಇರಿಸಲಾಗಿರುವ ಪೂರ್ಣ ಸಂಖ್ಯೆಗಳಾಗಿವೆ. ಇವುಗಳನ್ನು ಬಳಸುವ ಭಾಷೆಗಳು ಆಗಾಗ್ಗೆ ಈ ಕೆಳಗಿನ ಪ್ರತಿಯೊಂದು ಸಾಲಿನಲ್ಲೂ ಸಾಲು ಸಂಖ್ಯೆಗಳು ಮೌಲ್ಯದಲ್ಲಿ ಹೆಚ್ಚಾಗಬೇಕು ಎಂಬ ನಿರ್ಬಂಧವನ್ನು ಹೇರುತ್ತವೆ, ಆದರೆ ಅವು ಅನುಕ್ರಮವಾಗಿರಬೇಕಾಗಿಲ್ಲ. ಉದಾಹರಣೆಗೆ, ಬೇಸಿಕ್ನಲ್ಲಿಃ 10 LET X = 3 20 PRINT X ಸಿ ಮತ್ತು ಆಡಾದಂತಹ ಇತರ ಭಾಷೆಗಳಲ್ಲಿ, ಲೇಬಲ್ ಒಂದು ಗುರುತಿಸುವಿಕೆಯಾಗಿದೆ, ಇದು ಸಾಮಾನ್ಯವಾಗಿ ರೇಖೆಯ ಆರಂಭದಲ್ಲಿ ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತದೆ ಮತ್ತು ತಕ್ಷಣವೇ ಕೊಲೊನ್ ಅನ್ನು ಅನುಸರಿಸುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ಸಿಃ ಯಶಸ್ಸುಃ ಪ್ರಿಂಟ್ಎಫ್ ("ಕಾರ್ಯಾಚರಣೆಯು ಯಶಸ್ವಿಯಾಗಿದೆ. \ನ್"); ಆಲ್ಗೋಲ್ 60 ಭಾಷೆಯು ಪೂರ್ಣ ಸಂಖ್ಯೆಗಳು ಮತ್ತು ಗುರುತಿಸುವಿಕೆಗಳನ್ನು ಲೇಬಲ್ಗಳಾಗಿ ಅನುಮತಿಸುತ್ತದೆ (ಎರಡೂ ಈ ಕೆಳಗಿನ ಹೇಳಿಕೆಗೆ ಕೊಲೊನ್ಗಳಿಂದ ಲಿಂಕ್ ಮಾಡಲ್ಪಟ್ಟಿವೆ), ಆದರೆ ಯಾವುದೇ ಇತರ ಆಲ್ಗೋಲ್ ರೂಪಾಂತರಗಳು ಪೂರ್ಣ ಸಂಖ್ಯೆಗಳನ್ನು ಅನುಮತಿಸಿದರೆ ಕಡಿಮೆ. ಆರಂಭಿಕ ಫೋರ್ಟ್ರಾನ್ ಕಂಪೈಲರ್ಗಳು ಪೂರ್ಣ ಸಂಖ್ಯೆಗಳನ್ನು ಮಾತ್ರ ಲೇಬಲ್ಗಳಾಗಿ ಅನುಮತಿಸಿದವು. ಫೋರ್ಟ್ರಾನ್-90 ರಿಂದ ಪ್ರಾರಂಭಿಸಿ, ಆಲ್ಫಾನ್ಯೂಮರಿಕ್ ಲೇಬಲ್ಗಳನ್ನು ಸಹ ಅನುಮತಿಸಲಾಗಿದೆ. ಗೊಟೋ ಹೇಳಿಕೆಯು (ಗೋ ಅಂಡ್ ಟು ಎಂಬ ಇಂಗ್ಲಿಷ್ ಪದಗಳ ಸಂಯೋಜನೆ ಮತ್ತು ಅದಕ್ಕೆ ಅನುಗುಣವಾಗಿ ಉಚ್ಚರಿಸಲಾಗುತ್ತದೆ) ನಿಯಂತ್ರಣದ ಬೇಷರತ್ತಾದ ವರ್ಗಾವಣೆಯ ಅತ್ಯಂತ ಮೂಲಭೂತ ರೂಪವಾಗಿದೆ. ಕೀವರ್ಡ್ ಭಾಷೆಯನ್ನು ಅವಲಂಬಿಸಿ ಅಪ್ಪರ್ ಅಥವಾ ಲೋವರ್ ಕೇಸ್ನಲ್ಲಿರಬಹುದು, ಇದನ್ನು ಸಾಮಾನ್ಯವಾಗಿ ಹೀಗೆ ಬರೆಯಲಾಗುತ್ತದೆಃ ಗೋಟೋ ಲೇಬಲ್ ಗೋಟೋ ಹೇಳಿಕೆಯ ಪರಿಣಾಮವು ಮುಂದಿನ ಹೇಳಿಕೆಯನ್ನು ಸೂಚಿಸಲಾದ ಲೇಬಲ್ನಲ್ಲಿ (ಅಥವಾ ತಕ್ಷಣವೇ) ಕಾಣಿಸಿಕೊಳ್ಳುವ ಹೇಳಿಕೆಯಾಗಿ ಕಾರ್ಯಗತಗೊಳಿಸಲು ಕಾರಣವಾಗುತ್ತದೆ. ಗೊಟೊ ಹೇಳಿಕೆಗಳನ್ನು ಅನೇಕ ಕಂಪ್ಯೂಟರ್ ವಿಜ್ಞಾನಿಗಳು, ವಿಶೇಷವಾಗಿ ಡಿಜ್ಕ್ಸ್ಟ್ರಾ, ಹಾನಿಕಾರಕವೆಂದು ಪರಿಗಣಿಸಿದ್ದಾರೆ. ಸಬ್ರುಟೈನ್ಗಳ ಪರಿಭಾಷೆಯು ಬದಲಾಗುತ್ತದೆ; ಅವುಗಳನ್ನು ಪರ್ಯಾಯವಾಗಿ ದಿನಚರಿಗಳು, ಕಾರ್ಯವಿಧಾನಗಳು, ಕಾರ್ಯಗಳು (ವಿಶೇಷವಾಗಿ ಅವು ಫಲಿತಾಂಶಗಳನ್ನು ನೀಡಿದರೆ) ಅಥವಾ ವಿಧಾನಗಳು (ವಿಶೇಷವಾಗಿ ಅವು ವರ್ಗಗಳಿಗೆ ಅಥವಾ ಪ್ರಕಾರದ ವರ್ಗಗಳಿಗೆ ಸೇರಿದವರಾಗಿದ್ದರೆ) ಎಂದು ಕರೆಯಬಹುದು. 1950ರ ದಶಕದಲ್ಲಿ, ಕಂಪ್ಯೂಟರ್ ಮೆಮೊರಿಗಳು ಪ್ರಸ್ತುತ ಮಾನದಂಡಗಳಿಂದ ಬಹಳ ಚಿಕ್ಕದಾಗಿದ್ದವು, ಆದ್ದರಿಂದ ಪ್ರೋಗ್ರಾಂ ಗಾತ್ರವನ್ನು ಕಡಿಮೆ ಮಾಡಲು ಮುಖ್ಯವಾಗಿ ಸಬ್ರುಟೈನ್ಗಳನ್ನು ಬಳಸಲಾಗುತ್ತಿತ್ತು. ಒಂದು ಕೋಡ್ ಅನ್ನು ಒಮ್ಮೆ ಬರೆಯಲಾಗುತ್ತಿತ್ತು ಮತ್ತು ನಂತರ ಪ್ರೋಗ್ರಾಂನಲ್ಲಿ ಇತರ ವಿವಿಧ ಸ್ಥಳಗಳಿಂದ ಅನೇಕ ಬಾರಿ ಬಳಸಲಾಗುತ್ತಿತ್ತು. ಇಂದು, ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಹೆಚ್ಚು ರಚನಾತ್ಮಕವಾಗಿಸಲು ಸಹಾಯ ಮಾಡಲು ಸಬ್ರುಟೈನ್ಗಳನ್ನು ಹೆಚ್ಚಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ, ಉದಾಹರಣೆಗೆ, ಕೆಲವು ಅಲ್ಗಾರಿದಮ್ ಅನ್ನು ಪ್ರತ್ಯೇಕಿಸುವ ಮೂಲಕ ಅಥವಾ ಕೆಲವು ಡೇಟಾ ಪ್ರವೇಶ ವಿಧಾನವನ್ನು ಮರೆಮಾಚುವ ಮೂಲಕ. ಅನೇಕ ಪ್ರೋಗ್ರಾಮರ್ಗಳು ಒಂದು ಪ್ರೋಗ್ರಾಂನಲ್ಲಿ ಕೆಲಸ ಮಾಡುತ್ತಿದ್ದರೆ, ಸಬ್ರುಟೈನ್ಗಳು ಒಂದು ರೀತಿಯ ಮಾಡ್ಯುಲಾರಿಟಿಯಾಗಿದ್ದು ಅದು ಕೆಲಸವನ್ನು ವಿಭಜಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ. ರಚನಾತ್ಮಕ ಪ್ರೋಗ್ರಾಮಿಂಗ್ನಲ್ಲಿ, ಅನುಕ್ರಮ ಆಜ್ಞೆಗಳ ಕ್ರಮಬದ್ಧ ಅನುಕ್ರಮವನ್ನು ಮೂಲ ನಿಯಂತ್ರಣ ರಚನೆಗಳಲ್ಲಿ ಒಂದೆಂದು ಪರಿಗಣಿಸಲಾಗುತ್ತದೆ, ಇದನ್ನು ಪುನರಾವರ್ತನೆ, ಪುನರಾವರ್ತನೆ ಮತ್ತು ಆಯ್ಕೆಯ ಜೊತೆಗೆ ಪ್ರೋಗ್ರಾಂಗಳಿಗೆ ಬಿಲ್ಡಿಂಗ್ ಬ್ಲಾಕ್ ಆಗಿ ಬಳಸಲಾಗುತ್ತದೆ. ಕನಿಷ್ಠ ರಚನಾತ್ಮಕ ನಿಯಂತ್ರಣ ಹರಿವು ಮೇ 1966 ರಲ್ಲಿ, ಬೋಮ್ ಮತ್ತು ಜಾಕೋಪಿನಿ ಕಮ್ಯುನಿಕೇಷನ್ಸ್ ಆಫ್ ದಿ ಎಸಿಎಂನಲ್ಲಿ ಒಂದು ಲೇಖನವನ್ನು ಪ್ರಕಟಿಸಿದರು, ಇದು ಗೊಟೊಗಳೊಂದಿಗಿನ ಯಾವುದೇ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಕೇವಲ ಆಯ್ಕೆ (ಐಎಫ್ ಥೆನ್ ಎಲ್ಸ್) ಮತ್ತು ಲೂಪ್ಗಳನ್ನು (ಡಬ್ಲ್ಯೂಹೆಚ್ಐಎಲ್ಇ ಷರತ್ತು ಡಿಒ ಐಎಕ್ಸ್ಎಕ್ಸ್) ಒಳಗೊಂಡಿರುವ ಗೊಟೊ-ಫ್ರೀ ರೂಪವಾಗಿ ಪರಿವರ್ತಿಸಬಹುದು ಎಂದು ತೋರಿಸಿದೆ, ಬಹುಶಃ ನಕಲು ಕೋಡ್ ಮತ್ತು/ಅಥವಾ ಬೂಲಿಯನ್ ಅಸ್ಥಿರಗಳ (ನಿಜ/ಸುಳ್ಳು ಧ್ವಜಗಳು) ಸೇರ್ಪಡೆಯೊಂದಿಗೆ. ಆಯ್ಕೆಯನ್ನು ಲೂಪ್ಗಳಿಂದ ಬದಲಾಯಿಸಬಹುದು ಎಂದು ನಂತರದ ಲೇಖಕರು ತೋರಿಸಿದರು (ಮತ್ತು ಇನ್ನೂ ಹೆಚ್ಚು ಬೂಲಿಯನ್ ಅಸ್ಥಿರಗಳು). ಅಂತಹ ಕನಿಷ್ಠೀಯತೆಯು ಸಾಧ್ಯವೆಂಬುದು ಅದು ಅಪೇಕ್ಷಣೀಯವಾಗಿದೆ ಎಂದು ಅರ್ಥವಲ್ಲ; ಎಲ್ಲಾ ನಂತರ, ಕಂಪ್ಯೂಟರ್ಗಳಿಗೆ ಸೈದ್ಧಾಂತಿಕವಾಗಿ ಕೇವಲ ಒಂದು ಯಂತ್ರ ಸೂಚನೆಯ ಅಗತ್ಯವಿರುತ್ತದೆ (ಒಂದು ಸಂಖ್ಯೆಯನ್ನು ಇನ್ನೊಂದರಿಂದ ಕಳೆಯಿರಿ ಮತ್ತು ಫಲಿತಾಂಶವು ಋಣಾತ್ಮಕವಾಗಿದ್ದರೆ ಶಾಖೆ), ಆದರೆ ಪ್ರಾಯೋಗಿಕ ಕಂಪ್ಯೂಟರ್ಗಳು ಡಜನ್ಗಟ್ಟಲೆ ಅಥವಾ ನೂರಾರು ಯಂತ್ರ ಸೂಚನೆಗಳನ್ನು ಹೊಂದಿರುತ್ತವೆ. ಬೋಮ್ ಮತ್ತು ಜಾಕೋಪಿನಿ ಅವರ ಲೇಖನವು ಎಲ್ಲಾ ಕಾರ್ಯಕ್ರಮಗಳು ಗೋಟೋ-ಮುಕ್ತವಾಗಬಹುದೆಂದು ತೋರಿಸಿದೆ. ಒಂದು ಪ್ರವೇಶ ಮತ್ತು ಒಂದು ನಿರ್ಗಮನವನ್ನು ಹೊಂದಿರುವ ನಿಯಂತ್ರಣ ರಚನೆಗಳನ್ನು ಇತರ ಯಾವುದೇ ರೂಪಕ್ಕಿಂತ ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ತುಂಬಾ ಸುಲಭ ಎಂದು ಇತರ ಸಂಶೋಧನೆಗಳು ತೋರಿಸಿವೆ, ಮುಖ್ಯವಾಗಿ ಅವುಗಳನ್ನು ನಿಯಂತ್ರಣ ಹರಿವನ್ನು ಅಡ್ಡಿಪಡಿಸದೆ ಹೇಳಿಕೆಯಾಗಿ ಎಲ್ಲಿಯಾದರೂ ಬಳಸಬಹುದು. ಬೇರೆ ರೀತಿಯಲ್ಲಿ ಹೇಳುವುದಾದರೆ, ಅವು ಸಮಾಧಾನಕರವಾಗಿದ್ದವು. (ನಂತರದ ಬೆಳವಣಿಗೆಗಳು, ಉದಾಹರಣೆಗೆ ಕಟ್ಟುನಿಟ್ಟಲ್ಲದ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳು-ಮತ್ತು ತೀರಾ ಇತ್ತೀಚೆಗೆ, ಸಂಯೋಜಿಸಬಹುದಾದ ಸಾಫ್ಟ್ವೇರ್ ವಹಿವಾಟುಗಳು-ಈ ಕಾರ್ಯತಂತ್ರವನ್ನು ಮುಂದುವರೆಸಿ, ಪ್ರೋಗ್ರಾಂಗಳ ಘಟಕಗಳನ್ನು ಇನ್ನಷ್ಟು ಮುಕ್ತವಾಗಿ ಸಂಯೋಜಿಸುವಂತೆ ಮಾಡಿವೆ.) ಕೆಲವು ವಿದ್ವಾಂಸರು ಬೋಮ್-ಜಾಕೋಪಿನಿ ಫಲಿತಾಂಶಕ್ಕೆ ಶುದ್ಧವಾದ ವಿಧಾನವನ್ನು ತೆಗೆದುಕೊಂಡರು ಮತ್ತು ಲೂಪ್ಗಳ ಮಧ್ಯದಿಂದ ಬ್ರೇಕ್ ಮತ್ತು ರಿಟರ್ನ್ ನಂತಹ ಸೂಚನೆಗಳು ಸಹ ಕೆಟ್ಟ ಅಭ್ಯಾಸವೆಂದು ವಾದಿಸಿದರು, ಏಕೆಂದರೆ ಅವು ಬೋಮ್-ಜಾಕೋಪಿನಿ ಪುರಾವೆಯಲ್ಲಿ ಅಗತ್ಯವಿಲ್ಲ, ಮತ್ತು ಆದ್ದರಿಂದ ಅವರು ಎಲ್ಲಾ ಲೂಪ್ಗಳು ಒಂದೇ ನಿರ್ಗಮನ ಬಿಂದುವನ್ನು ಹೊಂದಿರಬೇಕು ಎಂದು ಪ್ರತಿಪಾದಿಸಿದರು. ಈ ಶುದ್ಧವಾದ ವಿಧಾನವು ಪ್ಯಾಸ್ಕಲ್ ಭಾಷೆಯಲ್ಲಿ ಸಾಕಾರಗೊಂಡಿದೆ (1968-1969 ನಲ್ಲಿ ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ), ಇದು 1990 ರ ದಶಕದ ಮಧ್ಯಭಾಗದವರೆಗೂ ಶೈಕ್ಷಣಿಕ ಕ್ಷೇತ್ರದಲ್ಲಿ ಪರಿಚಯಾತ್ಮಕ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಅನ್ನು ಕಲಿಸಲು ಆದ್ಯತೆಯ ಸಾಧನವಾಗಿತ್ತು. ಬೋಹ್ಮ್-ಜಾಕೋಪಿನಿ ಪ್ರಮೇಯದ ನೇರ ಅನ್ವಯವು ರಚನಾತ್ಮಕ ಚಾರ್ಟ್ನಲ್ಲಿ ಹೆಚ್ಚುವರಿ ಸ್ಥಳೀಯ ಅಸ್ಥಿರಗಳನ್ನು ಪರಿಚಯಿಸಲು ಕಾರಣವಾಗಬಹುದು ಮತ್ತು ಕೆಲವು ಕೋಡ್ ನಕಲುಗೂ ಕಾರಣವಾಗಬಹುದು. ಪ್ಯಾಸ್ಕಲ್ ಈ ಎರಡೂ ಸಮಸ್ಯೆಗಳಿಂದ ಪ್ರಭಾವಿತನಾಗಿದ್ದಾನೆ ಮತ್ತು ಎರಿಕ್ ಎಸ್. ರಾಬರ್ಟ್ಸ್ ಉಲ್ಲೇಖಿಸಿದ ಪ್ರಾಯೋಗಿಕ ಅಧ್ಯಯನಗಳ ಪ್ರಕಾರ, ವಿದ್ಯಾರ್ಥಿ ಪ್ರೋಗ್ರಾಮರ್ಗಳು ಹಲವಾರು ಸರಳ ಸಮಸ್ಯೆಗಳಿಗೆ ಪ್ಯಾಸ್ಕಲ್ನಲ್ಲಿ ಸರಿಯಾದ ಪರಿಹಾರಗಳನ್ನು ರೂಪಿಸಲು ಕಷ್ಟಪಟ್ಟಿದ್ದರು, ಇದರಲ್ಲಿ ಒಂದು ಶ್ರೇಣಿಯಲ್ಲಿ ಒಂದು ಅಂಶವನ್ನು ಹುಡುಕಲು ಕಾರ್ಯವನ್ನು ಬರೆಯುವುದು ಸೇರಿದೆ. 1980ರಲ್ಲಿ ರಾಬರ್ಟ್ಸ್ ಉಲ್ಲೇಖಿಸಿದ ಹೆನ್ರಿ ಶಪಿರೊ ಅವರ ಅಧ್ಯಯನವು, ಪ್ಯಾಸ್ಕಲ್-ಒದಗಿಸಿದ ನಿಯಂತ್ರಣ ರಚನೆಗಳನ್ನು ಮಾತ್ರ ಬಳಸಿ, ಕೇವಲ 20 ಪ್ರತಿಶತ ವಿಷಯಗಳು ಮಾತ್ರ ಸರಿಯಾದ ಪರಿಹಾರವನ್ನು ನೀಡಿವೆ ಎಂದು ಕಂಡುಹಿಡಿದಿದೆ, ಆದರೆ ಯಾವುದೇ ವಿಷಯವು ಲೂಪ್ ಮಧ್ಯದಿಂದ ರಿಟರ್ನ್ ಬರೆಯಲು ಅನುಮತಿಸಿದರೆ ಈ ಸಮಸ್ಯೆಗೆ ತಪ್ಪಾದ ಕೋಡ್ ಅನ್ನು ಬರೆಯುವುದಿಲ್ಲ. ಆಚರಣೆಯಲ್ಲಿ ನಿಯಂತ್ರಣ ರಚನೆಗಳು ನಿಯಂತ್ರಣ ರಚನೆಗಳನ್ನು ಹೊಂದಿರುವ ಹೆಚ್ಚಿನ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳು ಆರಂಭಿಕ ಕೀವರ್ಡ್ ಅನ್ನು ಹೊಂದಿರುತ್ತವೆ, ಇದು ಒಳಗೊಂಡಿರುವ ನಿಯಂತ್ರಣ ರಚನೆಯ ಪ್ರಕಾರವನ್ನು ಸೂಚಿಸುತ್ತದೆ. ನಿಯಂತ್ರಣ ರಚನೆಗಳು ಅಂತಿಮ ಕೀವರ್ಡ್ ಅನ್ನು ಹೊಂದಿದೆಯೇ ಅಥವಾ ಇಲ್ಲವೇ ಎಂಬುದರ ಬಗ್ಗೆ ಭಾಷೆಗಳು ವಿಭಜನೆಯಾಗುತ್ತವೆ. ಯಾವುದೇ ಅಂತಿಮ ಕೀವರ್ಡ್ ಇಲ್ಲಃ ALGOL 60, C, C + +, ಹಾಸ್ಕೆಲ್, ಜಾವಾ, ಪ್ಯಾಸ್ಕಲ್, ಪರ್ಲ್, ಪಿಎಚ್ಪಿ, ಪಿಎಲ್/ಐ, ಪೈಥಾನ್, ಪವರ್ಶೆಲ್. ಅಂತಹ ಭಾಷೆಗಳಿಗೆ ಹೇಳಿಕೆಗಳನ್ನು ಒಟ್ಟುಗೂಡಿಸಲು ಕೆಲವು ವಿಧಾನಗಳ ಅಗತ್ಯವಿದೆಃ ALGOL 60 ಮತ್ತು ಪ್ಯಾಸ್ಕಲ್ಃ ಸ್ಟಾರ್ಟ್. ಎಂಡ್ ಸಿ, ಸಿ + +, ಜಾವಾ, ಪರ್ಲ್, ಪಿಎಚ್ಪಿ, ಮತ್ತು ಪವರ್ಶೆಲ್ಃ ಕರ್ಲಿ ಬ್ರಾಕೆಟ್ಗಳು {.} ಪಿಎಲ್/ಐಃ ಡಿಒ. ಎಂಡ್ ಪೈಥಾನ್ಃ ಇಂಡೆಂಟ್ ಲೆವೆಲ್ ಅನ್ನು ಬಳಸುತ್ತದೆ (ಆಫ್-ಸೈಡ್ ನಿಯಮವನ್ನು ನೋಡಿ) ಹಾಸ್ಕೆಲ್ಃ ಇಂಡೆಂಟ್ ಲೆವೆಲ್ ಅಥವಾ ಕರ್ಲಿ ಬ್ರಾಕೆಟ್ಗಳನ್ನು ಬಳಸಬಹುದು, ಮತ್ತು ಅವುಗಳನ್ನು ಮುಕ್ತವಾಗಿ ಲುವಾವನ್ನು ಬೆರೆಸಬಹುದುಃ ಡು ಅನ್ನು ಬಳಸುತ್ತದೆ. ಅಂತಿಮ ಕೀವರ್ಡ್ಃ ಅದಾ, ಎಪಿಎಲ್, ALGOL 68, ಮಾಡ್ಯುಲಾ-2, ಫೋರ್ಟ್ರಾನ್ 77, ಮೈತ್ರಿಲ್, ವಿಷುಯಲ್ ಬೇಸಿಕ್. ಅಂತಿಮ ಕೀವರ್ಡ್ನ ರೂಪಗಳು ಬದಲಾಗುತ್ತವೆಃ ಅಡಾಃ ಅಂತಿಮ ಕೀವರ್ಡ್ ಎಂಡ್ + ಸ್ಪೇಸ್ + ಆರಂಭಿಕ ಕೀವರ್ಡ್ ಉದಾ. ಎಂಡ್ ಇಫ್, ಲೂಪ್. ಎಂಡ್ ಲೂಪ್ ಎಪಿಎಲ್ಃ ಅಂತಿಮ ಕೀವರ್ಡ್ ಎಂದರೆಃ ಐಚ್ಛಿಕವಾಗಿ ಎಂಡ್ + ಆರಂಭಿಕ ಕೀವರ್ಡ್, ಉದಾ.: ಇಫ್.: ಎಂಡ್ ಅಥವಾಃ ಇಫ್.: ಎಂಡ್ ಇಫ್, ಸೆಲೆಕ್ಟ್.: ಎಂಡ್ ಅಥವಾಃ ಸೆಲೆಕ್ಟ್.: ಎಂಡ್ ಸೆಲೆಕ್ಟ್, ಆದಾಗ್ಯೂ, ಅಂತಿಮ ಸ್ಥಿತಿಯನ್ನು ಸೇರಿಸಿದರೆ, ಅಂತಿಮ ಕೀವರ್ಡ್ ಆಗುತ್ತದೆಃ ALGOL 68 ರವರೆಗೆ, ಮಿಥ್ರಿಲ್ಃ ಆರಂಭಿಕ ಕೀವರ್ಡ್ ಅನ್ನು ಹಿಂದಕ್ಕೆ ಉಚ್ಚರಿಸಲಾಗುತ್ತದೆ ಉದಾ. ಇಫ್. ಎಂಡ್ ಇಫ್; ಫಾರ್. ನೆಕ್ಸ್ಟ್; ಡು. ಲೂಪ್; ವೈಲ್. ವೆಂಡ್ ಚಾಯ್ಸ್ ಇಫ್-ಥೆನ್-(ಎಲ್ಸ್) ಹೇಳಿಕೆಗಳು ಷರತ್ತುಬದ್ಧ ಅಭಿವ್ಯಕ್ತಿಗಳು ಮತ್ತು ಷರತ್ತುಬದ್ಧ ರಚನೆಗಳು ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಯ ಲಕ್ಷಣಗಳಾಗಿವೆ, ಇದು ಪ್ರೋಗ್ರಾಮರ್-ನಿರ್ದಿಷ್ಟ ಬೂಲಿಯನ್ ಸ್ಥಿತಿಯು ನಿಜ ಅಥವಾ ಸುಳ್ಳು ಎಂದು ಮೌಲ್ಯಮಾಪನ ಮಾಡುತ್ತದೆಯೇ ಎಂಬುದರ ಆಧಾರದ ಮೇಲೆ ವಿಭಿನ್ನ ಲೆಕ್ಕಾಚಾರಗಳು ಅಥವಾ ಕ್ರಿಯೆಗಳನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ. IF.GOTO. ರಚನೆಯಿಲ್ಲದ ಭಾಷೆಗಳಲ್ಲಿ ಕಂಡುಬರುವ ಒಂದು ಫಾರ್ಮ್, ಒಂದು ವಿಶಿಷ್ಟವಾದ ಯಂತ್ರ ಸಂಕೇತ ಸೂಚನೆಯನ್ನು ಅನುಕರಿಸುತ್ತದೆ, ಷರತ್ತನ್ನು ಪೂರೈಸಿದಾಗ ಲೇಬಲ್ ಅಥವಾ ಲೈನ್ ಸಂಖ್ಯೆಗೆ (ಜಿ. ಓ. ಟಿ. ಓ) ಹೋಗುತ್ತದೆ. IF.THEN. (ENDIF). ಜಿಗಿತಕ್ಕೆ ಸೀಮಿತವಾಗುವ ಬದಲು, ಯಾವುದೇ ಸರಳ ಹೇಳಿಕೆ ಅಥವಾ ನೆಸ್ಟೆಡ್ ಬ್ಲಾಕ್, ಥೆನ್ ಕೀವರ್ಡ್ ಅನ್ನು ಅನುಸರಿಸಬಹುದು. ಇದು ಒಂದು ರಚನಾತ್ಮಕ ರೂಪವಾಗಿದೆ. IF.THEN.ELSE. (ENDIF). ಮೇಲಿನಂತೆ, ಆದರೆ ಷರತ್ತು ತಪ್ಪಾಗಿದ್ದರೆ ಎರಡನೇ ಕ್ರಮವನ್ನು ಕೈಗೊಳ್ಳಬೇಕಾಗುತ್ತದೆ. ಇದು ಅನೇಕ ವ್ಯತ್ಯಾಸಗಳನ್ನು ಹೊಂದಿರುವ ಅತ್ಯಂತ ಸಾಮಾನ್ಯ ರೂಪಗಳಲ್ಲಿ ಒಂದಾಗಿದೆ. ಕೆಲವರಿಗೆ ಟರ್ಮಿನಲ್ ಎಂಡಿಐಎಫ್ ಅಗತ್ಯವಿರುತ್ತದೆ, ಇತರರಿಗೆ ಅಗತ್ಯವಿಲ್ಲ. ಸಿ ಮತ್ತು ಸಂಬಂಧಿತ ಭಾಷೆಗಳಿಗೆ ಅಂತಿಮ ಕೀವರ್ಡ್ ಅಥವಾ 'ನಂತರ' ಅಗತ್ಯವಿಲ್ಲ, ಆದರೆ ಷರತ್ತಿನ ಸುತ್ತಲೂ ಆವರಣದ ಅಗತ್ಯವಿರುತ್ತದೆ. ಷರತ್ತುಬದ್ಧ ಹೇಳಿಕೆಗಳನ್ನು ಇತರ ಷರತ್ತುಬದ್ಧ ಹೇಳಿಕೆಗಳಲ್ಲಿ ಸೇರಿಸಬಹುದು ಮತ್ತು ಆಗಾಗ್ಗೆ ಸೇರಿಸಬಹುದು. ಕೆಲವು ಭಾಷೆಗಳು ELSE ಮತ್ತು IF ಅನ್ನು ELSEIF ಗೆ ಸಂಯೋಜಿಸಲು ಅವಕಾಶ ಮಾಡಿಕೊಡುತ್ತವೆ, ಇದು ಸಂಯುಕ್ತ ಹೇಳಿಕೆಯ ಕೊನೆಯಲ್ಲಿ ENDIF ಅಥವಾ ಇತರ ಅಂತಿಮ ಹೇಳಿಕೆಗಳ ಸರಣಿಯನ್ನು ಹೊಂದುವ ಅಗತ್ಯವನ್ನು ತಪ್ಪಿಸುತ್ತದೆ. ಕಡಿಮೆ ಸಾಮಾನ್ಯ ವ್ಯತ್ಯಾಸಗಳು ಸೇರಿವೆಃ ಒಂದು ಸಂಖ್ಯಾ ಮೌಲ್ಯವು ಧನಾತ್ಮಕ, ಋಣಾತ್ಮಕ ಅಥವಾ ಶೂನ್ಯವಾಗಿದೆಯೇ ಎಂದು ಪರೀಕ್ಷಿಸಲು, ಫೋರ್ಟ್ರಾನ್ನಂತಹ ಕೆಲವು ಭಾಷೆಗಳು ತ್ರಿಮುಖ ಅಥವಾ ಅಂಕಗಣಿತವನ್ನು ಹೊಂದಿರುತ್ತವೆ. ಕೆಲವು ಭಾಷೆಗಳು ಇಫ್ ಹೇಳಿಕೆಯ ಕ್ರಿಯಾತ್ಮಕ ರೂಪವನ್ನು ಹೊಂದಿವೆ, ಉದಾಹರಣೆಗೆ ಲಿಸ್ಪ್ಸ್ ಕಾಂಡ್. ಕೆಲವು ಭಾಷೆಗಳು ಐಎಫ್ ಹೇಳಿಕೆಯ ಆಪರೇಟರ್ ರೂಪವನ್ನು ಹೊಂದಿವೆ, ಉದಾಹರಣೆಗೆ ಸಿ ಯ ಟೆರ್ನರಿ ಆಪರೇಟರ್. ಪರ್ಲ್ ಸಿ-ಶೈಲಿಯನ್ನು ಯಾವಾಗ ಮತ್ತು ಯಾವಾಗ ಹೊರತು ಪೂರಕವಾಗಿಸುತ್ತದೆ. ಸ್ಮಾಲ್ಟಾಕ್ ಯಾವುದೇ ಮೂಲಭೂತ ಭಾಷಾ ರಚನೆಯ ಬದಲು ಷರತ್ತುಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಇಫ್ ಟ್ರೂ ಮತ್ತು ಇಫ್ ಫಾಲ್ಸ್ ಸಂದೇಶಗಳನ್ನು ಬಳಸುತ್ತದೆ. ಕೇಸ್ ಮತ್ತು ಸ್ವಿಚ್ ಸ್ಟೇಟ್ಮೆಂಟ್ಗಳು ಸ್ವಿಚ್ ಸ್ಟೇಟ್ಮೆಂಟ್ಗಳು (ಅಥವಾ ಕೇಸ್ ಸ್ಟೇಟ್ಮೆಂಟ್ಗಳು, ಅಥವಾ ಮಲ್ಟಿಪ್ವೇ ಶಾಖೆಗಳು) ನಿರ್ದಿಷ್ಟ ಮೌಲ್ಯವನ್ನು ನಿರ್ದಿಷ್ಟ ಸ್ಥಿರಾಂಕಗಳೊಂದಿಗೆ ಹೋಲಿಸಿ ಮತ್ತು ಹೊಂದಿಕೆಯಾಗುವ ಮೊದಲ ಸ್ಥಿರಾಂಕದ ಪ್ರಕಾರ ಕ್ರಮ ಕೈಗೊಳ್ಳುತ್ತವೆ. ಯಾವುದೇ ಪಂದ್ಯವು ಯಶಸ್ವಿಯಾಗದಿದ್ದರೆ ತೆಗೆದುಕೊಳ್ಳಬೇಕಾದ ಪೂರ್ವನಿಯೋಜಿತ ಕ್ರಮಕ್ಕೆ ("ಇಲ್ಲದಿದ್ದರೆ", "ಇಲ್ಲದಿದ್ದರೆ") ಸಾಮಾನ್ಯವಾಗಿ ಅವಕಾಶವಿರುತ್ತದೆ. ಸ್ವಿಚ್ ಸ್ಟೇಟ್ಮೆಂಟ್ಗಳು ಲುಕ್ಅಪ್ ಕೋಷ್ಟಕಗಳಂತಹ ಕಂಪೈಲರ್ ಆಪ್ಟಿಮೈಸೇಶನ್ಗಳನ್ನು ಅನುಮತಿಸಬಹುದು. ಡೈನಾಮಿಕ್ ಭಾಷೆಗಳಲ್ಲಿ, ಪ್ರಕರಣಗಳು ಸ್ಥಿರ ಅಭಿವ್ಯಕ್ತಿಗಳಿಗೆ ಸೀಮಿತವಾಗಿಲ್ಲದಿರಬಹುದು, ಮತ್ತು ಬಲಭಾಗದಲ್ಲಿರುವ ಶೆಲ್ ಸ್ಕ್ರಿಪ್ಟ್ ಉದಾಹರಣೆಯಲ್ಲಿರುವಂತೆ ಮಾದರಿಯ ಹೊಂದಾಣಿಕೆಗೆ ವಿಸ್ತರಿಸಬಹುದು, ಅಲ್ಲಿ *) ಯಾವುದೇ ಸ್ಟ್ರಿಂಗ್ಗೆ ಹೊಂದಿಕೆಯಾಗುವ ಗ್ಲೋಬ್ ಆಗಿ ಡೀಫಾಲ್ಟ್ ಕೇಸ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತದೆ. ಎಸ್. ಕ್ಯೂ. ಎಲ್. ನ ಡಿಕೋಡ್ ಹೇಳಿಕೆಯಲ್ಲಿರುವಂತೆ ಕೇಸ್ ಲಾಜಿಕ್ ಅನ್ನು ಕ್ರಿಯಾತ್ಮಕ ರೂಪದಲ್ಲಿ ಸಹ ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದು. ಲೂಪ್ ಎನ್ನುವುದು ಹೇಳಿಕೆಗಳ ಒಂದು ಅನುಕ್ರಮವಾಗಿದ್ದು, ಇದನ್ನು ಒಮ್ಮೆ ನಿರ್ದಿಷ್ಟಪಡಿಸಲಾಗುತ್ತದೆ ಆದರೆ ಇದನ್ನು ಅನುಕ್ರಮವಾಗಿ ಹಲವಾರು ಬಾರಿ ನಡೆಸಬಹುದು. ಲೂಪ್ "ಇನ್ಸೈಡ್" ಕೋಡ್ ಅನ್ನು (ಲೂಪ್ನ ಮುಖ್ಯ ಭಾಗವನ್ನು, ಕೆಳಗೆ XXX ಎಂದು ತೋರಿಸಲಾಗಿದೆ) ನಿರ್ದಿಷ್ಟ ಸಂಖ್ಯೆಯ ಬಾರಿ, ಅಥವಾ ಪ್ರತಿಯೊಂದು ವಸ್ತುಗಳ ಸಂಗ್ರಹಕ್ಕೆ ಒಮ್ಮೆ, ಅಥವಾ ಕೆಲವು ಷರತ್ತುಗಳನ್ನು ಪೂರೈಸುವವರೆಗೆ, ಅಥವಾ ಅನಿರ್ದಿಷ್ಟವಾಗಿ ಪಾಲಿಸಲಾಗುತ್ತದೆ. ಹಾಸ್ಕೆಲ್ ಮತ್ತು ಸ್ಕೀಮ್ನಂತಹ ಕ್ರಿಯಾತ್ಮಕ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳಲ್ಲಿ, ಪುನರಾವರ್ತಿತ ಮತ್ತು ಪುನರಾವರ್ತಿತ ಪ್ರಕ್ರಿಯೆಗಳೆರಡನ್ನೂ ವಾಕ್ಯರಚನೆಯ ಲೂಪಿಂಗ್ ರಚನೆಗಳ ಬದಲಿಗೆ ಬಾಲ ಪುನರಾವರ್ತಿತ ಕಾರ್ಯವಿಧಾನಗಳೊಂದಿಗೆ ವ್ಯಕ್ತಪಡಿಸಲಾಗುತ್ತದೆ. ಎಣಿಕೆ-ನಿಯಂತ್ರಿತ ಲೂಪ್ಗಳು ಹೆಚ್ಚಿನ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳು ಲೂಪ್ ಅನ್ನು ನಿರ್ದಿಷ್ಟ ಸಂಖ್ಯೆಯ ಬಾರಿ ಪುನರಾವರ್ತಿಸುವ ರಚನೆಗಳನ್ನು ಹೊಂದಿವೆ. ಹೆಚ್ಚಿನ ಸಂದರ್ಭಗಳಲ್ಲಿ ಎಣಿಕೆ ಮೇಲ್ಮುಖವಾಗಿ ಹೋಗುವ ಬದಲು ಕೆಳಮುಖವಾಗಿ ಹೋಗಬಹುದು ಮತ್ತು 1ನ್ನು ಹೊರತುಪಡಿಸಿ ಬೇರೆ ಹಂತದ ಗಾತ್ರಗಳನ್ನು ಬಳಸಬಹುದು. ಈ ಉದಾಹರಣೆಗಳಲ್ಲಿ, ಎನ್ <1 ಆಗಿದ್ದರೆ, ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಯನ್ನು ಅವಲಂಬಿಸಿ ಲೂಪ್ನ ಮುಖ್ಯ ಭಾಗವು ಒಮ್ಮೆ ಕಾರ್ಯಗತಗೊಳ್ಳಬಹುದು (ನಾನು 1 ಮೌಲ್ಯವನ್ನು ಹೊಂದಿದ್ದೇನೆ) ಅಥವಾ ಇಲ್ಲ. ಅನೇಕ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳಲ್ಲಿ, ಎಣಿಕೆ-ನಿಯಂತ್ರಿತ ಲೂಪ್ನಲ್ಲಿ ಪೂರ್ಣಾಂಕಗಳನ್ನು ಮಾತ್ರ ವಿಶ್ವಾಸಾರ್ಹವಾಗಿ ಬಳಸಬಹುದು. ಯಂತ್ರಾಂಶದ ನಿರ್ಬಂಧಗಳ ಕಾರಣದಿಂದಾಗಿ ಫ್ಲೋಟಿಂಗ್-ಪಾಯಿಂಟ್ ಸಂಖ್ಯೆಗಳನ್ನು ನಿಖರವಾಗಿ ಪ್ರತಿನಿಧಿಸಲಾಗುವುದಿಲ್ಲ, ಆದ್ದರಿಂದ X: = 0.1 ಹಂತ 0.1 ರಿಂದ 1.0 ಡುಗಳಂತಹ ಲೂಪ್ ಅನ್ನು ಸುತ್ತಿನ ದೋಷಗಳು ಮತ್ತು/ಅಥವಾ ಯಂತ್ರಾಂಶ ಮತ್ತು/ಅಥವಾ ಕಂಪೈಲರ್ ಆವೃತ್ತಿಯನ್ನು ಅವಲಂಬಿಸಿ 9 ಅಥವಾ 10 ಬಾರಿ ಪುನರಾವರ್ತಿಸಬಹುದು. ಇದಲ್ಲದೆ, ಪುನರಾವರ್ತಿತ ಸೇರ್ಪಡೆಯಿಂದ Xನ ಹೆಚ್ಚಳವು ಸಂಭವಿಸಿದಲ್ಲಿ, ಶೇಖರಣೆಯಾದ ಪೂರ್ಣಾಂಕದ ದೋಷಗಳು ಎಂದರೆ ಪ್ರತಿ ಪುನರಾವರ್ತನೆಯಲ್ಲಿನ Xನ ಮೌಲ್ಯವು ನಿರೀಕ್ಷಿತ ಅನುಕ್ರಮವಾದ 0.1,2.3,..., 1ಕ್ಕಿಂತ ಗಣನೀಯವಾಗಿ ಭಿನ್ನವಾಗಿರಬಹುದು ಎಂದರ್ಥ. ಷರತ್ತು-ನಿಯಂತ್ರಿತ ಲೂಪ್ಗಳು ಹೆಚ್ಚಿನ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳು ಕೆಲವು ಷರತ್ತುಗಳು ಬದಲಾಗುವವರೆಗೆ ಲೂಪ್ ಅನ್ನು ಪುನರಾವರ್ತಿಸುವ ರಚನೆಗಳನ್ನು ಹೊಂದಿವೆ. ಕೆಲವು ವ್ಯತ್ಯಾಸಗಳು ಲೂಪ್ನ ಆರಂಭದಲ್ಲಿ ಸ್ಥಿತಿಯನ್ನು ಪರೀಕ್ಷಿಸುತ್ತವೆ; ಇತರರು ಅದನ್ನು ಕೊನೆಯಲ್ಲಿ ಪರೀಕ್ಷಿಸುತ್ತಾರೆ. ಪರೀಕ್ಷೆಯು ಆರಂಭದಲ್ಲಿದ್ದರೆ, ದೇಹವನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ಬಿಟ್ಟುಬಿಡಬಹುದು; ಅದು ಕೊನೆಯಲ್ಲಿದ್ದರೆ, ದೇಹವನ್ನು ಯಾವಾಗಲೂ ಒಮ್ಮೆಯಾದರೂ ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ. ನಿಯಂತ್ರಣ ವಿರಾಮವು ಮೌಲ್ಯಗಳ ಗುಂಪುಗಳಿಗೆ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಪ್ರಚೋದಿಸಲು ಸಾಮಾನ್ಯ ಲೂಪ್ಗಳಲ್ಲಿ ಬಳಸುವ ಮೌಲ್ಯ ಬದಲಾವಣೆ ಪತ್ತೆ ವಿಧಾನವಾಗಿದೆ. ಮೌಲ್ಯಗಳನ್ನು ಲೂಪ್ನೊಳಗೆ ಮೇಲ್ವಿಚಾರಣೆ ಮಾಡಲಾಗುತ್ತದೆ ಮತ್ತು ಬದಲಾವಣೆಯು ಪ್ರೋಗ್ರಾಂನ ಹರಿವನ್ನು ಅವುಗಳಿಗೆ ಸಂಬಂಧಿಸಿದ ಗುಂಪು ಘಟನೆಯ ನಿರ್ವಹಣೆಗೆ ತಿರುಗಿಸುತ್ತದೆ. ಹಲವಾರು ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳು (ಉದಾಹರಣೆಗೆ, ಅಡಾ, ಡಿ, ಸಿ + + 11, ಸ್ಮಾಲ್ಟಾಕ್, ಪಿಎಚ್ಪಿ, ಪರ್ಲ್, ಆಬ್ಜೆಕ್ಟ್ ಪ್ಯಾಸ್ಕಲ್, ಜಾವಾ, ಸಿ #, ಮ್ಯಾಟ್ಲ್ಯಾಬ್, ವಿಷುಯಲ್ ಬೇಸಿಕ್, ರೂಬಿ, ಪೈಥಾನ್, ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್, ಫೋರ್ಟ್ರಾನ್ 95 ಮತ್ತು ನಂತರದ) ಒಂದು ಶ್ರೇಣಿಯ ಎಲ್ಲಾ ಅಂಶಗಳ ಮೂಲಕ ಸೂಚ್ಯ ಲೂಪಿಂಗ್ ಅನ್ನು ಅನುಮತಿಸುವ ವಿಶೇಷ ರಚನೆಗಳನ್ನು ಹೊಂದಿವೆ. ಕೆಲವು ಸಂಗ್ರಹಃ [: ಪ್ರತಿ ಎಲಿಮೆಂಟ್ |xxx]. ಸಂಗ್ರಹದಲ್ಲಿರುವ ವಸ್ತುವಿಗಾಗಿ XXX ತುದಿಯನ್ನು ಪ್ರಾರಂಭಿಸಿ; ಫೋರ್ಚ್ (ಐಟಂ; ಮೈ ಕಲೆಕ್ಷನ್) {XXX} ಕೆಲವು ಅರೇ {XXX} ಫೋರ್ಚ್ ($ಕೆಲವು ಅರೇ $k => $v) {XXX} ಕಲೆಕ್ಷನ್ <ಸ್ಟ್ರಿಂಗ್> ಕೋಲ್; ಫಾರ್ (ಸ್ಟ್ರಿಂಗ್ s: ಕೋಲ್) {} ಫೋರ್ಚ್ (ಸ್ಟ್ರಿಂಗ್ s ಇನ್ ಮೈ ಸ್ಟ್ರಿಂಗ್ ಕಲೆಕ್ಷನ್) {XXX} ಕೆಲವು ಕಲೆಕ್ಷನ್ | ಫಾರ್ಇಚ್-ಆಬ್ಜೆಕ್ಟ್ {$_} ಫಾರ್ ಆಲ್ (ಸೂಚ್ಯಂಕ = ಮೊದಲಃ ಕೊನೆಯಃ ಹಂತ.) ಸ್ಕಾಲಾ ಫಾರ್-ಎಕ್ಸ್ಪ್ರೆಶನ್ಗಳನ್ನು ಹೊಂದಿದೆ, ಇದು ಸಂಗ್ರಹ-ನಿಯಂತ್ರಿತ ಲೂಪ್ಗಳನ್ನು ಸಾಮಾನ್ಯಗೊಳಿಸುತ್ತದೆ ಮತ್ತು ಅಸಿಂಕ್ರೋನಸ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್ನಂತಹ ಇತರ ಬಳಕೆಗಳನ್ನು ಸಹ ಬೆಂಬಲಿಸುತ್ತದೆ. ಹಾಸ್ಕೆಲ್ ಡು-ಎಕ್ಸ್ಪ್ರೆಶನ್ಗಳು ಮತ್ತು ಕಾಂಪ್ರೆಹೆನ್ಷನ್ಗಳನ್ನು ಹೊಂದಿದ್ದಾರೆ, ಇದು ಸ್ಕಾಲಾದಲ್ಲಿನ ಫಾರ್-ಎಕ್ಸ್ಪ್ರೆಶನ್ಗಳಿಗೆ ಹೋಲುವ ಕಾರ್ಯವನ್ನು ಒದಗಿಸುತ್ತದೆ. ಸಾಮಾನ್ಯ ಪುನರಾವರ್ತನೆ ಸಿ 'ಸ್ ಫಾರ್ ಸ್ಟೇಟ್ಮೆಂಟ್ ಮತ್ತು ಕಾಮನ್ ಲಿಸ್ಪ್ನ ಡು ಫಾರ್ಮ್ನಂತಹ ಸಾಮಾನ್ಯ ಪುನರಾವರ್ತನೆಯ ರಚನೆಗಳನ್ನು ಮೇಲಿನ ಯಾವುದೇ ರೀತಿಯ ಲೂಪ್ಗಳನ್ನು ವ್ಯಕ್ತಪಡಿಸಲು ಬಳಸಬಹುದು, ಮತ್ತು ಇತರವುಗಳು, ಉದಾಹರಣೆಗೆ ಕೆಲವು ಸಂಖ್ಯೆಯ ಸಂಗ್ರಹಗಳ ಮೇಲೆ ಸಮಾನಾಂತರವಾಗಿ ಲೂಪ್ ಮಾಡುವುದು. ಹೆಚ್ಚು ನಿರ್ದಿಷ್ಟವಾದ ಲೂಪಿಂಗ್ ರಚನೆಯನ್ನು ಬಳಸಬಹುದಾದಲ್ಲಿ, ಇದನ್ನು ಸಾಮಾನ್ಯವಾಗಿ ಸಾಮಾನ್ಯ ಪುನರಾವರ್ತನೆಯ ರಚನೆಯ ಮೇಲೆ ಆದ್ಯತೆ ನೀಡಲಾಗುತ್ತದೆ, ಏಕೆಂದರೆ ಇದು ಸಾಮಾನ್ಯವಾಗಿ ಅಭಿವ್ಯಕ್ತಿಯ ಉದ್ದೇಶವನ್ನು ಸ್ಪಷ್ಟಪಡಿಸುತ್ತದೆ. ಅನಂತ ಲೂಪ್ಗಳನ್ನು ಪ್ರೋಗ್ರಾಂ ವಿಭಾಗದ ಲೂಪ್ಗಳನ್ನು ಶಾಶ್ವತವಾಗಿ ಅಥವಾ ದೋಷದಂತಹ ಅಸಾಧಾರಣ ಪರಿಸ್ಥಿತಿ ಉದ್ಭವಿಸುವವರೆಗೆ ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಬಳಸಲಾಗುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ಈವೆಂಟ್-ಚಾಲಿತ ಪ್ರೋಗ್ರಾಂ (ಸರ್ವರ್ನಂತಹ) ಶಾಶ್ವತವಾಗಿ ಲೂಪ್ ಆಗಬೇಕು, ಈವೆಂಟ್ಗಳು ಸಂಭವಿಸಿದಂತೆ ಅವುಗಳನ್ನು ನಿರ್ವಹಿಸಬೇಕು, ಆಪರೇಟರ್ನಿಂದ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಕೊನೆಗೊಳಿಸಿದಾಗ ಮಾತ್ರ ನಿಲ್ಲಬೇಕು. ಇತರ ನಿಯಂತ್ರಣ ಹರಿವಿನ ರಚನೆಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಅನಂತ ಕುಣಿಕೆಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದು. ಸಾಮಾನ್ಯವಾಗಿ, ರಚನೆಯಿಲ್ಲದ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ನಲ್ಲಿ ಇದನ್ನು ಜಂಪ್ ಬ್ಯಾಕ್ ಅಪ್ (ಗೊಟೊ) ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ, ಆದರೆ ಸಂರಚಿತ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ನಲ್ಲಿ ಇದು ಅನಿರ್ದಿಷ್ಟ ಲೂಪ್ (ವೈಲ್ ಲೂಪ್) ಆಗಿದ್ದು, ಇದು ಎಂದಿಗೂ ಕೊನೆಗೊಳ್ಳುವುದಿಲ್ಲ, ಷರತ್ತನ್ನು ಬಿಟ್ಟುಬಿಡುವುದರ ಮೂಲಕ ಅಥವಾ ಅದನ್ನು ವೈಲ್ (ಟ್ರೂ) ಎಂದು ಸ್ಪಷ್ಟವಾಗಿ ಸರಿ ಎಂದು ಹೊಂದಿಸುವ ಮೂಲಕ. ಕೆಲವು ಭಾಷೆಗಳು ಅನಂತ ಲೂಪ್ಗಳಿಗೆ ವಿಶೇಷ ರಚನೆಗಳನ್ನು ಹೊಂದಿವೆ, ಸಾಮಾನ್ಯವಾಗಿ ಅನಿರ್ದಿಷ್ಟ ಲೂಪ್ನಿಂದ ಸ್ಥಿತಿಯನ್ನು ಬಿಟ್ಟುಬಿಡುತ್ತವೆ. ಉದಾಹರಣೆಗಳಲ್ಲಿ ಅಡಾ (ಲೂಪ್. ಎಂಡ್ ಲೂಪ್), ಫೋರ್ಟ್ರಾನ್ (ಡಿಒ. ಎಂಡ್ ಡಿಒ), ಗೋ ({.} ಗಾಗಿ), ಮತ್ತು ರೂಬಿ (ಲೂಪ್ ಡು. ಎಂಡ್) ಸೇರಿವೆ. ಆಗಾಗ್ಗೆ, ಷರತ್ತು-ನಿಯಂತ್ರಿತ ಲೂಪ್ನಲ್ಲಿನ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ದೋಷದಿಂದ ಅನಂತ ಲೂಪ್ ಅನ್ನು ಅನುದ್ದೇಶಪೂರ್ವಕವಾಗಿ ರಚಿಸಲಾಗುತ್ತದೆ, ಇದರಲ್ಲಿ ಲೂಪ್ ಸ್ಥಿತಿಯು ಲೂಪ್ನೊಳಗೆ ಎಂದಿಗೂ ಬದಲಾಗದ ಅಸ್ಥಿರಗಳನ್ನು ಬಳಸುತ್ತದೆ. ಮುಂದಿನ ಪುನರಾವರ್ತನೆಯೊಂದಿಗೆ ಮುಂದುವರಿಕೆ ಕೆಲವೊಮ್ಮೆ ಲೂಪ್ನ ದೇಹದೊಳಗೆ ಲೂಪ್ನ ದೇಹದ ಉಳಿದ ಭಾಗವನ್ನು ಬಿಟ್ಟು ಲೂಪ್ನ ಮುಂದಿನ ಪುನರಾವರ್ತನೆಯೊಂದಿಗೆ ಮುಂದುವರೆಯುವ ಬಯಕೆ ಇರುತ್ತದೆ. ಕೆಲವು ಭಾಷೆಗಳು ಕಂಟಿನ್ಯೂ (ಹೆಚ್ಚಿನ ಭಾಷೆಗಳು), ಸ್ಕಿಪ್, ಸೈಕಲ್ (ಫೋರ್ಟ್ರಾನ್), ಅಥವಾ ನೆಕ್ಸ್ಟ್ (ಪರ್ಲ್ ಮತ್ತು ರೂಬಿ) ನಂತಹ ಹೇಳಿಕೆಗಳನ್ನು ಒದಗಿಸುತ್ತವೆ, ಇದು ಇದನ್ನು ಮಾಡುತ್ತದೆ. ಪರಿಣಾಮವೆಂದರೆ ಒಳಗಿನ ಲೂಪ್ ಬಾಡಿಯನ್ನು ಅಕಾಲಿಕವಾಗಿ ಕೊನೆಗೊಳಿಸುವುದು ಮತ್ತು ನಂತರ ಮುಂದಿನ ಪುನರಾವರ್ತನೆಯೊಂದಿಗೆ ಸಾಮಾನ್ಯ ರೀತಿಯಲ್ಲಿ ಪುನರಾರಂಭಿಸುವುದು. ಪುನರಾವರ್ತನೆಯು ಲೂಪ್ನಲ್ಲಿ ಕೊನೆಯದಾಗಿದ್ದರೆ, ಪರಿಣಾಮವೆಂದರೆ ಇಡೀ ಲೂಪನ್ನು ಮೊದಲೇ ಕೊನೆಗೊಳಿಸುವುದು. ಪ್ರಸ್ತುತ ಪುನರಾವರ್ತನೆಯನ್ನು ಮರುಪ್ರಾರಂಭಿಸಿ ಪರ್ಲ್ ಮತ್ತು ರೂಬಿಗಳಂತಹ ಕೆಲವು ಭಾಷೆಗಳು ಪ್ರಸ್ತುತ ಪುನರಾವರ್ತನೆಯನ್ನು ಪ್ರಾರಂಭದಿಂದ ಮರುಪ್ರಾರಂಭಿಸುವ ಮರುಪ್ರಾರಂಭದ ಹೇಳಿಕೆಯನ್ನು ಹೊಂದಿವೆ. ರೀಸ್ಟಾರ್ಟ್ ಲೂಪ್ ರೂಬಿ ಆರಂಭಿಕ ಪುನರಾವರ್ತನೆಯಿಂದ ಸಂಪೂರ್ಣ ಲೂಪ್ ಅನ್ನು ಮರುಪ್ರಾರಂಭಿಸುವ ಮರುಪ್ರಯತ್ನ ಹೇಳಿಕೆಯನ್ನು ಹೊಂದಿದೆ. ಟೇಬಲ್ ಮೂಲಕ ಹುಡುಕಲು ಎಣಿಕೆ-ನಿಯಂತ್ರಿತ ಲೂಪ್ ಅನ್ನು ಬಳಸುವಾಗ, ಅಗತ್ಯವಿರುವ ವಸ್ತುವು ಕಂಡುಬಂದ ತಕ್ಷಣ ಹುಡುಕಾಟವನ್ನು ನಿಲ್ಲಿಸುವುದು ಅಪೇಕ್ಷಣೀಯವಾಗಿದೆ. ಕೆಲವು ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳು ಬ್ರೇಕ್ (ಹೆಚ್ಚಿನ ಭಾಷೆಗಳು), ಎಕ್ಸಿಟ್ (ವಿಷುಯಲ್ ಬೇಸಿಕ್), ಅಥವಾ ಲಾಸ್ಟ್ (ಪರ್ಲ್) ನಂತಹ ಹೇಳಿಕೆಗಳನ್ನು ಒದಗಿಸುತ್ತವೆ, ಇದರ ಪರಿಣಾಮವೆಂದರೆ ಪ್ರಸ್ತುತ ಲೂಪ್ ಅನ್ನು ತಕ್ಷಣವೇ ಕೊನೆಗೊಳಿಸುವುದು ಮತ್ತು ಆ ಲೂಪ್ ನಂತರ ತಕ್ಷಣವೇ ಹೇಳಿಕೆಗೆ ನಿಯಂತ್ರಣವನ್ನು ವರ್ಗಾಯಿಸುವುದು. ಮುಂಚಿತವಾಗಿ ನಿರ್ಗಮಿಸುವ ಲೂಪ್ಗಳಿಗೆ ಮತ್ತೊಂದು ಪದವೆಂದರೆ ಲೂಪ್-ಅಂಡ್-ಎ-ಹಾಫ್. ಈ ಕೆಳಗಿನ ಉದಾಹರಣೆಯನ್ನು ಆಡಾದಲ್ಲಿ ಮಾಡಲಾಗುತ್ತದೆ, ಇದು ಮಧ್ಯದಲ್ಲಿ ಪರೀಕ್ಷೆಯೊಂದಿಗೆ ಲೂಪ್ಗಳು ಮತ್ತು ಲೂಪ್ಗಳಿಂದ ಆರಂಭಿಕ ನಿರ್ಗಮನ ಎರಡನ್ನೂ ಬೆಂಬಲಿಸುತ್ತದೆ. ಎರಡೂ ವೈಶಿಷ್ಟ್ಯಗಳು ತುಂಬಾ ಹೋಲುತ್ತವೆ ಮತ್ತು ಎರಡೂ ಕೋಡ್ ತುಣುಕುಗಳನ್ನು ಹೋಲಿಸುವುದರಿಂದ ವ್ಯತ್ಯಾಸವನ್ನು ತೋರಿಸುತ್ತದೆಃ ಆರಂಭಿಕ ನಿರ್ಗಮನವನ್ನು ಇಫ್ ಹೇಳಿಕೆಯೊಂದಿಗೆ ಸಂಯೋಜಿಸಬೇಕು, ಆದರೆ ಮಧ್ಯದಲ್ಲಿರುವ ಸ್ಥಿತಿಯು ಸ್ವಯಂ-ಒಳಗೊಂಡಿರುವ ರಚನೆಯಾಗಿದೆ. 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 ರ ಪಠ್ಯಪುಸ್ತಕದಲ್ಲಿ, ಡೇವಿಡ್ ವ್ಯಾಟ್ ಬಹು-ಮಟ್ಟದ ವಿರಾಮಗಳು ಮತ್ತು ರಿಟರ್ನ್ ಸ್ಟೇಟ್ಮೆಂಟ್ಗಳ ನಡುವಿನ ಹೋಲಿಕೆಯನ್ನು ವಿವರಿಸಲು ಟೆನ್ನೆಂಟ್ನ ಸೀಕ್ವೆನ್ಸರ್ ಕಲ್ಪನೆಯನ್ನು ಬಳಸುತ್ತಾರೆ. ಎಸ್ಕೇಪ್ ಸೀಕ್ವೆನ್ಸರ್ಗಳು ಎಂದು ಕರೆಯಲ್ಪಡುವ ಸೀಕ್ವೆನ್ಸರ್ಗಳ ಒಂದು ವರ್ಗವನ್ನು "ಪಠ್ಯದಿಂದ ಸುತ್ತುವ ಆಜ್ಞೆ ಅಥವಾ ಕಾರ್ಯವಿಧಾನದ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯನ್ನು ಕೊನೆಗೊಳಿಸುವ ಸೀಕ್ವೆನ್ಸರ್" ಎಂದು ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ, ಇದು ಲೂಪ್ಗಳಿಂದ ವಿರಾಮಗಳನ್ನು (ಬಹು-ಮಟ್ಟದ ವಿರಾಮಗಳನ್ನು ಒಳಗೊಂಡಂತೆ) ಮತ್ತು ರಿಟರ್ನ್ ಸ್ಟೇಟ್ಮೆಂಟ್ಗಳನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ ಎಂದು ವ್ಯಾಟ್ ಹೇಳುತ್ತಾರೆ. ಆದಾಗ್ಯೂ, ಸಾಮಾನ್ಯವಾಗಿ ಅಳವಡಿಸಲಾಗಿರುವಂತೆ, ರಿಟರ್ನ್ ಸೀಕ್ವೆನ್ಸರ್ಗಳು ಸಹ (ರಿಟರ್ನ್) ಮೌಲ್ಯವನ್ನು ಹೊಂದಿರಬಹುದು, ಆದರೆ ಸಮಕಾಲೀನ ಭಾಷೆಗಳಲ್ಲಿ ಅಳವಡಿಸಲಾಗಿರುವಂತೆ ಬ್ರೇಕ್ ಸೀಕ್ವೆನ್ಸರ್ ಸಾಮಾನ್ಯವಾಗಿ ಸಾಧ್ಯವಿಲ್ಲ. ಲೂಪ್ ರೂಪಾಂತರಗಳು ಮತ್ತು ಅಸ್ಥಿರ ಲೂಪ್ ರೂಪಾಂತರಗಳು ಮತ್ತು ಲೂಪ್ ಅಸ್ಥಿರಗಳನ್ನು ಲೂಪ್ಗಳ ನಿಖರತೆಯನ್ನು ವ್ಯಕ್ತಪಡಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ. ಪ್ರಾಯೋಗಿಕವಾಗಿ ಹೇಳುವುದಾದರೆ, ಲೂಪ್ ರೂಪಾಂತರವು ಆರಂಭಿಕ ಋಣಾತ್ಮಕವಲ್ಲದ ಮೌಲ್ಯವನ್ನು ಹೊಂದಿರುವ ಪೂರ್ಣಾಂಕ ಅಭಿವ್ಯಕ್ತಿಯಾಗಿದೆ. ಪ್ರತಿ ಲೂಪ್ ಪುನರಾವರ್ತನೆಯ ಸಮಯದಲ್ಲಿ ರೂಪಾಂತರದ ಮೌಲ್ಯವು ಕಡಿಮೆಯಾಗಬೇಕು ಆದರೆ ಲೂಪ್ನ ಸರಿಯಾದ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯ ಸಮಯದಲ್ಲಿ ಎಂದಿಗೂ ಋಣಾತ್ಮಕವಾಗಬಾರದು. ಲೂಪ್ ರೂಪಾಂತರಗಳನ್ನು ಲೂಪ್ಗಳು ಕೊನೆಗೊಳ್ಳುತ್ತವೆ ಎಂದು ಖಾತರಿಪಡಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ. ಲೂಪ್ ಇನ್ವೇರಿಯಂಟ್ ಎಂಬುದು ಮೊದಲ ಲೂಪ್ ಪುನರಾವರ್ತನೆಯ ಮೊದಲು ನಿಜವಾಗಿರಬೇಕು ಮತ್ತು ಪ್ರತಿ ಪುನರಾವರ್ತನೆಯ ನಂತರವೂ ನಿಜವಾಗಿರಬೇಕು. ಒಂದು ಲೂಪ್ ಸರಿಯಾಗಿ ಕೊನೆಗೊಂಡಾಗ, ನಿರ್ಗಮನ ಸ್ಥಿತಿ ಮತ್ತು ಲೂಪ್ ಇನ್ವೇರಿಯಂಟ್ ಎರಡೂ ತೃಪ್ತಿಯಾಗುತ್ತವೆ ಎಂದು ಇದು ಸೂಚಿಸುತ್ತದೆ. ಸತತ ಪುನರಾವರ್ತನೆಗಳ ಸಮಯದಲ್ಲಿ ಲೂಪ್ನ ನಿರ್ದಿಷ್ಟ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಮೇಲ್ವಿಚಾರಣೆ ಮಾಡಲು ಲೂಪ್ ಇನ್ವೇರಿಯಂಟ್ಗಳನ್ನು ಬಳಸಲಾಗುತ್ತದೆ. ಐಫೆಲ್ನಂತಹ ಕೆಲವು ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳು ಲೂಪ್ ರೂಪಾಂತರಗಳು ಮತ್ತು ಅಸ್ಥಿರಗಳಿಗೆ ಸ್ಥಳೀಯ ಬೆಂಬಲವನ್ನು ಹೊಂದಿವೆ. ಇತರ ಸಂದರ್ಭಗಳಲ್ಲಿ, ಜಾವಾದಲ್ಲಿ ಲೂಪ್ ಹೇಳಿಕೆಗಳಿಗಾಗಿ ಜಾವಾ ಮಾಡೆಲಿಂಗ್ ಭಾಷೆಯ ವಿವರಣೆಯಂತಹ ಬೆಂಬಲವು ಆಡ್-ಆನ್ ಆಗಿದೆ. ಲೂಪ್ ಉಪಭಾಷೆ ಕೆಲವು ಲಿಸ್ಪ್ ಉಪಭಾಷೆಗಳು ಲೂಪ್ಗಳನ್ನು ವಿವರಿಸಲು ವ್ಯಾಪಕವಾದ ಉಪಭಾಷೆಯನ್ನು ಒದಗಿಸುತ್ತವೆ. ಒಂದು ಆರಂಭಿಕ ಉದಾಹರಣೆಯನ್ನು ಕನ್ವರ್ಶನಲ್ ಲಿಸ್ಪ್ ಆಫ್ ಇಂಟರ್ಲಿಸ್ಪ್ನಲ್ಲಿ ಕಾಣಬಹುದು. ಕಾಮನ್ ಲಿಸ್ಪ್ ಅಂತಹ ಉಪಭಾಷೆಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವ ಲೂಪ್ ಮ್ಯಾಕ್ರೋವನ್ನು ಒದಗಿಸುತ್ತದೆ. ಲೂಪ್ ವ್ಯವಸ್ಥೆಯ ಅಡ್ಡ-ಉಲ್ಲೇಖ ಕೋಷ್ಟಕವು (ನಿಜ) ಈ ಉದ್ದೇಶಕ್ಕಾಗಿ ಅನಂತ ಲೂಪ್ ಎಂದು ಪರಿಗಣಿಸುವುದಿಲ್ಲ, ಏಕೆಂದರೆ ಇದು ಮೀಸಲಾದ ಭಾಷೆಯ ರಚನೆಯಲ್ಲ. ಸಿ 'ಸ್ ಫಾರ್ (init; ಟೆಸ್ಟ್; ಇಂಕ್ರಿಮೆಂಟ್) ಲೂಪ್ ಒಂದು ಸಾಮಾನ್ಯ ಲೂಪ್ ರಚನೆಯಾಗಿದೆ, ನಿರ್ದಿಷ್ಟವಾಗಿ ಎಣಿಕೆಯಲ್ಲ, ಆದರೂ ಇದನ್ನು ಹೆಚ್ಚಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ. ಲೇಬಲ್ಗಳು ಮತ್ತು ಗೊಟೊಗಳ ಬಳಕೆಯ ಮೂಲಕ ಎಪಿಎಲ್, ಸಿ, ಸಿ + + ಮತ್ತು ಸಿ #ನಲ್ಲಿ ಆಳವಾದ ವಿರಾಮಗಳನ್ನು ಸಾಧಿಸಬಹುದು. ವಸ್ತುಗಳ ಮೇಲೆ ಪುನರಾವರ್ತನೆಯನ್ನು ಪಿಎಚ್ಪಿ 5ರಲ್ಲಿ ಸೇರಿಸಲಾಗಿದೆ. ಎಣಿಕೆಯ ಲೂಪ್ ಅನ್ನು ಹೆಚ್ಚಿಸುವ ಪಟ್ಟಿ ಅಥವಾ ಜನರೇಟರ್ ಮೇಲೆ ಪುನರಾವರ್ತಿಸುವ ಮೂಲಕ ಅನುಕರಿಸಬಹುದು, ಉದಾಹರಣೆಗೆ, ಪೈಥಾನ್ನ ಶ್ರೇಣಿ (). ಎಕ್ಸೆಪ್ಶನ್ ಹ್ಯಾಂಡ್ಲಿಂಗ್ ಅನ್ನು ಬಳಸುವ ಮೂಲಕ ಆಳವಾದ ವಿರಾಮಗಳನ್ನು ಸಾಧಿಸಬಹುದು. ಯಾವುದೇ ವಿಶೇಷ ರಚನೆಯಿಲ್ಲ, ಏಕೆಂದರೆ ಇದಕ್ಕಾಗಿ ವೈಲ್ ಕಾರ್ಯವನ್ನು ಬಳಸಬಹುದು. ಯಾವುದೇ ವಿಶೇಷ ರಚನೆಯಿಲ್ಲ, ಆದರೆ ಬಳಕೆದಾರರು ಸಾಮಾನ್ಯ ಲೂಪ್ ಕಾರ್ಯಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಬಹುದು. ಸಿ + + 11 ಮಾನದಂಡವು ಶ್ರೇಣಿ-ಆಧಾರಿತ ಫಾರ್ ಅನ್ನು ಪರಿಚಯಿಸಿತು. ಎಸ್ಟಿಎಲ್ನಲ್ಲಿ, ಎಸ್ಟಿಎಲ್ ಧಾರಕಗಳಲ್ಲಿ ಪುನರಾವರ್ತಿಸುವ ಮತ್ತು ಪ್ರತಿ ಅಂಶಕ್ಕೆ ಯೂನರಿ ಕಾರ್ಯವನ್ನು ಕರೆಯುವ ಪ್ರತಿ ಟೆಂಪ್ಲೇಟ್ ಕಾರ್ಯಕ್ಕಾಗಿ ಎಸ್ಟಿಡಿಃಃ ಇದೆ. ಈ ಧಾರಕಗಳ ಮೇಲೆ ಕಾರ್ಯವನ್ನು ಸ್ಥೂಲವಾಗಿಯೂ ನಿರ್ಮಿಸಬಹುದು. ಎಣಿಕೆ-ನಿಯಂತ್ರಿತ ಲೂಪಿಂಗ್ ಅನ್ನು ಪೂರ್ಣಾಂಕದ ಮಧ್ಯಂತರದಾದ್ಯಂತ ಪುನರಾವರ್ತನೆಯಿಂದ ಪರಿಣಾಮ ಬೀರುತ್ತದೆ; ನಿರ್ಗಮನಕ್ಕೆ ಹೆಚ್ಚುವರಿ ಷರತ್ತನ್ನು ಸೇರಿಸುವ ಮೂಲಕ ಮುಂಚಿತವಾಗಿ ನಿರ್ಗಮಿಸುತ್ತದೆ. ಐಫೆಲ್ ಕಾಯ್ದಿರಿಸಿದ ಪದದ ಮರುಪ್ರಯತ್ನವನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆ, ಆದಾಗ್ಯೂ ಇದನ್ನು ಎಕ್ಸೆಪ್ಶನ್ ಹ್ಯಾಂಡ್ಲಿಂಗ್ನಲ್ಲಿ ಬಳಸಲಾಗುತ್ತದೆ, ಲೂಪ್ ನಿಯಂತ್ರಣದಲ್ಲಿ ಅಲ್ಲ. ಜಾವಾ ಮಾಡೆಲಿಂಗ್ ಲಾಂಗ್ವೇಜ್ (ಜೆಎಂಎಲ್) ನಡವಳಿಕೆಯ ಇಂಟರ್ಫೇಸ್ ನಿರ್ದಿಷ್ಟ ಭಾಷೆಯ ಅಗತ್ಯವಿದೆ. ಲೂಪ್ ರೂಪಾಂತರಗಳು ಪೂರ್ಣಾಂಕಗಳಾಗಿರಬೇಕು; ಅನಂತ ರೂಪಾಂತರಗಳನ್ನು ಬೆಂಬಲಿಸಲಾಗುವುದಿಲ್ಲ. ಡಿ ಅನಂತ ಸಂಗ್ರಹಗಳನ್ನು ಮತ್ತು ಆ ಸಂಗ್ರಹಗಳ ಮೇಲೆ ಪುನರಾವರ್ತಿಸುವ ಸಾಮರ್ಥ್ಯವನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆ. ಇದಕ್ಕೆ ಯಾವುದೇ ವಿಶೇಷ ರಚನೆಯ ಅಗತ್ಯವಿರುವುದಿಲ್ಲ. ಗೋ ಟು ಮತ್ತು ಕಾರ್ಯವಿಧಾನಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಆಳವಾದ ವಿರಾಮಗಳನ್ನು ಸಾಧಿಸಬಹುದು. ಕಾಮನ್ ಲಿಸ್ಪ್ ಸಾಮಾನ್ಯ ಸಂಗ್ರಹ ಪ್ರಕಾರದ ಪರಿಕಲ್ಪನೆಗೆ ಮುಂಚೆಯೇ ಇದೆ. ರಚನಾತ್ಮಕ ಸ್ಥಳೀಯವಲ್ಲದ ನಿಯಂತ್ರಣ ಹರಿವು ಅನೇಕ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳು, ವಿಶೇಷವಾಗಿ ಹೆಚ್ಚು ಕ್ರಿಯಾತ್ಮಕ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಶೈಲಿಗಳನ್ನು ಬೆಂಬಲಿಸುವವು, ಸ್ಥಳೀಯವಲ್ಲದ ನಿಯಂತ್ರಣ ಹರಿವಿಗೆ ರಚನೆಗಳನ್ನು ನೀಡುತ್ತವೆ. ಇವುಗಳು ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯ ಹರಿವನ್ನು ನಿರ್ದಿಷ್ಟ ಸಂದರ್ಭದಿಂದ ಹೊರಬರಲು ಮತ್ತು ಕೆಲವು ಪೂರ್ವ ಘೋಷಿತ ಹಂತದಲ್ಲಿ ಪುನರಾರಂಭಿಸಲು ಕಾರಣವಾಗುತ್ತವೆ. ಷರತ್ತುಗಳು, ವಿನಾಯಿತಿಗಳು ಮತ್ತು ನಿರಂತರತೆಗಳು ಮೂರು ಸಾಮಾನ್ಯ ರೀತಿಯ ಸ್ಥಳೀಯವಲ್ಲದ ನಿಯಂತ್ರಣ ರಚನೆಗಳಾಗಿವೆ; ಜನರೇಟರ್ಗಳು, ಕೊರೌಟೈನ್ಗಳು ಮತ್ತು ಅಸಿಂಕ್ ಕೀವರ್ಡ್ಗಳಂತಹ ಹೆಚ್ಚು ವಿಲಕ್ಷಣವಾದವುಗಳು ಸಹ ಅಸ್ತಿತ್ವದಲ್ಲಿವೆ. ಷರತ್ತುಗಳು ಪಿಎಲ್/ಐ ಕೆಲವು 22 ಪ್ರಮಾಣಿತ ಷರತ್ತುಗಳನ್ನು ಹೊಂದಿದೆ (ಉದಾಹರಣೆಗೆ, ಝೀರೋಡೈವಿಡ್ ಸಬ್ಸ್ಕ್ರಿಪ್ಟ್ ಎಂಡಿಫೈಲ್) ಇವುಗಳನ್ನು ಹೆಚ್ಚಿಸಬಹುದು ಮತ್ತು ಇವುಗಳನ್ನು ಈ ಕೆಳಗಿನವುಗಳಿಂದ ತಡೆಹಿಡಿಯಬಹುದುಃ ಷರತ್ತು ಕ್ರಮದಲ್ಲಿ; ಪ್ರೋಗ್ರಾಮರ್ಗಳು ತಮ್ಮದೇ ಆದ ಹೆಸರಿನ ಷರತ್ತುಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಬಹುದು ಮತ್ತು ಬಳಸಬಹುದು. ರಚನೆಯಾಗದ ಹೇಳಿಕೆಯಂತೆ, ಕೇವಲ ಒಂದು ಹೇಳಿಕೆಯನ್ನು ಮಾತ್ರ ನಿರ್ದಿಷ್ಟಪಡಿಸಬಹುದು, ಆದ್ದರಿಂದ ಅನೇಕ ಸಂದರ್ಭಗಳಲ್ಲಿ ನಿಯಂತ್ರಣದ ಹರಿವು ಎಲ್ಲಿ ಪುನರಾರಂಭಿಸಬೇಕು ಎಂಬುದನ್ನು ನಿರ್ಧರಿಸಲು ಜಿ. ಓ. ಟಿ. ಓ ಅಗತ್ಯವಿದೆ. ದುರದೃಷ್ಟವಶಾತ್, ಕೆಲವು ಅನುಷ್ಠಾನಗಳು ಸ್ಥಳ ಮತ್ತು ಸಮಯ ಎರಡರಲ್ಲೂ ಗಣನೀಯ ಓವರ್ಹೆಡ್ ಅನ್ನು ಹೊಂದಿದ್ದವು (ವಿಶೇಷವಾಗಿ ಸಬ್ಸ್ಕ್ರಿಪ್ಟ್), ಆದ್ದರಿಂದ ಅನೇಕ ಪ್ರೋಗ್ರಾಮರ್ಗಳು ಷರತ್ತುಗಳನ್ನು ಬಳಸುವುದನ್ನು ತಪ್ಪಿಸಲು ಪ್ರಯತ್ನಿಸಿದರು. ಸಾಮಾನ್ಯ ವಾಕ್ಯರಚನೆಯ ಉದಾಹರಣೆಗಳುಃ ಆನ್ ಷರತ್ತಿನ ಗೊಟೋ ಲೇಬಲ್ ವಿನಾಯಿತಿಗಳು ಆಧುನಿಕ ಭಾಷೆಗಳು ಗೊಟೋ ಅಥವಾ (ಬಹು-ಮಟ್ಟದ) ವಿರಾಮಗಳು ಅಥವಾ ರಿಟರ್ನ್ಗಳ ಬಳಕೆಯನ್ನು ಅವಲಂಬಿಸದ ಎಕ್ಸೆಪ್ಶನ್ ಹ್ಯಾಂಡ್ಲಿಂಗ್ಗಾಗಿ ವಿಶೇಷ ರಚನಾತ್ಮಕ ರಚನೆಯನ್ನು ಹೊಂದಿವೆ. ಉದಾಹರಣೆಗೆ, ಸಿ + + ನಲ್ಲಿ ಹೀಗೆ ಬರೆಯಬಹುದುಃ "ಪ್ರಯತ್ನಿಸಿ" {XXX1// ಇಲ್ಲಿ ಎಲ್ಲಿಯಾದರೂ "" ಎಸೆಯಿರಿ "" ಕೆಲವು ಮೌಲ್ಯ; "" ಕ್ಯಾಚ್ (ಕೆಲವು ವರ್ಗ ಮತ್ತು ಕೆಲವುಐಡಿ) "" {// ಕೆಲವು ವರ್ಗದ ಕ್ರಿಯೆಯ ಕ್ಯಾಚ್ ಮೌಲ್ಯ "" ಫಾರ್ಸೋಮ್ಕ್ಲಾಸ್ "" ಕ್ಯಾಚ್ (ಕೆಲವು ಪ್ರಕಾರ ಮತ್ತು ಇನ್ನೊಂದುಐಡಿ) {// ಕೆಲವು ಪ್ರಕಾರದ ಕ್ರಿಯೆಯ ಕ್ಯಾಚ್ ಮೌಲ್ಯ "" ಫಾರ್ಸೋಮ್ಟೈಪ್ "" ಕ್ಯಾಚ್ (.) {// ಈಗಾಗಲೇ ಹಿಡಿಯದ ಯಾವುದನ್ನಾದರೂ ಕ್ಯಾಚ್ ಮಾಡಿ "" ಫಾರ್ಅನ್ನಿಥಿಂಗ್ಇಲ್ಸ್ "" ಮೇಲೆ ಯಾವುದೇ ಸಂಖ್ಯೆ ಮತ್ತು ವಿವಿಧ ಕ್ಯಾಚ್ ಷರತ್ತುಗಳನ್ನು ಬಳಸಬಹುದು. ನಿರ್ದಿಷ್ಟ ಎಸೆತಕ್ಕೆ ಹೊಂದಿಕೆಯಾಗುವ ಯಾವುದೇ ಕ್ಯಾಚ್ ಇಲ್ಲದಿದ್ದರೆ, ಹೊಂದಾಣಿಕೆಯ ಕ್ಯಾಚ್ ಕಂಡುಬರುವವರೆಗೆ ಅಥವಾ ಮುಖ್ಯ ಪ್ರೋಗ್ರಾಂನ ಅಂತ್ಯವನ್ನು ತಲುಪುವವರೆಗೆ ಅಥವಾ ಸೂಕ್ತವಾದ ದೋಷ ಸಂದೇಶದೊಂದಿಗೆ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಬಲವಂತವಾಗಿ ನಿಲ್ಲಿಸುವವರೆಗೆ ಸಬ್ರುಟೀನ್ ಕರೆಗಳು ಮತ್ತು/ಅಥವಾ ನೆಸ್ಟೆಡ್ ಬ್ಲಾಕ್ಗಳ ಮೂಲಕ ಹಿಂತಿರುಗುವುದನ್ನು ನಿಯಂತ್ರಿಸಿ. ಸಿ + + ನ ಪ್ರಭಾವದ ಮೂಲಕ, ಜಾವಾ ಅಥವಾ ಸಿ #ನಂತಹ ಇಂದು ಜನಪ್ರಿಯವಾಗಿರುವ ಇತರ ಭಾಷೆಗಳಲ್ಲಿ ಮಾದರಿ-ಹೊಂದಾಣಿಕೆಯ ಎಕ್ಸೆಪ್ಶನ್ ಹ್ಯಾಂಡ್ಲರ್ ಅನ್ನು ಘೋಷಿಸಲು ಮೀಸಲಿಟ್ಟಿರುವ ಕೀವರ್ಡ್ ಕ್ಯಾಚ್ ಆಗಿದೆ. ಆಡಾದಂತಹ ಕೆಲವು ಇತರ ಭಾಷೆಗಳು ಎಕ್ಸೆಪ್ಶನ್ ಹ್ಯಾಂಡ್ಲರ್ ಅನ್ನು ಪರಿಚಯಿಸಲು ಕೀವರ್ಡ್ ಎಕ್ಸೆಪ್ಶನ್ ಅನ್ನು ಬಳಸುತ್ತವೆ ಮತ್ತು ನಂತರ ಮಾದರಿಯ ಹೊಂದಾಣಿಕೆಗೆ ಬೇರೆ ಕೀವರ್ಡ್ ಅನ್ನು (ಆಡಾದಲ್ಲಿದ್ದಾಗ) ಸಹ ಬಳಸಬಹುದು. ಆಪಲ್ಸ್ಕ್ರಿಪ್ಟ್ನಂತಹ ಕೆಲವು ಭಾಷೆಗಳು ಎಕ್ಸೆಪ್ಶನ್ ಹ್ಯಾಂಡ್ಲರ್ ಸಿಂಟ್ಯಾಕ್ಸ್ನಲ್ಲಿ ಪ್ಲೇಸ್ಹೋಲ್ಡರ್ಗಳನ್ನು ಸಂಯೋಜಿಸಿ ಎಕ್ಸೆಪ್ಶನ್ ಸಂಭವಿಸಿದಾಗ ಹಲವಾರು ಮಾಹಿತಿಯ ತುಣುಕುಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಹೊರತೆಗೆಯುತ್ತವೆ. ಆಪಲ್ಸ್ಕ್ರಿಪ್ಟ್ನ ದೋಷ ರಚನೆಯಿಂದ ಈ ವಿಧಾನವನ್ನು ಕೆಳಗೆ ಉದಾಹರಿಸಲಾಗಿದೆಃ ದೋಷದಲ್ಲಿ ನನ್ನ ಸಂಖ್ಯೆಯನ್ನು ನನ್ನ ಸಂಖ್ಯೆ/0 ಗೆ ಹೊಂದಿಸಲು ಪ್ರಯತ್ನಿಸಿ ಇ ಸಂಖ್ಯೆ ಎನ್ ಅನ್ನು ಎಫ್ ನಿಂದ ಟಿ ಭಾಗಶಃ ಫಲಿತಾಂಶಕ್ಕೆ ಹೊಂದಿಸಲು ಪ್ರಯತ್ನಿಸಿ (ಇ = "ಶೂನ್ಯದಿಂದ ಭಾಗಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ") ನಂತರ "ನೀವು ಅದನ್ನು ಮಾಡಬಾರದು" ಎಂಬ ಸಂವಾದವನ್ನು ಪ್ರದರ್ಶಿಸಿ ಡೇವಿಡ್ ವ್ಯಾಟ್ನ 2004 ರ ಪಠ್ಯಪುಸ್ತಕವು ಸೀಕ್ವೆನ್ಸರ್ಗಳ ಚೌಕಟ್ಟಿನಲ್ಲಿ ಎಕ್ಸೆಪ್ಶನ್ ಹ್ಯಾಂಡ್ಲಿಂಗ್ ಅನ್ನು ಸಹ ವಿಶ್ಲೇಷಿಸುತ್ತದೆ (ಲೂಪ್ಗಳಿಂದ ಆರಂಭಿಕ ನಿರ್ಗಮನಗಳ ವಿಭಾಗದಲ್ಲಿ ಈ ಲೇಖನದಲ್ಲಿ ಪರಿಚಯಿಸಲಾಗಿದೆ). ವ್ಯಾಟ್ ಗಮನಿಸಿದಂತೆ, ಸಾಮಾನ್ಯವಾಗಿ ಅಂಕಗಣಿತದ ಉಕ್ಕಿ ಹರಿಯುವಿಕೆಗಳು ಅಥವಾ ಕಡತವು ಕಂಡುಬರದಂತಹ ಇನ್ಪುಟ್/ಔಟ್ಪುಟ್ ವೈಫಲ್ಯಗಳೊಂದಿಗೆ ಉದಾಹರಣೆಯಾಗಿ ಕಂಡುಬರುವ ಅಸಹಜ ಪರಿಸ್ಥಿತಿಯು ಒಂದು ರೀತಿಯ ದೋಷವಾಗಿದೆ, ಇದು "ಕೆಲವು ಕೆಳ-ಮಟ್ಟದ ಪ್ರೋಗ್ರಾಂ ಘಟಕದಲ್ಲಿ ಪತ್ತೆಯಾಗುತ್ತದೆ, ಆದರೆ [ಇದಕ್ಕಾಗಿ] ನಿರ್ವಾಹಕರು ಹೆಚ್ಚು ಸ್ವಾಭಾವಿಕವಾಗಿ ಉನ್ನತ-ಮಟ್ಟದ ಪ್ರೋಗ್ರಾಂ ಘಟಕದಲ್ಲಿ ನೆಲೆಗೊಂಡಿರುತ್ತಾರೆ". ಉದಾಹರಣೆಗೆ, ಒಂದು ಪ್ರೋಗ್ರಾಂ ಫೈಲ್ಗಳನ್ನು ಓದಲು ಹಲವಾರು ಕರೆಗಳನ್ನು ಹೊಂದಿರಬಹುದು, ಆದರೆ ಫೈಲ್ ಕಂಡುಬರದಿದ್ದಾಗ ನಿರ್ವಹಿಸುವ ಕ್ರಿಯೆಯು ಪ್ರೋಗ್ರಾಂಗೆ ಸಂಬಂಧಿಸಿದ ಫೈಲ್ನ ಅರ್ಥವನ್ನು (ಉದ್ದೇಶ) ಅವಲಂಬಿಸಿರುತ್ತದೆ ಮತ್ತು ಆದ್ದರಿಂದ ಈ ಅಸಹಜ ಪರಿಸ್ಥಿತಿಗೆ ನಿರ್ವಹಣಾ ದಿನಚರಿಯನ್ನು ಕಡಿಮೆ-ಮಟ್ಟದ ಸಿಸ್ಟಮ್ ಕೋಡ್ನಲ್ಲಿ ಇರಿಸಲಾಗುವುದಿಲ್ಲ. ಏಕ-ನಿರ್ಗಮನ ಸಂರಚಿತ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಅಥವಾ (ಬಹು-ನಿರ್ಗಮನ) ರಿಟರ್ನ್ ಸೀಕ್ವೆನ್ಸರ್ಗಳಾಗಿ ಕರೆ ಮಾಡುವವರಲ್ಲಿ ಸ್ಥಿತಿ ಫ್ಲ್ಯಾಗ್ ಪರೀಕ್ಷೆಯನ್ನು ಪರಿಚಯಿಸುವುದರಿಂದ, "ಅಪ್ಲಿಕೇಶನ್ ಕೋಡ್ ಸ್ಥಿತಿ ಫ್ಲ್ಯಾಗ್ಗಳ ಪರೀಕ್ಷೆಗಳಿಂದ ಅಸ್ತವ್ಯಸ್ತಗೊಳ್ಳುತ್ತದೆ" ಮತ್ತು "ಪ್ರೋಗ್ರಾಮರ್ ಸ್ಥಿತಿ ಫ್ಲ್ಯಾಗ್ ಅನ್ನು ಪರೀಕ್ಷಿಸಲು ಮರೆತುಬಿಡಬಹುದು ಅಥವಾ ಸೋಮಾರಿಯಾಗಿ ಬಿಟ್ಟುಬಿಡಬಹುದು" ಎಂಬ ಪರಿಸ್ಥಿತಿಗೆ ಕಾರಣವಾಗುತ್ತದೆ ಎಂದು ವಾಟ್ಸ್ ಮತ್ತಷ್ಟು ಟಿಪ್ಪಣಿ ಮಾಡಿದ್ದಾರೆ. ವಾಸ್ತವವಾಗಿ, ಸ್ಥಿತಿ ಧ್ವಜಗಳಿಂದ ಪ್ರತಿನಿಧಿಸಲ್ಪಡುವ ಅಸಹಜ ಸಂದರ್ಭಗಳನ್ನು ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ ನಿರ್ಲಕ್ಷಿಸಲಾಗುತ್ತದೆ! " ಸ್ಥಿತಿ ಚಿಹ್ನೆಗಳ ಪರೀಕ್ಷೆಗೆ ವ್ಯತಿರಿಕ್ತವಾಗಿ, ವಿನಾಯಿತಿಗಳು ವಿರುದ್ಧವಾದ ಪೂರ್ವನಿಯೋಜಿತ ನಡವಳಿಕೆಯನ್ನು ಹೊಂದಿರುತ್ತವೆ, ಇದು ಪ್ರೋಗ್ರಾಮರ್ ಸ್ಪಷ್ಟವಾಗಿ ವಿನಾಯಿತಿಯೊಂದಿಗೆ ಯಾವುದೇ ರೀತಿಯಲ್ಲಿ ವ್ಯವಹರಿಸದ ಹೊರತು, ಬಹುಶಃ ಅದನ್ನು ನಿರ್ಲಕ್ಷಿಸಲು ಸ್ಪಷ್ಟ ಕೋಡ್ ಅನ್ನು ಸೇರಿಸುವ ಮೂಲಕ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಕೊನೆಗೊಳಿಸಲು ಕಾರಣವಾಗುತ್ತದೆ ಎಂದು ವ್ಯಾಟ್ ಹೇಳುತ್ತಾರೆ. ಈ ವಾದಗಳ ಆಧಾರದ ಮೇಲೆ, ವ್ಯಾಟ್ ಜಂಪ್ ಸೀಕ್ವೆನ್ಸರ್ಗಳು ಅಥವಾ ಎಸ್ಕೇಪ್ ಸೀಕ್ವೆನ್ಸರ್ಗಳು ಮೇಲೆ ಚರ್ಚಿಸಿದ ಶಬ್ದಾರ್ಥಗಳೊಂದಿಗೆ ಮೀಸಲಾದ ಎಕ್ಸೆಪ್ಶನ್ ಸೀಕ್ವೆನ್ಸರ್ನಂತೆ ಸೂಕ್ತವಲ್ಲ ಎಂದು ತೀರ್ಮಾನಿಸುತ್ತಾರೆ. ಆಬ್ಜೆಕ್ಟ್ ಪ್ಯಾಸ್ಕಲ್, ಡಿ, ಜಾವಾ, ಸಿ #, ಮತ್ತು ಪೈಥಾನ್ಗಳಲ್ಲಿ ಅಂತಿಮವಾಗಿ ಟ್ರೈ ಕನ್ಸ್ಟ್ರಕ್ಟ್ಗೆ ಒಂದು ಷರತ್ತನ್ನು ಸೇರಿಸಬಹುದು. ನಿಯಂತ್ರಣವು ಎಷ್ಟು ಬಿಟ್ಟುಹೋದರೂ, ಕೊನೆಯ ಷರತ್ತಿನೊಳಗಿನ ಕೋಡ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವ ಭರವಸೆ ಇದೆ. ಸಂಸ್ಕರಣೆಯನ್ನು ಪೂರ್ಣಗೊಳಿಸಿದಾಗ ದುಬಾರಿ ಸಂಪನ್ಮೂಲವನ್ನು (ತೆರೆದ ಕಡತ ಅಥವಾ ದತ್ತಸಂಚಯ ಸಂಪರ್ಕದಂತಹ) ತ್ಯಜಿಸಬೇಕಾದ ಕೋಡ್ ಅನ್ನು ಬರೆಯುವಾಗ ಇದು ಉಪಯುಕ್ತವಾಗಿದೆಃ ಫೈಲ್ ಸ್ಟ್ರೀಮ್ ಎಸ್ಟಿಎಂ = ಶೂನ್ಯ;// ಸಿ #ಉದಾಹರಣೆ ಪ್ರಯತ್ನಿಸಿ {ಎಸ್ಟಿಎಂ = ಹೊಸ ಫೈಲ್ ಸ್ಟ್ರೀಮ್ ("logfile.txt", FileMode.Create); ರಿಟರ್ನ್ ಪ್ರೊಸೆಸ್ ಸ್ಟಫ್ (ಎಸ್ಟಿಎಂ);// ಎಕ್ಸೆಪ್ಶನ್ ಅನ್ನು ಎಸೆಯಬಹುದು} ಅಂತಿಮವಾಗಿ {ಇಫ್ (ಎಸ್ಟಿಎಂ! = ಶೂನ್ಯ) stm.Close ();} ಈ ಮಾದರಿಯು ಸಾಕಷ್ಟು ಸಾಮಾನ್ಯವಾಗಿರುವುದರಿಂದ, ಸಿ #ವಿಶೇಷ ವಾಕ್ಯರಚನೆಯನ್ನು ಹೊಂದಿದೆಃ ಬಳಸುವುದು (ವರ್ ಎಸ್ಟಿಎಂ = ಹೊಸ ಫೈಲ್ ಸ್ಟ್ರೀಮ್ ("logfile.txt", FileMode.Create)) (ರಿಟರ್ನ್ ಪ್ರೊಸೆಸ್ ಸ್ಟಫ್ (ಎಸ್ಟಿಎಂ);// ಬಿಟ್ಟುಹೋದ ನಂತರ ಎಕ್ಸೆಪ್ಶನ್ ಅನ್ನು ಎಸೆಯಬಹುದು) ಪೈಥಾನ್ 'ಸ್ ವಿತ್ ಸ್ಟೇಟ್ಮೆಂಟ್ ಮತ್ತು ರೂಬಿ' ಸ್ ಬ್ಲಾಕ್ ಆರ್ಗ್ಯುಮೆಂಟ್ ಅನ್ನು File.open ಗೆ ಇದೇ ರೀತಿಯ ಪರಿಣಾಮಕ್ಕೆ ಬಳಸಲಾಗುತ್ತದೆ. ಮೇಲೆ ತಿಳಿಸಲಾದ ಎಲ್ಲಾ ಭಾಷೆಗಳು ಪ್ರಮಾಣಿತ ವಿನಾಯಿತಿಗಳನ್ನು ಮತ್ತು ಅವುಗಳನ್ನು ಯಾವ ಸಂದರ್ಭಗಳಲ್ಲಿ ಎಸೆಯಲಾಗುತ್ತದೆ ಎಂಬುದನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತವೆ. ಬಳಕೆದಾರರು ತಮ್ಮದೇ ಆದ ಅಪವಾದಗಳನ್ನು ಎಸೆಯಬಹುದು; ವಾಸ್ತವವಾಗಿ ಸಿ + + ಬಳಕೆದಾರರಿಗೆ ಇಂಟಿನಂತಹ ಮೂಲಭೂತ ಪ್ರಕಾರಗಳನ್ನು ಒಳಗೊಂಡಂತೆ ಯಾವುದೇ ರೀತಿಯನ್ನೂ ಎಸೆಯಲು ಮತ್ತು ಹಿಡಿಯಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ, ಆದರೆ ಜಾವಾದಂತಹ ಇತರ ಭಾಷೆಗಳು ಅಷ್ಟು ಅನುಮತಿಸುವುದಿಲ್ಲ. ಮುಂದುವರಿಕೆಗಳು ಅಸಿಂಕ್ ಸಿ #5 "ನೇರ ಶೈಲಿಯಲ್ಲಿ" ಅಸಿಂಕ್ರೋನಸ್ ಐ/ಒ ಅನ್ನು ಬೆಂಬಲಿಸಲು ಅಸಿಂಕ್ ಕೀವರ್ಡ್ ಅನ್ನು ಪರಿಚಯಿಸಿತು. ಸೆಮಿಕೊರೌಟೈನ್ಸ್ ಎಂದೂ ಕರೆಯಲಾಗುವ ಜನರೇಟರ್ ಜನರೇಟರ್ಗಳು, ಗ್ರಾಹಕ ವಿಧಾನಕ್ಕೆ ತಾತ್ಕಾಲಿಕವಾಗಿ ನಿಯಂತ್ರಣವನ್ನು ನೀಡಲು ಅವಕಾಶ ಮಾಡಿಕೊಡುತ್ತವೆ, ಸಾಮಾನ್ಯವಾಗಿ ಕೀವರ್ಡ್ (ಇಳುವರಿ ವಿವರಣೆ) ಅನ್ನು ಬಳಸುತ್ತವೆ. ಅಸಿಂಕ್ ಕೀವರ್ಡ್ನಂತೆ, ಇದು "ನೇರ ಶೈಲಿಯಲ್ಲಿ" ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಅನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆ. ಕೊರೌಟೈನ್ಗಳು ಪರಸ್ಪರ ನಿಯಂತ್ರಣವನ್ನು ನೀಡುವ ಕಾರ್ಯಗಳಾಗಿವೆ-ಎಳೆಗಳಿಲ್ಲದ ಸಹಕಾರಿ ಬಹುಕಾರ್ಯಕದ ಒಂದು ರೂಪ. ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಯು ನಿರಂತರತೆ ಅಥವಾ ಜನರೇಟರ್ಗಳನ್ನು ಒದಗಿಸಿದರೆ ಕೊರೌಟೈನ್ಗಳನ್ನು ಗ್ರಂಥಾಲಯವಾಗಿ ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದು-ಆದ್ದರಿಂದ ಪ್ರಾಯೋಗಿಕವಾಗಿ ಕೊರೌಟೈನ್ಗಳು ಮತ್ತು ಜನರೇಟರ್ಗಳ ನಡುವಿನ ವ್ಯತ್ಯಾಸವು ತಾಂತ್ರಿಕ ವಿವರವಾಗಿದೆ. ಸ್ಥಳೀಯವಲ್ಲದ ನಿಯಂತ್ರಣ ಹರಿವು ಅಡ್ಡ ಉಲ್ಲೇಖ ಪ್ರಸ್ತಾಪಿತ ನಿಯಂತ್ರಣ ರಚನೆಗಳು 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ರಲ್ಲಿ ಪ್ರಸ್ತಾಪಿಸಿದರು. ಮಾರ್ಪಡಿಸಿದ ಆವೃತ್ತಿಯನ್ನು ಇಲ್ಲಿ ಪ್ರಸ್ತುತಪಡಿಸಲಾಗಿದೆ. ಈವೆಂಟ್ ಎ ಅಥವಾ ಈವೆಂಟ್ ಬಿ ಅಥವಾ ಈವೆಂಟ್ ಸಿ ಯಿಂದ ನಿರ್ಗಮಿಸಿದಾಗ; XXX ಈವೆಂಟ್ ಎ ಯಿಂದ ನಿರ್ಗಮಿಸುತ್ತದೆಃ ಆಕ್ಷನ್ ಎ ಈವೆಂಟ್ ಬಿಃ ಆಕ್ಷನ್ ಬಿ ಈವೆಂಟ್ ಸಿಃ ಆಕ್ಷನ್ ಸಿ ಎಂಡೆಕ್ಸಿಟ್; XXX ಒಳಗೆ ಸಂಭವಿಸಬಹುದಾದ ಘಟನೆಗಳನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಲು ನಿರ್ಗಮನವನ್ನು ಬಳಸಿದಾಗ, ಈವೆಂಟ್ನ ಹೆಸರನ್ನು ಹೇಳಿಕೆಯಾಗಿ ಬಳಸುವ ಮೂಲಕ ಅವುಗಳ ಸಂಭವವನ್ನು ಸೂಚಿಸಲಾಗುತ್ತದೆ. ಕೆಲವು ಘಟನೆಗಳು ಸಂಭವಿಸಿದಾಗ, ಸಂಬಂಧಿತ ಕ್ರಮವನ್ನು ಕೈಗೊಳ್ಳಲಾಗುತ್ತದೆ, ಮತ್ತು ನಂತರ ನಿರ್ಗಮನದ ನಂತರ ನಿಯಂತ್ರಣವು ಹಾದುಹೋಗುತ್ತದೆ. ಈ ರಚನೆಯು ಕೆಲವು ಸನ್ನಿವೇಶಗಳು ಅನ್ವಯವಾಗುತ್ತವೆ ಎಂಬುದನ್ನು ನಿರ್ಧರಿಸುವ ಮತ್ತು ಆ ಪರಿಸ್ಥಿತಿಗೆ ತೆಗೆದುಕೊಳ್ಳಬೇಕಾದ ಕ್ರಮಗಳ ನಡುವೆ ಬಹಳ ಸ್ಪಷ್ಟವಾದ ಪ್ರತ್ಯೇಕತೆಯನ್ನು ಒದಗಿಸುತ್ತದೆ. ಎಕ್ಸಿಟ್ ಎಕ್ಸೆಪ್ಶನ್ ಹ್ಯಾಂಡ್ಲಿಂಗ್ ಅನ್ನು ಕಲ್ಪನಾತ್ಮಕವಾಗಿ ಹೋಲುತ್ತದೆ, ಮತ್ತು ಎಕ್ಸೆಪ್ಶನ್ಗಳು ಅಥವಾ ಅಂತಹುದೇ ರಚನೆಗಳನ್ನು ಈ ಉದ್ದೇಶಕ್ಕಾಗಿ ಅನೇಕ ಭಾಷೆಗಳಲ್ಲಿ ಬಳಸಲಾಗುತ್ತದೆ. ಈ ಕೆಳಗಿನ ಸರಳ ಉದಾಹರಣೆಯು ಒಂದು ನಿರ್ದಿಷ್ಟ ವಸ್ತುವಿಗಾಗಿ ಎರಡು ಆಯಾಮದ ಕೋಷ್ಟಕವನ್ನು ಹುಡುಕುವುದನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ. ಕಂಡುಬಂದಾಗ ಅಥವಾ ಕಾಣೆಯಾದಾಗ ನಿರ್ಗಮನ; I: = 1 ರಿಂದ N ಗೆ J: = 1 ಗೆ M ಮಾಡಲು ಟೇಬಲ್ [I, J] = ಗುರಿ ನಂತರ ಕಂಡುಬಂದರೆ; ಕಾಣೆಯಾಗಿದೆ; ನಿರ್ಗಮನಗಳು ಕಂಡುಬಂದಿವೆಃ ಮುದ್ರಣ ("ಐಟಂ ಟೇಬಲ್ನಲ್ಲಿ ಇದೆ"); ಕಾಣೆಯಾಗಿದೆಃ ಮುದ್ರಣ ("ಐಟಂ ಟೇಬಲ್ನಲ್ಲಿ ಇಲ್ಲ"); ಎಂಡಿಕ್ಸಿಟ್; ಭದ್ರತೆ ಸಾಫ್ಟ್ವೇರ್ ತುಣುಕಿನ ಮೇಲೆ ದಾಳಿ ಮಾಡುವ ಒಂದು ಮಾರ್ಗವೆಂದರೆ ಪ್ರೋಗ್ರಾಂನ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯ ಹರಿವನ್ನು ಮರುನಿರ್ದೇಶಿಸುವುದು. ಈ ದಾಳಿಗಳ ವಿರುದ್ಧ ರಕ್ಷಿಸಲು ಸ್ಟ್ಯಾಕ್ ಕ್ಯಾನರಿಗಳು, ಬಫರ್ ಓವರ್ಫ್ಲೋ ರಕ್ಷಣೆ, ನೆರಳು ಸ್ಟ್ಯಾಕ್ಗಳು ಮತ್ತು ವಿ ಟೇಬಲ್ ಪಾಯಿಂಟರ್ ಪರಿಶೀಲನೆ ಸೇರಿದಂತೆ ವಿವಿಧ ನಿಯಂತ್ರಣ-ಹರಿವಿನ ಸಮಗ್ರತೆಯ ತಂತ್ರಗಳನ್ನು ಬಳಸಲಾಗುತ್ತದೆ. ಶಾಖೆ (ಕಂಪ್ಯೂಟರ್ ವಿಜ್ಞಾನ) ನಿಯಂತ್ರಣ-ಹರಿವಿನ ವಿಶ್ಲೇಷಣೆ ನಿಯಂತ್ರಣ-ಹರಿವಿನ ರೇಖಾಚಿತ್ರ ನಿಯಂತ್ರಣ-ಹರಿವಿನ ರೇಖಾಚಿತ್ರ ನಿಯಂತ್ರಣ ಕೋಷ್ಟಕ ಕೊರೌಟೈನ್ ಸೈಕ್ಲೋಮ್ಯಾಟಿಕ್ ಸಂಕೀರ್ಣತೆ ಡ್ರಾಕಾನ್-ಚಾರ್ಟ್ ಫ್ಲೋಚಾರ್ಟ್ ಗೊಟೊ ಜೆರೂ, ನಿಯಂತ್ರಣ ರಚನೆಗಳನ್ನು ಕಲಿಯಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ ಮುಖ್ಯ ಲೂಪ್ ರಿಕರ್ಶನ್ ಶೆಡ್ಯೂಲಿಂಗ್ (ಕಂಪ್ಯೂಟಿಂಗ್) ಸ್ಪಾಗೆಟ್ಟಿ ಕೋಡ್ ಸ್ಟ್ರಕ್ಚರ್ಡ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಸಬ್ರೌಟೈನ್ ಸ್ವಿಚ್ ಸ್ಟೇಟ್ಮೆಂಟ್, ನಿಯಂತ್ರಣ ಹರಿವನ್ನು ಷರತ್ತುಬದ್ಧವಾಗಿ ಬದಲಾಯಿಸುತ್ತದೆ. ಕಾಮ್. ಎಸಿಎಂ 4,321-322,1961. ಬಾಹ್ಯ ಕೊಂಡಿಗಳು ಗೋ ಟು ಸ್ಟೇಟ್ಮೆಂಟ್ ಕನ್ಸರ್ಟೆಡ್ ಹಾರ್ಮಫುಲ್ ಎ ಲಿಂಗ್ವಿಸ್ಟಿಕ್ ಕಾಂಟ್ರಿಬ್ಯೂಷನ್ ಆಫ್ ಗೋಟೋ-ಲೆಸ್ ಪ್ರೊಗ್ರಾಮಿಂಗ್ ಆರ್ಟಿಕಲ್ಸ್ ವಿತ್ ಉದಾ ಅಡಾ ಕೋಡ್