ಲೂಪ್ಗಾಗಿ "ಬ್ಯಾಷ್" ಅನ್ನು ಬರೆಯುವುದು ಹೇಗೆ

ಶೆಲ್ ಲಿಪಿಯಲ್ಲಿನ ಬಾಶ್ "ಫಾರ್" ಲೂಪ್ ಅನ್ನು ಹೇಗೆ ಬಳಸುವುದು

ಬಾಶ್ (ಇದು ಬೌರ್ನ್ ಎಗೈನ್ ಶೆಲ್ ಅನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ) ಅತ್ಯಂತ ಲಿನಕ್ಸ್ ಮತ್ತು ಯುನಿಕ್ಸ್ ಆಧಾರಿತ ಕಾರ್ಯಾಚರಣಾ ವ್ಯವಸ್ಥೆಗಳಿಂದ ಬಳಸಲ್ಪಡುವ ಸ್ಕ್ರಿಪ್ಟಿಂಗ್ ಭಾಷೆಯಾಗಿದೆ.

ಒಂದು ಟರ್ಮಿನಲ್ ವಿಂಡೊದಲ್ಲಿ ಇನ್ನೊಂದು ನಂತರ ಒಂದು BASH ಆಜ್ಞೆಗಳನ್ನು ನೀವು ಚಲಾಯಿಸಬಹುದು ಅಥವಾ ಶೆಲ್ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಉತ್ಪಾದಿಸಲು ಪಠ್ಯ ಕಡತಕ್ಕೆ ಆಜ್ಞೆಗಳನ್ನು ಸೇರಿಸಬಹುದು.

ಶೆಲ್ ಸ್ಕ್ರಿಪ್ಟುಗಳನ್ನು ಬರೆಯುವುದರ ಬಗ್ಗೆ ದೊಡ್ಡ ವಿಷಯವೆಂದರೆ ನೀವು ಅವುಗಳನ್ನು ಮತ್ತೆ ಮತ್ತೆ ಚಲಾಯಿಸಬಹುದು. ಉದಾಹರಣೆಗಾಗಿ, ನೀವು ಒಂದು ಬಳಕೆದಾರರಿಗೆ ಒಂದು ವ್ಯವಸ್ಥೆಯನ್ನು ಸೇರಿಸುವ ಅಗತ್ಯವಿದೆ, ಅವರ ಅನುಮತಿಗಳನ್ನು ಹೊಂದಿಸಿ ಮತ್ತು ಅವುಗಳ ಆರಂಭಿಕ ಪರಿಸರವನ್ನು ನಿರ್ವಹಿಸಬೇಕಾಗುತ್ತದೆ. ನೀವು ಕಮಾಂಡ್ಗಳನ್ನು ಒಂದು ಕಾಗದದ ಮೇಲೆ ಬರೆಯಬಹುದು ಮತ್ತು ನೀವು ಹೊಸ ಬಳಕೆದಾರರನ್ನು ಸೇರ್ಪಡಿಸಿದಾಗ ಅವುಗಳನ್ನು ರನ್ ಮಾಡಬಹುದು ಅಥವಾ ನೀವು ಒಂದೇ ಲಿಪಿಯನ್ನು ಬರೆಯಬಹುದು ಮತ್ತು ಪ್ಯಾರಾಮೀಟರ್ಗಳನ್ನು ಆ ಸ್ಕ್ರಿಪ್ಟ್ಗೆ ಹಾದು ಹೋಗಬಹುದು.

ಬ್ಯಾಷ್ನಂತಹ ಸ್ಕ್ರಿಪ್ಟಿಂಗ್ ಭಾಷೆಗಳು ಇತರ ಭಾಷೆಗಳಂತೆ ಇದೇ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ರಚನೆಗಳನ್ನು ಹೊಂದಿವೆ. ಉದಾಹರಣೆಗೆ, ನೀವು ಕೀಲಿಮಣೆಯಿಂದ ಇನ್ಪುಟ್ ಪಡೆಯಲು ಮತ್ತು ಅವುಗಳನ್ನು ಅಸ್ಥಿರವಾಗಿ ಶೇಖರಿಸಿಡಲು ಆಮದು ನಿಯತಾಂಕಗಳನ್ನು ಬಳಸಬಹುದು. ಇನ್ಪುಟ್ ನಿಯತಾಂಕಗಳ ಮೌಲ್ಯದ ಆಧಾರದ ಮೇಲೆ ನಿರ್ದಿಷ್ಟ ಕ್ರಿಯೆಯನ್ನು ಮಾಡಲು ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ನೀವು ಪಡೆಯಬಹುದು.

ಯಾವುದೇ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಮತ್ತು ಸ್ಕ್ರಿಪ್ಟಿಂಗ್ ಭಾಷೆಯ ಒಂದು ಪ್ರಮುಖ ಭಾಗವು ಅದೇ ರೀತಿಯ ಕೋಡ್ ಅನ್ನು ಮತ್ತೆ ಮತ್ತೆ ಚಾಲನೆ ಮಾಡುವ ಸಾಮರ್ಥ್ಯವಾಗಿದೆ.

ಕೋಡ್ ಅನ್ನು ಪುನರಾವರ್ತಿಸಲು ಹಲವು ವಿಧಾನಗಳಿವೆ (ಲೂಪ್ಗಳು ಎಂದೂ ಸಹ ಕರೆಯಲಾಗುತ್ತದೆ). ಈ ಮಾರ್ಗದರ್ಶಿಯಲ್ಲಿ, "for" ಲೂಪ್ ಅನ್ನು ಹೇಗೆ ಬರೆಯಬೇಕು ಎಂದು ನಿಮಗೆ ತೋರಿಸಲಾಗುತ್ತದೆ.

ಎ ಫಾರ್ ಲೂಪ್ ಕೋಡ್ನ ನಿರ್ದಿಷ್ಟ ಭಾಗವನ್ನು ಪುನರಾವರ್ತಿಸುತ್ತದೆ. ಅವುಗಳು ಉಪಯುಕ್ತವಾಗಿದ್ದು, ಒಂದು ನಿರ್ದಿಷ್ಟ ಕಂಡೀಶನ್ ಪೂರೈಸುವವರೆಗೂ ಒಂದು ಸರಣಿಯ ಕಮಾಂಡ್ಗಳು ಚಾಲನೆಯಲ್ಲಿರುತ್ತವೆ, ನಂತರ ಅವರು ನಿಲ್ಲಿಸುತ್ತಾರೆ.

ಈ ಮಾರ್ಗದರ್ಶಿಯಲ್ಲಿ, ಬ್ಯಾಷ್ ಲಿಪಿಯೊಳಗೆ ಲೂಪ್ಗಾಗಿ ಬಳಸುವ ಐದು ವಿಧಾನಗಳನ್ನು ನಿಮಗೆ ತೋರಿಸಲಾಗುತ್ತದೆ.

ಪ್ರಾರಂಭಿಸುವುದು ಮೊದಲು

ಲೂಪ್ ಉದಾಹರಣೆಗಳಿಗಾಗಿ ನೀವು ಪ್ರಾರಂಭಿಸುವ ಮೊದಲು, ನೀವು ಟರ್ಮಿನಲ್ ವಿಂಡೋವನ್ನು ತೆರೆಯಬೇಕಾಗುತ್ತದೆ ಮತ್ತು ಈ ಹಂತಗಳನ್ನು ಅನುಸರಿಸಿ:

1. Mkdir ಸ್ಕ್ರಿಪ್ಟುಗಳನ್ನು ನಮೂದಿಸಿ ( ಇಲ್ಲಿ mkdir ಕುರಿತು ಇನ್ನಷ್ಟು ತಿಳಿಯಿರಿ )
2. CD ಸ್ಕ್ರಿಪ್ಟುಗಳನ್ನು ನಮೂದಿಸಿ ( ಇದು ಡೈರೆಕ್ಟರಿಯನ್ನು ಸ್ಕ್ರಿಪ್ಟುಗಳಿಗೆ ಬದಲಾಯಿಸುತ್ತದೆ )
3. ನ್ಯಾನೋ examplen.sh ನಮೂದಿಸಿ (ಇಲ್ಲಿ n ನೀವು ಕೆಲಸ ಮಾಡುತ್ತಿದ್ದ ಉದಾಹರಣೆ)
4. ಸ್ಕ್ರಿಪ್ಟ್ ನಮೂದಿಸಿ
5. ಉಳಿಸಲು CTRL + O ಒತ್ತಿರಿ ಮತ್ತು CTRL + X ನಿರ್ಗಮಿಸಲು
6. Bash examplen.sh ಅನ್ನು ರನ್ ಮಾಡಿ (ಮತ್ತೆ, ನೀವು ಕೆಲಸ ಮಾಡುತ್ತಿದ್ದ ಉದಾಹರಣೆ)

ಒಂದು ಪಟ್ಟಿ ಮೂಲಕ ಲೂಪ್ ಹೇಗೆ

#! / ಬಿನ್ / ಬ್ಯಾಷ್
1 2 3 4 5 ರಲ್ಲಿ ಸಂಖ್ಯೆಗೆ
ಮಾಡಿ
ಪ್ರತಿಧ್ವನಿ $ ಸಂಖ್ಯೆ
ಮಾಡಲಾಗುತ್ತದೆ
ನಿರ್ಗಮನ 0

"ಫಾರ್" ಲೂಪ್ಗಳನ್ನು ಬಳಸುವ ಬ್ಯಾಷ್ ಮಾರ್ಗವು ಇತರ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಮತ್ತು ಸ್ಕ್ರಿಪ್ಟಿಂಗ್ ಭಾಷೆಗಳು "ಫಾರ್" ಲೂಪ್ಗಳನ್ನು ನಿರ್ವಹಿಸುವ ರೀತಿಯಲ್ಲಿ ಸ್ವಲ್ಪ ವಿಭಿನ್ನವಾಗಿದೆ. ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಮುರಿದುಬಿಡೋಣ ...

ಒಂದು ಬಾಶ್ "ಫಾರ್" ಲೂಪ್ನಲ್ಲಿ ಎಲ್ಲದರಲ್ಲೂ, ಮಾಡಬೇಕಾದ ಮತ್ತು ಮಾಡಿದ ನಡುವಿನ ಹೇಳಿಕೆಗಳನ್ನು ಪಟ್ಟಿಯ ಪ್ರತಿಯೊಂದು ಐಟಂಗೆ ಒಮ್ಮೆ ನಿರ್ವಹಿಸಲಾಗುತ್ತದೆ.

ಮೇಲಿನ ಉದಾಹರಣೆಯಲ್ಲಿ, ಪಟ್ಟಿಯು (ಅಂದರೆ 1 2 3 4 5) ಪದದ ನಂತರ ಬರುವ ಎಲ್ಲವೂ ಆಗಿದೆ.

ಪ್ರತಿ ಬಾರಿ ಲೂಪ್ ಪುನರಾವರ್ತನೆಯಾಗುತ್ತದೆ, ಪಟ್ಟಿಯಲ್ಲಿ "ಮುಂದಿನ " ಪದದ ನಂತರ ಸೂಚಿಸಲಾದ ವೇರಿಯೇಬಲ್ನಲ್ಲಿ ಮುಂದಿನ ಮೌಲ್ಯವನ್ನು ಸೇರಿಸಲಾಗುತ್ತದೆ. ಮೇಲಿನ ಲೂಪ್ನಲ್ಲಿ, ವೇರಿಯಬಲ್ ಅನ್ನು ಸಂಖ್ಯೆ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ.

ಪರದೆಯ ಮಾಹಿತಿಯನ್ನು ಪ್ರದರ್ಶಿಸಲು ಪ್ರತಿಧ್ವನಿ ಹೇಳಿಕೆ ಬಳಸಲಾಗುತ್ತದೆ.

ಆದ್ದರಿಂದ, ಈ ಉದಾಹರಣೆಯು 1 ರಿಂದ 5 ರವರೆಗಿನ ಸಂಖ್ಯೆಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಮತ್ತು ಅವುಗಳನ್ನು ಒಂದು ಪರದೆಯೊಂದಕ್ಕೆ ತೆರೆಯುತ್ತದೆ:

• 1
• 2
• 3
• 4
• 5

ಪ್ರಾರಂಭ ಮತ್ತು ಅಂತಿಮ ಹಂತದ ನಡುವೆ ಲೂಪ್ ಹೇಗೆ

ಮೇಲಿನ ಉದಾಹರಣೆಯೊಂದಿಗಿನ ತೊಂದರೆವೆಂದರೆ ನೀವು ಒಂದು ದೊಡ್ಡ ಪಟ್ಟಿಯನ್ನು (1 ರಿಂದ 500 ಗೆ ಹೇಳಲು) ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು ಬಯಸಿದರೆ, ಅದು ಮೊದಲ ಸ್ಥಾನದಲ್ಲಿ ಎಲ್ಲಾ ಸಂಖ್ಯೆಯನ್ನು ಟೈಪ್ ಮಾಡಲು ವಯಸ್ಸಿನ ಸಮಯವನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ.

ಇದು ಒಂದು ಆರಂಭದ ಮತ್ತು ಅಂತಿಮ ಬಿಂದುವನ್ನು ಹೇಗೆ ನಿರ್ದಿಷ್ಟಪಡಿಸುವುದು ಎಂಬುದನ್ನು ತೋರಿಸುವ ಎರಡನೇ ಉದಾಹರಣೆಗೆ ನಮ್ಮನ್ನು ತರುತ್ತದೆ:

#! / ಬಿನ್ / ಬ್ಯಾಷ್
{1.10} ರಲ್ಲಿ ಸಂಖ್ಯೆಗಾಗಿ
ಮಾಡಿ
ಪ್ರತಿಧ್ವನಿ "$ ಸಂಖ್ಯೆ"
ಮಾಡಲಾಗುತ್ತದೆ
ನಿರ್ಗಮನ 0

ನಿಯಮಗಳು ಮೂಲತಃ ಒಂದೇ ಆಗಿವೆ. " ಇನ್" ಪದದ ನಂತರ ಮೌಲ್ಯಗಳು ಮೂಲಕ ತಿರುಗಿ ಪಟ್ಟಿ ಮಾಡಿ ಮತ್ತು ಪಟ್ಟಿಯಲ್ಲಿ ಪ್ರತಿ ಮೌಲ್ಯವನ್ನು ವೇರಿಯಬಲ್ (ಅಂದರೆ ಸಂಖ್ಯೆ) ನಲ್ಲಿ ಇರಿಸಲಾಗುತ್ತದೆ, ಮತ್ತು ಪ್ರತಿ ಬಾರಿ ಲೂಪ್ ಪುನರಾವರ್ತನೆಯಾಗುತ್ತದೆ, ಮಾಡುವ ಮತ್ತು ಮಾಡಿದ ನಡುವಿನ ಹೇಳಿಕೆಗಳನ್ನು ನಿರ್ವಹಿಸಲಾಗುತ್ತದೆ.

ಪಟ್ಟಿ ರೂಪುಗೊಳ್ಳುವ ಮಾರ್ಗವೆಂದರೆ ಮುಖ್ಯ ವ್ಯತ್ಯಾಸ. ಕರ್ಲಿ ಬ್ರಾಕೆಟ್ಗಳು {@} ಮೂಲಭೂತವಾಗಿ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಸೂಚಿಸುತ್ತದೆ, ಮತ್ತು ಈ ಸಂದರ್ಭದಲ್ಲಿ, 1 ರಿಂದ 10 ರವರೆಗೆ (ಎರಡು ಚುಕ್ಕೆಗಳು ಒಂದು ಶ್ರೇಣಿಯ ಪ್ರಾರಂಭ ಮತ್ತು ಅಂತ್ಯವನ್ನು ಪ್ರತ್ಯೇಕಿಸುತ್ತವೆ).

ಈ ಉದಾಹರಣೆಯು ಆದ್ದರಿಂದ, 1 ಮತ್ತು 10 ರ ನಡುವಿನ ಪ್ರತಿ ಸಂಖ್ಯೆಯ ಮೂಲಕ ಹಾದುಹೋಗುತ್ತದೆ ಮತ್ತು ಪರದೆಯ ಸಂಖ್ಯೆಯನ್ನು ಕೆಳಗಿನಂತೆ ತೋರಿಸುತ್ತದೆ:

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10

ಅದೇ ಲೂಪ್ ಈ ರೀತಿಯಂತೆ ಬರೆಯಲ್ಪಟ್ಟಿರಬಹುದು, ಸಿಂಟ್ಯಾಕ್ಸನ್ನು ಮೊದಲ ಉದಾಹರಣೆಗೆ ಹೋಲುತ್ತದೆ:

1 2 3 4 5 6 7 8 9 10 ರಲ್ಲಿ ಸಂಖ್ಯೆ

ಒಂದು ಶ್ರೇಣಿಯಲ್ಲಿ ಸಂಖ್ಯೆಯನ್ನು ಸ್ಕಿಪ್ ಮಾಡುವುದು ಹೇಗೆ

ಹಿಂದಿನ ಉದಾಹರಣೆಯು ಪ್ರಾರಂಭ ಮತ್ತು ಅಂತಿಮ ಬಿಂದುವಿನ ನಡುವೆ ಹೇಗೆ ಲೂಪ್ ಮಾಡುವುದು ಎಂಬುದನ್ನು ತೋರಿಸುತ್ತದೆ, ಇದೀಗ ನಾವು ಶ್ರೇಣಿಯಲ್ಲಿನ ಸಂಖ್ಯೆಗಳನ್ನು ಹೇಗೆ ಅಳಿಸಬೇಕೆಂದು ನೋಡುತ್ತೇವೆ.

ನೀವು 0 ಮತ್ತು 100 ರ ನಡುವೆ ಲೂಪ್ ಮಾಡಲು ಬಯಸುತ್ತೀರೆಂದು ಯೋಚಿಸಿ ಆದರೆ ಪ್ರತಿ ಹತ್ತನೆಯ ಸಂಖ್ಯೆಯನ್ನು ಮಾತ್ರ ತೋರಿಸಿ. ಕೆಳಗಿನ ಸ್ಕ್ರಿಪ್ಟ್ ಹೀಗೆ ಮಾಡುವುದನ್ನು ಹೇಗೆ ತೋರಿಸುತ್ತದೆ:

#! / ಬಿನ್ / ಬ್ಯಾಷ್
ಸಂಖ್ಯೆಗೆ {0..100..10}
ಮಾಡಿ
ಪ್ರತಿಧ್ವನಿ "$ ಸಂಖ್ಯೆ"
ಮಾಡಲಾಗುತ್ತದೆ
ನಿರ್ಗಮನ 0

ನಿಯಮಗಳು ಮೂಲತಃ ಒಂದೇ ಆಗಿವೆ. ಪಟ್ಟಿ ಮತ್ತು ವೇರಿಯಬಲ್ ಮತ್ತು ಮಾಡಬೇಕಾದ ಮತ್ತು ಮಾಡಬೇಕಾದ ಹೇಳಿಕೆಗಳ ಒಂದು ಸೆಟ್ ಇದೆ. ಈ ಸಮಯದ ಪಟ್ಟಿಯು ಈ ರೀತಿ ಕಾಣುತ್ತದೆ: {0..100..10}.

ಮೊದಲನೇ ಸಂಖ್ಯೆ 0 ಮತ್ತು ಅಂತಿಮ ಸಂಖ್ಯೆ 100 ಆಗಿದೆ. ಮೂರನೆಯ ಸಂಖ್ಯೆ (10) ಎಂಬುದು ಪಟ್ಟಿಯಲ್ಲಿರುವ ಐಟಂಗಳ ಸಂಖ್ಯೆಯಾಗಿದ್ದು ಅದನ್ನು ಬಿಟ್ಟುಬಿಡುತ್ತದೆ.

ಮೇಲಿನ ಉದಾಹರಣೆ, ಆದ್ದರಿಂದ, ಕೆಳಗಿನ ಔಟ್ಪುಟ್ ತೋರಿಸುತ್ತದೆ:

• 0
• 10
• 20
• 30
• 40
• 50
• 60
• 70
• 80
• 90
• 100

ಲೂಪ್ಗಾಗಿ ಇನ್ನಷ್ಟು ಸಂಪ್ರದಾಯಬದ್ಧವಾದದ್ದು

ಇತರ ಪ್ರೊಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳೊಂದಿಗೆ ಹೋಲಿಸಿದಾಗ ಕುಣಿಕೆಗಳ ಬಚ್ಚಿಟ್ಟ ಬರವಣಿಗೆ ಸ್ವಲ್ಪ ವಿಚಿತ್ರವಾಗಿದೆ.

ಆದಾಗ್ಯೂ, ಸಿ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗೆ ಇದೇ ರೀತಿಯ ಶೈಲಿಯಲ್ಲಿ ನೀವು ಲೂಪ್ಗಾಗಿ ಇದನ್ನು ಬರೆಯಬಹುದು:

#! / ಬಿನ್ / ಬ್ಯಾಷ್
ಫಾರ್ ((ಸಂಖ್ಯೆ = 1; ಸಂಖ್ಯೆ <100; ಸಂಖ್ಯೆ ++))
{
ವೇಳೆ (($ ಸಂಖ್ಯೆ% 5 == 0))
ನಂತರ
ಪ್ರತಿಧ್ವನಿ "$ ಸಂಖ್ಯೆ 5 ರಿಂದ ಭಾಗಿಸಬಹುದು"
fi
}
ನಿರ್ಗಮನ 0

ವೇರಿಯೇಬಲ್ ಸಂಖ್ಯೆಯನ್ನು 1 (ಸಂಖ್ಯೆ = 1 ) ಗೆ ಹೊಂದಿಸುವ ಮೂಲಕ ಲೂಪ್ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ. ಒಂದು ಸಂಖ್ಯೆಯ ಮೌಲ್ಯವು 100 ಕ್ಕಿಂತ ಕಡಿಮೆಯಿದ್ದರೆ (ಲೂಪ್ = 100 ). ಪ್ರತಿ ಪುನರಾವರ್ತನೆಯ ನಂತರ ಸಂಖ್ಯೆ 1 ಅನ್ನು ಸೇರಿಸುವ ಮೂಲಕ ಸಂಖ್ಯೆಯ ಮೌಲ್ಯವು ಬದಲಾಯಿಸುತ್ತದೆ ( ಸಂಖ್ಯೆ ++ ).

ಲೂಪ್ನ ಪ್ರತಿಯೊಂದು ಪುನರಾವರ್ತನೆಯ ಮೂಲಕ ಸುರುಳಿಯಾದ ಬ್ರೇಸ್ಗಳ ನಡುವಿನ ಎಲ್ಲವೂ ನಡೆಸಲಾಗುತ್ತದೆ.

ಕಟ್ಟುಪಟ್ಟಿಗಳ ನಡುವಿನ ಬಿಟ್ ಸಂಖ್ಯೆಯ ಮೌಲ್ಯವನ್ನು ಪರಿಶೀಲಿಸುತ್ತದೆ, 5 ರಿಂದ ಅದನ್ನು ವಿಭಜಿಸುತ್ತದೆ ಮತ್ತು ಶೇಷವನ್ನು 0 ಗೆ ಹೋಲಿಸುತ್ತದೆ. ಉಳಿದವು 0 ಆಗಿದ್ದರೆ ಸಂಖ್ಯೆ 5 ರಿಂದ ಭಾಗಿಸಬಹುದು ಮತ್ತು ನಂತರ ಪರದೆಯ ಮೇಲೆ ಪ್ರದರ್ಶಿಸಲಾಗುತ್ತದೆ.

ಉದಾಹರಣೆಗೆ:

• 5 ರಿಂದ 5 ಕ್ಕೆ ಭಾಗಿಸಬಹುದು
• 10 ರಿಂದ 10 ಕ್ಕೆ ಭಾಗಿಸಬಹುದು
• 15 ರಿಂದ 5 ಭಾಗಿಸಬಹುದು

ನೀವು ಪುನರಾವರ್ತನೆಯ ಹಂತದ ಗಾತ್ರವನ್ನು ಬದಲಾಯಿಸಲು ಬಯಸಿದರೆ ನೀವು ಸಂಖ್ಯೆ + ಸಂಖ್ಯೆ + 2 , ಸಂಖ್ಯೆ = ಸಂಖ್ಯೆ + 5 , ಅಥವಾ ಸಂಖ್ಯೆ = ಸಂಖ್ಯೆ + 10 ಎಂದು + + ವಿಭಾಗವನ್ನು ತಿದ್ದುಪಡಿ ಮಾಡಬಹುದು.

ಇದನ್ನು ಇನ್ನೂ + = 2 ಅಥವಾ ಸಂಖ್ಯೆ + = 5 ಕ್ಕೆ ಕಡಿಮೆ ಮಾಡಬಹುದು.

ಒಂದು ಪ್ರಾಯೋಗಿಕ ಉದಾಹರಣೆ

ಲೂಪ್ಗಳು ಸಂಖ್ಯೆಗಳ ಪಟ್ಟಿಗಳನ್ನು ಪುನರಾವರ್ತಿಸಲು ಹೆಚ್ಚು ಮಾಡಬಹುದು. ನೀವು ನಿಜವಾಗಿಯೂ ಇತರ ಆಜ್ಞೆಗಳ ಔಟ್ಪುಟ್ ಅನ್ನು ಪಟ್ಟಿಯಂತೆ ಬಳಸಬಹುದು.

ಕೆಳಗಿನ ಉದಾಹರಣೆಯು ಆಡಿಯೊ ಫೈಲ್ಗಳನ್ನು MP3 ನಿಂದ WAV ಗೆ ಹೇಗೆ ಪರಿವರ್ತಿಸುವುದು ಎಂಬುದನ್ನು ತೋರಿಸುತ್ತದೆ:

#! / ಬಿನ್ / ಬ್ಯಾಷ್

ಈ ಉದಾಹರಣೆಯಲ್ಲಿನ ಪಟ್ಟಿ ಪ್ರಸ್ತುತ ಫೋಲ್ಡರ್ನಲ್ಲಿನ ಎಂಪಿ 3 ವಿಸ್ತರಣೆಯೊಂದಿಗೆ ಪ್ರತಿ ಫೈಲ್ ಆಗಿದೆ ಮತ್ತು ವೇರಿಯೇಬಲ್ ಫೈಲ್ ಆಗಿದೆ .

Mpg ಆಜ್ಞೆಯು MP3 ಫೈಲ್ ಅನ್ನು WAV ಗೆ ಪರಿವರ್ತಿಸುತ್ತದೆ. ಆದಾಗ್ಯೂ, ನೀವು ಮೊದಲು ನಿಮ್ಮ ಪ್ಯಾಕೇಜ್ ವ್ಯವಸ್ಥಾಪಕವನ್ನು ಬಳಸಿಕೊಂಡು ಇದನ್ನು ಅನುಸ್ಥಾಪಿಸಬೇಕಾಗಬಹುದು.