ಬ್ಯಾಷ್ ಸಿದ್ಧಾಂತ

0. ಸೂಚ್ಯಂಕ

1. ಹೆಚ್ಚಿನ ಜನರಿಗೆ ಸಂಭವಿಸುವ ಸಂಗತಿಗಳು
2. ಸ್ಕ್ರಿಪ್ಟ್‌ನ ರಚನೆ
3. ಪರದೆಯ ಮೇಲೆ ಮುದ್ರಿಸು
4. ಬಳಕೆದಾರ INPUT ಓದಿ
5. ಬ್ಯಾಷ್ನಲ್ಲಿ ಲೆಕ್ಕಾಚಾರಗಳು
6. ನಿಯಮಗಳು
7. ಕುಣಿಕೆಗಳು
8. ಕಾರ್ಯಗಳು
9. ಗೆಟಾಪ್ಸ್

1. ಹೆಚ್ಚಿನ ಜನರಿಗೆ ಸಂಭವಿಸುವ ವಿಷಯಗಳು

/ ಬಿನ್ / ಬ್ಯಾಷ್ ಅಥವಾ / ಬಿನ್ / ಶ

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

ಯುನಿಕೋಡ್ vs ಎಎಸ್ಸಿಐಐ

ನಿಮ್ಮ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳಲ್ಲಿ "¿" ಅಥವಾ "ñ" ಅನ್ನು ಏಕೆ ಬಳಸಬಾರದು ಎಂದು ನೀವು ಎಂದಾದರೂ ಯೋಚಿಸಿದ್ದೀರಾ? ಅಥವಾ ಉಚ್ಚಾರಣೆಯನ್ನು ಬಳಸುವುದೇ? ಸಂವಾದಾತ್ಮಕ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳಲ್ಲಿ ಇದು ಸಾಕಷ್ಟು ಕಿರಿಕಿರಿ ಉಂಟುಮಾಡುತ್ತದೆ. ಬ್ಯಾಷ್‌ನ ಡೀಫಾಲ್ಟ್ ಎನ್‌ಕೋಡಿಂಗ್ ಎಎಸ್‌ಸಿಐಐ ಅಥವಾ ಅದೇ, ಇಂಗ್ಲಿಷ್ ಅಕ್ಷರ ಸೆಟ್. ಅದನ್ನು ಬದಲಾಯಿಸಲು, ನಾವು ಯುನಿಕೋಡ್ ಅನ್ನು ಬಳಸಲು ಬಯಸುತ್ತೇವೆ ಎಂದು ನಮ್ಮ ಸ್ಕ್ರಿಪ್ಟ್‌ಗೆ ಮಾತ್ರ ಹೇಳಬೇಕಾಗಿದೆ. ಅದಕ್ಕಾಗಿ ನೀವು ಕಮಾಂಡ್ ಇಂಟರ್ಪ್ರಿಟರ್ ನಂತರ ಒಂದು ಸಾಲನ್ನು ಸೇರಿಸಬೇಕಾಗಿದೆ:

# - * - ಎನ್ಕೋಡಿಂಗ್: ಯುಟಿಎಫ್ -8 - * -

ಜಾಗರೂಕರಾಗಿರಿ, ಈ ಸಾಲು ಸ್ಕ್ರಿಪ್ಟ್‌ನ ಪ್ರಾರಂಭದಲ್ಲಿರುವುದು ಮುಖ್ಯ.

ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಿ

People ನೊಂದಿಗೆ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳನ್ನು ಎಷ್ಟು ಜನರು ಚಲಾಯಿಸುತ್ತಾರೆ ಎಂಬುದು ತಮಾಷೆಯಾಗಿದೆ$ ಬ್ಯಾಷ್ script.sh" ಬದಲಾಗಿ "$ ./script.sh'ಎಲ್ಲಾ ನಂತರ, ಇದಕ್ಕಾಗಿ ನಾವು ಶೆಲ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಿದ್ದೇವೆ.

ಮರಣದಂಡನೆ ಅನುಮತಿಗಳನ್ನು ಸೇರಿಸಲು, ನೀವು ಕಾರ್ಯಗತಗೊಳಿಸಬೇಕು:

sudo + x script.sh

BIN = "ನಾವು ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳನ್ನು ಹೊಂದಿರುವ ಫೋಲ್ಡರ್" PATH = "$ BIN $ PATH"

2. ಲಿಪಿಯ ರಚನೆ

1. ತಲೆ ಹಲಗೆ
2. ಜಾಗತಿಕ ಅಸ್ಥಿರಗಳ ವ್ಯಾಖ್ಯಾನ
3. ಸಹಾಯ
4. ಕಾರ್ಯಗಳು
5. ಮುಖ್ಯ ದೇಹ

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

ಕಾರ್ಯಗಳನ್ನು ಬಳಸಲು, ನಮ್ಮ ಸ್ಕ್ರಿಪ್ಟ್‌ನ ಮುಖ್ಯ ದೇಹದ ಮೊದಲು ಅವುಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಬೇಕು. ಮತ್ತು ನಮ್ಮ ಎಲ್ಲಾ ಸ್ಕ್ರಿಪ್ಟ್‌ನ ಜಾಗತಿಕ ಮಟ್ಟದಲ್ಲಿ, ಮುಖ್ಯ ದೇಹದಲ್ಲಿ ಮತ್ತು ಕಾರ್ಯಗಳಲ್ಲಿ ನಾವು ಅಸ್ಥಿರಗಳನ್ನು ಬಳಸಲು ಬಯಸಿದರೆ, ನಾವು ಅವುಗಳನ್ನು ಎಲ್ಲದರ ಪ್ರಾರಂಭದಲ್ಲಿ, ಹೆಡರ್ ನಂತರ ವ್ಯಾಖ್ಯಾನಿಸಬೇಕು.

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

ಕಾರ್ಯ ಸಹಾಯ () {ಪ್ರತಿಧ್ವನಿ "" "ನಮ್ಮ ಉತ್ತಮವಾಗಿ ಫಾರ್ಮ್ಯಾಟ್ ಮಾಡಿದ ಸಹಾಯ ಪಠ್ಯ." "" ನಿರ್ಗಮಿಸಿದರೆ [[-z $ 1 || $ 1 == "-h" || $ 1 == "- ಸಹಾಯ"]]; ನಂತರ fi ಗೆ ಸಹಾಯ ಮಾಡಿ

ನಾವು ಸಹಾಯ ಕಾರ್ಯಕ್ಕೆ "ನಿರ್ಗಮನ" ಅನ್ನು ಸೇರಿಸಿದರೆ, ನಾವು ಸಹಾಯವನ್ನು ಚಲಾಯಿಸುವಾಗಲೆಲ್ಲಾ ನಾವು ಸ್ಕ್ರಿಪ್ಟ್‌ನಿಂದ ನಿರ್ಗಮಿಸುತ್ತೇವೆ, ಉದಾಹರಣೆಗೆ ದೋಷ ಸಂದೇಶಗಳ ನಂತರ, ಇತ್ಯಾದಿ. ನಾವು ಕೋಡ್‌ನ ಕೆಲವು ಸಾಲುಗಳನ್ನು ಉಳಿಸುತ್ತೇವೆ.

ಸ್ಕ್ರಿಪ್ಟ್ ನಿಯತಾಂಕಗಳಿಲ್ಲದೆ ಚಾಲನೆಯಲ್ಲಿದ್ದರೆ ಅಥವಾ -h / –help ಅನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಿದರೆ ನಿರ್ಗಮನವು ಪರದೆಯ ಮೇಲೆ ಪ್ರದರ್ಶನ ಸಹಾಯವನ್ನು ಸೂಚಿಸುತ್ತದೆ ಮತ್ತು ನಿರ್ಗಮಿಸುತ್ತದೆ. ನೀವು ಅದನ್ನು ನೋಡಿದರೆ, ಅದು ಹೆಚ್ಚಿನ ಲಿನಕ್ಸ್ ಪ್ರೋಗ್ರಾಂಗಳ ಪ್ರಮಾಣಿತ ನಡವಳಿಕೆಯಾಗಿದೆ.

3. ಪರದೆಯ ಮೇಲೆ ಮುದ್ರಿಸು

ಬ್ಯಾಷ್‌ನಲ್ಲಿ ಪರದೆಗೆ ಮುದ್ರಿಸಲು 2 ಮುಖ್ಯ ಆಜ್ಞೆಗಳಿವೆ: «ಪ್ರತಿಧ್ವನಿ"ವೈ"printf«. ಅವೆರಡೂ ಅಷ್ಟೇ ವೇಗವಾಗಿರುತ್ತವೆ ಮತ್ತು ಎರಡೂ ಬ್ಯಾಷ್‌ನ ಭಾಗವಾಗಿದೆ. ಹರಿಕಾರನಿಗೆ ಮುಖ್ಯ ವ್ಯತ್ಯಾಸವೆಂದರೆ ಪ್ರತಿಧ್ವನಿ ಕೊನೆಯಲ್ಲಿ ಹೊಸ ಮಾರ್ಗವನ್ನು ಸೇರಿಸುತ್ತದೆ, ಆದರೆ «printf"ಇಲ್ಲ.

ಎಕೋ ತುಂಬಾ ಒಳ್ಳೆಯದು ಮತ್ತು ಹೆಚ್ಚಿನ ಜನರು ಇದನ್ನು ಬಳಸುತ್ತಾರೆ, ಆದರೆ ಬಳಕೆದಾರರ INPUT ಅನ್ನು ಓದುವಾಗ, ಅಥವಾ ಪದ ಸಂಸ್ಕರಣೆಯ ಮೂಲಕ ಫೈಲ್‌ಗಳಿಂದ ತೆಗೆದ ಅಸ್ಥಿರಗಳನ್ನು ಮುದ್ರಿಸಲು ನೀವು ಬಯಸಿದಾಗ, ವಿಚಿತ್ರವಾದ ಸಂಗತಿಗಳು ಸಂಭವಿಸಬಹುದು. ಅವುಗಳನ್ನು ಸಾಮಾನ್ಯವಾಗಿ ಸುಲಭವಾಗಿ ಪರಿಹರಿಸಲಾಗುತ್ತದೆ, ಡಬಲ್ ಉಲ್ಲೇಖಗಳನ್ನು ಏಕ ಅಥವಾ ಪ್ರತಿಕ್ರಮಕ್ಕೆ ಬದಲಾಯಿಸುವುದು ಅಥವಾ ಉಲ್ಲೇಖಗಳಿಂದ ವೇರಿಯಬಲ್ ಉಲ್ಲೇಖಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳುವುದು ಸುಲಭ. «ಎಕೋStrong ನಾವು ಯಾವಾಗಲೂ ಉಬುಂಟು ಅಥವಾ ಯಾವಾಗಲೂ ಫೆಡೋರಾವನ್ನು ಬಳಸುತ್ತಿದ್ದರೆ, ಅದು ನಮ್ಮ ಮೇಲೆ ಪರಿಣಾಮ ಬೀರುವುದಿಲ್ಲ, ಆದರೆ ನಾವು ವಿತರಣೆಯನ್ನು ಬದಲಾಯಿಸಿದರೆ ಅದು ಹೇಗೆ ಮಾಡುತ್ತದೆ ಎಂಬುದನ್ನು ಅವಲಂಬಿಸಿ ವಿಚಿತ್ರವಾದ ಸಂಗತಿಗಳು ಹೇಗೆ ಸಂಕಲಿಸಲ್ಪಟ್ಟವು ಎಂಬುದರ ಮೇಲೆ ಅವಲಂಬಿತವಾಗಿದೆಯೇ?

ಅದಕ್ಕಾಗಿಯೇ ನಾನು use ಅನ್ನು ಬಳಸುತ್ತೇನೆprintf«, ಇದು ನನಗೆ ತಲೆನೋವು ನೀಡುವುದಿಲ್ಲ ಮತ್ತು ಹೆಚ್ಚು ವರ್ತಿಸುತ್ತದೆ«printfC ಸಿ ಅಥವಾ «ನಿಂದಮುದ್ರಣY ಪೈಥಾನ್‌ನಲ್ಲಿ, ನಿಮ್ಮ ಸ್ಕ್ರಿಪ್ಟ್‌ ಅನ್ನು ನೀವು ಇನ್ನೊಂದು ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗೆ ಪೋರ್ಟ್ ಮಾಡಲು ಬಯಸಿದರೆ ಇದು ಬಹಳ ಮುಖ್ಯ.

4. ಬಳಕೆದಾರ INPUT ಓದಿ

ನಮ್ಮ ಸ್ಕ್ರಿಪ್ಟ್‌ನ ಹೆಸರಿನ ನಂತರ ಮತ್ತು ENTER ಕೀಲಿಯನ್ನು ಹೊಡೆಯುವ ಮೊದಲು ನಾವು ಬರೆಯುವ ಎಲ್ಲವನ್ನೂ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ವಿಶೇಷ ಅಸ್ಥಿರಗಳಲ್ಲಿ ಉಳಿಸಲಾಗುತ್ತದೆ. ಈ ಅಸ್ಥಿರಗಳು $ X ಪ್ರಕಾರದವು, ಅಲ್ಲಿ X ಒಂದು ಸಂಖ್ಯೆಯಾಗಿದೆ.

«$0Script ನಮ್ಮ ಸ್ಕ್ರಿಪ್ಟ್‌ನ ಹೆಸರನ್ನು ಮತ್ತು from ನಿಂದ ಸೂಚಿಸುತ್ತದೆ$1After ಅನಂತಕ್ಕೆ ನಾವು ನಂತರ ಬರೆದ ಎಲ್ಲವೂ ವೇರಿಯಬಲ್. ಉದಾಹರಣೆಗೆ:

cat << EOF >> test.sh #! / bin / bash # - * - ಎನ್ಕೋಡಿಂಗ್: UTF-8 - * - printf "\ $ 0 = $ 0 \ n" printf "\ $ 1 = $ 1 \ n" printf "\ $ 2 = $ 2 \ n "EOF chmod + x script.sh ./script.sh my file.txt

ನಾವು ಪರೀಕ್ಷಾ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ರಚಿಸುತ್ತೇವೆ, ಅದನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದು ಮತ್ತು ಅದನ್ನು 2 ನಿಯತಾಂಕಗಳೊಂದಿಗೆ ಚಲಾಯಿಸುತ್ತೇವೆ. ಇದರ ಪರದೆಯ output ಟ್‌ಪುಟ್ ಅನ್ನು ನಾವು ಪಡೆಯುತ್ತೇವೆ:

$ 0 = ./script.sh $ 1 = ನನ್ನ $ 2 = file.txt

ಉಲ್ಲೇಖಗಳನ್ನು ಬಳಸಿಕೊಂಡು ನಾವು "my file.txt" ಅನ್ನು "$ 1" ಗೆ ರವಾನಿಸಬಹುದಿತ್ತು.

ನಾವು "ರೀಡ್" ಆಜ್ಞೆಯೊಂದಿಗೆ ಬಳಕೆದಾರರ INPUT ಅನ್ನು ಸಹ ಓದಬಹುದು, ನಾವು ನಿಯತಾಂಕವನ್ನು ಉಳಿಸಲು ಬಯಸುವ ವೇರಿಯೇಬಲ್ ಅನ್ನು ನೇರವಾಗಿ ಸೂಚಿಸುತ್ತದೆ. ಉದಾಹರಣೆಗೆ:

printf "ನಿಮ್ಮ ಹೆಸರೇನು? \ n" NAME printf ಅನ್ನು ಓದಿ "ಹಲೋ, $ NAME. \ n"

5. ಬ್ಯಾಷ್ನಲ್ಲಿ ಲೆಕ್ಕಾಚಾರಗಳು

ಅದಕ್ಕಾಗಿ ನಾವು use ಅನ್ನು ಬಳಸಬಹುದುexr«, ಎಲ್ಲಿಯವರೆಗೆ ನಾವು ಸಂಕೀರ್ಣ ಲೆಕ್ಕಾಚಾರಗಳನ್ನು ಮಾಡಬೇಕಾಗಿಲ್ಲ. ಎರಡು ವಿಷಯಗಳನ್ನು ಗಮನಿಸಬೇಕು, ಮೊದಲನೆಯದು «exrNumber ಸಂಪೂರ್ಣ ಸಂಖ್ಯೆಗಳನ್ನು ಮಾತ್ರ ಒಪ್ಪಿಕೊಳ್ಳುತ್ತದೆ, ಎರಡನೆಯದು ವಿಭಾಗವು ಸಂಪೂರ್ಣ ಫಲಿತಾಂಶವನ್ನು ನೀಡುತ್ತದೆ, ಉಳಿದವುಗಳನ್ನು ನಾವು ಬಳಸಬಹುದು «%".

ಸಾಮಾನ್ಯವಾಗಿ ನಾವು ಎಕ್ಸ್‌ಪ್ರೆಸ್ ಫಲಿತಾಂಶವನ್ನು ವೇರಿಯೇಬಲ್‌ಗೆ ನಿಯೋಜಿಸಲು ಬಯಸುತ್ತೇವೆ. ನಾವು ಅದನ್ನು ಎರಡು ರೀತಿಯಲ್ಲಿ ಮಾಡಬಹುದು:

VAR2 = `expr $ VAR1 / 10` VAR2 = $ (expr $ VAR1 / 100)

ನೀವು ಸಹ ಬಿಟ್ಟುಬಿಡಬಹುದು «exrDouble ಡಬಲ್ ಆವರಣಗಳನ್ನು ಬಳಸುವುದು:

VAR2 = $ (($ VAR1 / 100%))

6. ಷರತ್ತುಗಳು

ಇದನ್ನು ಈಗಾಗಲೇ about ಬಗ್ಗೆ ಬಹಳ ವಿಸ್ತಾರವಾಗಿ ಬರೆಯಲಾಗಿದೆif«,«ಬೇರೆ«,«Elif»ಮತ್ತು ಷರತ್ತುಗಳು. ಅದರ ಬಗ್ಗೆ ನೀವು ಇಲ್ಲಿ ಓದಬಹುದು:

• ಬ್ಯಾಷ್ನಲ್ಲಿ ಪ್ರೋಗ್ರಾಮಿಂಗ್: ಭಾಗ 1
• ಬ್ಯಾಷ್: ಹಾಗಿದ್ದರೆ, ಬೇರೆ ಪರಿಸ್ಥಿತಿಗಳು
• ಫೈಲ್ ಅಥವಾ ಫೋಲ್ಡರ್ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆಯೇ ಅಥವಾ ಇಲ್ಲವೇ ಮತ್ತು ಲೂಪ್ನೊಂದಿಗೆ ಹೆಚ್ಚಿನದನ್ನು ಪರಿಶೀಲಿಸಿ
• ಬ್ಯಾಷ್ನಲ್ಲಿ ಪ್ರೋಗ್ರಾಮಿಂಗ್: ಭಾಗ 2

ಸರಳ ಚದರ ಆವರಣಗಳ ಬಳಕೆಯ ನಡುವಿನ ವ್ಯತ್ಯಾಸವನ್ನು ನಾನು ಹೈಲೈಟ್ ಮಾಡಲು ಬಯಸುತ್ತೇನೆ, «[]«, ಮತ್ತು ಡಬಲ್ ಬ್ರಾಕೆಟ್ಗಳು,«[[]]«, ಷರತ್ತುಗಳಿಗಾಗಿ. ಡಬಲ್ ಬ್ರಾಕೆಟ್ಗಳೊಂದಿಗೆ ನಾವು ಹೆಚ್ಚುವರಿ ಷರತ್ತುಗಳನ್ನು ಬಳಸಬಹುದು:

• «&&»ಫಾರ್ ಮತ್ತು
• «||»ಫಾರ್ ಅಥವಾ

ಬಳಸಲು "&&"ವೈ"||Square ಸರಳ ಚದರ ಆವರಣಗಳೊಂದಿಗೆ, ಪ್ರತಿಯೊಂದು ಭಾಗವನ್ನು ಪ್ರತ್ಯೇಕ ಚದರ ಆವರಣಗಳಲ್ಲಿ ಬೇರ್ಪಡಿಸಬೇಕು. ಸಹಾಯವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಬೇಕೇ ಎಂದು ನೋಡಲು ಸ್ಕ್ರಿಪ್ಟ್‌ನ ಭಾಗಕ್ಕೆ ಬಳಸಿದ ಉದಾಹರಣೆ ಹೀಗಿರುತ್ತದೆ:

if [-z "$ 1"] || ["$ 1" == "-h"] || ["$ 1" == "- ಸಹಾಯ"]]; ನಂತರ fi ಗೆ ಸಹಾಯ ಮಾಡಿ

ದೋಷಗಳನ್ನು ತಡೆಗಟ್ಟಲು ಉಲ್ಲೇಖಗಳಲ್ಲಿ ವೇರಿಯಬಲ್ ಹೆಸರುಗಳನ್ನು ಬರೆಯುವುದರಿಂದ ಇದು ನಮ್ಮನ್ನು ಉಳಿಸುತ್ತದೆ. ಉದಾಹರಣೆಗೆ:

[$ 1 = 1] ವೇಳೆ; ನಂತರ printf "ನಿಯತಾಂಕವು 1 ಕ್ಕೆ ಸಮಾನವಾಗಿರುತ್ತದೆ." fi if ["$ 1" = 1]; ನಂತರ printf "ನಿಯತಾಂಕವು 1 ಕ್ಕೆ ಸಮಾನವಾಗಿರುತ್ತದೆ." fi if [[$ 1 = 1]]; ನಂತರ printf "ನಿಯತಾಂಕವು 1 ಕ್ಕೆ ಸಮಾನವಾಗಿರುತ್ತದೆ." fi

Script.sh ಅನ್ನು ಯಾವುದೇ ನಿಯತಾಂಕಗಳಿಲ್ಲದೆ ಚಲಾಯಿಸಿದರೆ, ಮೊದಲ ಪ್ರಕರಣವು ದೋಷವನ್ನು ನೀಡುತ್ತದೆ:

bash: [: =: unary ಆಪರೇಟರ್ ನಿರೀಕ್ಷಿಸಲಾಗಿದೆ

ಇದರ ಬಗ್ಗೆ ಮಾತನಾಡಲಾಗಿಲ್ಲ isಸಂದರ್ಭದಲ್ಲಿ«, ಸರಳೀಕರಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ«if«. ನಮ್ಮಲ್ಲಿ ಯಾವುದೂ ಇಲ್ಲದಿದ್ದಾಗ ಆರಂಭದಲ್ಲಿ ಪ್ರಾರಂಭಿಸೋಣifCode ಎಲ್ಲಾ ಕೋಡ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ. ನಾವು ಷರತ್ತು ಸೇರಿಸಿದರೆ «if»ನಾವು ಎರಡು ಪ್ರಕರಣಗಳನ್ನು ಹೊಂದಿದ್ದೇವೆ, ಅದರಲ್ಲಿ ಒಂದು ಕೋಡ್‌ನ ಬ್ಲಾಕ್«ifBlock ಮತ್ತು ಈ ಬ್ಲಾಕ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸದ ಇತರ ಪ್ರಕರಣ.

ನಾವು «ಅನ್ನು ಸೇರಿಸಿದರೆಬೇರೆ«ನಾವು ಎರಡು ಪ್ರಕರಣಗಳನ್ನು ಸಹ ಹೊಂದಿದ್ದೇವೆ, ಆದರೆ ಈ ಎರಡು ಪ್ರಕರಣಗಳು ಹಿಂದಿನ ಪ್ರಕರಣಗಳಿಗಿಂತ ಭಿನ್ನವಾಗಿವೆ. ಏಕೆಂದರೆ ಈಗ ಎರಡು ಷರತ್ತುಬದ್ಧ ಕೋಡ್ ಬ್ಲಾಕ್‌ಗಳು, ಎ ಮತ್ತು ಬಿ, ಮತ್ತು ಸಿ ಬ್ಲಾಕ್ ಇರುತ್ತದೆ, ಅದು ಉಳಿದ ಪ್ರೋಗ್ರಾಂ ಆಗಿದೆ. ಎ ಅಥವಾ ಬಿ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ, ಮತ್ತು ಸಿ. ಹಿಂದಿನ ಸಂದರ್ಭದಲ್ಲಿ ಅದು ಎ ಮತ್ತು ಸಿ ಅಥವಾ ಕೇವಲ ಸಿ ಆಗಿತ್ತು.

ಬರೆಯುವ ಪರಿಸ್ಥಿತಿಗಳನ್ನು ತಪ್ಪಿಸಲು «if / else"ಒಳಗೆ"ಬೇರೆ»ಮತ್ತು ಕೋಡ್ ಓದುವಿಕೆಯನ್ನು ಸರಳೀಕರಿಸಲು, ಇದನ್ನು ರಚಿಸಲಾಗಿದೆ«Elif«. ಹಿಂದಿನದನ್ನು ಅವಲಂಬಿಸಿರುವ ಅನೇಕ ಷರತ್ತುಗಳನ್ನು ನಾವು ಹೊಂದಿರುವಾಗ, ಉದಾಹರಣೆಗೆ ಸಂಖ್ಯೆಗಳ ಶ್ರೇಣಿ ಅಥವಾ ಪ್ರಕಾರ:

[[$ VAR1 = 1]] ವೇಳೆ VAR1 = $ 1; ನಂತರ printf "1 \ n" ಎಲಿಫ್ [[$ VAR1 = 2]]; ನಂತರ printf "2 \ n" ಎಲಿಫ್ [[$ VAR1 = 3]]; ನಂತರ printf "3 \ n" else printf "none \ n" fi

ಕೊನೆಯ ಸಂದರ್ಭದಲ್ಲಿ «ElifConditions ಅನೇಕ ಷರತ್ತುಗಳನ್ನು ಓದಲಾಗುತ್ತದೆ. ಈ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಸುವ್ಯವಸ್ಥಿತಗೊಳಿಸಿದರೆ:

VAR1 = case 1 ಕೇಸ್ $ VAR 1 ರಲ್ಲಿ) printf "1 \ n" ;; 2) printf "2 \ n" ;; 3 | 4) printf "3 ಅಥವಾ 4, ಇದು \ n" ಅನ್ನು ಅವಲಂಬಿಸಿರುತ್ತದೆ; *) printf "none \ n" ;; ಅದು ಸಿ

ಈ ಸಂದರ್ಭದಲ್ಲಿ VAR1 ಅನ್ನು ವೇರಿಯೇಬಲ್ ಓದಲಾಗುತ್ತದೆ, ಮತ್ತು ಅದು ಯಾವುದೇ ಪ್ರಕರಣಗಳಿಗೆ ಸಮನಾಗಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸಲಾಗುತ್ತದೆ, ಇಲ್ಲದಿದ್ದರೆ, ಡೀಫಾಲ್ಟ್ ಕೇಸ್ "*" ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ. ಡಬಲ್ ಸೆಮಿಕೋಲನ್‌ಗಳು to ಗೆ ಸಮಾನವಾಗಿರುತ್ತದೆಬ್ರೇಕ್«, ಅವರು ಹೇಳುತ್ತಾರೆ«ಸಂದರ್ಭದಲ್ಲಿ»ಅದು ಕೊನೆಗೊಳ್ಳಬೇಕು.

7. ಕುಣಿಕೆಗಳು

ಯಾವುದೇ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಯಲ್ಲಿ ಕೆಲವೇ ಕುಣಿಕೆಗಳು ತಿಳಿದಿವೆ. ಬ್ಯಾಷ್‌ನಲ್ಲಿ ಅವು «ಹಾಗೆಯೇ«,«ರವರೆಗೆ"ವೈ"ಫಾರ್«. ಇವುಗಳ ಬಗ್ಗೆ ಈಗಾಗಲೇ ಬ್ಲಾಗ್‌ನಲ್ಲಿ ಬರೆಯಲಾಗಿದೆ:

• ಬ್ಯಾಷ್ನಲ್ಲಿ ಪ್ರೋಗ್ರಾಮಿಂಗ್: ಭಾಗ 1
• ಬ್ಯಾಷ್ನಲ್ಲಿ ಪ್ರೋಗ್ರಾಮಿಂಗ್: ಭಾಗ 2

ಎರಡು ರೀತಿಯ ಕುಣಿಕೆಗಳಿವೆ «ಫಾರ್«, ಆ ಪ್ರಕಾರದವುಗಳು«L LOQUESEA ನಲ್ಲಿ VAR ಗಾಗಿ»ಮತ್ತು ಸಿ type ಪ್ರಕಾರಗಳು ಯಾವುವು$ for ((I = 0; I <= 10; I ++))«. ಎರಡನೇ ವಿಧದ ಕುಣಿಕೆಗಳು «ಫಾರ್Very ತುಂಬಾ ಉಪಯುಕ್ತವಾಗಿದೆ, ಇದು ಲೂಪ್‌ನ ಆರಂಭದಲ್ಲಿ 3 ಭಾಗಗಳನ್ನು ಹೊಂದಿದೆ:

• ಅಸ್ಥಿರಗಳ ಘೋಷಣೆ ಮತ್ತು ಪ್ರಾರಂಭ (ಈ ಸಂದರ್ಭದಲ್ಲಿ ಸಹಾಯಕ ವೇರಿಯಬಲ್ "I = 0").
• ಮರಣದಂಡನೆ ಸ್ಥಿತಿ (ನಾನು 10 ಕ್ಕಿಂತ ಕಡಿಮೆ ಅಥವಾ ಸಮನಾಗಿರುವವರೆಗೆ).
• ಸಹಾಯಕ ವೇರಿಯೇಬಲ್ನ ಹೆಚ್ಚಳ

ನನ್ನ ಅಭಿಪ್ರಾಯದಲ್ಲಿ ಇದು ಎಲ್ಲಕ್ಕಿಂತ ಶಕ್ತಿಶಾಲಿ ಲೂಪ್ ಆಗಿದೆ. ಒಂದು ಉದಾಹರಣೆ, ಇದು ಎಲ್ಲಾ ಸಂಖ್ಯೆಗಳನ್ನು 0 ರಿಂದ 10 ರವರೆಗೆ ಮುದ್ರಿಸುತ್ತದೆ, ಒಳಗೊಂಡಂತೆ:

#! / bin / bash for ((I = 0; I <= 10; I ++)); printf "$ I \ n" ಮುಗಿದಿದೆ

8. ಕಾರ್ಯಗಳು

ಬ್ಯಾಷ್ ನಮಗೆ ಮಾಡಲು ಅನುಮತಿಸದ ಕೆಲವು ವಿಷಯಗಳಿವೆ, ಸರಿ? ಮೊದಲ ನೋಟದಲ್ಲಿ, ಬ್ಯಾಷ್ ಕಾರ್ಯಗಳು ನಿಮ್ಮನ್ನು 3 ಕೆಲಸಗಳನ್ನು ತಡೆಯುತ್ತದೆ: ಕಾರ್ಯಗಳಲ್ಲಿ ಸ್ಥಳೀಯ ಅಸ್ಥಿರಗಳನ್ನು ಘೋಷಿಸುವುದು, ಕಾರ್ಯಗಳಿಗೆ ನಿಯತಾಂಕಗಳನ್ನು ಹಾದುಹೋಗುವುದು ಮತ್ತು ನಿಯತಾಂಕಗಳನ್ನು ಹಿಂದಿರುಗಿಸುವುದು. ಪ್ರತಿಯೊಂದಕ್ಕೂ ಪರಿಹಾರವಿದೆ.

ಹಾಗೆ ಏನೂ ಮಾಡಬೇಡಿ:

#! / bin / bash VAR = 1 printc "$ VAR \ n" ಕಾರ್ಯ ಹಲೋ () {VAR = 2 printf "$ VAR \ n"} ಹಲೋ printf "$ VAR \ n"

ಇದು 1, 2 ಮತ್ತು 2 ಪರದೆಯ ಮೇಲೆ ಮುದ್ರಿಸುತ್ತದೆ.

ಸ್ಥಳೀಯ ಅಸ್ಥಿರಗಳನ್ನು ಘೋಷಿಸಲು, add ಸೇರಿಸಿಸ್ಥಳೀಯDec ಘೋಷಿಸುವಾಗ:

#!

ಇದು ಪರದೆಯ ಮೇಲೆ 1, 1, 2, 1 ಅನ್ನು ಮುದ್ರಿಸುತ್ತದೆ.

ಒಂದು ಕಾರ್ಯಕ್ಕೆ ನೀವು ನಿಯತಾಂಕಗಳನ್ನು ಹೇಗೆ ರವಾನಿಸುತ್ತೀರಿ?

#! / ಬಿನ್ / ಬ್ಯಾಷ್ # - * - ಎನ್‌ಕೋಡಿಂಗ್: ಯುಟಿಎಫ್ -8 - * - ಫಂಕ್ಷನ್ ಹಲೋ () {printf "ಹಲೋ $ 1 \ n"}

printf "ನಿಮ್ಮ ಹೆಸರೇನು? \ n"
VAR1 ಓದಿ
ಹಲೋ $ VAR1

ನಿಯತಾಂಕಗಳನ್ನು ಹೇಗೆ ಹಿಂತಿರುಗಿಸಲಾಗುತ್ತದೆ?

#! printf "$ VAR8 $ VAR1 \ n"

ನೀವು ನೋಡುವಂತೆ, ಇದು ಎರಡು ನ್ಯೂನತೆಗಳನ್ನು ಹೊಂದಿದೆ, ನೀವು ಕೇವಲ ಒಂದು ನಿಯತಾಂಕವನ್ನು ಮಾತ್ರ ಹಿಂತಿರುಗಿಸಬಹುದು, ಅದು ವೆಕ್ಟರ್ ಆಗಿರಬಹುದು, ಮತ್ತು ನೀವು ನಿಯತಾಂಕವನ್ನು ಹಿಂತಿರುಗಿಸಲು ಬಯಸಿದರೆ, ಆ ಕಾರ್ಯದಿಂದ ನೀವು ಇನ್ನು ಮುಂದೆ ಪರದೆಯ ಮೇಲೆ ಮುದ್ರಿಸಲಾಗುವುದಿಲ್ಲ.

9. ಗೆಟಾಪ್ಸ್

ಸಂಕೀರ್ಣವಾದ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳನ್ನು ರಚಿಸಲು ಬ್ಯಾಷ್ ಬಗ್ಗೆ ನೀವು ತಿಳಿದುಕೊಳ್ಳಬೇಕಾದ ಕೊನೆಯ ವಿಷಯವೆಂದರೆ «ಗೆಟಾಪ್ಸ್«. ಆದೇಶವನ್ನು ಲೆಕ್ಕಿಸದೆ ಸ್ಕ್ರಿಪ್ಟ್‌ಗೆ ಆಯ್ಕೆಗಳನ್ನು ರವಾನಿಸಲು ಇದನ್ನು ಬಳಸಲಾಗುತ್ತದೆ. ಕೇವಲ ತೊಂದರೆಯೆಂದರೆ ಅದು ಸಣ್ಣ ಆಯ್ಕೆಗಳ ಮೇಲೆ ಮಾತ್ರ ಪರಿಣಾಮ ಬೀರುತ್ತದೆ:

#! / bin / bash # - * - ಎನ್ಕೋಡಿಂಗ್: UTF-8 - * - VARC = 0 ಕಾರ್ಯ ಸಹಾಯ () {printf "ಸಹಾಯ ಸಂದೇಶ \ n" ನಿರ್ಗಮಿಸಿ} [[-z $ 1]]; ಗೆಟೊಪ್ಟ್‌ಗಳು: ha: b: c OPT; ಕೇಸ್ ಮಾಡಿ $ OPT h ನಲ್ಲಿ) ಸಹಾಯ ;; :) ಸಹಾಯ ;; a) VARA = $ OPTARG ;; b) VARB = $ OPTARG ;; c) VARC = 1 ;; \?) ಸಹಾಯ ;; esac done # VARA, VARB ಮತ್ತು VARC ನೊಂದಿಗೆ # ಕೆಲಸ ಮಾಡುವ ಸ್ಕ್ರಿಪ್ಟ್‌ನ ಮುಖ್ಯ ಬ್ಲಾಕ್

«ಗೆಟೊಪ್ಟ್ಸ್The ಆಯ್ಕೆಗಳನ್ನು ಒಂದೊಂದಾಗಿ ಓದುತ್ತದೆ, ಆದ್ದರಿಂದ ಲೂಪ್ ಅಗತ್ಯವಿದೆ.

Using ಬಳಸಿ ರವಾನಿಸಬಹುದಾದ 2 ರೀತಿಯ ಆಯ್ಕೆಗಳಿವೆ.ಗೆಟೊಪ್ಟ್ಸ್":

• ಧ್ವಜಗಳು ಎಂದು ಕರೆಯಲ್ಪಡುವ ನಿಯತಾಂಕಗಳು, ಈ ಸಂದರ್ಭದಲ್ಲಿ -c ಅಥವಾ -h. ನಾವು ಬಳಸಲು ಬಯಸುವ ಅಕ್ಷರದೊಂದಿಗೆ ಅವುಗಳನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಲಾಗಿದೆ. ಅವು ಬೂಲಿಯನ್ ಅಸ್ಥಿರಗಳಂತೆ, «ನಿಜವಾದ»(ಇವೆ) ಅಥವಾ«ಸುಳ್ಳು"(ಅವರು ಇಲ್ಲಿಲ್ಲ).
• ಸಂಬಂಧಿತ ವಾದಗಳೊಂದಿಗೆ ನಿಯತಾಂಕಗಳು, -ಒಂದು, -ಬಿ ಏನು. ಕೆಳಗಿನ ಕೊಲೊನ್ನೊಂದಿಗೆ ನಮಗೆ ಬೇಕಾದ ಅಕ್ಷರದೊಂದಿಗೆ ಅವುಗಳನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಲಾಗಿದೆ. ವಾದವನ್ನು OPTARG ನಲ್ಲಿ ಸಂಗ್ರಹಿಸಲಾಗಿದೆ (ಈ ಹೆಸರನ್ನು ಬದಲಾಯಿಸಲಾಗುವುದಿಲ್ಲ).

ಈ ಸ್ಕ್ರಿಪ್ಟ್ ಏನು ಮಾಡುತ್ತದೆ?

ಯಾವುದೇ ಆಯ್ಕೆಯನ್ನು ರವಾನಿಸದಿದ್ದಾಗ, "-h" ನಿಯತಾಂಕವನ್ನು ಹಾದುಹೋದಾಗ, ಅಮಾನ್ಯ ನಿಯತಾಂಕವನ್ನು ಹಾದುಹೋದಾಗ (ಉದಾಹರಣೆಗೆ "-x", ಇದನ್ನು "\?" ನಿಂದ ಮಾಡಲಾಗುತ್ತದೆ) ಅಥವಾ ಯಾವಾಗ ಯಾವುದೇ ವಾದವಿಲ್ಲದ ಮಾನ್ಯ ನಿಯತಾಂಕ (":"). ಉಳಿದ ಸಂದರ್ಭಗಳಲ್ಲಿ ಇದು VARC ಯಲ್ಲಿ "-c" ನ ಉಪಸ್ಥಿತಿಯನ್ನು 1 ಆಗಿ ಉಳಿಸುತ್ತದೆ, ಮತ್ತು ಮೌಲ್ಯಗಳು VARA ಮತ್ತು VARB ನಲ್ಲಿ "-a" ಮತ್ತು "-b" ನೊಂದಿಗೆ ಹಾದುಹೋಗುತ್ತವೆ.