Linux માં એક પછી એક ચલાવવા માટે આદેશોને કેવી રીતે જોડવા

જ્યારે મેં પહેલીવાર લિનક્સનો ઉપયોગ કર્યો, ત્યારે સોફ્ટવેર સ્ટોર્સ અસ્તિત્વમાં નહોતા. સિનેપ્ટિક જેવા પેકેજ મેનેજરો હતા, પરંતુ જીનોમ સોફ્ટવેર, ડિસ્કવર અથવા પમાક જેવું કંઈ નથી. પ્રથમ વસ્તુ જે મેં શીખી તે ઉબુન્ટુ રીપોઝીટરીઝ અને પછી પેકેજોને અપડેટ કરવાનું હતું. પાછળથી મને એવા પેકેજો પણ દૂર કરવાની આદત પડી ગઈ કે જેની હવે જરૂર ન હતી, પરંતુ આ હંમેશા આગ્રહણીય નથી. હું તે સમજાવું છું કારણ કે આ લેખ તેના વિશે છે લિનક્સમાં આદેશોને કેવી રીતે જોડવા.

ત્યાં છે તે કરવાની ત્રણ રીતો જે સૌથી સામાન્ય છે. તેમાંના એકમાં, એક નિષ્ફળ જાય કે નહીં તે ધ્યાનમાં લીધા વિના તમામ આદેશો ચલાવવામાં આવશે; બીજું, બીજાથી, માત્ર ત્યારે જ અમલમાં આવશે જો પાછલું કામ કર્યું હોય; ત્રીજા એકમાં, એક અથવા બીજાને ચલાવવામાં આવશે. આદેશો વચ્ચેના દરેક આદેશ અથવા પ્રતીકનો અર્થ એક વસ્તુ છે, અને બધું નીચે સમજાવવામાં આવશે.

આદેશોને &&,; સાથે જોડો. અને ||

ઉપરોક્ત સમજાવ્યા પછી, ચાલો પહેલા && ઓપરેટર વિશે વાત કરીએ. તેમ છતાં ત્યાં બે "અને" (અને), તે એક તરીકે ગણી શકાય, પરંતુ બીજો આદેશ જો પ્રથમ કામ કરે તો જ તે ચાલશે. ઉદાહરણ તરીકે, જો આપણે ડેબિયન/ઉબુન્ટુ પર આધારિત ઑપરેટિંગ સિસ્ટમ પર હોઈએ અને અમે અધિકૃત OBS સ્ટુડિયો રિપોઝીટરી ઉમેરી હોય, તો તેને ઇન્સ્ટોલ કરવા માટે અમારે રિપોઝીટરીઝને અપડેટ કરવી પડશે અને પછી સત્તાવાર સ્ત્રોતમાંથી OBS ઇન્સ્ટોલ કરવું પડશે. આદેશ આના જેવો દેખાશે:

sudo apt update && sudo apt install obs-studio

આનો અર્થ છે "રિપોઝીટરીઝને અપડેટ કરો અને, જો અમે તેને અપડેટ કરી શકીએ, તો OBS ઇન્સ્ટોલ કરો." જો, ઉદાહરણ તરીકે, અમારી પાસે ઇન્ટરનેટ કનેક્શન નથી અને રિપોઝીટરીઝ અપડેટ કરી શકાતી નથી, તો બીજો આદેશ ચલાવવામાં આવશે નહીં.

બીજો અર્ધવિરામ ઓપરેટર છે. અમે આ ઓપરેટર (;) નો ઉપયોગ કરીશું જો આપણે ઘણા આદેશોને એક્ઝિક્યુટ કરવા ઈચ્છતા હોઈએ કે એક નિષ્ફળ જાય કે નહીં. ઉદાહરણ તરીકે, જો અમારી પાસે મોટી સ્ક્રીન છે જે તેને મંજૂરી આપે છે, તો અમે લખી શકીએ છીએ:

neofetch ; cpufetch

અને એ જ ટર્મિનલ વિન્ડોમાં આપણે ઓપરેટિંગ સિસ્ટમ, ડેસ્કટોપ વગેરે વિશેની માહિતી જોઈશું (નિયોફેચ), અને CPU (cpufetch). જો આપણે બેમાંથી એકની જોડણી ખોટી કરીએ, તો બીજી દેખાશે.

છેલ્લે, આપણી પાસે બે વર્ટીકલ બાર (||) છે જેનો અર્થ થાય છે "O", એટલે કે એક અથવા બીજી. જો અમારી પાસે આદેશ_1 અને આદેશ_2 હોય, તો અમે લખીશું:

comando_1 || comando_2

અને ઉપરથી, તે આદેશ_1 ચલાવવાનો પ્રયત્ન કરશે. જો તે અસફળ હોય તો તે કમાન્ડ_2 પર જશે અને જ્યાં સુધી તે અંત સુધી પહોંચે અથવા કામ કરે ત્યાં સુધી ચાલુ રહેશે. ઉદાહરણ તરીકે, આપણે લખી શકીએ છીએ cd ડિરેક્ટરી || mkdir ડિરેક્ટરી, જેની સાથે આપણે તે ડિરેક્ટરી દાખલ કરીશું અથવા, જો તે અસ્તિત્વમાં નથી, તો તે તેને બનાવશે.

જો મારે વધુ જોડવું હોય તો શું?

એક લીટીમાં આપણે બે કરતાં વધુ આદેશો અને ઓપરેટરોને પણ જોડી શકીએ છીએ. દાખ્લા તરીકે:

comando_1 || comando_2 && comando_3

ઉપરથી, તે આદેશ 1 ચલાવવાનો પ્રયત્ન કરશે. જો તે સફળ થશે, તો તે બંધ થઈ જશે. જો નહિં, તો જ્યાં સુધી આદેશ 2 સફળ થાય ત્યાં સુધી તે આદેશ 2 અને પછી ત્રીજો અમલ કરશે.

અને આ રીતે Linux માં આદેશો જોડવામાં આવે છે. તમારે ફક્ત યાદ રાખવાનું છે કે દરેક ઓપરેટરનો અર્થ શું છે:

• &&= y, જો ઉપરોક્ત કામ કર્યું છે.
• || = અથવા.
• ;= બધું.