ಲಿನಕ್ಸ್‌ನಲ್ಲಿ ಒಂದರ ನಂತರ ಒಂದನ್ನು ಚಲಾಯಿಸಲು ಆಜ್ಞೆಗಳನ್ನು ಹೇಗೆ ಸಂಯೋಜಿಸುವುದು

ನಾನು ಲಿನಕ್ಸ್ ಅನ್ನು ಮೊದಲು ಬಳಸಿದಾಗ, ಸಾಫ್ಟ್‌ವೇರ್ ಸ್ಟೋರ್‌ಗಳು ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲ. ಸಿನಾಪ್ಟಿಕ್‌ನಂತಹ ಪ್ಯಾಕೇಜ್ ಮ್ಯಾನೇಜರ್‌ಗಳು ಇದ್ದವು, ಆದರೆ ಗ್ನೋಮ್ ಸಾಫ್ಟ್‌ವೇರ್, ಡಿಸ್ಕವರ್ ಅಥವಾ ಪ್ಯಾಮಾಕ್‌ನಂತಹ ಯಾವುದೂ ಇಲ್ಲ. ನಾನು ಕಲಿತ ಮೊದಲ ವಿಷಯವೆಂದರೆ ಉಬುಂಟು ರೆಪೊಸಿಟರಿಗಳನ್ನು ಮತ್ತು ನಂತರ ಪ್ಯಾಕೇಜ್‌ಗಳನ್ನು ನವೀಕರಿಸುವುದು. ನಂತರ ನಾನು ಇನ್ನು ಮುಂದೆ ಅಗತ್ಯವಿಲ್ಲದ ಪ್ಯಾಕೇಜ್‌ಗಳನ್ನು ತೆಗೆದುಹಾಕುವ ಅಭ್ಯಾಸವನ್ನು ಪಡೆದುಕೊಂಡೆ, ಆದರೆ ಇದನ್ನು ಯಾವಾಗಲೂ ಶಿಫಾರಸು ಮಾಡುವುದಿಲ್ಲ. ನಾನು ಅದನ್ನು ವಿವರಿಸುತ್ತೇನೆ ಏಕೆಂದರೆ ಈ ಲೇಖನವು ಸುಮಾರು ಲಿನಕ್ಸ್‌ನಲ್ಲಿ ಆಜ್ಞೆಗಳನ್ನು ಹೇಗೆ ಸಂಯೋಜಿಸುವುದು.

ಹೇ ಇದನ್ನು ಮಾಡುವ ಮೂರು ವಿಧಾನಗಳು ಹೆಚ್ಚು ಸಾಮಾನ್ಯವಾಗಿದೆ. ಅವುಗಳಲ್ಲಿ ಒಂದರಲ್ಲಿ, ಒಂದು ವಿಫಲವಾಗಿದೆಯೇ ಅಥವಾ ಇಲ್ಲವೇ ಎಂಬುದನ್ನು ಲೆಕ್ಕಿಸದೆ ಎಲ್ಲಾ ಆಜ್ಞೆಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ; ಎರಡನೆಯದು, ಎರಡನೆಯದರಿಂದ, ಹಿಂದಿನದು ಕೆಲಸ ಮಾಡಿದರೆ ಮಾತ್ರ ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ; ಮೂರನೆಯದರಲ್ಲಿ, ಒಂದು ಅಥವಾ ಇನ್ನೊಂದನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ. ಆಜ್ಞೆಗಳ ನಡುವಿನ ಪ್ರತಿಯೊಂದು ಆಜ್ಞೆ ಅಥವಾ ಚಿಹ್ನೆಯು ಒಂದು ವಿಷಯ ಎಂದರ್ಥ, ಮತ್ತು ಎಲ್ಲವನ್ನೂ ಕೆಳಗೆ ವಿವರಿಸಲಾಗುವುದು.

ಆಜ್ಞೆಗಳನ್ನು &&,; ಮತ್ತು ||

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

sudo apt update && sudo apt install obs-studio

ಇದರರ್ಥ "ರೆಪೊಸಿಟರಿಗಳನ್ನು ನವೀಕರಿಸಿ ಮತ್ತು ನಾವು ಅವುಗಳನ್ನು ನವೀಕರಿಸಬಹುದಾದರೆ, OBS ಅನ್ನು ಸ್ಥಾಪಿಸಿ." ಉದಾಹರಣೆಗೆ, ನಾವು ಇಂಟರ್ನೆಟ್ ಸಂಪರ್ಕವನ್ನು ಹೊಂದಿಲ್ಲದಿದ್ದರೆ ಮತ್ತು ರೆಪೊಸಿಟರಿಗಳನ್ನು ನವೀಕರಿಸಲಾಗದಿದ್ದರೆ, ಎರಡನೇ ಆಜ್ಞೆಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುವುದಿಲ್ಲ.

ಎರಡನೆಯದು ಸೆಮಿಕೋಲನ್ ಆಪರೇಟರ್. ಒಂದು ವಿಫಲವಾಗಿದೆಯೇ ಅಥವಾ ಇಲ್ಲವೇ ಎಂಬುದನ್ನು ಲೆಕ್ಕಿಸದೆ ನಾವು ಹಲವಾರು ಆಜ್ಞೆಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಬಯಸಿದರೆ ನಾವು ಈ ಆಪರೇಟರ್ (;) ಅನ್ನು ಬಳಸುತ್ತೇವೆ. ಉದಾಹರಣೆಗೆ, ನಾವು ಅದನ್ನು ಅನುಮತಿಸುವ ದೊಡ್ಡ ಪರದೆಯನ್ನು ಹೊಂದಿದ್ದರೆ, ನಾವು ಬರೆಯಬಹುದು:

neofetch ; cpufetch

ಮತ್ತು ಅದೇ ಟರ್ಮಿನಲ್ ವಿಂಡೋದಲ್ಲಿ ನಾವು ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್, ಡೆಸ್ಕ್ಟಾಪ್, ಇತ್ಯಾದಿಗಳ ಬಗ್ಗೆ ಮಾಹಿತಿಯನ್ನು ನೋಡುತ್ತೇವೆ (ನಿಯೋಫೆಚ್), ಮತ್ತು CPU (cpufetch) ಎರಡರಲ್ಲಿ ಒಂದನ್ನು ತಪ್ಪಾಗಿ ಬರೆದರೆ ಇನ್ನೊಂದು ಕಾಣಿಸುತ್ತದೆ.

ಅಂತಿಮವಾಗಿ, ನಾವು ಎರಡು ಲಂಬ ಬಾರ್‌ಗಳನ್ನು ಹೊಂದಿದ್ದೇವೆ (||) ಅಂದರೆ "O", ಅಂದರೆ ಒಂದು ಅಥವಾ ಇನ್ನೊಂದು. ನಾವು command_1 ಮತ್ತು command_2 ಹೊಂದಿದ್ದರೆ, ನಾವು ಬರೆಯುತ್ತೇವೆ:

comando_1 || comando_2

ಮತ್ತು ಮೇಲಿನಿಂದ, ಇದು ಕಮಾಂಡ್_1 ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಪ್ರಯತ್ನಿಸುತ್ತದೆ. ಇದು ವಿಫಲವಾದಲ್ಲಿ ಅದು command_2 ಗೆ ಹೋಗುತ್ತದೆ ಮತ್ತು ಅದು ಕೊನೆಗೊಳ್ಳುವವರೆಗೆ ಅಥವಾ ಕೆಲಸ ಮಾಡುವವರೆಗೆ ಮುಂದುವರಿಯುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ನಾವು ಬರೆಯಬಹುದು cd ಡೈರೆಕ್ಟರಿ || mkdir ಡೈರೆಕ್ಟರಿ, ಅದರೊಂದಿಗೆ ನಾವು ಆ ಡೈರೆಕ್ಟರಿಯನ್ನು ನಮೂದಿಸುತ್ತೇವೆ ಅಥವಾ ಅದು ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲದಿದ್ದರೆ, ಅದು ಅದನ್ನು ರಚಿಸುತ್ತದೆ.

ನಾನು ಹೆಚ್ಚು ಸಂಯೋಜಿಸಲು ಬಯಸಿದರೆ ಏನು?

ಒಂದು ಸಾಲಿನಲ್ಲಿ ನಾವು ಎರಡಕ್ಕಿಂತ ಹೆಚ್ಚು ಆಜ್ಞೆಗಳನ್ನು ಮತ್ತು ನಿರ್ವಾಹಕರನ್ನು ಸಹ ಸಂಯೋಜಿಸಬಹುದು. ಉದಾಹರಣೆಗೆ:

comando_1 || comando_2 && comando_3

ಮೇಲಿನಿಂದ, ಇದು ಆಜ್ಞೆ 1 ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಪ್ರಯತ್ನಿಸುತ್ತದೆ. ಅದು ಯಶಸ್ವಿಯಾದರೆ, ಅದು ನಿಲ್ಲುತ್ತದೆ. ಇಲ್ಲದಿದ್ದರೆ, ಕಮಾಂಡ್ 2 ಯಶಸ್ವಿಯಾಗುವವರೆಗೆ ಅದು ಕಮಾಂಡ್ 2 ಮತ್ತು ಮೂರನೆಯದನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತದೆ.

ಮತ್ತು ಲಿನಕ್ಸ್‌ನಲ್ಲಿ ಆಜ್ಞೆಗಳನ್ನು ಹೇಗೆ ಸಂಯೋಜಿಸಲಾಗಿದೆ. ನೀವು ಮಾಡಬೇಕಾಗಿರುವುದು ಪ್ರತಿಯೊಬ್ಬ ಆಪರೇಟರ್ ಎಂದರೆ ಏನು ಎಂಬುದನ್ನು ನೆನಪಿನಲ್ಲಿಡಿ:

• &&= y, ಮೇಲಿನವು ಕೆಲಸ ಮಾಡಿದ್ದರೆ.
• || = ಅಥವಾ.
• ;= ಎಲ್ಲವೂ.