ಇಂದು ನಾವು ಬ್ಯಾಷ್ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳ ಬಗ್ಗೆ ಮಾತನಾಡುತ್ತೇವೆ. ಈ - , ಬ್ಯಾಷ್ ಶೆಲ್ಗಾಗಿ ಬರೆಯಲಾಗಿದೆ. zsh, tcsh, ksh ನಂತಹ ಇತರ ಶೆಲ್‌ಗಳಿವೆ, ಆದರೆ ನಾವು ಬ್ಯಾಷ್ ಮೇಲೆ ಕೇಂದ್ರೀಕರಿಸುತ್ತೇವೆ. ಈ ವಸ್ತುವು ಪ್ರತಿಯೊಬ್ಬರಿಗೂ ಉದ್ದೇಶಿಸಲಾಗಿದೆ, ಒಂದೇ ಸ್ಥಿತಿಯು ಕೆಲಸ ಮಾಡುವ ಸಾಮರ್ಥ್ಯವಾಗಿದೆ ಲಿನಕ್ಸ್.
ಕಮಾಂಡ್ ಲೈನ್ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳು ಕೀಬೋರ್ಡ್‌ನಿಂದ ನಮೂದಿಸಬಹುದಾದ ಅದೇ ಆಜ್ಞೆಗಳ ಸಂಗ್ರಹಗಳಾಗಿವೆ, ಅದನ್ನು ಫೈಲ್‌ಗಳಾಗಿ ಸಂಗ್ರಹಿಸಬಹುದು ಮತ್ತು ಕೆಲವು ಸಾಮಾನ್ಯ ಉದ್ದೇಶದಿಂದ ಒಂದುಗೂಡಿಸಬಹುದು. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ತಂಡಗಳ ಕೆಲಸದ ಫಲಿತಾಂಶಗಳು ಸ್ವತಂತ್ರ ಮೌಲ್ಯವನ್ನು ಹೊಂದಿರಬಹುದು ಅಥವಾ ಇತರ ತಂಡಗಳಿಗೆ ಇನ್‌ಪುಟ್ ಡೇಟಾವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸಬಹುದು. ಆಗಾಗ್ಗೆ ನಿರ್ವಹಿಸಲಾದ ಕ್ರಿಯೆಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸಲು ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳು ಪ್ರಬಲ ಮಾರ್ಗವಾಗಿದೆ.
ಆದ್ದರಿಂದ, ನಾವು ಆಜ್ಞಾ ಸಾಲಿನ ಬಗ್ಗೆ ಮಾತನಾಡಿದರೆ, ಅರ್ಧವಿರಾಮ ಚಿಹ್ನೆಯಿಂದ ಪ್ರತ್ಯೇಕಿಸಿ ನಮೂದಿಸುವ ಮೂಲಕ ಹಲವಾರು ಆಜ್ಞೆಗಳನ್ನು ಏಕಕಾಲದಲ್ಲಿ ಕಾರ್ಯಗತಗೊಳಿಸಲು ಇದು ನಿಮ್ಮನ್ನು ಅನುಮತಿಸುತ್ತದೆ:
pwd ; whoami
ವಾಸ್ತವವಾಗಿ, ನಿಮ್ಮ ಟರ್ಮಿನಲ್‌ನಲ್ಲಿ ನೀವು ಇದನ್ನು ಪ್ರಯತ್ನಿಸಿದರೆ, ಎರಡು ಆಜ್ಞೆಗಳನ್ನು ಒಳಗೊಂಡಿರುವ ನಿಮ್ಮ ಮೊದಲ ಬ್ಯಾಷ್ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಈಗಾಗಲೇ ಬರೆಯಲಾಗಿದೆ. ಇದು ಈ ರೀತಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ. ಮೊದಲು ತಂಡ pwd ಪ್ರಸ್ತುತ ಕಾರ್ಯನಿರ್ವಹಿಸುವ ಡೈರೆಕ್ಟರಿಯ ಬಗ್ಗೆ ಮಾಹಿತಿಯನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತದೆ, ನಂತರ ಆಜ್ಞೆ whoamiನೀವು ಲಾಗ್ ಇನ್ ಆಗಿರುವ ಬಳಕೆದಾರರ ಬಗ್ಗೆ ಮಾಹಿತಿಯನ್ನು ತೋರಿಸುತ್ತದೆ.
ಈ ವಿಧಾನವನ್ನು ಬಳಸಿಕೊಂಡು, ಒಂದು ಸಾಲಿನಲ್ಲಿ ನೀವು ಇಷ್ಟಪಡುವಷ್ಟು ಆಜ್ಞೆಗಳನ್ನು ನೀವು ಸಂಯೋಜಿಸಬಹುದು, ಪ್ರೋಗ್ರಾಂಗೆ ರವಾನಿಸಬಹುದಾದ ಗರಿಷ್ಠ ಸಂಖ್ಯೆಯ ಆರ್ಗ್ಯುಮೆಂಟ್ಗಳು ಮಾತ್ರ ಮಿತಿಯಾಗಿದೆ. ಕೆಳಗಿನ ಆಜ್ಞೆಯನ್ನು ಬಳಸಿಕೊಂಡು ನೀವು ಈ ಮಿತಿಯನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಬಹುದು:
getconf ARG_MAXಆಜ್ಞಾ ಸಾಲಿನ ಒಂದು ಉತ್ತಮ ಸಾಧನವಾಗಿದೆ, ಆದರೆ ನಿಮಗೆ ಅಗತ್ಯವಿರುವಾಗ ಪ್ರತಿ ಬಾರಿ ನೀವು ಆಜ್ಞೆಗಳನ್ನು ನಮೂದಿಸಬೇಕು. ನಾವು ಕಮಾಂಡ್‌ಗಳ ಸೆಟ್ ಅನ್ನು ಫೈಲ್‌ಗೆ ಬರೆದರೆ ಮತ್ತು ಅವುಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಆ ಫೈಲ್ ಅನ್ನು ಸರಳವಾಗಿ ಕರೆದರೆ ಏನು? ವಾಸ್ತವವಾಗಿ, ನಾವು ಮಾತನಾಡುತ್ತಿರುವ ಫೈಲ್ ಅನ್ನು ಆಜ್ಞಾ ಸಾಲಿನ ಸ್ಕ್ರಿಪ್ಟ್ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ.
ಬ್ಯಾಷ್ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳು ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ
ಆಜ್ಞೆಯನ್ನು ಬಳಸಿಕೊಂಡು ಖಾಲಿ ಫೈಲ್ ಅನ್ನು ರಚಿಸಿ touch. ಅದರ ಮೊದಲ ಸಾಲಿನಲ್ಲಿ ನಾವು ಯಾವ ಶೆಲ್ ಅನ್ನು ಬಳಸಲಿದ್ದೇವೆ ಎಂಬುದನ್ನು ಸೂಚಿಸಬೇಕಾಗಿದೆ. ನಾವು ಆಸಕ್ತಿ ಹೊಂದಿದ್ದೇವೆ bash, ಆದ್ದರಿಂದ ಫೈಲ್‌ನ ಮೊದಲ ಸಾಲು ಹೀಗಿರುತ್ತದೆ:
#!/bin/bash
ಶೆಲ್ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸದ ಕಾಮೆಂಟ್‌ಗಳನ್ನು ಸೂಚಿಸಲು ಈ ಫೈಲ್‌ನಲ್ಲಿರುವ ಇತರ ಸಾಲುಗಳು ಹ್ಯಾಶ್ ಚಿಹ್ನೆಯನ್ನು ಬಳಸುತ್ತವೆ. ಆದಾಗ್ಯೂ, ಮೊದಲ ಸಾಲು ವಿಶೇಷ ಪ್ರಕರಣವಾಗಿದೆ, ಒಂದು ಹ್ಯಾಶ್ ನಂತರ ಆಶ್ಚರ್ಯಸೂಚಕ ಚಿಹ್ನೆ ಇರುತ್ತದೆ (ಈ ಅನುಕ್ರಮವನ್ನು ಕರೆಯಲಾಗುತ್ತದೆ ) ಮತ್ತು ಮಾರ್ಗ bash, ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ನಿರ್ದಿಷ್ಟವಾಗಿ ರಚಿಸಲಾಗಿದೆ ಎಂದು ಸಿಸ್ಟಮ್‌ಗೆ ಸೂಚಿಸಿ bash.
ಶೆಲ್ ಆಜ್ಞೆಗಳನ್ನು ಲೈನ್ ಫೀಡ್‌ನಿಂದ ಪ್ರತ್ಯೇಕಿಸಲಾಗಿದೆ, ಕಾಮೆಂಟ್‌ಗಳನ್ನು ಹ್ಯಾಶ್ ಚಿಹ್ನೆಯಿಂದ ಪ್ರತ್ಯೇಕಿಸಲಾಗಿದೆ. ಇದು ಈ ರೀತಿ ಕಾಣುತ್ತದೆ:
#!/bin/bash
# This is a comment
pwd
whoamiಇಲ್ಲಿ, ಕಮಾಂಡ್ ಲೈನ್‌ನಲ್ಲಿರುವಂತೆ, ನೀವು ಒಂದು ಸಾಲಿನಲ್ಲಿ ಆಜ್ಞೆಗಳನ್ನು ಬರೆಯಬಹುದು, ಅರ್ಧವಿರಾಮ ಚಿಹ್ನೆಗಳಿಂದ ಬೇರ್ಪಡಿಸಬಹುದು. ಆದಾಗ್ಯೂ, ನೀವು ವಿವಿಧ ಸಾಲುಗಳಲ್ಲಿ ಆಜ್ಞೆಗಳನ್ನು ಬರೆದರೆ, ಫೈಲ್ ಅನ್ನು ಓದಲು ಸುಲಭವಾಗುತ್ತದೆ. ಯಾವುದೇ ಸಂದರ್ಭದಲ್ಲಿ, ಶೆಲ್ ಅವುಗಳನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುತ್ತದೆ.
ಸ್ಕ್ರಿಪ್ಟ್ ಫೈಲ್ ಅನುಮತಿಗಳನ್ನು ಹೊಂದಿಸಲಾಗುತ್ತಿದೆ
ಫೈಲ್ ಅನ್ನು ಉಳಿಸಿ ಅದಕ್ಕೆ ಹೆಸರನ್ನು ನೀಡಿ myscript, ಮತ್ತು ಬ್ಯಾಷ್ ಸ್ಕ್ರಿಪ್ಟ್ ರಚಿಸುವ ಕೆಲಸ ಬಹುತೇಕ ಮುಗಿದಿದೆ. ಈಗ ಉಳಿದಿರುವುದು ಈ ಫೈಲ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವಂತೆ ಮಾಡುವುದು, ಇಲ್ಲದಿದ್ದರೆ, ನೀವು ಅದನ್ನು ಚಲಾಯಿಸಲು ಪ್ರಯತ್ನಿಸಿದರೆ, ನೀವು ದೋಷವನ್ನು ಎದುರಿಸುತ್ತೀರಿ Permission denied.
ತಪ್ಪಾಗಿ ಕಾನ್ಫಿಗರ್ ಮಾಡಲಾದ ಅನುಮತಿಗಳೊಂದಿಗೆ ಸ್ಕ್ರಿಪ್ಟ್ ಫೈಲ್ ಅನ್ನು ಚಲಾಯಿಸಲು ಪ್ರಯತ್ನಿಸಲಾಗುತ್ತಿದೆ
ಫೈಲ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವಂತೆ ಮಾಡೋಣ:
chmod +x ./myscriptಈಗ ಅದನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಪ್ರಯತ್ನಿಸೋಣ:
./myscriptಅನುಮತಿಗಳನ್ನು ಹೊಂದಿಸಿದ ನಂತರ ಎಲ್ಲವೂ ಸರಿಯಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ.
ಬ್ಯಾಷ್ ಸ್ಕ್ರಿಪ್ಟ್ ಯಶಸ್ವಿಯಾಗಿ ರನ್ ಆಗುತ್ತಿದೆ
ಸಂದೇಶ ಔಟ್ಪುಟ್
Linux ಕನ್ಸೋಲ್‌ಗೆ ಪಠ್ಯವನ್ನು ಔಟ್ಪುಟ್ ಮಾಡಲು, ಆಜ್ಞೆಯನ್ನು ಬಳಸಿ echo. ಈ ಸತ್ಯದ ಜ್ಞಾನವನ್ನು ಬಳಸೋಣ ಮತ್ತು ನಮ್ಮ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಸಂಪಾದಿಸೋಣ, ಅದರಲ್ಲಿರುವ ಆಜ್ಞೆಗಳ ಮೂಲಕ ಔಟ್ಪುಟ್ ಆಗಿರುವ ಡೇಟಾಗೆ ವಿವರಣೆಗಳನ್ನು ಸೇರಿಸೋಣ:
#!/bin/bash
# our comment is here
echo "The current directory is:"
pwd
echo "The user logged in is:"
whoamiನವೀಕರಿಸಿದ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಚಲಾಯಿಸಿದ ನಂತರ ಇದು ಸಂಭವಿಸುತ್ತದೆ.
ಸ್ಕ್ರಿಪ್ಟ್‌ನಿಂದ ಸಂದೇಶಗಳನ್ನು ಔಟ್ಪುಟ್ ಮಾಡುವುದು
ಈಗ ನಾವು ಆಜ್ಞೆಯನ್ನು ಬಳಸಿಕೊಂಡು ವಿವರಣಾತ್ಮಕ ಟಿಪ್ಪಣಿಗಳನ್ನು ಪ್ರದರ್ಶಿಸಬಹುದು echo. Linux ಉಪಕರಣಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಫೈಲ್ ಅನ್ನು ಹೇಗೆ ಸಂಪಾದಿಸುವುದು ಎಂದು ನಿಮಗೆ ತಿಳಿದಿಲ್ಲದಿದ್ದರೆ ಅಥವಾ ನೀವು ಮೊದಲು ಆಜ್ಞೆಯನ್ನು ನೋಡಿಲ್ಲದಿದ್ದರೆ echo, ನೋಡೋಣ ವಸ್ತು.
ವೇರಿಯೇಬಲ್‌ಗಳನ್ನು ಬಳಸುವುದು
ಇತರ ಆಜ್ಞೆಗಳ ಬಳಕೆಗಾಗಿ ಆಜ್ಞೆಗಳ ಫಲಿತಾಂಶಗಳಂತಹ ಸ್ಕ್ರಿಪ್ಟ್ ಫೈಲ್‌ನಲ್ಲಿ ಮಾಹಿತಿಯನ್ನು ಸಂಗ್ರಹಿಸಲು ವೇರಿಯೇಬಲ್‌ಗಳು ನಿಮಗೆ ಅವಕಾಶ ಮಾಡಿಕೊಡುತ್ತವೆ.
ವೈಯಕ್ತಿಕ ಆಜ್ಞೆಗಳನ್ನು ಅವುಗಳ ಫಲಿತಾಂಶಗಳನ್ನು ಸಂಗ್ರಹಿಸದೆ ಕಾರ್ಯಗತಗೊಳಿಸುವುದರಲ್ಲಿ ಯಾವುದೇ ತಪ್ಪಿಲ್ಲ, ಆದರೆ ಈ ವಿಧಾನವು ಅದರ ಸಾಮರ್ಥ್ಯಗಳಲ್ಲಿ ಸಾಕಷ್ಟು ಸೀಮಿತವಾಗಿದೆ.
ಬ್ಯಾಷ್ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳಲ್ಲಿ ಬಳಸಬಹುದಾದ ಎರಡು ವಿಧದ ಅಸ್ಥಿರಗಳಿವೆ:
- ಪರಿಸರ ವೇರಿಯಬಲ್ಸ್
- ಬಳಕೆದಾರ ಅಸ್ಥಿರಗಳು
ಪರಿಸರ ವೇರಿಯಬಲ್ಸ್
ಕೆಲವೊಮ್ಮೆ ಶೆಲ್ ಆಜ್ಞೆಗಳು ಕೆಲವು ಸಿಸ್ಟಮ್ ಡೇಟಾದೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಬೇಕಾಗುತ್ತದೆ. ಪ್ರಸ್ತುತ ಬಳಕೆದಾರರ ಹೋಮ್ ಡೈರೆಕ್ಟರಿಯನ್ನು ಹೇಗೆ ಪ್ರದರ್ಶಿಸುವುದು ಎಂಬುದರ ಉದಾಹರಣೆ ಇಲ್ಲಿದೆ:
#!/bin/bash
# display user home
echo "Home for the current user is: $HOME"
ನಾವು ಸಿಸ್ಟಮ್ ವೇರಿಯಬಲ್ ಅನ್ನು ಬಳಸಬಹುದು ಎಂಬುದನ್ನು ದಯವಿಟ್ಟು ಗಮನಿಸಿ $HOME ಡಬಲ್ ಉಲ್ಲೇಖಗಳಲ್ಲಿ, ಇದು ಸಿಸ್ಟಮ್ ಅನ್ನು ಗುರುತಿಸುವುದನ್ನು ತಡೆಯುವುದಿಲ್ಲ. ಮೇಲಿನ ಸನ್ನಿವೇಶವನ್ನು ನೀವು ಚಲಾಯಿಸಿದರೆ ಇದು ನಿಮಗೆ ಸಿಗುತ್ತದೆ.
ಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಪರಿಸರ ವೇರಿಯಬಲ್ ಅನ್ನು ಬಳಸುವುದು
ನೀವು ಪರದೆಯ ಮೇಲೆ ಡಾಲರ್ ಚಿಹ್ನೆಯನ್ನು ಪ್ರದರ್ಶಿಸಬೇಕಾದರೆ ಏನು ಮಾಡಬೇಕು? ಇದನ್ನು ಪ್ರಯತ್ನಿಸೋಣ:
echo "I have $1 in my pocket"
ಸಿಸ್ಟಂ ಉಲ್ಲೇಖಿಸಿದ ಸ್ಟ್ರಿಂಗ್‌ನಲ್ಲಿ ಡಾಲರ್ ಚಿಹ್ನೆಯನ್ನು ಪತ್ತೆ ಮಾಡುತ್ತದೆ ಮತ್ತು ನಾವು ವೇರಿಯೇಬಲ್ ಅನ್ನು ಉಲ್ಲೇಖಿಸಿದ್ದೇವೆ ಎಂದು ಭಾವಿಸುತ್ತೇವೆ. ವ್ಯಾಖ್ಯಾನಿಸದ ವೇರಿಯಬಲ್‌ನ ಮೌಲ್ಯವನ್ನು ಪ್ರದರ್ಶಿಸಲು ಸ್ಕ್ರಿಪ್ಟ್ ಪ್ರಯತ್ನಿಸುತ್ತದೆ $1. ಇದು ನಮಗೆ ಬೇಕಿಲ್ಲ. ಏನ್ ಮಾಡೋದು?
ಈ ಪರಿಸ್ಥಿತಿಯಲ್ಲಿ, ಡಾಲರ್ ಚಿಹ್ನೆಯ ಮೊದಲು ಎಸ್ಕೇಪ್ ಕ್ಯಾರೆಕ್ಟರ್, ಬ್ಯಾಕ್‌ಸ್ಲ್ಯಾಷ್ ಅನ್ನು ಬಳಸುವುದು ಸಹಾಯ ಮಾಡುತ್ತದೆ:
echo "I have $1 in my pocket"ಸ್ಕ್ರಿಪ್ಟ್ ಈಗ ನಿರೀಕ್ಷಿತ ನಿಖರವಾಗಿ ಔಟ್ಪುಟ್ ಮಾಡುತ್ತದೆ.
ಡಾಲರ್ ಚಿಹ್ನೆಯನ್ನು ಮುದ್ರಿಸಲು ತಪ್ಪಿಸಿಕೊಳ್ಳುವ ಅನುಕ್ರಮವನ್ನು ಬಳಸುವುದು
ಬಳಕೆದಾರ ಅಸ್ಥಿರಗಳು
ಪರಿಸರದ ಅಸ್ಥಿರಗಳ ಜೊತೆಗೆ, ಬ್ಯಾಷ್ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳು ಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ನಿಮ್ಮ ಸ್ವಂತ ಅಸ್ಥಿರಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲು ಮತ್ತು ಬಳಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ಸ್ಕ್ರಿಪ್ಟ್ ಕಾರ್ಯಗತಗೊಳ್ಳುವವರೆಗೆ ಅಂತಹ ಅಸ್ಥಿರಗಳು ಮೌಲ್ಯವನ್ನು ಹೊಂದಿರುತ್ತವೆ.
ಸಿಸ್ಟಮ್ ವೇರಿಯಬಲ್‌ಗಳಂತೆ, ಡಾಲರ್ ಚಿಹ್ನೆಯನ್ನು ಬಳಸಿಕೊಂಡು ಬಳಕೆದಾರ ಅಸ್ಥಿರಗಳನ್ನು ಪ್ರವೇಶಿಸಬಹುದು:
TNW-CUS-FMP - ನಮ್ಮ ಸೇವೆಗಳ ಮೇಲೆ 10% ರಿಯಾಯಿತಿಗಾಗಿ ಪ್ರೋಮೋ ಕೋಡ್, 7 ದಿನಗಳಲ್ಲಿ ಸಕ್ರಿಯಗೊಳಿಸಲು ಲಭ್ಯವಿದೆ
#!/bin/bash
# testing variables
grade=5
person="Adam"
echo "$person is a good boy, he is in grade $grade"ಅಂತಹ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಚಲಾಯಿಸಿದ ನಂತರ ಇದು ಸಂಭವಿಸುತ್ತದೆ.
ಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಕಸ್ಟಮ್ ವೇರಿಯೇಬಲ್‌ಗಳು
ಕಮಾಂಡ್ ಪರ್ಯಾಯ
ಬ್ಯಾಷ್ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳ ಅತ್ಯಂತ ಉಪಯುಕ್ತ ವೈಶಿಷ್ಟ್ಯವೆಂದರೆ ಕಮಾಂಡ್ ಔಟ್‌ಪುಟ್‌ನಿಂದ ಮಾಹಿತಿಯನ್ನು ಹೊರತೆಗೆಯುವ ಮತ್ತು ಅದನ್ನು ವೇರಿಯೇಬಲ್‌ಗಳಿಗೆ ನಿಯೋಜಿಸುವ ಸಾಮರ್ಥ್ಯ, ಈ ಮಾಹಿತಿಯನ್ನು ಸ್ಕ್ರಿಪ್ಟ್ ಫೈಲ್‌ನಲ್ಲಿ ಎಲ್ಲಿ ಬೇಕಾದರೂ ಬಳಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.
ಇದನ್ನು ಎರಡು ರೀತಿಯಲ್ಲಿ ಮಾಡಬಹುದು.
- ಬ್ಯಾಕ್‌ಟಿಕ್ "`" ಅನ್ನು ಬಳಸುವುದು
- ವಿನ್ಯಾಸದ ಮೂಲಕ
$()
ಮೊದಲ ವಿಧಾನವನ್ನು ಬಳಸುವಾಗ, ಬ್ಯಾಕ್‌ಟಿಕ್‌ನ ಸ್ಥಳದಲ್ಲಿ ಒಂದೇ ಉದ್ಧರಣ ಚಿಹ್ನೆಯನ್ನು ಸೇರಿಸದಂತೆ ಜಾಗರೂಕರಾಗಿರಿ. ಆಜ್ಞೆಯನ್ನು ಅಂತಹ ಎರಡು ಐಕಾನ್‌ಗಳಲ್ಲಿ ಸುತ್ತುವರಿಯಬೇಕು:
mydir=`pwd`ಎರಡನೆಯ ವಿಧಾನದಲ್ಲಿ, ಅದೇ ವಿಷಯವನ್ನು ಈ ರೀತಿ ಬರೆಯಲಾಗಿದೆ:
mydir=$(pwd)ಮತ್ತು ಸ್ಕ್ರಿಪ್ಟ್ ಈ ರೀತಿ ಕಾಣಿಸಬಹುದು:
#!/bin/bash
mydir=$(pwd)
echo $mydir
ಅದರ ಕಾರ್ಯಾಚರಣೆಯ ಸಮಯದಲ್ಲಿ, ಆಜ್ಞೆಯ ಔಟ್ಪುಟ್ pwdವೇರಿಯೇಬಲ್‌ನಲ್ಲಿ ಉಳಿಸಲಾಗುತ್ತದೆ mydir, ಇದರಲ್ಲಿನ ವಿಷಯಗಳು, ಆಜ್ಞೆಯನ್ನು ಬಳಸಿ echo, ಕನ್ಸೋಲ್‌ಗೆ ಹೋಗುತ್ತದೆ.
ವೇರಿಯೇಬಲ್‌ನಲ್ಲಿ ಆಜ್ಞೆಯ ಫಲಿತಾಂಶಗಳನ್ನು ಉಳಿಸುವ ಸ್ಕ್ರಿಪ್ಟ್
ಗಣಿತದ ಕಾರ್ಯಾಚರಣೆಗಳು
ಸ್ಕ್ರಿಪ್ಟ್ ಫೈಲ್‌ನಲ್ಲಿ ಗಣಿತದ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ನಿರ್ವಹಿಸಲು, ನೀವು ರಚನೆಯನ್ನು ಬಳಸಬಹುದು $((a+b)):
#!/bin/bash
var1=$(( 5 + 5 ))
echo $var1
var2=$(( $var1 * 2 ))
echo $var2
ಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಗಣಿತದ ಕಾರ್ಯಾಚರಣೆಗಳು
ವೇಳೆ-ನಂತರ ನಿಯಂತ್ರಣ ನಿರ್ಮಾಣ
ಕೆಲವು ಸನ್ನಿವೇಶಗಳಲ್ಲಿ, ನೀವು ಕಮಾಂಡ್ ಎಕ್ಸಿಕ್ಯೂಶನ್ ಹರಿವನ್ನು ನಿಯಂತ್ರಿಸಬೇಕಾಗುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ಒಂದು ನಿರ್ದಿಷ್ಟ ಮೌಲ್ಯವು ಐದಕ್ಕಿಂತ ಹೆಚ್ಚಿದ್ದರೆ, ನೀವು ಒಂದು ಕ್ರಿಯೆಯನ್ನು ನಿರ್ವಹಿಸಬೇಕಾಗುತ್ತದೆ, ಇಲ್ಲದಿದ್ದರೆ, ಇನ್ನೊಂದು. ಇದು ಅನೇಕ ಸಂದರ್ಭಗಳಲ್ಲಿ ಅನ್ವಯಿಸುತ್ತದೆ, ಮತ್ತು ಇಲ್ಲಿ ನಿಯಂತ್ರಣ ರಚನೆಯು ನಮಗೆ ಸಹಾಯ ಮಾಡುತ್ತದೆ if-then. ಅದರ ಸರಳ ರೂಪದಲ್ಲಿ ಇದು ಈ ರೀತಿ ಕಾಣುತ್ತದೆ:
if команда
then
команды
fiಕೆಲಸದ ಉದಾಹರಣೆ ಇಲ್ಲಿದೆ:
#!/bin/bash
if pwd
then
echo "It works"
fi
ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಆಜ್ಞೆಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಿದರೆ pwdಯಶಸ್ವಿಯಾಗಿ ಪೂರ್ಣಗೊಳ್ಳುತ್ತದೆ, "ಇದು ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ" ಎಂಬ ಪಠ್ಯವನ್ನು ಕನ್ಸೋಲ್‌ನಲ್ಲಿ ಪ್ರದರ್ಶಿಸಲಾಗುತ್ತದೆ.
ನಮ್ಮಲ್ಲಿರುವ ಜ್ಞಾನವನ್ನು ಬಳಸೋಣ ಮತ್ತು ಹೆಚ್ಚು ಸಂಕೀರ್ಣವಾದ ಲಿಪಿಯನ್ನು ಬರೆಯೋಣ. ನಾವು ನಿರ್ದಿಷ್ಟ ಬಳಕೆದಾರರನ್ನು ಹುಡುಕಬೇಕಾಗಿದೆ ಎಂದು ಹೇಳೋಣ /etc/passwd, ಮತ್ತು ನೀವು ಅದನ್ನು ಹುಡುಕಲು ನಿರ್ವಹಿಸುತ್ತಿದ್ದರೆ, ಅದು ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ ಎಂದು ವರದಿ ಮಾಡಿ.
#!/bin/bash
user=likegeeks
if grep $user /etc/passwd
then
echo "The user $user Exists"
fiಈ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಚಲಾಯಿಸಿದ ನಂತರ ಏನಾಗುತ್ತದೆ.
ಬಳಕೆದಾರರ ಹುಡುಕಾಟ
ಇಲ್ಲಿ ನಾವು ಆಜ್ಞೆಯನ್ನು ಬಳಸಿದ್ದೇವೆ grepಫೈಲ್‌ನಲ್ಲಿ ಬಳಕೆದಾರರನ್ನು ಹುಡುಕಲು /etc/passwd. ತಂಡದ ವೇಳೆ grepನಿಮಗೆ ಪರಿಚಯವಿಲ್ಲ, ಅದರ ವಿವರಣೆಯನ್ನು ಕಾಣಬಹುದು .
ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, ಬಳಕೆದಾರರು ಕಂಡುಬಂದರೆ, ಸ್ಕ್ರಿಪ್ಟ್ ಅನುಗುಣವಾದ ಸಂದೇಶವನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತದೆ. ಬಳಕೆದಾರರನ್ನು ಕಂಡುಹಿಡಿಯಲಾಗದಿದ್ದರೆ ಏನು? ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಸ್ಕ್ರಿಪ್ಟ್ ನಮಗೆ ಏನನ್ನೂ ಹೇಳದೆ ಸರಳವಾಗಿ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯನ್ನು ಪೂರ್ಣಗೊಳಿಸುತ್ತದೆ. ಈ ಬಗ್ಗೆಯೂ ಅವರು ನಮಗೆ ಹೇಳಬೇಕೆಂದು ನಾವು ಬಯಸುತ್ತೇವೆ, ಆದ್ದರಿಂದ ನಾವು ಕೋಡ್ ಅನ್ನು ಸುಧಾರಿಸುತ್ತೇವೆ.
ವೇಳೆ-ನಂತರ-ಬೇರೆ ನಿಯಂತ್ರಣ ರಚನೆ
ಪ್ರೋಗ್ರಾಂ ಯಶಸ್ವಿ ಹುಡುಕಾಟ ಮತ್ತು ವೈಫಲ್ಯದ ಫಲಿತಾಂಶಗಳನ್ನು ವರದಿ ಮಾಡಲು ಸಾಧ್ಯವಾಗುವಂತೆ, ನಾವು ನಿರ್ಮಾಣವನ್ನು ಬಳಸುತ್ತೇವೆ if-then-else. ಇದು ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂಬುದು ಇಲ್ಲಿದೆ:
if команда
then
команды
else
команды
fi
ಮೊದಲ ಆಜ್ಞೆಯು ಶೂನ್ಯವನ್ನು ಹಿಂದಿರುಗಿಸಿದರೆ, ಅಂದರೆ ಅದನ್ನು ಯಶಸ್ವಿಯಾಗಿ ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗಿದೆ, ಸ್ಥಿತಿಯು ನಿಜವಾಗಿರುತ್ತದೆ ಮತ್ತು ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯು ಶಾಖೆಯ ಉದ್ದಕ್ಕೂ ಮುಂದುವರಿಯುವುದಿಲ್ಲ else. ಇಲ್ಲದಿದ್ದರೆ, ಶೂನ್ಯವನ್ನು ಹೊರತುಪಡಿಸಿ ಬೇರೆ ಯಾವುದನ್ನಾದರೂ ಹಿಂತಿರುಗಿಸಿದರೆ, ಅದು ವೈಫಲ್ಯವನ್ನು ಸೂಚಿಸುತ್ತದೆ ಅಥವಾ ತಪ್ಪು ಫಲಿತಾಂಶವನ್ನು ಸೂಚಿಸುತ್ತದೆ, ನಂತರ ಆಜ್ಞೆಗಳು else.
ಕೆಳಗಿನ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಬರೆಯೋಣ:
#!/bin/bash
user=anotherUser
if grep $user /etc/passwd
then
echo "The user $user Exists"
else
echo "The user $user doesn’t exist"
fi
ಅವನ ಮರಣದಂಡನೆ ಚರಂಡಿಗೆ ಹೋಯಿತು else.
if-then-else ಸ್ಟ್ರಕ್ಟ್‌ನೊಂದಿಗೆ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ರನ್ ಮಾಡುವುದು
ಸರಿ, ನಾವು ಮುಂದುವರಿಯೋಣ ಮತ್ತು ಹೆಚ್ಚು ಸಂಕೀರ್ಣವಾದ ಪರಿಸ್ಥಿತಿಗಳ ಬಗ್ಗೆ ನಮ್ಮನ್ನು ಕೇಳಿಕೊಳ್ಳೋಣ. ನೀವು ಒಂದು ಸ್ಥಿತಿಯನ್ನು ಪರಿಶೀಲಿಸಬೇಕಾದರೆ, ಆದರೆ ಹಲವಾರು? ಉದಾಹರಣೆಗೆ, ಬಯಸಿದ ಬಳಕೆದಾರರು ಕಂಡುಬಂದರೆ, ಒಂದು ಸಂದೇಶವನ್ನು ಪ್ರದರ್ಶಿಸಬೇಕು, ಕೆಲವು ಇತರ ಷರತ್ತುಗಳನ್ನು ಪೂರೈಸಿದರೆ, ಇನ್ನೊಂದು ಸಂದೇಶವನ್ನು ಪ್ರದರ್ಶಿಸಬೇಕು, ಇತ್ಯಾದಿ. ಅಂತಹ ಪರಿಸ್ಥಿತಿಯಲ್ಲಿ, ನೆಸ್ಟೆಡ್ ಪರಿಸ್ಥಿತಿಗಳು ನಮಗೆ ಸಹಾಯ ಮಾಡುತ್ತವೆ. ಇದು ಈ ರೀತಿ ಕಾಣುತ್ತದೆ:
if команда1
then
команды
elif команда2
then
команды
fi
ಮೊದಲ ಆಜ್ಞೆಯು ಶೂನ್ಯವನ್ನು ಹಿಂದಿರುಗಿಸಿದರೆ, ಅದು ಅದರ ಯಶಸ್ವಿ ಮರಣದಂಡನೆಯನ್ನು ಸೂಚಿಸುತ್ತದೆ, ಮೊದಲ ಬ್ಲಾಕ್ನಲ್ಲಿನ ಆಜ್ಞೆಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ then, ಇಲ್ಲದಿದ್ದರೆ, ಮೊದಲ ಷರತ್ತು ತಪ್ಪಾಗಿದ್ದರೆ ಮತ್ತು ಎರಡನೆಯ ಆಜ್ಞೆಯು ಶೂನ್ಯವನ್ನು ಹಿಂದಿರುಗಿಸಿದರೆ, ಕೋಡ್‌ನ ಎರಡನೇ ಬ್ಲಾಕ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ.
#!/bin/bash
user=anotherUser
if grep $user /etc/passwd
then
echo "The user $user Exists"
elif ls /home
then
echo "The user doesn’t exist but anyway there is a directory under /home"
fi
ಅಂತಹ ಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ, ನೀವು ಆಜ್ಞೆಯನ್ನು ಬಳಸಿಕೊಂಡು ಹೊಸ ಬಳಕೆದಾರರನ್ನು ರಚಿಸಬಹುದು useradd, ಹುಡುಕಾಟವು ಫಲಿತಾಂಶಗಳನ್ನು ನೀಡದಿದ್ದಲ್ಲಿ ಅಥವಾ ಬೇರೆ ಯಾವುದನ್ನಾದರೂ ಉಪಯುಕ್ತವಾದುದನ್ನು ಮಾಡಿ.
ಸಂಖ್ಯೆಗಳ ಹೋಲಿಕೆ
ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳಲ್ಲಿ ನೀವು ಸಂಖ್ಯಾ ಮೌಲ್ಯಗಳನ್ನು ಹೋಲಿಸಬಹುದು. ಸಂಬಂಧಿತ ಆಜ್ಞೆಗಳ ಪಟ್ಟಿಯನ್ನು ಕೆಳಗೆ ನೀಡಲಾಗಿದೆ.
n1 -eq n2ನಿಜವಾಗಿದ್ದರೆ ಹಿಂತಿರುಗಿಸುತ್ತದೆn1ಸಮನಾಗಿರುತ್ತದೆn2.
n1 -ge n2ನಿಜವಾಗಿದ್ದರೆ ಹಿಂತಿರುಗಿಸುತ್ತದೆn1ಹೆಚ್ಚು ಅಥವಾ ಸಮಾನn2.
n1 -gt n2ನಿಜವಾಗಿದ್ದರೆ ಹಿಂತಿರುಗಿಸುತ್ತದೆn1ಹೆಚ್ಚುn2.
n1 -le n2ನಿಜವಾಗಿದ್ದರೆ ಹಿಂತಿರುಗಿಸುತ್ತದೆn1ಕಡಿಮೆ ಅಥವಾ ಸಮಾನn2.
n1 -lt n2n1 ಗಿಂತ ಕಡಿಮೆಯಿದ್ದರೆ ಸರಿ ಎಂದು ಹಿಂತಿರುಗಿಸುತ್ತದೆn2.
n1 -ne n2ನಿಜವಾಗಿದ್ದರೆ ಹಿಂತಿರುಗಿಸುತ್ತದೆn1ಸಮಾನವಾಗಿಲ್ಲn2.
ಉದಾಹರಣೆಯಾಗಿ, ಹೋಲಿಕೆ ಆಪರೇಟರ್‌ಗಳಲ್ಲಿ ಒಂದನ್ನು ಪ್ರಯತ್ನಿಸೋಣ. ಅಭಿವ್ಯಕ್ತಿ ಚೌಕಾಕಾರದ ಆವರಣಗಳಲ್ಲಿ ಸುತ್ತುವರಿದಿದೆ ಎಂಬುದನ್ನು ಗಮನಿಸಿ.
#!/bin/bash
val1=6
if [ $val1 -gt 5 ]
then
echo "The test value $val1 is greater than 5"
else
echo "The test value $val1 is not greater than 5"
fiಇದನ್ನೇ ಈ ಆಜ್ಞೆಯು ಔಟ್ಪುಟ್ ಮಾಡುತ್ತದೆ.
ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳಲ್ಲಿನ ಸಂಖ್ಯೆಗಳ ಹೋಲಿಕೆ
ವೇರಿಯಬಲ್ ಮೌಲ್ಯ val15 ಕ್ಕಿಂತ ಹೆಚ್ಚು, ಶಾಖೆಯು ಕಾರ್ಯಗತಗೊಳ್ಳಲು ಕೊನೆಗೊಳ್ಳುತ್ತದೆ thenಹೋಲಿಕೆ ಆಪರೇಟರ್ ಮತ್ತು ಅನುಗುಣವಾದ ಸಂದೇಶವನ್ನು ಕನ್ಸೋಲ್‌ನಲ್ಲಿ ಪ್ರದರ್ಶಿಸಲಾಗುತ್ತದೆ.
ಸ್ಟ್ರಿಂಗ್ ಹೋಲಿಕೆ
ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳು ಸ್ಟ್ರಿಂಗ್ ಮೌಲ್ಯಗಳನ್ನು ಸಹ ಹೋಲಿಸಬಹುದು. ಹೋಲಿಕೆ ನಿರ್ವಾಹಕರು ತುಂಬಾ ಸರಳವಾಗಿ ಕಾಣುತ್ತಾರೆ, ಆದರೆ ಸ್ಟ್ರಿಂಗ್ ಹೋಲಿಕೆ ಕಾರ್ಯಾಚರಣೆಗಳು ಕೆಲವು ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಹೊಂದಿವೆ, ಅದನ್ನು ನಾವು ಕೆಳಗೆ ಸ್ಪರ್ಶಿಸುತ್ತೇವೆ. ಆಪರೇಟರ್‌ಗಳ ಪಟ್ಟಿ ಇಲ್ಲಿದೆ.
str1 = str2ಸಮಾನತೆಗಾಗಿ ತಂತಿಗಳನ್ನು ಪರೀಕ್ಷಿಸುತ್ತದೆ, ತಂತಿಗಳು ಒಂದೇ ಆಗಿದ್ದರೆ ನಿಜ ಎಂದು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.
str1 != str2ಸ್ಟ್ರಿಂಗ್‌ಗಳು ಒಂದೇ ಆಗಿಲ್ಲದಿದ್ದರೆ ನಿಜ ಎಂದು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.
str1 < str2ನಿಜವಾಗಿದ್ದರೆ ಹಿಂತಿರುಗಿಸುತ್ತದೆstr1ಕಡಿಮೆstr2.
str1 > str2ನಿಜವಾಗಿದ್ದರೆ ಹಿಂತಿರುಗಿಸುತ್ತದೆstr1ಗಿಂತ ಹೆಚ್ಚುstr2.
-n str1ಉದ್ದವಾಗಿದ್ದರೆ ನಿಜ ಎಂದು ಹಿಂತಿರುಗಿಸುತ್ತದೆstr1ಸೊನ್ನೆಯ ಮೇಲೆ.
-z str1ಉದ್ದವಾಗಿದ್ದರೆ ನಿಜ ಎಂದು ಹಿಂತಿರುಗಿಸುತ್ತದೆstr1ಶೂನ್ಯಕ್ಕೆ ಸಮನಾಗಿರುತ್ತದೆ.
ಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ತಂತಿಗಳನ್ನು ಹೋಲಿಸುವ ಉದಾಹರಣೆ ಇಲ್ಲಿದೆ:
#!/bin/bash
user ="likegeeks"
if [$user = $USER]
then
echo "The user $user is the current logged in user"
fiಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಿದ ಪರಿಣಾಮವಾಗಿ, ನಾವು ಈ ಕೆಳಗಿನವುಗಳನ್ನು ಪಡೆಯುತ್ತೇವೆ.
ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳಲ್ಲಿ ತಂತಿಗಳನ್ನು ಹೋಲಿಸುವುದು
ಇಲ್ಲಿ ಸ್ಟ್ರಿಂಗ್ ಹೋಲಿಕೆಯ ಒಂದು ವೈಶಿಷ್ಟ್ಯವು ಪ್ರಸ್ತಾಪಿಸಲು ಯೋಗ್ಯವಾಗಿದೆ. ಅವುಗಳೆಂದರೆ, ">" ಮತ್ತು "<" ಆಪರೇಟರ್‌ಗಳನ್ನು ಬ್ಯಾಕ್‌ಸ್ಲ್ಯಾಷ್‌ನೊಂದಿಗೆ ತಪ್ಪಿಸಿಕೊಳ್ಳಬೇಕು, ಇಲ್ಲದಿದ್ದರೆ ಸ್ಕ್ರಿಪ್ಟ್ ಸರಿಯಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುವುದಿಲ್ಲ, ಆದರೂ ಯಾವುದೇ ದೋಷ ಸಂದೇಶಗಳು ಗೋಚರಿಸುವುದಿಲ್ಲ. ಸ್ಕ್ರಿಪ್ಟ್ ">" ಚಿಹ್ನೆಯನ್ನು ಔಟ್ಪುಟ್ ಮರುನಿರ್ದೇಶನ ಆದೇಶದಂತೆ ಅರ್ಥೈಸುತ್ತದೆ.
ಈ ಆಪರೇಟರ್‌ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವುದು ಕೋಡ್‌ನಲ್ಲಿ ಹೇಗೆ ಕಾಣುತ್ತದೆ ಎಂಬುದು ಇಲ್ಲಿದೆ:
#!/bin/bash
val1=text
val2="another text"
if [ $val1 > $val2 ]
then
echo "$val1 is greater than $val2"
else
echo "$val1 is less than $val2"
fiಸ್ಕ್ರಿಪ್ಟ್‌ನ ಫಲಿತಾಂಶಗಳು ಇಲ್ಲಿವೆ.
ಸ್ಟ್ರಿಂಗ್ ಹೋಲಿಕೆ, ಎಚ್ಚರಿಕೆ ನೀಡಲಾಗಿದೆ
ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗಿದ್ದರೂ, ಎಚ್ಚರಿಕೆಯನ್ನು ನೀಡುತ್ತದೆ ಎಂಬುದನ್ನು ದಯವಿಟ್ಟು ಗಮನಿಸಿ:
./myscript: line 5: [: too many arguments
ಈ ಎಚ್ಚರಿಕೆಯನ್ನು ತೊಡೆದುಹಾಕಲು, ನಾವು ತೀರ್ಮಾನಿಸುತ್ತೇವೆ $val2 ಎರಡು ಉಲ್ಲೇಖಗಳಲ್ಲಿ:
#!/bin/bash
val1=text
val2="another text"
if [ $val1 > "$val2" ]
then
echo "$val1 is greater than $val2"
else
echo "$val1 is less than $val2"
fiಈಗ ಎಲ್ಲವೂ ಸರಿಯಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ.
ಸ್ಟ್ರಿಂಗ್ ಹೋಲಿಕೆ
">" ಮತ್ತು "<" ಆಪರೇಟರ್‌ಗಳ ಮತ್ತೊಂದು ವೈಶಿಷ್ಟ್ಯವೆಂದರೆ ಅವರು ದೊಡ್ಡಕ್ಷರ ಮತ್ತು ಸಣ್ಣ ಅಕ್ಷರಗಳೊಂದಿಗೆ ಹೇಗೆ ಕೆಲಸ ಮಾಡುತ್ತಾರೆ. ಈ ವೈಶಿಷ್ಟ್ಯವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು, ಈ ಕೆಳಗಿನ ವಿಷಯದೊಂದಿಗೆ ಪಠ್ಯ ಫೈಲ್ ಅನ್ನು ಸಿದ್ಧಪಡಿಸೋಣ:
Likegeeks
likegeeks
ಅದಕ್ಕೆ ಹೆಸರಿಟ್ಟು ಉಳಿಸೋಣ myfile, ನಂತರ ಟರ್ಮಿನಲ್‌ನಲ್ಲಿ ಈ ಕೆಳಗಿನ ಆಜ್ಞೆಯನ್ನು ಚಲಾಯಿಸಿ:
sort myfileಇದು ಫೈಲ್‌ನಿಂದ ಸಾಲುಗಳನ್ನು ಈ ರೀತಿ ವಿಂಗಡಿಸುತ್ತದೆ:
likegeeks
Likegeeks
ತಂಡದ sort, ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ, ಆರೋಹಣ ಕ್ರಮದಲ್ಲಿ ಸ್ಟ್ರಿಂಗ್ಗಳನ್ನು ವಿಂಗಡಿಸುತ್ತದೆ, ಅಂದರೆ, ನಮ್ಮ ಉದಾಹರಣೆಯಲ್ಲಿ ಸಣ್ಣ ಅಕ್ಷರವು ದೊಡ್ಡಕ್ಷರಕ್ಕಿಂತ ಚಿಕ್ಕದಾಗಿದೆ. ಈಗ ಅದೇ ತಂತಿಗಳನ್ನು ಹೋಲಿಸುವ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಸಿದ್ಧಪಡಿಸೋಣ:
#!/bin/bash
val1=Likegeeks
val2=likegeeks
if [ $val1 > $val2 ]
then
echo "$val1 is greater than $val2"
else
echo "$val1 is less than $val2"
fiನೀವು ಅದನ್ನು ಚಲಾಯಿಸಿದರೆ, ಎಲ್ಲವೂ ವಿಭಿನ್ನವಾಗಿದೆ ಎಂದು ತಿರುಗುತ್ತದೆ - ಸಣ್ಣ ಅಕ್ಷರವು ಈಗ ದೊಡ್ಡ ಅಕ್ಷರಕ್ಕಿಂತ ದೊಡ್ಡದಾಗಿದೆ.
ಸ್ಕ್ರಿಪ್ಟ್ ಫೈಲ್‌ನಲ್ಲಿ ವಿಂಗಡಣೆ ಆಜ್ಞೆ ಮತ್ತು ಸ್ಟ್ರಿಂಗ್ಗಳನ್ನು ಹೋಲಿಸುವುದು
ಹೋಲಿಕೆ ಆಜ್ಞೆಗಳಲ್ಲಿ, ದೊಡ್ಡಕ್ಷರ ಅಕ್ಷರಗಳು ಸಣ್ಣ ಅಕ್ಷರಗಳಿಗಿಂತ ಚಿಕ್ಕದಾಗಿದೆ. ಇಲ್ಲಿ ಸ್ಟ್ರಿಂಗ್ ಹೋಲಿಕೆಯನ್ನು ಅಕ್ಷರಗಳ ASCII ಕೋಡ್‌ಗಳನ್ನು ಹೋಲಿಸುವ ಮೂಲಕ ಮಾಡಲಾಗುತ್ತದೆ, ವಿಂಗಡಣೆಯ ಕ್ರಮವು ಅಕ್ಷರ ಸಂಕೇತಗಳನ್ನು ಅವಲಂಬಿಸಿರುತ್ತದೆ.
ತಂಡದ sort, ಪ್ರತಿಯಾಗಿ, ಸಿಸ್ಟಮ್ ಭಾಷೆಯ ಸೆಟ್ಟಿಂಗ್‌ಗಳಲ್ಲಿ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ವಿಂಗಡಣೆಯ ಕ್ರಮವನ್ನು ಬಳಸುತ್ತದೆ.
ಫೈಲ್ ಪರಿಶೀಲನೆಗಳು
ಬಹುಶಃ ಕೆಳಗಿನ ಆಜ್ಞೆಗಳನ್ನು ಬ್ಯಾಷ್ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳಲ್ಲಿ ಹೆಚ್ಚಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ. ಫೈಲ್‌ಗಳಿಗೆ ಸಂಬಂಧಿಸಿದಂತೆ ವಿವಿಧ ಷರತ್ತುಗಳನ್ನು ಪರಿಶೀಲಿಸಲು ಅವು ನಿಮಗೆ ಅವಕಾಶ ಮಾಡಿಕೊಡುತ್ತವೆ. ಈ ಆಜ್ಞೆಗಳ ಪಟ್ಟಿ ಇಲ್ಲಿದೆ.
-d fileಫೈಲ್ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆಯೇ ಮತ್ತು ಡೈರೆಕ್ಟರಿಯಾಗಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತದೆ.
-e fileಫೈಲ್ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತದೆ.
-f fileಫೈಲ್ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆಯೇ ಮತ್ತು ಫೈಲ್ ಆಗಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತದೆ.
-r fileಫೈಲ್ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆಯೇ ಮತ್ತು ಓದಬಲ್ಲದು ಎಂಬುದನ್ನು ಪರಿಶೀಲಿಸುತ್ತದೆ.
-s file Пಫೈಲ್ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆಯೇ ಮತ್ತು ಖಾಲಿಯಾಗಿಲ್ಲವೇ ಎಂಬುದನ್ನು ಪರಿಶೀಲಿಸುತ್ತದೆ.
-w fileಫೈಲ್ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆಯೇ ಮತ್ತು ಬರೆಯಬಹುದೇ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತದೆ.
-x fileಫೈಲ್ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆಯೇ ಮತ್ತು ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದೇ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತದೆ.
file1 -nt file2ಇದು ಹೊಸದಾಗಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತದೆfile1ಗಿಂತfile2.
file1 -ot file2ಹಳೆಯದಾಗಿದ್ದರೆ ಪರಿಶೀಲಿಸುತ್ತದೆfile1ಗಿಂತfile2.
-O fileಫೈಲ್ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆಯೇ ಮತ್ತು ಪ್ರಸ್ತುತ ಬಳಕೆದಾರರ ಮಾಲೀಕತ್ವದಲ್ಲಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತದೆ.
-G fileಫೈಲ್ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆಯೇ ಮತ್ತು ಅದರ ಗುಂಪು ID ಪ್ರಸ್ತುತ ಬಳಕೆದಾರರ ಗುಂಪು ID ಗೆ ಹೊಂದಿಕೆಯಾಗುತ್ತದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತದೆ.
ಈ ಆಜ್ಞೆಗಳು, ಹಾಗೆಯೇ ಇಂದು ಚರ್ಚಿಸಲಾದ ಇತರವುಗಳನ್ನು ನೆನಪಿಟ್ಟುಕೊಳ್ಳುವುದು ಸುಲಭ. ಅವರ ಹೆಸರುಗಳು, ವಿವಿಧ ಪದಗಳ ಸಂಕ್ಷೇಪಣಗಳಾಗಿದ್ದು, ಅವರು ನಿರ್ವಹಿಸುವ ತಪಾಸಣೆಗಳನ್ನು ನೇರವಾಗಿ ಸೂಚಿಸುತ್ತವೆ.
ಆಚರಣೆಯಲ್ಲಿರುವ ಆಜ್ಞೆಗಳಲ್ಲಿ ಒಂದನ್ನು ಪ್ರಯತ್ನಿಸೋಣ:
#!/bin/bash
mydir=/home/likegeeks
if [ -d $mydir ]
then
echo "The $mydir directory exists"
cd $ mydir
ls
else
echo "The $mydir directory does not exist"
fiಈ ಸ್ಕ್ರಿಪ್ಟ್, ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಡೈರೆಕ್ಟರಿಗಾಗಿ, ಅದರ ವಿಷಯಗಳನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತದೆ.
ಡೈರೆಕ್ಟರಿಯ ವಿಷಯಗಳನ್ನು ಪಟ್ಟಿ ಮಾಡುವುದು
ಉಳಿದ ಆಜ್ಞೆಗಳನ್ನು ನೀವೇ ಪ್ರಯೋಗಿಸಬಹುದು ಎಂದು ನಾವು ನಂಬುತ್ತೇವೆ; ಅವೆಲ್ಲವನ್ನೂ ಒಂದೇ ತತ್ತ್ವದ ಪ್ರಕಾರ ಬಳಸಲಾಗುತ್ತದೆ.
ಫಲಿತಾಂಶಗಳು
ಇಂದು ನಾವು ಬ್ಯಾಷ್ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳನ್ನು ಬರೆಯಲು ಪ್ರಾರಂಭಿಸುವುದು ಹೇಗೆ ಎಂಬುದರ ಕುರಿತು ಮಾತನಾಡಿದ್ದೇವೆ ಮತ್ತು ಕೆಲವು ಮೂಲಭೂತ ವಿಷಯಗಳನ್ನು ಒಳಗೊಂಡಿದೆ. ವಾಸ್ತವವಾಗಿ, ಬ್ಯಾಷ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ವಿಷಯವು ದೊಡ್ಡದಾಗಿದೆ. ಈ ಲೇಖನವು 11 ವಸ್ತುಗಳ ದೊಡ್ಡ ಸರಣಿಯ ಮೊದಲ ಭಾಗದ ಅನುವಾದವಾಗಿದೆ. ನೀವು ಇದೀಗ ಮುಂದುವರಿಸಲು ಬಯಸಿದರೆ, ಈ ವಸ್ತುಗಳ ಮೂಲಗಳ ಪಟ್ಟಿ ಇಲ್ಲಿದೆ. ಅನುಕೂಲಕ್ಕಾಗಿ, ನೀವು ಈಗಷ್ಟೇ ಓದಿದ ಅನುವಾದವನ್ನು ಇಲ್ಲಿ ಸೇರಿಸಲಾಗಿದೆ.
- — ಇಲ್ಲಿ ನಾವು ಬ್ಯಾಷ್ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳನ್ನು ಹೇಗೆ ರಚಿಸುವುದು ಎಂಬುದರ ಕುರಿತು ಮಾತನಾಡುತ್ತಿದ್ದೇವೆ, ಅಸ್ಥಿರಗಳ ಬಳಕೆಯನ್ನು ಪರಿಗಣಿಸಲಾಗುತ್ತದೆ, ಷರತ್ತುಬದ್ಧ ರಚನೆಗಳು, ಲೆಕ್ಕಾಚಾರಗಳು, ಸಂಖ್ಯೆಗಳ ಹೋಲಿಕೆಗಳು, ತಂತಿಗಳು ಮತ್ತು ಫೈಲ್‌ಗಳ ಬಗ್ಗೆ ಮಾಹಿತಿಯನ್ನು ಕಂಡುಹಿಡಿಯುವುದು ವಿವರಿಸಲಾಗಿದೆ.
- - ಲೂಪ್‌ಗಳಿಗಾಗಿ ಮತ್ತು ಸಮಯದಲ್ಲಿ ಕೆಲಸ ಮಾಡುವ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಇಲ್ಲಿ ಬಹಿರಂಗಪಡಿಸಲಾಗುತ್ತದೆ.
- — ಈ ವಸ್ತುವನ್ನು ಕಮಾಂಡ್ ಲೈನ್ ನಿಯತಾಂಕಗಳು ಮತ್ತು ಕೀಗಳನ್ನು ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳಿಗೆ ರವಾನಿಸಬಹುದು, ಬಳಕೆದಾರರು ನಮೂದಿಸುವ ಮತ್ತು ಫೈಲ್‌ಗಳಿಂದ ಓದಬಹುದಾದ ಡೇಟಾದೊಂದಿಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ.
- - ಇಲ್ಲಿ ನಾವು ಫೈಲ್ ಡಿಸ್ಕ್ರಿಪ್ಟರ್‌ಗಳ ಬಗ್ಗೆ ಮಾತನಾಡುತ್ತಿದ್ದೇವೆ ಮತ್ತು ಅವರೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುತ್ತಿದ್ದೇವೆ, ಇನ್‌ಪುಟ್, ಔಟ್ಪುಟ್, ದೋಷ ಸ್ಟ್ರೀಮ್‌ಗಳು ಮತ್ತು ಔಟ್ಪುಟ್ ಮರುನಿರ್ದೇಶನದ ಬಗ್ಗೆ.
- — ಈ ವಸ್ತುವನ್ನು ಲಿನಕ್ಸ್ ಸಿಗ್ನಲ್‌ಗಳು, ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳಲ್ಲಿ ಅವುಗಳ ಸಂಸ್ಕರಣೆ ಮತ್ತು ವೇಳಾಪಟ್ಟಿಯಲ್ಲಿ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳನ್ನು ಪ್ರಾರಂಭಿಸಲು ಮೀಸಲಿಡಲಾಗಿದೆ.
- — ಇಲ್ಲಿ ನೀವು ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳಲ್ಲಿ ಕಾರ್ಯಗಳನ್ನು ರಚಿಸುವುದು ಮತ್ತು ಬಳಸುವುದು ಮತ್ತು ಲೈಬ್ರರಿಗಳನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸುವ ಬಗ್ಗೆ ಕಲಿಯಬಹುದು.
- - ಈ ಲೇಖನವು ಸೆಡ್ ಸ್ಟ್ರೀಮಿಂಗ್ ಪಠ್ಯ ಸಂಪಾದಕದೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಮೀಸಲಾಗಿರುತ್ತದೆ.
- — ಈ ವಸ್ತುವನ್ನು awk ಡೇಟಾ ಸಂಸ್ಕರಣಾ ಭಾಷೆಯಲ್ಲಿ ಪ್ರೋಗ್ರಾಮಿಂಗ್‌ಗೆ ಮೀಸಲಿಡಲಾಗಿದೆ.
- — ಇಲ್ಲಿ ನೀವು ಬ್ಯಾಷ್ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳಲ್ಲಿ ನಿಯಮಿತ ಅಭಿವ್ಯಕ್ತಿಗಳನ್ನು ಬಳಸುವ ಬಗ್ಗೆ ಓದಬಹುದು.
- — ಬಳಕೆದಾರರಿಗೆ ಕಳುಹಿಸಬಹುದಾದ ಸಂದೇಶಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವ ತಂತ್ರಗಳು ಮತ್ತು ಡಿಸ್ಕ್ ಮಾನಿಟರಿಂಗ್ ವಿಧಾನಗಳು ಇಲ್ಲಿವೆ.
- — ಈ ವಸ್ತುವನ್ನು ಎಕ್ಸ್‌ಪೆಕ್ಟ್ ಟೂಲ್‌ಗೆ ಸಮರ್ಪಿಸಲಾಗಿದೆ, ಇದರೊಂದಿಗೆ ನೀವು ಸಂವಾದಾತ್ಮಕ ಉಪಯುಕ್ತತೆಗಳೊಂದಿಗೆ ಸಂವಹನವನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸಬಹುದು. ನಿರ್ದಿಷ್ಟವಾಗಿ ಹೇಳುವುದಾದರೆ, ನಾವು ನಿರೀಕ್ಷಿಸುವ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳು ಮತ್ತು ಬ್ಯಾಷ್ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳು ಮತ್ತು ಇತರ ಕಾರ್ಯಕ್ರಮಗಳೊಂದಿಗೆ ಅವುಗಳ ಪರಸ್ಪರ ಕ್ರಿಯೆಯ ಕುರಿತು ಮಾತನಾಡುತ್ತಿದ್ದೇವೆ.
ಈ ಲೇಖನಗಳ ಸರಣಿಯ ಮೌಲ್ಯಯುತವಾದ ವೈಶಿಷ್ಟ್ಯವೆಂದರೆ, ಸರಳವಾದ, ಯಾವುದೇ ಹಂತದ ಬಳಕೆದಾರರಿಗೆ ಸೂಕ್ತವಾದದ್ದು, ಇದು ಕ್ರಮೇಣ ಸಾಕಷ್ಟು ಗಂಭೀರವಾದ ವಿಷಯಗಳಿಗೆ ಕಾರಣವಾಗುತ್ತದೆ, ಎಲ್ಲರಿಗೂ Linux ಆಜ್ಞಾ ಸಾಲಿನ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳ ರಚನೆಯಲ್ಲಿ ಮುನ್ನಡೆಯಲು ಅವಕಾಶವನ್ನು ನೀಡುತ್ತದೆ. .
ಆತ್ಮೀಯ ಓದುಗರೇ! ಅವರು ತಮ್ಮ ಪಾಂಡಿತ್ಯದ ಉತ್ತುಂಗವನ್ನು ಹೇಗೆ ತಲುಪಿದರು ಎಂಬುದರ ಕುರಿತು ಮಾತನಾಡಲು ನಾವು ಬ್ಯಾಷ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಗುರುಗಳನ್ನು ಕೇಳುತ್ತೇವೆ, ಅವರ ರಹಸ್ಯಗಳನ್ನು ಹಂಚಿಕೊಳ್ಳುತ್ತೇವೆ ಮತ್ತು ಅವರ ಮೊದಲ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಬರೆದವರಿಂದ ಅನಿಸಿಕೆಗಳನ್ನು ಸ್ವೀಕರಿಸಲು ನಾವು ಎದುರು ನೋಡುತ್ತೇವೆ.
ನೋಂದಾಯಿತ ಬಳಕೆದಾರರು ಮಾತ್ರ ಸಮೀಕ್ಷೆಯಲ್ಲಿ ಭಾಗವಹಿಸಬಹುದು. , ದಯವಿಟ್ಟು.
ನಾನು ಲೇಖನಗಳ ಉಳಿದ ಸರಣಿಯನ್ನು ಅನುವಾದಿಸಬೇಕೇ?
-
ಹೌದು!
-
ಇಲ್ಲ ಅಗತ್ಯವಿಲ್ಲ
1030 ಬಳಕೆದಾರರು ಮತ ಹಾಕಿದ್ದಾರೆ. 106 ಬಳಕೆದಾರರು ದೂರ ಉಳಿದಿದ್ದಾರೆ.
ಮೂಲ: www.habr.com