|
ಬ್ಯಾಷ್ ಅನ್ನು ಮಾತ್ರವಲ್ಲದೆ ಯಾವುದೇ ರೀತಿಯ ಸ್ಕ್ರಿಪ್ಟ್ ಬಳಸುವಾಗ ಇದೇ ಪ್ರಶ್ನೆ ಉದ್ಭವಿಸಬಹುದು. ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಇಂಟರ್ಪ್ರಿಟರ್ ಮೂಲಕ ಚಲಾಯಿಸುವುದಕ್ಕೂ ಅದನ್ನು ನೇರವಾಗಿ ಚಲಾಯಿಸುವುದಕ್ಕೂ ಪ್ರಮುಖ ವ್ಯತ್ಯಾಸವಿದೆಯೇ?
ಲೆಟ್ಸ್ ಯೂಸ್ ಲಿನಕ್ಸ್ (ಯುಎಲ್) ನಿಂದ ಈ ಆಸಕ್ತಿದಾಯಕ ಪೋಸ್ಟ್ನಲ್ಲಿ ನಾವು ಬಹಿರಂಗಪಡಿಸುವ ಇನ್ನೊಂದು ರಹಸ್ಯ. |
ಸ್ಕ್ರಿಪ್ಟ್‌ನ ಫೈಲ್ ಹೆಸರನ್ನು ಇಂಟರ್ಪ್ರಿಟರ್ಗೆ (ಶ, ಪೈಥಾನ್, ಪರ್ಲ್, ಇತ್ಯಾದಿ) ರವಾನಿಸುವ ಮೂಲಕ ನೀವು ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಚಲಾಯಿಸಿದಾಗ, ನೀವು ನಿಜವಾಗಿಯೂ ಇಂಟರ್ಪ್ರಿಟರ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತಿದ್ದೀರಿ, ನೀವು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಬಯಸುವ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಆರ್ಗ್ಯುಮೆಂಟ್ ಆಗಿ ಹಾದುಹೋಗುತ್ತೀರಿ. ಉದಾಹರಣೆಗೆ, ನಾವು ಮಿಸ್ ಇಂಟರ್ಪ್ರಿಟ್.ಶ್ ಆರ್ಗ್ಯುಮೆಂಟ್ ಅನ್ನು ಹಾದುಹೋಗುವ ಮೂಲಕ sh ಇಂಟರ್ಪ್ರಿಟರ್ ಅನ್ನು ಚಲಾಯಿಸುತ್ತೇವೆ.
sh myscript.sh
ನೀವು ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಸ್ವತಃ ಚಲಾಯಿಸಿದರೆ, ಸಿಸ್ಟಮ್ ಅದಕ್ಕೆ ಅಗತ್ಯವಿರುವ ಇಂಟರ್ಪ್ರಿಟರ್ ಅನ್ನು ಕರೆಯುತ್ತದೆ ಮತ್ತು ನಂತರ, ಹೌದು, ಅದು ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತದೆ, ಅದನ್ನು ಇಂಟರ್ಪ್ರಿಟರ್ಗೆ ಆರ್ಗ್ಯುಮೆಂಟ್ ಆಗಿ ರವಾನಿಸುತ್ತದೆ, ಆದರೆ ಎಲ್ಲವೂ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಮತ್ತು ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಿದ ಬಳಕೆದಾರರಿಲ್ಲದೆ ತಿಳಿಯುತ್ತದೆ.
./myscript.sh
ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಸ್ವತಃ ಚಲಾಯಿಸಲು, 2 ಷರತ್ತುಗಳನ್ನು ಪೂರೈಸಬೇಕು:
1) ಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ "ಬ್ಯಾಂಗ್ ಲೈನ್" ಇರಬೇಕು. ಇದು ಸ್ಕ್ರಿಪ್ಟ್‌ನ ಮೊದಲ ಸಾಲು, ಇದು # ಅಕ್ಷರಗಳೊಂದಿಗೆ ಪ್ರಾರಂಭವಾಗಬೇಕು! ಮತ್ತು ಇಂಟರ್ಪ್ರಿಟರ್ ಇರುವ ಮಾರ್ಗವನ್ನು ನೀವು ನಿರ್ದಿಷ್ಟಪಡಿಸಬೇಕು. ಈ ಸ್ಥಿತಿಯು ಬ್ಯಾಷ್‌ನಿಂದ ಮಾತ್ರವಲ್ಲದೆ ಯಾವುದೇ ರೀತಿಯ ಸ್ಕ್ರಿಪ್ಟ್‌ಗೆ (ಪೈಥಾನ್, ಪರ್ಲ್, ಇತ್ಯಾದಿ) ನಿಜವಾಗಿದೆ ಎಂಬುದನ್ನು ಗಮನಿಸುವುದು ಮುಖ್ಯ.
ಆದ್ದರಿಂದ, ಉದಾಹರಣೆಗೆ, ನಮ್ಮ ಸ್ಕ್ರಿಪ್ಟ್ ಈ ಕೆಳಗಿನವುಗಳನ್ನು ಮೊದಲ ಸಾಲಿನಂತೆ ಹೊಂದಿರಬೇಕು:
#! / ಬಿನ್ / ಬ್ಯಾಷ್
2) ಫೈಲ್ ಎಕ್ಸಿಕ್ಯೂಟ್ ಅನುಮತಿಗಳನ್ನು ಹೊಂದಿರಬೇಕು:
ನಮ್ಮ ಸ್ಕ್ರಿಪ್ಟ್‌ಗೆ ಮರಣದಂಡನೆ ಅನುಮತಿಗಳನ್ನು ನೀಡಲು, ನಾವು ಬರೆಯಬೇಕು:
chmod a + x miscript.sh
ಸಿದ್ಧ, ಈಗ ಅದನ್ನು ಈ ರೀತಿ ಚಲಾಯಿಸಿ:
./myscript.sh
ಅಥವಾ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು "ವಿಶೇಷ" ಮಾರ್ಗಕ್ಕೆ ನಕಲಿಸುವ ಮೂಲಕ ಅದನ್ನು ಸುಲಭವಾಗಿ ಆಹ್ವಾನಿಸಲು ಅನುಮತಿಸುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ನಾವು ಅದನ್ನು / usr / sbin ಗೆ ನಕಲಿಸಬಹುದು ಮತ್ತು ಅದು ಇರುವ ಪೂರ್ಣ ಮಾರ್ಗವನ್ನು ಸೇರಿಸದೆಯೇ ಎಲ್ಲಿಂದಲಾದರೂ ಚಲಾಯಿಸಬಹುದು:
ನಾವು ನಕಲಿಸುತ್ತೇವೆ:
sudo cp miscript.sh / usr / sbin / miscript
ನಾವು ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತೇವೆ:
ತಪ್ಪಾಗಿ ಬರೆಯಿರಿ
ನೀವು ನೋಡುವಂತೆ, ವಾಸ್ತವದಲ್ಲಿ ತೆರೆಮರೆಯಲ್ಲಿ ಏನಾಗುತ್ತದೆ ಎಂಬುದು ಎರಡೂ ಸಂದರ್ಭಗಳಲ್ಲಿ ಬಹಳ ಹೋಲುತ್ತದೆ. ಆದಾಗ್ಯೂ, "ಬ್ಯಾಂಗ್ ಲೈನ್" ಅನ್ನು ಸೇರಿಸುವ ಮೂಲಕ, ನಿಮ್ಮ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳನ್ನು ವಿತರಿಸಲು ಹೆಚ್ಚು ಸುಲಭವಾಗುತ್ತದೆ, ಏಕೆಂದರೆ ಬಳಕೆದಾರರು ಅವುಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಅಗತ್ಯವಿರುವ ವ್ಯಾಖ್ಯಾನಕಾರರು ಇರುವ ಮಾರ್ಗವನ್ನು ನೆನಪಿಟ್ಟುಕೊಳ್ಳಬೇಕಾಗಿಲ್ಲ. ತೀರ್ಮಾನ: ಇದು ಮೂಲತಃ ಆರಾಮ ಪ್ರಶ್ನೆಯಾಗಿದೆ.
ನಾನು ನಿಮ್ಮೊಂದಿಗೆ ಒಪ್ಪುತ್ತೇನೆ ಎರ್ಪವರ್, ಇಂಟರ್ಪ್ರಿಟರ್ನ ಆವೃತ್ತಿ ಮತ್ತು ಅದರ ಮಾರ್ಗ ಎರಡೂ ಬದಲಾಗಬಲ್ಲವು ಮತ್ತು ಸ್ಥಿರವಾಗಿಲ್ಲ, ಇನ್ನೂ ಹೆಚ್ಚಾಗಿ ಗ್ನು / ಲಿನಕ್ಸ್ ವಿತರಣೆಗಳು ಬ್ಯಾಷ್ ಅನ್ನು ಮಾತ್ರ ಬಳಸುವುದಿಲ್ಲ ಎಂದು ಪರಿಗಣಿಸಿದರೆ (ಇವೆ: ಫ್ರೀಬಿಎಸ್ಡಿ, ಓಪನ್ ಸೋಲಾರಿಸ್, ಮ್ಯಾಕ್) ಮತ್ತು ಅನೇಕ ಅವುಗಳಲ್ಲಿ ವಿಭಿನ್ನ ಸಂರಚನೆಗಳು ಅಥವಾ ಮಾರ್ಗಗಳಿವೆ.
ಮುಖ್ಯ ವಿಷಯವೆಂದರೆ ಸ್ಕ್ರಿಪ್ಟ್‌ನ ಕರೆಯೊಂದಿಗೆ ./ ಅಥವಾ sh (ಅಥವಾ ಪೈಥಾನ್ ... ಇತ್ಯಾದಿ) ನೊಂದಿಗೆ ಆಟವಾಡಲು ನಿಮಗೆ (ನೀವು ಚೆನ್ನಾಗಿ ಹೇಳಿದಂತೆ) ನಮ್ಯತೆ ಇದೆ ಎಂದು ತಿಳಿಯುವುದು.
ಬ್ಯಾಷ್ ಎನ್ನುವುದು ಕಂಪ್ಯೂಟರ್ ಪ್ರೋಗ್ರಾಂ ಆಗಿದ್ದು, ಅದರ ಕಾರ್ಯವು ಆದೇಶಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವುದು.
ಇದು ಯುನಿಕ್ಸ್ ಶೆಲ್ ಅನ್ನು ಆಧರಿಸಿದೆ ಮತ್ತು ಇದು ಪೋಸಿಕ್ಸ್ ಕಂಪ್ಲೈಂಟ್ ಆಗಿದೆ.
ಬದಲಾಗಿ sh ಎನ್ನುವುದು ಕಂಪ್ಯೂಟರ್ ಪ್ರೋಗ್ರಾಂ ಆಗಿದ್ದು, ಇದರ ಕಾರ್ಯವು ಆದೇಶಗಳನ್ನು ಅರ್ಥೈಸುವುದು.
ಪ್ರಕ್ರಿಯೆ ನಿಯಂತ್ರಣ, ಪುನರ್ನಿರ್ದೇಶನದಂತಹ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಸಂಯೋಜಿಸುತ್ತದೆ
ಇನ್ಪುಟ್ / output ಟ್ಪುಟ್, ಫೈಲ್ ಪಟ್ಟಿ ಮತ್ತು ಓದುವಿಕೆ, ರಕ್ಷಣೆ,
ಸಂವಹನಗಳು ಮತ್ತು ಕಾರ್ಯಕ್ರಮಗಳನ್ನು ಬರೆಯಲು ಆಜ್ಞಾ ಭಾಷೆ
ಬ್ಯಾಚ್‌ಗಳು ಅಥವಾ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳು. ಇದು ಯುನಿಕ್ಸ್‌ನ ಮೊದಲ ಆವೃತ್ತಿಗಳಲ್ಲಿ ಬಳಸಲಾದ ಇಂಟರ್ಪ್ರಿಟರ್ ಆಗಿತ್ತು ಮತ್ತು ಇದು ವಾಸ್ತವಿಕ ಮಾನದಂಡವಾಯಿತು.
ಹಲೋ, ನಾನು ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳ ಬಳಕೆಯಲ್ಲಿ ಹರಿಕಾರನಾಗಿದ್ದೇನೆ ಮತ್ತು ನನ್ನಲ್ಲಿರುವ ಸಮಸ್ಯೆಗೆ ಯಾರಾದರೂ ನನಗೆ ಸಹಾಯ ಮಾಡಬಹುದೇ ಎಂದು ತಿಳಿಯಲು ನಾನು ಬಯಸುತ್ತೇನೆ:
ನಾನು ಕನ್ಸೋಲ್ ಮೂಲಕ ಹಲವಾರು ಆರಂಭಿಕ ಡೇಟಾವನ್ನು ಸೇರಿಸುವ ಅಗತ್ಯವಿರುವ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ನಿರ್ವಹಿಸುತ್ತಿದ್ದೇನೆ ಮತ್ತು ಸ್ಕ್ರಿಪ್ಟ್ ಮೂಲಕ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಆರಂಭಿಕ ಡೇಟಾದೊಂದಿಗೆ ಕಾರ್ಯಗತಗೊಳಿಸಲು ಸಾಧ್ಯವಿದೆ ಎಂದು ನಾನು ಕಂಡುಕೊಂಡಿದ್ದೇನೆ, ಹಾಗಾಗಿ ನಾನು ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಚಲಾಯಿಸಲು ಅಗತ್ಯವಿರುವಾಗ ಅದನ್ನು ಮತ್ತೆ ಮತ್ತೆ ಬರೆಯಬೇಕಾಗಿಲ್ಲ.
ಇದನ್ನು ಹೇಗೆ ಮಾಡಬೇಕೆಂದು ನನಗೆ ತಿಳಿದಿಲ್ಲ, ಆದ್ದರಿಂದ ಯಾರಾದರೂ ನನಗೆ ಸಹಾಯ ಮಾಡಲು ಸಾಧ್ಯವಾದರೆ ನಾನು ತುಂಬಾ ಕೃತಜ್ಞನಾಗಿದ್ದೇನೆ.
ನೋಡಿ, ನೀವು ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಯಾವ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಯಲ್ಲಿ ಬರೆಯುತ್ತಿದ್ದೀರಿ ಎಂಬುದರ ಮೇಲೆ ಅದು ಅವಲಂಬಿತವಾಗಿರುತ್ತದೆ. ಆದಾಗ್ಯೂ, ಯಾವುದೇ ಸಂದರ್ಭದಲ್ಲಿ ನಿಮಗೆ ಬೇಕಾಗಿರುವುದು:
1) ಸ್ಕ್ರಿಪ್ಟ್ ಕಾರ್ಯಗತಗೊಂಡಾಗಲೆಲ್ಲಾ ಬಳಕೆದಾರರು ಆ ಡೇಟಾವನ್ನು ನಮೂದಿಸಬೇಕೆಂದು ನೀವು ಬಯಸಿದರೆ, ಇನ್ಪುಟ್ನಲ್ಲಿ ನಮೂದಿಸಲಾದ ಮೌಲ್ಯಗಳನ್ನು ವೇರಿಯೇಬಲ್ ತೆಗೆದುಕೊಳ್ಳುವುದು ಸಾಮಾನ್ಯ ವಿಧಾನವಾಗಿದೆ.
2) ಮೌಲ್ಯಗಳು ಯಾವಾಗಲೂ ಒಂದೇ ಆಗಿದ್ದರೆ, ನೀವು ಸ್ಥಿರಾಂಕಗಳನ್ನು ಬಳಸಬಹುದು.
3) ನಿಮ್ಮ ಸ್ಕ್ರಿಪ್ಟ್ ನಿಯತಾಂಕಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳುವ ಸಾಧ್ಯತೆಯಾಗಿದೆ.
ಚೀರ್ಸ್! ಪಾಲ್.
ನೀವು ಪ್ರಸ್ತಾಪಿಸುತ್ತಿರುವುದು ಕುತೂಹಲಕಾರಿಯಾಗಿದೆ. ಇದನ್ನು 2 ರೂಪಗಳಲ್ಲಿ ಕರೆಯಲಾಗುತ್ತದೆ: ಶೆಬಾಂಗ್ ಲೈನ್ ಅಥವಾ ನೇರವಾಗಿ ಬ್ಯಾಂಗ್ ಲೈನ್. ನಾನು ನಿಮಗೆ ಮಾಹಿತಿಯನ್ನು ನೀಡುತ್ತೇನೆ: http://python.about.com/od/programmingglossary/g/defbangline.htm
ಚೀರ್ಸ್! ಪಾಲ್.
ಕುತೂಹಲಕಾರಿ, ನಾನು ಆ ವಿವರವನ್ನು ಯೋಚಿಸುವುದನ್ನು ನಿಲ್ಲಿಸಲಿಲ್ಲ. ಕನ್ಸೋಲರ್ ರಿಟೌಚಿಂಗ್ ಕುರಿತು ಹೆಚ್ಚಿನ ಲೇಖನಗಳನ್ನು ನೋಡಲು ಆಸಕ್ತಿದಾಯಕವಾಗಿದೆ, ಅವುಗಳಲ್ಲಿ ಹೊಂದಾಣಿಕೆಯಾಗಲು ಮತ್ತು ಸಿಸ್ಟಮ್ ವೇಗವನ್ನು ಸುಧಾರಿಸಲು ಮಾತ್ರ ಇರುವ ಅನಗತ್ಯ ಕಿಲೋ ಕೋಡ್ ಅನ್ನು ತೆಗೆದುಹಾಕಲು ಪ್ರಸಿದ್ಧ ಕರ್ನಲ್ ಮರುಸಂಗ್ರಹಣೆ.
ಸರಿ. ನಾನು ಅದನ್ನು ನೆನಪಿನಲ್ಲಿಟ್ಟುಕೊಳ್ಳುತ್ತೇನೆ.
ಚೀರ್ಸ್! ಪಾಲ್.
ಅದು ಕೆಲಸ ಮಾಡಿದ್ದಕ್ಕೆ ನನಗೆ ಖುಷಿಯಾಗಿದೆ. ಆಸಕ್ತಿದಾಯಕ ಮತ್ತು ಪ್ರಾಯೋಗಿಕವೆಂದು ನಾನು ಭಾವಿಸುವ ವಿಷಯಗಳನ್ನು ಪೋಸ್ಟ್ ಮಾಡಲು ನಾನು ಯಾವಾಗಲೂ ಪ್ರಯತ್ನಿಸುತ್ತೇನೆ.
ಒಂದು ಅಪ್ಪುಗೆ! ಪಾಲ್.
ಉತ್ತಮ ಅಭ್ಯಾಸ ಹೊಂದಿರುವ ಪ್ರತಿಯೊಬ್ಬ ಪ್ರೋಗ್ರಾಮರ್ ಕೋಡ್‌ನ ಮೊದಲ ಸಾಲಿಗೆ "ಬ್ಯಾಂಗ್ ಲೈನ್" ಅನ್ನು ಸೇರಿಸುತ್ತಾರೆ. ಪೈಥಾನ್‌ನಲ್ಲಿ ನಾನು ಕೋಡಿಂಗ್ ಮತ್ತು ಬ್ಯಾಂಗ್ ಲೈನ್ ಅನ್ನು ಎಂದಿಗೂ ಮರೆಯುವುದಿಲ್ಲ.
#! / usr / bin / python2.7
# *. * ಎನ್ಕೋಡಿಂಗ್ = utf-8 *. *
ಅತ್ಯುತ್ತಮ, ಆಶಾದಾಯಕವಾಗಿ ನೀವು ಆಜ್ಞಾ ಸಾಲಿನ ಬಗ್ಗೆ ಹೆಚ್ಚಿನ ಮಾಹಿತಿಯನ್ನು ಪ್ರಕಟಿಸಬಹುದು, ಅದರಲ್ಲೂ ವಿಶೇಷವಾಗಿ ಮೂಲ ಫೈಲ್‌ಗಳಿಂದ (tar.gz, ಇತ್ಯಾದಿ) ಕಂಪೈಲ್ ಮಾಡಲು ಅಥವಾ ಸ್ಥಾಪಿಸಲು ಬಂದಾಗ
"ಬ್ಯಾಂಗ್ ಲೈನ್" ಬಗ್ಗೆ ನಾನು ಎಂದಿಗೂ ಕೇಳಲಿಲ್ಲ, ನಾನು ಅದನ್ನು ಯಾವಾಗಲೂ ಶೆಬಾಂಗ್ ಎಂದು ತಿಳಿದಿದ್ದೇನೆ
http://en.wikipedia.org/wiki/Shebang_%28Unix%29
ಸಂಬಂಧಿಸಿದಂತೆ
ಆಸಕ್ತಿದಾಯಕ ಟಿಪ್ಪಣಿ ... ಧನ್ಯವಾದಗಳು!
ಎಷ್ಟು ಆಸಕ್ತಿದಾಯಕವಾಗಿದೆ, ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಮತ್ತು ಸ್ಕ್ರಿಪ್ಟ್‌ಗೆ ಸಂಬಂಧಿಸಿದ ಪ್ರತಿಯೊಂದರಲ್ಲೂ ನಾನು ಸಂಪೂರ್ಣವಾಗಿ ಅಜ್ಞಾನಿಯೆಂದು ಘೋಷಿಸುತ್ತೇನೆ, ಅದು ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂದು ನನಗೆ ತಿಳಿದಿರಲಿಲ್ಲ, ಆದರೆ ಕೆಲವು ಆ ಹೆಡರ್ ಅನ್ನು ನಾನು ಗಮನಿಸಿದ್ದೇನೆ.
ಈ ನಮೂದಿಗೆ ಸಂಬಂಧಿಸಿದ ನನಗೆ ಸಂಭವಿಸಿದ ಸ್ಪಷ್ಟೀಕರಣ: ನಾನು ಅಡೋಬ್ ಏರ್ ಗ್ಯಾಜೆಟ್ ಅನ್ನು ಸ್ಥಾಪಿಸಲು ಬಯಸಿದ್ದೇನೆ (ಪೋಕರ್ ಆಡ್ಸ್ ಕ್ಯಾಲ್ಕುಲೇಟರ್). ಅಡೋಬ್ ಏರ್ ಸ್ಥಾಪಕವು ಅನುಗುಣವಾದ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು "ಸು" ನೊಂದಿಗೆ ರನ್ ಮಾಡುತ್ತದೆ ಆದರೆ ರೂಪದಲ್ಲಿ ./ ರೂಟ್ ಪಾಸ್ವರ್ಡ್ ಕೇಳುತ್ತದೆ. ಸ್ಕ್ರಿಪ್ಟ್‌ಗೆ ಮರಣದಂಡನೆ ಅನುಮತಿಗಳು ಇಲ್ಲದಿರುವುದರಿಂದ, ಅದು ಅನುಮತಿಯನ್ನು ನಿರಾಕರಿಸಿದೆ, ಪರಿಹಾರ: ನೀವು ಅನುಮತಿಗಳನ್ನು ಬದಲಾಯಿಸಲು ಬಯಸದಿದ್ದರೆ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು sh ನೊಂದಿಗೆ ಚಲಾಯಿಸಿ (tmp chmod ಫೋಲ್ಡರ್‌ಗೆ ಹೋಗುವುದಕ್ಕಿಂತ ವೇಗವಾಗಿ ಮತ್ತು ಎಲ್ಲವೂ). ಅಲ್ಲಿ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ, ಅದು ಅಡೋಬ್ ಸ್ಥಾಪಕ ಮತ್ತು ಮತ್ತೊಂದು ಚಿಟ್ಟೆ ವಿಷಯ ಎಂದು ಕರೆಯುತ್ತದೆ.
ಬಹಳ ಆಸಕ್ತಿದಾಯಕ ಲೇಖನ! ಕನ್ಸೋಲ್ ಬಗ್ಗೆ ಸ್ವಲ್ಪ ಹೆಚ್ಚು ತಿಳಿದುಕೊಳ್ಳಲು ನನಗೆ ಸಹಾಯ ಮಾಡಿದ್ದಕ್ಕಾಗಿ ಧನ್ಯವಾದಗಳು. ಈ ರೀತಿಯ ಲೇಖನಗಳನ್ನು ನೀವು ಪ್ರಕಟಿಸುತ್ತಿದ್ದರೆ ನೋಡೋಣ ^^.
ಇದನ್ನು ಮುಂದುವರಿಸಿ, ಇದು ನಿಸ್ಸಂದೇಹವಾಗಿ ನನ್ನ ನೆಚ್ಚಿನ ಬ್ಲಾಗ್ ಆಗಿದೆ !!
ಬಳಸಿದ ಇಂಟರ್ಪ್ರಿಟರ್ನ ಆವೃತ್ತಿಗಳ ನಡುವೆ ವ್ಯತ್ಯಾಸಗಳಿರಬಹುದು ಎಂಬುದನ್ನು ನೆನಪಿನಲ್ಲಿಡಿ. ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ನೇರವಾಗಿ ಶೆಬಾಂಗ್ ಪ್ರಕಾರ ಚಲಾಯಿಸುವುದರಿಂದ ಇಂಟರ್ಪ್ರಿಟರ್ನ ಯಾವ ಆವೃತ್ತಿಯನ್ನು ಬಳಸಬೇಕೆಂದು ಸೂಚಿಸಲು ಯಾವುದೇ ಮಾರ್ಗವಿಲ್ಲ, ಅದು ಅಗತ್ಯವಾಗಬಹುದು. ನೀವು ಇಂಟರ್ಪ್ರಿಟರ್ ಅನ್ನು ಚಲಾಯಿಸಿದರೆ ಮತ್ತು ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಪ್ಯಾರಾಮೀಟರ್ ಆಗಿ ರವಾನಿಸಿದರೆ, ಅದರ ಯಾವ ಆವೃತ್ತಿಯು ಚಾಲನೆಯಲ್ಲಿದೆ ಎಂದು ನಿಮಗೆ ತಿಳಿದಿದೆ.
ಉದಾಹರಣೆಗೆ ಪೈಥಾನ್‌ನಲ್ಲಿ, ಶೆಬಾಂಗ್ #! / Usr / bin / python2.4 ಆಗಿದ್ದರೆ ಪ್ರೋಗ್ರಾಂ ಅದು #! / Usr / bin / python2.6 ಅಥವಾ ಅದು #! / Usr / bin / python ಆಗಿದ್ದರೆ ವಿಭಿನ್ನವಾಗಿ ಚಲಿಸುತ್ತದೆ. (ಇದು ಸಾಮಾನ್ಯವಾಗಿ ಪೈಥಾನ್ ಆವೃತ್ತಿಗೆ ಸಾಂಕೇತಿಕ ಲಿಂಕ್ ಆಗಿದ್ದು ಅದನ್ನು ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ ಸ್ಥಾಪಿಸಲಾಗಿದೆ ಮತ್ತು ಕಾನ್ಫಿಗರ್ ಮಾಡಲಾಗಿದೆ). ಇದು ಸಂಭವಿಸುತ್ತದೆ ಏಕೆಂದರೆ ಪೈಥಾನ್ 2.6 ಪೈಥಾನ್ 2.4 ರಲ್ಲಿ ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲದ ಹೊಸ ಕ್ರಿಯಾತ್ಮಕತೆಯನ್ನು ಹೊಂದಿದೆ, ಆದ್ದರಿಂದ ಸಿಸ್ಟಮ್ ಅನ್ನು ಪೈಥಾನ್ 2.4 ಅನ್ನು ಮಾತ್ರ ಸ್ಥಾಪಿಸಿದ್ದರೆ #! ಬದಲಾಗಿ, ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು "python2.4 /path/al/script.py" ಅಥವಾ "python2.6 /path/al/script.py/" ನೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸುವ ಮೂಲಕ ನೀವು ಬಯಸುವ ಪೈಥಾನ್ ಆವೃತ್ತಿಯೊಂದಿಗೆ ಚಲಾಯಿಸಲು ನೀವು ಯಾವಾಗಲೂ ಒತ್ತಾಯಿಸಬಹುದು.
ಶೆಲ್ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳಿಗಾಗಿ, ನೀವು ಬಳಸುವ ಚಿಪ್ಪುಗಳ ನಡುವೆ ವ್ಯತ್ಯಾಸಗಳಿವೆ, ಆದ್ದರಿಂದ #! / Bin / sh ಮತ್ತು #! / Bin / bash ಅನ್ನು ಬಳಸುವುದರಿಂದ ಸ್ಕ್ರಿಪ್ಟ್‌ಗೆ ಅನುಗುಣವಾಗಿ ವಿಭಿನ್ನ ಫಲಿತಾಂಶಗಳನ್ನು ಪಡೆಯಬಹುದು. ನೀವು ಬ್ಯಾಷ್‌ನಲ್ಲಿ ಮಾತ್ರ ಇರುವ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಬರೆಯುತ್ತಿದ್ದರೆ ಆದರೆ #! / Bin / sh ಶೆಬಾಂಗ್ ಅನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಿದರೆ, ನಿಮ್ಮ ಸ್ಕ್ರಿಪ್ಟ್ ಬಹುಶಃ ಲಿನಕ್ಸ್‌ನಲ್ಲಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ (ಹೆಚ್ಚಿನ ವಿತರಣೆಗಳಲ್ಲಿ / ಬಿನ್ / ಶ್ ಬ್ಯಾಷ್‌ಗೆ ಸಾಂಕೇತಿಕ ಲಿಂಕ್ ಆಗಿದೆ) ಆದರೆ ಅದು ಬಹುಶಃ ವಿಫಲಗೊಳ್ಳುತ್ತದೆ ಬ್ಯಾಷ್ ಸ್ಥಾಪಿಸದ ಅಥವಾ / ಬಿನ್ / ಷಾ / ಬಿನ್ / ಬ್ಯಾಷ್‌ಗೆ ಸಾಂಕೇತಿಕ ಲಿಂಕ್ ಅಲ್ಲದ ಇತರ ಯುನಿಕ್ಸ್.
ಪೋರ್ಟಬಿಲಿಟಿಗೂ ಸಹ ಸಂಬಂಧಿಸಿದೆ, ಶೆಬಾಂಗ್‌ನಲ್ಲಿ ಸೂಚಿಸಲಾದ ಮಾರ್ಗವು ಸಂಪೂರ್ಣವಾಗಿದೆ ಎಂದು ಗಣನೆಗೆ ತೆಗೆದುಕೊಳ್ಳಬೇಕು ಮತ್ತು ವ್ಯಾಖ್ಯಾನಕಾರರನ್ನು ಇತರ ಸ್ಥಳಗಳಲ್ಲಿ ಸ್ಥಾಪಿಸಿದ ಸಂದರ್ಭಗಳಿವೆ. ಉದಾಹರಣೆಗೆ, ನಿಮ್ಮ ವಿತರಣೆಯಿಂದ ಪ್ಯಾಕೇಜ್ ಬಳಸುವ ಬದಲು ನೀವು ಪೈಥಾನ್ ಅನ್ನು ಡೌನ್‌ಲೋಡ್ ಮಾಡಿ ಕಂಪೈಲ್ ಮಾಡಿದ್ದರೆ ಪೈಥಾನ್ ಇಂಟರ್ಪ್ರಿಟರ್ ಅನ್ನು / usr / local / bin / python ನಲ್ಲಿ ಸ್ಥಾಪಿಸುವುದು ಸಾಮಾನ್ಯವಾಗಿದೆ. ನಿಮ್ಮ ಶೆಬಾಂಗ್ #! / Usr / bin / python ಆಗಿದ್ದರೆ, ಸ್ಕ್ರಿಪ್ಟ್ ಆ ವ್ಯವಸ್ಥೆಗಳಲ್ಲಿ ಕಾರ್ಯನಿರ್ವಹಿಸುವುದಿಲ್ಲ. ಈ ಸಮಸ್ಯೆಗಳನ್ನು ತಪ್ಪಿಸಲು ಪ್ರಯತ್ನಿಸಲು, ನೀವು ವಿವರಿಸಿದಂತೆ ಶೆಬಾಂಗ್ "#! / Usr / bin / env python" (ಅಥವಾ "#! / Usr / bin / env sh") ಆಗಿ ಬಳಸಬಹುದು. http://en.wikipedia.org/wiki/Shebang_(Unix)#Portability
ಧನ್ಯವಾದಗಳು ಜೊನಾಥನ್! ನೀವು ಕಾಮೆಂಟ್ ಮಾಡುವುದನ್ನು ನೋಡಲು ಸಂತೋಷವಾಗಿದೆ!
ಚೀರ್ಸ್! ಪಾಲ್.
ನಾನು ತಿಳಿಯಬೇಕಾದದ್ದನ್ನು ಎಲ್ಲಿಯೂ ಮಾಡುವುದಿಲ್ಲ, ಅಥವಾ ಕನಿಷ್ಠ ಅದನ್ನು ಸರ್ಚ್ ಎಂಜಿನ್‌ನಲ್ಲಿ ಹೇಗೆ ಬೆಳೆಸುವುದು ಎಂದು ನನಗೆ ತಿಳಿದಿಲ್ಲ, ಒಂದು ಕಾರಣಕ್ಕಾಗಿ xX ಆಪ್ಟಿಟ್ಯೂಡ್ ಅಥವಾ «ಸು command ಆಜ್ಞೆಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ರಚಿಸಲು ನಾನು ಬಯಸುತ್ತೇನೆ (ಇದು ಕೇವಲ ಒಂದು ಉದಾಹರಣೆಯಾಗಿದೆ ಆದರೆ ಅವು 2 ಪ್ರಕರಣಗಳಾಗಿವೆ ನಾನು ಯೋಚಿಸಬಹುದು) ಮತ್ತು ಆಪ್ಟಿಟ್ಯೂಡ್ನ ಸಂದರ್ಭದಲ್ಲಿ ಕೆಲವೊಮ್ಮೆ ಅದು "ಯೋನ್" ಅನ್ನು ನಮೂದಿಸಲು ನನ್ನನ್ನು ಕೇಳುತ್ತದೆ ಅಥವಾ "ಸು" ನಲ್ಲಿ ಅದು ಪಾಸ್ವರ್ಡ್ ಕೇಳುತ್ತದೆ ... ಪ್ಯಾರಾಮೀಟರ್ ಅನ್ನು ಹಾದುಹೋಗುವ ಮೂಲಕ ಅಥವಾ ತಿಳಿದಿಲ್ಲದ ಕೆಲವು ವಿಧಾನವನ್ನು ಬಳಸಿಕೊಂಡು ಸ್ಕ್ರಿಪ್ಟ್ ಈ ಆಯ್ಕೆಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಆಯ್ಕೆ ಮಾಡಲು ನಾನು ಬಯಸುತ್ತೇನೆ ... . ಗಮನಕ್ಕೆ ಧನ್ಯವಾದಗಳು
ಹಲೋ ಆಂಟೋನಿಯೊ! ನಿಮ್ಮ ಸಮಸ್ಯೆ ಪಾಸ್ವರ್ಡ್ ಅನ್ನು ನಮೂದಿಸಬೇಕಾದರೆ, ಪರಿಹಾರವಿದೆ ಎಂದು ನಾನು ಭಾವಿಸುವುದಿಲ್ಲ. ನಿಖರವಾಗಿ ಏಕೆಂದರೆ ಇದು ಸುರಕ್ಷತಾ ಕ್ರಮವಾಗಿದೆ, ಇದರಿಂದ ಪ್ರತಿಯೊಬ್ಬರೂ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಸ್ಥಾಪಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ.
ಯೋಗ್ಯತೆಗೆ ಸಂಬಂಧಿಸಿದಂತೆ ಮತ್ತು ಹೌದು ಎಂದು ಹೇಳಬೇಕೆಂದರೆ, ಅದನ್ನು ಪರಿಹರಿಸಬಹುದು ಎಂದು ನಾನು ಭಾವಿಸುತ್ತೇನೆ. ಈ ಸಮಯದಲ್ಲಿ ಬಳಸಲು ನಿಖರವಾದ ನಿಯತಾಂಕ ನನಗೆ ನೆನಪಿಲ್ಲ, ಆದರೆ ಮ್ಯಾನ್ ಪುಟಗಳಲ್ಲಿ ಕಂಡುಹಿಡಿಯಿರಿ. ಟರ್ಮಿನಲ್ ತೆರೆಯಿರಿ ಮತ್ತು ಆಜ್ಞೆಯನ್ನು ನಮೂದಿಸಿ: man aptitude.
ತಬ್ಬಿಕೊಳ್ಳಿ! ಪಾಲ್.
ತುಂಬಾ ಒಳ್ಳೆಯ ಪೋಸ್ಟ್.
ನಾನು ವಿಶೇಷವಾಗಿ ಇಷ್ಟಪಟ್ಟಿದ್ದೇನೆ-ಈ ಪೋಸ್ಟ್ನಲ್ಲಿ- ಉದ್ಭವಿಸುವ ಪ್ರಶ್ನೆ / ಅನುಮಾನಕ್ಕೆ ಬಹಳ ಸ್ಪಷ್ಟವಾಗಿ ಮತ್ತು ಸಂಕ್ಷಿಪ್ತವಾಗಿ ಉತ್ತರಿಸಲಾಗುತ್ತದೆ.