ಗ್ನು / ಲಿನಕ್ಸ್‌ನಲ್ಲಿ ಶೆಲ್ ಸ್ಕ್ರಿಪ್ಟ್ ರಚಿಸಲು ಉತ್ತಮ ಅಭ್ಯಾಸಗಳು

ಸಾಮಾನ್ಯವಾಗಿ ನೀವು ಕೆಲಸ ಮಾಡಲು ಪ್ರಾರಂಭಿಸಿದಾಗ ಗ್ನೂ / ಲಿನಕ್ಸ್ ಮತ್ತು / ಅಥವಾ ಯುನಿಕ್ಸ್ ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಂಗಳೊಂದಿಗೆ ಸರ್ವರ್‌ಗಳ ಆಡಳಿತ ಪ್ರದೇಶ, ಒಬ್ಬರು ಸಾಮಾನ್ಯವಾಗಿ ಇರುವ ಪರಿಸರದಲ್ಲಿ ಒಬ್ಬರು (ಮುಖಗಳು) ಕೆಲಸ ಮಾಡುತ್ತಿದ್ದಾರೆ ಇತರ ನಿರ್ವಾಹಕರು ಬರೆದ ನಿಗದಿತ ಕಾರ್ಯಗಳ ಗುಂಪೇ ಮತ್ತು ಕೆಲವು ಸಮಯದಲ್ಲಿ ನಾವು ಮಾಡಬೇಕು ನಿರ್ವಹಿಸಿ (ನಿರ್ವಹಿಸಿ) ಫಾರ್ ಸಂಸ್ಥೆಯ ಹೊಸ ಅವಶ್ಯಕತೆಗಳನ್ನು ಅನುಸರಿಸಲು ಯಾವುದೇ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಿ, ಸುಧಾರಿಸಿ ಮತ್ತು / ಅಥವಾ ನಿವಾರಿಸಿ ಅವನು ಎಲ್ಲಿ ಕೆಲಸ ಮಾಡುತ್ತಾನೆ. ಆದ್ದರಿಂದ ಯಾವುದೇ ಹೊಸ, ಆಶ್ಚರ್ಯವೇನಿಲ್ಲ ಸಿಸ್ಅಡ್ಮಿನ್ ಯಾವುದೇ ಕೆಲಸದ ಸ್ಥಳದಲ್ಲಿ, ಕೆಲವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವ ತೊಡಕಿನ ಕೆಲಸವನ್ನು ನೀವು ಎದುರಿಸುತ್ತೀರಿ ಶೆಲ್ ಸ್ಕ್ರಿಪ್ಟ್ ಇತರರು ರಚಿಸಿದ್ದಾರೆ ಹಳೆಯ ಸಿಸ್ಅಡ್ಮಿನ್, ಇವುಗಳನ್ನು ಸರಿಯಾಗಿ ಬರೆಯಲಾಗಿಲ್ಲ, ಅಥವಾ ತಾರ್ಕಿಕ ಅಥವಾ ಬರವಣಿಗೆಯ ರಚನೆಯಲ್ಲಿವೆ, ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಸುಲಭವಲ್ಲ, ಅಥವಾ ಕೆಟ್ಟ ಸಂದರ್ಭದಲ್ಲಿ, ಆಜ್ಞಾ ಆಜ್ಞೆಗಳೊಂದಿಗೆ, ವಿಲಕ್ಷಣ, ಹಳೆಯ, ಅಸಮರ್ಥ ಅಥವಾ ವಿಚಿತ್ರ ಮತ್ತು ಗೊಂದಲಮಯ ರೀತಿಯಲ್ಲಿ ಬರೆಯಲಾಗಿದೆ.

ಹಾಗೆಯೇ ಕಳಪೆ ಲಿಖಿತ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳನ್ನು ಪರಿಹರಿಸುವುದು ಯಾವಾಗಲೂ ಕ್ಷಣಿಕ ಕಿರಿಕಿರಿ, ಇದು ಯಾರಿಗಾದರೂ ಕಲಿಸುತ್ತದೆ ಉತ್ತಮ ಸಿಸ್ಅಡ್ಮಿನ್ ಮುಖ್ಯವಾದದ್ದು. ಒಂದು ರಚಿಸಲು ಹೋದರೆ ಎ ಶೆಲ್ ಸ್ಕ್ರಿಪ್ಟ್ ಇಂದು ಮೀರಿ ಬಳಸುವುದು, ಯಾವಾಗಲೂ ಉತ್ತಮವಾಗಿರುತ್ತದೆ ಅವುಗಳನ್ನು ಅತ್ಯಂತ ವೃತ್ತಿಪರ ಮತ್ತು ಪ್ರಮಾಣೀಕೃತ ರೀತಿಯಲ್ಲಿ ಬರೆಯಿರಿ, ಆದ್ದರಿಂದ ಕಾಲಾನಂತರದಲ್ಲಿ, ಬೇರೆಯವರು, ಅಥವಾ ಸ್ವತಃ, ಮಾಡಬಹುದು ಕನಿಷ್ಠ ಪ್ರಯತ್ನ ಮತ್ತು ಜ್ಞಾನವು ಕನಿಷ್ಠ ಸಮಯದಲ್ಲಿ ತಿಳುವಳಿಕೆ ಮತ್ತು ಆಡಳಿತವನ್ನು ಸಾಧಿಸುತ್ತದೆ.

ಆದ್ದರಿಂದ, ಪ್ರಕಟಣೆಗಳ ಪ್ರಾಯೋಗಿಕ ಸರಣಿಯ ನಂತರ "ಶೆಲ್ ಸ್ಕ್ರಿಪ್ಟಿಂಗ್ ಕಲಿಯಿರಿ" ಅಲ್ಲಿ ನಾವು ಕೆಲವು ಪ್ರಾಯೋಗಿಕ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳನ್ನು ಸರಳ ಮತ್ತು ಮೂಲ ಆಜ್ಞೆಗಳೊಂದಿಗೆ ಪರಿಶೀಲಿಸುತ್ತೇವೆ, ಈ ಹೊಸ ಸರಣಿಯೊಂದಿಗೆ ನಾವು ಪ್ರಾರಂಭಿಸುತ್ತೇವೆ "ಗ್ನು / ಲಿನಕ್ಸ್‌ನಲ್ಲಿ ಶೆಲ್ ಸ್ಕ್ರಿಪ್ಟ್ ರಚಿಸಲು ಉತ್ತಮ ಅಭ್ಯಾಸಗಳು", ಅಲ್ಲಿ ನಾವು ಅದರ ಪ್ರತಿಯೊಂದು ಸಣ್ಣ ಅಂಶಗಳ ಬಗ್ಗೆ ಮತ್ತು ಅನೇಕ ವಿಷಯಗಳಿಗೆ ಕಾರಣವನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ಕೇಂದ್ರೀಕರಿಸುತ್ತೇವೆ, ಅಂದರೆ, ನಾವು ಉತ್ತಮ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳನ್ನು ತಯಾರಿಸುವ ಕೆಲವು ಸುಳಿವುಗಳನ್ನು ನಾವು ಒಳಗೊಳ್ಳುತ್ತೇವೆ, ಆದರೆ ನಮಗಾಗಿ ಅಷ್ಟಾಗಿ ಅಲ್ಲ, ಆದರೆ ಮುಂದಿನ ವ್ಯಕ್ತಿಗೆ (ಸಿಸ್ಅಡ್ಮಿನ್) ಅವುಗಳನ್ನು ನಿರ್ವಹಿಸಿ. ಹಾಗಾಗಿ ನಾನು ಏನು ಕೋಡ್ ಮಾಡುತ್ತೇನೆ, ಹೇಗೆ ಮತ್ತು ಏಕೆ, ಮತ್ತು ಅದು ಇನ್ನು ಮುಂದೆ ಏಕೆ ಕಾರ್ಯನಿರ್ವಹಿಸುವುದಿಲ್ಲ ಎಂಬುದನ್ನು ಕಂಡುಹಿಡಿಯುವ ಬೇಸರದ ಮತ್ತು ಕಷ್ಟಕರವಾದ ಕೆಲಸವನ್ನು ನೀವು ಮಾಡಬೇಕಾಗಿಲ್ಲ.

ಇದರಲ್ಲಿ ಮೊದಲ (1 ನೇ) ಪೋಸ್ಟ್ ಈ ಹೊಸ ಸರಣಿಯ "ಗ್ನು / ಲಿನಕ್ಸ್‌ಗಾಗಿ ಉತ್ತಮ ಶೆಲ್ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಾಗಿ ಉತ್ತಮ ಅಭ್ಯಾಸಗಳು" ಏನಾಗುತ್ತದೆ ಅಥವಾ ಹೋಗಬೇಕು ಎಂಬುದರ ಕುರಿತು ನಾವು ಮಾತನಾಡುತ್ತೇವೆ ಶೆಲ್ ಸ್ಕ್ರಿಪ್ಟ್ ಹೆಡರ್.

=======================================
ಹೆಡರ್ - ಶೆಲ್ನ ಇನ್ವಾಕೇಶನ್
=======================================

#! / ಮಾರ್ಗ / ವ್ಯಾಖ್ಯಾನ [ನಿಯತಾಂಕ-ವಾದ]

ಉನ್ನತ ರೇಖೆಯು ಮೂಲ ರಚನೆಯಾಗಿದ್ದು, ಇದರೊಂದಿಗೆ ಗ್ನೂ / ಲಿನಕ್ಸ್‌ಗಾಗಿ ಶೆಲ್ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಆಹ್ವಾನಿಸಲಾಗುತ್ತದೆ. ಇದರ ಅಂಶಗಳನ್ನು ಈ ಕೆಳಗಿನಂತೆ ವಿವರಿಸಬಹುದು:

#! => ಶಾ-ಬ್ಯಾಂಗ್

ಶಾ-ಬ್ಯಾಂಗ್ (#!) ರಚಿಸಿದ ಅಥವಾ ರಚಿಸಬೇಕಾದ ಸ್ಕ್ರಿಪ್ಟ್‌ನ ಮೇಲ್ಭಾಗದಲ್ಲಿ a ನಮ್ಮ ಫೈಲ್ ಆಜ್ಞೆಗಳ ಒಂದು ಗುಂಪಾಗಿದೆ ಎಂದು ನಮ್ಮ ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಂಗೆ ಹೇಳುವ ಸ್ಕ್ರಿಪ್ಟ್, ಅದರ ನಂತರ ಸೂಚಿಸಲಾದ ಕಮಾಂಡ್ ಇಂಟರ್ಪ್ರಿಟರ್ನಿಂದ ಆಹಾರವನ್ನು ನೀಡಲಾಗುತ್ತದೆ (ವ್ಯಾಖ್ಯಾನಿಸಲಾಗುವುದು). ಅಕ್ಷರ ಜೋಡಿ #! ವಾಸ್ತವವಾಗಿ, ಇದು ಒಂದು ಮ್ಯಾಜಿಕ್ ಸಂಖ್ಯೆ ಎರಡು-ಬೈಟ್, ಅದು ವಿಶೇಷ ಮಾರ್ಕರ್ ಫೈಲ್ ಪ್ರಕಾರವನ್ನು ಗೊತ್ತುಪಡಿಸಿ, ಮತ್ತು ನಮ್ಮ ಸಂದರ್ಭದಲ್ಲಿ, ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದಾದ ಶೆಲ್ ಸ್ಕ್ರಿಪ್ಟ್. ಶಾ-ಬ್ಯಾಂಗ್ ಬಂದ ತಕ್ಷಣ ಹೆಸರು ಬಂದಿದೆ ಇಂಟರ್ಪ್ರಿಟರ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಬೇಕಾದ ಮಾರ್ಗವು ಇದೆ ಮತ್ತು ಹೇಳಿದ ಇಂಟರ್ಪ್ರಿಟರ್ನ ಹೆಸರು ಇದೆ. ಬೇರೆ ರೀತಿಯಲ್ಲಿ ಹೇಳುವುದಾದರೆ, ಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿನ ಆಜ್ಞೆಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವ ಪ್ರೋಗ್ರಾಂ, ಇದು ಇಂಟರ್ಪ್ರಿಟರ್, ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆ ಅಥವಾ ಉಪಯುಕ್ತತೆಯಾಗಿರಲಿ. ಈ ಶೆಲ್ ನಂತರ ಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿನ ಆಜ್ಞೆಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತದೆ, ಮೇಲ್ಭಾಗದಲ್ಲಿ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ (ಷಾ-ಬ್ಯಾಂಗ್ ನಂತರದ ಸಾಲು) ಮತ್ತು ಯಾವುದೇ ಕಾಮೆಂಟ್‌ಗಳನ್ನು ನಿರ್ಲಕ್ಷಿಸುತ್ತದೆ. ಕೆಲವು ಶಾ-ಬ್ಯಾಂಗ್ ಅವು ಹೀಗಿರಬಹುದು:

#! / bin / sh
#! / ಬಿನ್ / ಬ್ಯಾಷ್
#! / usr / bin / perl
#! / usr / bin / tcl
#! / bin / sed -f
#! / usr / awk -f

ಮೇಲೆ ವಿವರಿಸಿದ ಪ್ರತಿಯೊಂದು ಸಾಲುಗಳು (ಉದಾಹರಣೆಯಾಗಿ) ವಿಭಿನ್ನ ಶೆಲ್ ಅನ್ನು ಆಹ್ವಾನಿಸುತ್ತವೆ. ಗೆರೆ / ಬಿನ್ / ಶ, ಆಹ್ವಾನಿಸಿ ಶೆಲ್ ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ (ಗ್ನೂ / ಲಿನಕ್ಸ್ ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಂನಲ್ಲಿ ಬ್ಯಾಷ್ ಮಾಡಿ) ಅಥವಾ ಇತರ ರೀತಿಯ. ಬಳಸಿ #! / bin / sh, ಡೀಫಾಲ್ಟ್ ಮೌಲ್ಯ ಬೌರ್ನ್ ಶೆಲ್ ಯುನಿಕ್ಸ್ ಆಧಾರಿತ ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಂಗಳ ಹೆಚ್ಚಿನ ವಾಣಿಜ್ಯ ರೂಪಾಂತರಗಳಲ್ಲಿ, ಇದು ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ ಲಿನಕ್ಸ್ ಸರಿಯಾಗಿರದ ಇತರ ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್‌ಗಳಿಗೆ ಪೋರ್ಟಬಲ್, ಆದರೆ ಇದು ಅಥವಾ ಯುನಿಕ್ಸ್ ಅನ್ನು ಹೋಲುತ್ತದೆ ಅಥವಾ ಆಧರಿಸಿದೆ, ಆದರೂ ಇದು ಬಾಷ್‌ನ ನಿರ್ದಿಷ್ಟ ಗುಣಲಕ್ಷಣಗಳನ್ನು ತ್ಯಾಗ ಮಾಡುತ್ತದೆ. ಆದಾಗ್ಯೂ, ಅನುಕ್ರಮ "#! / ಬಿನ್ / ಶ" ರೂ to ಿಗೆ ​​ಅನುಗುಣವಾಗಿರುತ್ತದೆ POSIX sh ಪ್ರಮಾಣಿತ.

ಅದನ್ನು ನೆನಪಿನಲ್ಲಿಡಿ ಶಾ-ಬ್ಯಾಂಗ್ನಲ್ಲಿ ನೀಡಲಾದ ಮಾರ್ಗವು ಸರಿಯಾಗಿರಬೇಕು, ಇಲ್ಲದಿದ್ದರೆ ಸಾಮಾನ್ಯವಾಗಿ ದೋಷ ಸಂದೇಶ "ಆಜ್ಞೆ ಕಂಡುಬಂದಿಲ್ಲ", ಇದು ಸ್ಕ್ರಿಪ್ಟ್ ಮರಣದಂಡನೆಯ ಏಕೈಕ ಫಲಿತಾಂಶವಾಗಿರುತ್ತದೆ. ಅಕ್ಷರ ಜೋಡಿಯನ್ನು ನೆನಪಿಡಿ »#! « ಸ್ಕ್ರಿಪ್ಟ್ ಜೆನೆರಿಕ್ ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್ ಆಜ್ಞೆಗಳ ಗುಂಪನ್ನು ಮಾತ್ರ ಹೊಂದಿದ್ದರೆ ಅದನ್ನು ಬಿಟ್ಟುಬಿಡಬಹುದು, ಅಂದರೆ ಆಂತರಿಕ ಶೆಲ್ ನಿರ್ದೇಶನಗಳನ್ನು ಬಳಸದೆ. ಮತ್ತು ಅದನ್ನು ಮತ್ತೊಮ್ಮೆ ನೆನಪಿನಲ್ಲಿಡಿ »#! / ಬಿನ್ / ಶ« ಡೀಫಾಲ್ಟ್ ಶೆಲ್ ಇಂಟರ್ಪ್ರಿಟರ್ ಅನ್ನು ಆಹ್ವಾನಿಸುತ್ತದೆ, ಅದು ಡೀಫಾಲ್ಟ್ ಆಗಿರುತ್ತದೆ »#! / ಬಿನ್ / ಬ್ಯಾಷ್« ಅವರೊಂದಿಗೆ ತಂಡದಲ್ಲಿ ಗ್ನು / ಲಿನಕ್ಸ್ ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್.

ವಾದಗಳಿಗೆ ಸಂಬಂಧಿಸಿದಂತೆ, ಹಲವಾರು ಬಳಸಬಹುದಾಗಿದೆ ಆದರೆ ಸಾಮಾನ್ಯವಾದದ್ದು: »-ಇ«. ಇದು ಸ್ಕ್ರಿಪ್ಟ್ ಮಾಡುತ್ತದೆ ಯಾವುದೇ ಆಜ್ಞೆಯ ಮರಣದಂಡನೆ ದೋಷಗಳನ್ನು ಮೌಲ್ಯೀಕರಿಸಿo (ಮರಣದಂಡನೆ ಸಾಲು) ಮತ್ತು ಧನಾತ್ಮಕವಾಗಿದ್ದರೆ, ನಿಲುಗಡೆ ಮತ್ತು ನಿರ್ಗಮನವನ್ನು ಒತ್ತಾಯಿಸುತ್ತದೆ, ಒಂದು ವಿಶಿಷ್ಟವಾದದ್ದು »-F« ಫಾರ್ ಯಾವ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಲೋಡ್ ಮಾಡಬೇಕೆಂದು ಸೂಚಿಸಿ ಮತ್ತು ಅಪರೂಪದ ಒಂದು »-ಆರ್ಎಂ« ಅದರ ಮರಣದಂಡನೆ ಮುಗಿದ ನಂತರ ಅದನ್ನು ಅಳಿಸುವಿಕೆಯನ್ನು ಮಾಡುತ್ತದೆ. ನಲ್ಲಿ ನಿರ್ದಿಷ್ಟಪಡಿಸಲು ಮಾತ್ರ ಸಾಧ್ಯ ಶಾ-ಬ್ಯಾಂಗ್ ಒಂದು ವರೆಗೆ ಏಕ ವಾದ (ನಿಯತಾಂಕ) ಚಲಾಯಿಸಲು ಪ್ರೋಗ್ರಾಂ ಹೆಸರಿನ ನಂತರ.

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

ನನ್ನ ಸಲಹೆ (ಅತ್ಯುತ್ತಮ ಅಭ್ಯಾಸಗಳು) ಆಯ್ಕೆ ಮಾಡಲು ಅತ್ಯುತ್ತಮ ಶಾ-ಬ್ಯಾಂಗ್ ಮತ್ತು ಶಿರೋನಾಮೆ ಶೆಲ್ ಸ್ಕ್ರಿಪ್ಟ್ ಅವುಗಳು:

#! / usr / bin / env bash

ಆಜ್ಞೆಯನ್ನು ಏಕೆ ಬಳಸುವುದು »ಎನ್ವ್« ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಂಗೆ ಇಂಟರ್ಪ್ರಿಟರ್ ಅನ್ನು ಅದರೊಳಗೆ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ನಿಖರವಾದ ಮಾರ್ಗದೊಂದಿಗೆ ಬಳಸಬೇಕೆಂದು ನಾವು ಸೂಚಿಸುತ್ತೇವೆ, ಅದು ನಮಗೆ ಹೊಂದಲು ಅನುಮತಿಸುತ್ತದೆ ಶಾ-ಬ್ಯಾಂಗ್ ಅದು ಅದರ ಒಯ್ಯಬಲ್ಲತೆಯನ್ನು ಹೆಚ್ಚಿಸುತ್ತದೆ, ಏಕೆಂದರೆ ಎಲ್ಲದರಲ್ಲೂ ಅಲ್ಲ ಓಎಸ್ ಗ್ನು / ಲಿನಕ್ಸ್ ವ್ಯಾಖ್ಯಾನಕಾರರು ಅಥವಾ ಕಾರ್ಯಕ್ರಮಗಳು ಒಂದೇ ಮಾರ್ಗವನ್ನು ಹೊಂದಿವೆ. ಮತ್ತು ವಾದಗಳಿಲ್ಲದೆ, ಏಕೆಂದರೆ ಅದಕ್ಕಾಗಿ ಆಜ್ಞೆಯನ್ನು ಬಳಸುವುದು ಉತ್ತಮ ಸೆಟ್, ಏಕೆಂದರೆ ಅವನೊಂದಿಗೆ ನಾವು ಮಾಡಬಹುದು ದೋಷಗಳನ್ನು ಮೌಲ್ಯೀಕರಿಸಿ, ಸಾಮಾನ್ಯ (-e) ಅಥವಾ ನಿರ್ದಿಷ್ಟ (+ x / -x), ಅಥವಾ ಪರಿಸರ (-i) ಅಥವಾ ನಿರ್ದಿಷ್ಟ (-u / –unset) ಅಸ್ಥಿರಗಳಿಗಾಗಿ ಜಾಗತಿಕ ಪೂರ್ವನಿಗದಿಗಳನ್ನು ತೆರವುಗೊಳಿಸಿ. ಮತ್ತು ಅಂತಿಮವಾಗಿ, ಗೆ ನಿರ್ದಿಷ್ಟ (- ಒ) ಪೂರಕ ಕ್ರಿಯೆಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಿ ಸ್ಕ್ರಿಪ್ಟ್ ಒಳಗೆ.

ಆದ್ದರಿಂದ ನನ್ನ ಶಿಫಾರಸು ಮಾಡಿದ ಹೆಡರ್ ಹೀಗಿರುತ್ತದೆ:

#! / usr / bin / env bash
# ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಂನಿಂದ ಸಂಪೂರ್ಣ ಮಾರ್ಗದೊಂದಿಗೆ ಬ್ಯಾಷ್ ಇಂಟರ್ಪ್ರಿಟರ್ ಅನ್ನು ಸೂಚಿಸಿ.

ಸೆಟ್ -ಒ ಎರೆಕ್ಸಿಟ್
# ಆಜ್ಞೆ ಅಥವಾ ಮರಣದಂಡನೆ ವಿಫಲವಾದಾಗ ನಿಲ್ಲಿಸಲು ಮತ್ತು ಮುಚ್ಚಲು ಸ್ಕ್ರಿಪ್ಟ್‌ಗೆ ಹೇಳುವುದು.

ಸೆಟ್ -ಒ ನಾನ್ಸೆಟ್
# ಸ್ಕ್ರಿಪ್ಟ್ ಅಘೋಷಿತ ಅಸ್ಥಿರಗಳನ್ನು ಬಳಸಲು ಪ್ರಯತ್ನಿಸಿದಾಗ ನಿಲ್ಲಿಸಲು ಮತ್ತು ಮುಚ್ಚಲು ಸ್ಕ್ರಿಪ್ಟ್‌ಗೆ ಹೇಳುವುದು.

ಸೆಟ್ -ಒ ಪೈಪ್ಫೈಲ್
# ಶೂನ್ಯೇತರ ನಿರ್ಗಮನ ಕೋಡ್ ಅನ್ನು ಹಿಂದಿರುಗಿಸಿದ ಕೊನೆಯ ಆದೇಶದ ನಿರ್ಗಮನ ಸ್ಥಿತಿಯನ್ನು ಪಡೆಯಲು.

# ಸೆಟ್ -ಒ ಎಕ್ಸ್ಟ್ರೇಸ್
# ಏನು ನಡೆಯುತ್ತದೆ ಎಂಬುದನ್ನು ಪತ್ತೆಹಚ್ಚಲು. ಡೀಬಗ್ ಮಾಡಲು ಉಪಯುಕ್ತವಾಗಿದೆ. ದೋಷಗಳನ್ನು ಮಾತ್ರ ಪರಿಶೀಲಿಸಲು ಅದನ್ನು ಸಕ್ರಿಯಗೊಳಿಸಿ.

ಈ ಶಿಫಾರಸುಗಳನ್ನು ಹೆಚ್ಚುವರಿಯಾಗಿ ಅನುಸರಿಸಲು ಮರೆಯದಿರಿ:

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

02.- ಕೋಡ್ ವಿಭಾಗಗಳ ನಡುವೆ ಸ್ಥಳಗಳನ್ನು ಸೇರಿಸಿ: ಮಾಡ್ಯೂಲ್‌ಗಳು ಅಥವಾ ವಿಭಾಗಗಳ ಅಂತರವು ಕೋಡ್ ಅನ್ನು ಓದಬಲ್ಲ ಮತ್ತು ಸುಲಭವಾಗಿ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಸಹಾಯ ಮಾಡುವ ಕಾರಣ ಇದು ಕೋಡ್ ಅನ್ನು ಹೆಚ್ಚು ಅರ್ಥವಾಗುವಂತೆ ಮಾಡಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ.

03.- ಕೋಡ್ ಬಗ್ಗೆ ಸಾಧ್ಯವಾದಷ್ಟು ಕಾಮೆಂಟ್ ಮಾಡಿ: ಪ್ರತಿ ಕಮಾಂಡ್ ಆರ್ಡರ್ (ಎಕ್ಸಿಕ್ಯೂಶನ್ ಲೈನ್) ಅಥವಾ ಕೋಡ್ ವಿಭಾಗದ ಮೇಲ್ಭಾಗದಲ್ಲಿ (ಅಥವಾ ಕೆಳಗೆ) ಕೋಡ್‌ನೊಳಗೆ ಏನಾಗುತ್ತದೆ ಎಂಬುದನ್ನು ವಿವರಿಸಲು ಆಜ್ಞೆಗಳ ಅನುಕ್ರಮ (ಗಳ) ಕಾರ್ಯದ ವಿವರಣೆಯನ್ನು ಸೇರಿಸಲು ಸೂಕ್ತವಾಗಿದೆ.

04.- ಅವುಗಳ ಕಾರ್ಯಗಳ ವಿವರಣಾತ್ಮಕ ಹೆಸರುಗಳೊಂದಿಗೆ ಅಸ್ಥಿರಗಳನ್ನು ರಚಿಸಿ: ರಚಿಸಲಾದ ಕಾರ್ಯವನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ಗುರುತಿಸುವ ವಿವರಣಾತ್ಮಕ ವೇರಿಯಬಲ್ ಹೆಸರುಗಳನ್ನು ನಿಗದಿಪಡಿಸಿ. ಒಂದೇ ಕೋಡ್ ಬ್ಲಾಕ್‌ನ ಹೊರಗೆ ಎಂದಿಗೂ ಬಳಸಲಾಗದ ತಾತ್ಕಾಲಿಕ ಅಸ್ಥಿರಗಳನ್ನು ನೀವು ರಚಿಸಿದರೂ ಸಹ, ಅದು ಯಾವ ಮೌಲ್ಯಗಳು ಅಥವಾ ಕಾರ್ಯಗಳನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ಸೂಚ್ಯವಾಗಿ (ವಸ್ತುನಿಷ್ಠವಾಗಿ) ವಿವರಿಸುವ ಹೆಸರನ್ನು ಇಡುವುದು ಇನ್ನೂ ಒಳ್ಳೆಯದು.

05.- ಆಜ್ಞೆಯ ಬದಲಿಗಾಗಿ VARIABLE = $ (ಆಜ್ಞೆ) ಎಂಬ ಸಿಂಟ್ಯಾಕ್ಸ್ ಬಳಸಿ: ಮತ್ತೊಂದು ಆಜ್ಞೆಯಿಂದ ಪಡೆದ ಮೌಲ್ಯವನ್ನು ನೀವು ವೇರಿಯೇಬಲ್ ರಚಿಸಲು ಬಯಸಿದರೆ, ಅದನ್ನು ಬ್ಯಾಷ್‌ನಲ್ಲಿ ಮಾಡಲು ಎರಡು ಮಾರ್ಗಗಳಿವೆ. ಜೊತೆ ಬ್ಯಾಕ್ಟಿಕ್, ಅಂದರೆ, ಅಕ್ಷರಗಳೊಂದಿಗೆ `` , ಎಜ್ಮ್: VARIABLE = `ಆಜ್ಞೆ-ಆಯ್ಕೆಗಳ ನಿಯತಾಂಕಗಳು`, ಆದರೆ ಇದು ಈಗಾಗಲೇ ಅಸಮ್ಮತಿಗೊಂಡಿದೆ, ಆದ್ದರಿಂದ ಸಿಂಟ್ಯಾಕ್ಸ್ VARIABLE = $ (ಆಜ್ಞೆ) ಇದು ಅತ್ಯಂತ ಆಧುನಿಕ, ಅಂಗೀಕೃತ ಮತ್ತು ಶಿಫಾರಸು ಮಾಡಲಾದ ಮಾರ್ಗವಾಗಿದೆ. ಇಲ್ಲ -> DATE = `ದಿನಾಂಕ +% F` / ಹೌದು -> DATE = $ (ದಿನಾಂಕ +% F)

06.- ಪಾಸ್‌ವರ್ಡ್‌ನೊಂದಿಗೆ ಅಥವಾ ಇಲ್ಲದೆ ಸೂಪರ್‌ಯುಸರ್ ಮತ್ತು ಅಧಿಕೃತ ಬಳಕೆದಾರ ಮೌಲ್ಯಮಾಪನ ಮಾಡ್ಯೂಲ್‌ಗಳು ಮತ್ತು / ಅಥವಾ ಅಸ್ಥಿರಗಳನ್ನು ಬಳಸಿ: ಅಗತ್ಯವಿದ್ದರೆ ಭದ್ರತಾ ಮಟ್ಟವನ್ನು ಹೆಚ್ಚಿಸಲು.

07.- ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಂ (ಡಿಸ್ಟ್ರೊ, ಆವೃತ್ತಿ, ಆರ್ಕಿಟೆಕ್ಚರ್) ನ ಮೌಲ್ಯಮಾಪನದ ಮಾಡ್ಯೂಲ್‌ಗಳು ಮತ್ತು / ಅಥವಾ ಅಸ್ಥಿರಗಳನ್ನು ಬಳಸಿ: ಸೂಕ್ತವಲ್ಲದ ಪ್ಲ್ಯಾಟ್‌ಫಾರ್ಮ್‌ಗಳಲ್ಲಿ ಬಳಕೆಯನ್ನು ತಡೆಯಲು.

08.- ನಿರ್ಣಾಯಕ ಅಥವಾ ಬ್ಯಾಚ್ ಕ್ರಿಯೆಗಳ (ಮಾಡ್ಯೂಲ್‌ಗಳು / ಕಾರ್ಯಗಳು) ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯನ್ನು ಖಚಿತಪಡಿಸಲು ಮಾಡ್ಯೂಲ್‌ಗಳನ್ನು (ಕಾರ್ಯವಿಧಾನಗಳು / ವಿಭಾಗಗಳು) ಬಳಸಿ: ಸುಧಾರಣೆ ಅಥವಾ ಅಜಾಗರೂಕತೆಯಿಂದಾಗಿ ತಪ್ಪುಗಳನ್ನು ಕಡಿಮೆ ಮಾಡಲು.

09.- ಬಳಕೆದಾರ ಸ್ನೇಹಿ ಸಂಪರ್ಕಸಾಧನಗಳನ್ನು ಒದಗಿಸಿ (ಬಳಕೆದಾರ ಸ್ನೇಹಿ): ಟರ್ಮಿನಲ್ ಮೂಲಕ ಮೆನುಗಳು ಮತ್ತು ಬಣ್ಣಗಳೊಂದಿಗೆ ಸಂವಾದ ಮತ್ತು ಜೊತೆ En ೆನಿಟಿ, ಜಿಎಕ್ಸ್‌ಮೆಸೇಜ್ ಹೊಂದಿರುವ ಮೂಲ ಬಳಕೆದಾರರಿಗೆ ಚಿತ್ರಾತ್ಮಕ ಸಂಪರ್ಕಸಾಧನಗಳು. ಮತ್ತು ಸಾಧ್ಯವಾದರೆ ಧ್ವನಿಗೆ ಅನುಗುಣವಾಗಿ ಗುರುತಿಸಬಹುದಾದ ಘಟನೆಗಳನ್ನು ಗುರುತಿಸುವ ಸೋನಿಕ್ ಎಚ್ಚರಿಕೆಗಳ ಬೆಂಬಲವನ್ನು ಬಳಸಿ. ನಿಮ್ಮ ಸ್ಕ್ರಿಪ್ಟ್‌ಗೆ ಸಾಧ್ಯವಾದಷ್ಟು ನಾನು ಪ್ರಯತ್ನಿಸಿದೆ ಆಯ್ಕೆಗಳು / ಮಾಡ್ಯೂಲ್‌ಗಳು / ಕಾರ್ಯಗಳನ್ನು ಸಕ್ರಿಯಗೊಳಿಸುವ ಮತ್ತು ನಿಷ್ಕ್ರಿಯಗೊಳಿಸುವ ಮೂಲಕ ಎರಡೂ ರೀತಿಯಲ್ಲಿ ಕೆಲಸ ಮಾಡಿ.

10.- ಸ್ವಾಗತ ಮತ್ತು ವಿದಾಯ ಮಾಡ್ಯೂಲ್‌ಗಳನ್ನು ಸೇರಿಸಿ (ಸಂದೇಶಗಳು): ಬಳಕೆದಾರರೊಂದಿಗೆ ಸಂವಾದಾತ್ಮಕತೆಯನ್ನು ಹೆಚ್ಚಿಸಲು ಅಗತ್ಯವಿದ್ದರೆ.

11.- ಡಬಲ್ ಎಕ್ಸಿಕ್ಯೂಶನ್ ವೆರಿಫಿಕೇಶನ್ ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಸೇರಿಸಿ: ಒಂದೇ ಸಮಯದಲ್ಲಿ 1 ಕ್ಕಿಂತ ಹೆಚ್ಚು ಬಾರಿ ಕಾರ್ಯಗತಗೊಳ್ಳದಂತೆ ತಡೆಯಲು ಅದಕ್ಕಾಗಿ ಲಾಕ್ ಫೈಲ್ ಅನ್ನು ರಚಿಸಿ.

12.- ಬಾಹ್ಯ ಕಾರ್ಯಗಳು ಮತ್ತು / ಅಥವಾ ಮಾಡ್ಯೂಲ್‌ಗಳೊಂದಿಗೆ ಸ್ಕ್ರಿಪ್ಟ್‌ನ ಗಾತ್ರವನ್ನು ತರ್ಕಬದ್ಧಗೊಳಿಸಿ: ಸ್ಕ್ರಿಪ್ಟ್ ತುಂಬಾ ದೊಡ್ಡದಾಗಿದ್ದರೆ, ಕಾರ್ಯಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಕೋಡ್ ಅನ್ನು ಭಾಗಿಸಿ ಅಥವಾ ಅವುಗಳನ್ನು ಸಣ್ಣ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳಾಗಿ ವಿಂಗಡಿಸಿ, ಅದನ್ನು ಮುಖ್ಯವಾದ ಮೂಲಕ ಆಹ್ವಾನಿಸಲಾಗುತ್ತದೆ.

13.- ಸ್ಕ್ರಿಪ್ಟ್‌ನೊಳಗಿನ ಇತರ ವ್ಯಾಖ್ಯಾನಕಾರರಿಗೆ (ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳು) ಕರೆಗಳನ್ನು ಸ್ಪಷ್ಟ ಮತ್ತು ಸ್ಪಷ್ಟವಾದ ರೀತಿಯಲ್ಲಿ ಆಹ್ವಾನಿಸುವುದು: ಸಾಲುಗಳು ಅಥವಾ ಮಾಡ್ಯೂಲ್‌ಗಳ ಮೂಲಕ ಅವುಗಳನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ಆಹ್ವಾನಿಸುತ್ತದೆ.

ಉದಾಹರಣೆ:

# ================================================== #
#!/bin/bash
#Llamando a un interprete externo a BASH
echo 'El siguiente texto será mostrado por el interprete de PERL'
perl -e 'print "Este texto es mostrado por un script PERL embebido.\n";'
exit 0
# ==================================================#

# ==================================================# 
#!/bin/bash #Llamando al interprete de Python. 
echo 'El siguiente es un script de python:'
echo print "Hola, mundo!" | tee $HOME/.testpythonbash.py
python $HOME/.testpythonbash.py exit 0
# ==================================================#

# ======================================================= #
#!/bin/bash
# bash-y-perl.sh

echo "Saludos desde la parte BASH del script."
# Es posible añadir mas comandos BASH aqui.

exit 0
# Fin de la parte BASH del script.

###########################################################

#!/usr/bin/perl
# Esta parte del script se invoca con la opcion -x.

print "Saludos desde la parte PERL del script.\n";
# Podemos añadir mas comandos PERL aqui.

# Fin de la parte PERL del script.
# ======================================================= #
 

ಮುಂದಿನ ಪ್ರಕಟಣೆಗಳಲ್ಲಿ ನಾವು ಮೇಲೆ ವಿವರಿಸಿದ ಪ್ರತಿಯೊಂದು ಅಭ್ಯಾಸಗಳನ್ನು ಹೆಚ್ಚು ವಿವರವಾಗಿ ವಿಸ್ತರಿಸುತ್ತೇವೆ.

ಮತ್ತು ನಿಮ್ಮದೇ ಆದ ಇತರ ಕೆಲವು ಉತ್ತಮ ಅಭ್ಯಾಸಗಳು ನಿಮಗೆ ತಿಳಿದಿದ್ದರೆ, ಹೆಚ್ಚು ಸಂಪೂರ್ಣವಾದ ಸಂಯೋಜನೆಯನ್ನು ಮಾಡಲು ಅವುಗಳ ಬಗ್ಗೆ ಪ್ರತಿಕ್ರಿಯಿಸಲು ಹಿಂಜರಿಯಬೇಡಿ!

ಈ ಹೊಸ ಸರಣಿಯ ಮುಂದಿನ ಪ್ರಕಟಣೆಯವರೆಗೆ.