லினக்ஸில் ஒன்றன் பின் ஒன்றாக இயங்க கட்டளைகளை எவ்வாறு இணைப்பது

நான் முதன்முதலில் லினக்ஸைப் பயன்படுத்தியபோது, ​​அத்தகைய மென்பொருள் அங்காடிகள் இல்லை. சினாப்டிக் போன்ற தொகுப்பு மேலாளர்கள் இருந்தனர், ஆனால் க்னோம் மென்பொருள், டிஸ்கவர் அல்லது பாமாக் போன்ற எதுவும் இல்லை. நான் கற்றுக்கொண்ட முதல் விஷயம் உபுண்டு களஞ்சியங்களையும் அதன் பிறகு தொகுப்புகளையும் புதுப்பிப்பதாகும். பின்னர் தேவையில்லாத தொகுப்புகளை அகற்றும் பழக்கம் எனக்கு ஏற்பட்டது, ஆனால் இது எப்போதும் பரிந்துரைக்கப்படுவதில்லை. இந்தக் கட்டுரையைப் பற்றியது என்பதால் அதை விளக்குகிறேன் லினக்ஸில் கட்டளைகளை எவ்வாறு இணைப்பது.

அங்கு உள்ளது அதைச் செய்வதற்கான மூன்று வழிகள் மிகவும் பொதுவானவை. அவற்றில் ஒன்றில், ஒருவர் தோல்வியடைந்தாலும் இல்லாவிட்டாலும், அனைத்து கட்டளைகளும் செயல்படுத்தப்படும்; இரண்டாவது, இரண்டாவது, முந்தையது வேலை செய்திருந்தால் மட்டுமே செயல்படுத்தப்படும்; மூன்றாவது ஒன்றில், ஒன்று அல்லது மற்றொன்று செயல்படுத்தப்படும். கட்டளைகளுக்கு இடையில் உள்ள ஒவ்வொரு கட்டளையும் அல்லது சின்னமும் ஒரு பொருளைக் குறிக்கிறது, மேலும் அனைத்தும் கீழே விளக்கப்படும்.

கட்டளைகளை &&,; மற்றும் ||

மேலே விளக்கிய பிறகு, முதலில் && இயக்குநரைப் பற்றி பேசலாம். இரண்டு "மற்றும்" (மற்றும்) இருந்தாலும், அதை ஒன்றாகக் கணக்கிடலாம், ஆனால் இரண்டாவது கட்டளை முதல் வேலை செய்தால் மட்டுமே அது இயங்கும். எடுத்துக்காட்டாக, நாம் Debian / Ubuntu ஐ அடிப்படையாகக் கொண்ட இயக்க முறைமையில் இருந்தால், அதிகாரப்பூர்வ OBS ஸ்டுடியோ களஞ்சியத்தைச் சேர்த்திருந்தால், அதை நிறுவ, களஞ்சியங்களைப் புதுப்பித்து, அதிகாரப்பூர்வ மூலத்திலிருந்து OBS ஐ நிறுவ வேண்டும். கட்டளை இப்படி இருக்கும்:

sudo apt update && sudo apt install obs-studio

இதன் பொருள் "ரெபோசிட்டரிகளைப் புதுப்பிக்கவும், அவற்றைப் புதுப்பிக்க முடிந்தால், OBS ஐ நிறுவவும்." உதாரணமாக, எங்களிடம் இணைய இணைப்பு இல்லை மற்றும் களஞ்சியங்களைப் புதுப்பிக்க முடியாவிட்டால், இரண்டாவது கட்டளை செயல்படுத்தப்படாது.

இரண்டாவது அரைப்புள்ளி ஆபரேட்டர். ஒன்று தோல்வியுற்றாலும் இல்லாவிட்டாலும் பல கட்டளைகளை இயக்க விரும்பினால் இந்த ஆபரேட்டரை (;) பயன்படுத்துவோம். எடுத்துக்காட்டாக, அதை அனுமதிக்கும் பெரிய திரை இருந்தால், நாம் எழுதலாம்:

neofetch ; cpufetch

அதே டெர்மினல் விண்டோவில் ஆப்பரேட்டிங் சிஸ்டம், டெஸ்க்டாப் போன்ற தகவல்களைக் காண்போம் (neofetch), மற்றும் CPU (cpufetch) இரண்டில் ஒன்றை தவறாக எழுதினால் மற்றொன்று தோன்றும்.

இறுதியாக, எங்களிடம் இரண்டு செங்குத்து பட்டைகள் உள்ளன (||) அதாவது "O", அதாவது ஒன்று அல்லது மற்றொன்று. எங்களிடம் கட்டளை_1 மற்றும் கட்டளை_2 இருந்தால், நாங்கள் எழுதுவோம்:

comando_1 || comando_2

மேலே இருந்து, இது கட்டளை_1 ஐ இயக்க முயற்சிக்கும். அது தோல்வியுற்றால், அது கட்டளை_2 க்குச் சென்று, அது முடிவடையும் வரை அல்லது செயல்படும் வரை தொடரும். உதாரணமாக, நாம் எழுதலாம் cd கோப்பகம் || mkdir அடைவு, அதனுடன் நாம் அந்த கோப்பகத்தை உள்ளிடுவோம் அல்லது அது இல்லை என்றால், அதை உருவாக்கும்.

நான் மேலும் இணைக்க விரும்பினால் என்ன செய்வது?

ஒரு வரியில் நாம் இரண்டுக்கும் மேற்பட்ட கட்டளைகளையும், ஆபரேட்டர்களையும் கூட இணைக்கலாம். உதாரணத்திற்கு:

comando_1 || comando_2 && comando_3

மேலே இருந்து, கட்டளை 1 ஐ இயக்க முயற்சிக்கும். அது வெற்றியடைந்தால், அது நிறுத்தப்படும். இல்லையெனில், கட்டளை 2 வெற்றிபெறும் வரை, அது கட்டளை 2 ஐ இயக்கும்.

லினக்ஸில் கட்டளைகள் இணைக்கப்படுவது இதுதான். நீங்கள் செய்ய வேண்டியதெல்லாம், ஒவ்வொரு ஆபரேட்டருக்கும் என்ன அர்த்தம் என்பதை நினைவில் கொள்ள வேண்டும்:

• &&= y, மேலே வேலை செய்திருந்தால்.
• || = அல்லது.
• ;= எல்லாம்.