आवश्यक बैश एलियास जो आपकी उत्पादकता को बढ़ाएंगे

एक बैश एलियास बैश कमांड को नए के साथ पूरक या ओवरराइड करने की एक विधि है। बैश एलियास उपयोगकर्ताओं के लिए POSIX टर्मिनल में अपने अनुभव को अनुकूलित करना आसान बनाते हैं। वे अक्सर $HOME/.bashrc या $HOME/bash_aliases में परिभाषित होते हैं (जिसे $HOME/.bashrc द्वारा लोड किया जाना चाहिए)।

अधिकांश डिस्ट्रीब्यूशन किसी भी नए उपयोगकर्ता खाते की डिफ़ॉल्ट .bashrc फाइल में कम से कम कुछ लोकप्रिय एलियास जोड़ते हैं। ये बैश एलियास के सिंटैक्स को प्रदर्शित करने के लिए सरल हैं:

alias ls='ls -F'
alias ll='ls -lh'

सभी डिस्ट्रीब्यूशन पूर्व-आबाद एलियास के साथ शिप नहीं करते हैं। यदि आप मैन्युअल रूप से एलियास जोड़ते हैं, तो आपको उन्हें अपने वर्तमान बैश सत्र में लोड करना होगा:

$ source ~/.bashrc

अन्यथा, आप अपना टर्मिनल बंद कर सकते हैं और इसे फिर से खोल सकते हैं ताकि यह अपनी कॉन्फ़िगरेशन फाइल को रीलोड करे।

उन एलियास को आपके बैश इनिशियलाइज़ेशन स्क्रिप्ट में परिभाषित करने के साथ, आप तब ll टाइप कर सकते हैं और ls -l के परिणाम प्राप्त कर सकते हैं, और जब आप ls टाइप करते हैं तो आपको प्लेन ओल्ड ls के आउटपुट के बजाय परिणाम मिलते हैं।

वे एलियास रखने के लिए बहुत अच्छे हैं, लेकिन वे केवल सतह को खरोंचते हैं कि क्या संभव है। यहां शीर्ष 10 बैश एलियास हैं जिन्हें एक बार आज़माने के बाद आप उनके बिना नहीं रह पाएंगे।

पहले सेट अप करें

शुरू करने से पहले, ~/.bash_aliases नामक एक फाइल बनाएं:

$ touch ~/.bash_aliases

फिर, सुनिश्चित करें कि यह कोड आपके ~/.bashrc फाइल में दिखाई देता है:

if [ -e $HOME/.bash_aliases ]; then
source $HOME/.bash_aliases
fi

यदि आप इस लेख के किसी भी एलियास को स्वयं आज़माना चाहते हैं, तो उन्हें अपनी .bash_aliases फाइल में दर्ज करें, और फिर source ~/.bashrc कमांड के साथ उन्हें अपने बैश सत्र में लोड करें।

फाइल आकार के अनुसार सॉर्ट करें

यदि आपने GNOME में Nautilus, MacOS में Finder, या Windows में Explorer जैसे GUI फाइल मैनेजर के साथ अपना कंप्यूटिंग जीवन शुरू किया, तो आप शायद फाइलों की सूची को उनके आकार के अनुसार सॉर्ट करने के आदी हैं। आप इसे टर्मिनल में भी कर सकते हैं, लेकिन यह बिल्कुल संक्षिप्त नहीं है।

GNU सिस्टम पर अपनी कॉन्फ़िगरेशन में यह एलियास जोड़ें:

alias lt='ls --human-readable --size -1 -S --classify'

यह एलियास lt को एक ls कमांड से बदल देता है जो प्रत्येक आइटम का आकार प्रदर्शित करता है, और फिर इसे आकार के अनुसार सॉर्ट करता है, एक कॉलम में, फाइल के प्रकार को इंगित करने के लिए एक नोटेशन के साथ। अपना नया एलियास लोड करें, और फिर इसे आज़माएं:

$ source ~/.bashrc
$ lt
total 344K
140K configure*
44K aclocal.m4
36K LICENSE
32K config.status*
24K Makefile
24K Makefile.in
12K config.log
8.0K README.md
4.0K info.slackermedia.Git-portal.json
4.0K git-portal.spec
4.0K flatpak.path.patch
4.0K Makefile.am*
4.0K dot-gitlab.ci.yml
4.0K configure.ac*
0 autom4te.cache/
0 share/
0 bin/
0 install-sh@
0 compile@
0 missing@
0 COPYING@

MacOS या BSD पर, ls कमांड के समान विकल्प नहीं हैं, इसलिए यह एलियास इसके बजाय काम करता है:

alias lt='du -sh * | sort -h'

इस संस्करण के परिणाम थोड़े अलग हैं:

$ du -sh * | sort -h
0 compile
0 COPYING
0 install-sh
0 missing
4.0K configure.ac
4.0K dot-gitlab.ci.yml
4.0K flatpak.path.patch
4.0K git-portal.spec
4.0K info.slackermedia.Git-portal.json
4.0K Makefile.am
8.0K README.md
12K config.log
16K bin
24K Makefile
24K Makefile.in
32K config.status
36K LICENSE
44K aclocal.m4
60K share
140K configure
476K autom4te.cache

वास्तव में, लिनक्स पर भी, वह कमांड उपयोगी है, क्योंकि ls का उपयोग करके डायरेक्टरी और सिमलिंक्स को आकार में 0 के रूप में सूचीबद्ध किया जाता है, जो वह जानकारी नहीं हो सकती जो आप वास्तव में चाहते हैं। यह आपकी पसंद है।

इस एलियास विचार के लिए ब्रैड अलेक्जेंडर को धन्यवाद।

केवल माउंटेड ड्राइव देखें

mount कमांड बहुत सरल हुआ करती थी। केवल एक कमांड के साथ, आप अपने कंप्यूटर पर सभी माउंटेड फाइलसिस्टम की सूची प्राप्त कर सकते थे, और इसका उपयोग अक्सर वर्कस्टेशन से जुड़े ड्राइव के अवलोकन के लिए किया जाता था। तीन या चार से अधिक प्रविष्टियों को देखना प्रभावशाली हुआ करता था क्योंकि अधिकांश कंप्यूटरों में उससे अधिक USB पोर्ट नहीं होते हैं, इसलिए परिणाम प्रबंधनीय थे।

कंप्यूटर अब थोड़े अधिक जटिल हैं, और LVM, फिजिकल ड्राइव, नेटवर्क स्टोरेज, और वर्चुअल फाइलसिस्टम के बीच, mount के परिणाम पार्स करना मुश्किल हो सकते हैं:

sysfs on /sys type sysfs (rw,nosuid,nodev,noexec,relatime,seclabel)
proc on /proc type proc (rw,nosuid,nodev,noexec,relatime)
devtmpfs on /dev type devtmpfs (rw,nosuid,seclabel,size=8131024k,nr_inodes=2032756,mode=755)
securityfs on /sys/kernel/security type securityfs (rw,nosuid,nodev,noexec,relatime)
[...]
/dev/nvme0n1p2 on /boot type ext4 (rw,relatime,seclabel)
/dev/nvme0n1p1 on /boot/efi type vfat (rw,relatime,fmask=0077,dmask=0077,codepage=437,iocharset=ascii,shortname=winnt,errors=remount-ro)
[...]
gvfsd-fuse on /run/user/100977/gvfs type fuse.gvfsd-fuse (rw,nosuid,nodev,relatime,user_id=100977,group_id=100977)
/dev/sda1 on /run/media/seth/pocket type ext4 (rw,nosuid,nodev,relatime,seclabel,uhelper=udisks2)
/dev/sdc1 on /run/media/seth/trip type ext4 (rw,nosuid,nodev,relatime,seclabel,uhelper=udisks2)
binfmt_misc on /proc/sys/fs/binfmt_misc type binfmt_misc (rw,relatime)

उस समस्या को हल करने के लिए, इस तरह का एक एलियास आज़माएं:

alias mnt="mount | awk -F' ' '{ printf \"%s\t%s\n\",\$1,\$3; }' | column -t | egrep ^/dev/ | sort"

यह एलियास awk का उपयोग करके mount के आउटपुट को कॉलम द्वारा पार्स करता है, आउटपुट को उस तक कम कर देता है जो आप शायद ढूंढ रहे हैं (कौन सी हार्ड ड्राइव, और फाइल सिस्टम नहीं, माउंटेड हैं):

$ mnt
/dev/mapper/fedora-root /
/dev/nvme0n1p1 /boot/efi
/dev/nvme0n1p2 /boot
/dev/sda1 /run/media/seth/pocket
/dev/sdc1 /run/media/seth/trip

MacOS पर, mount कमांड भयानक रूप से वर्बोज आउटपुट प्रदान नहीं करता है, इसलिए एक एलियास ओवरकिल हो सकता है। हालांकि, यदि आप एक संक्षिप्त रिपोर्ट पसंद करते हैं, तो इसे आज़माएं:

alias mnt='mount | grep -E ^/dev | column -t'

परिणाम:

$ mnt
/dev/disk1s1 on / (apfs, local, journaled)
/dev/disk1s4 on /private/var/vm (apfs, local, noexec, journaled, noatime, nobrowse)

अपने ग्रेप इतिहास में कमांड ढूंढें

कभी-कभी आप टर्मिनल में कुछ करने का तरीका ढूंढते हैं, और खुद से वादा करते हैं कि आप जो सीखा है उसे कभी नहीं भूलेंगे। फिर एक घंटा बीत जाता है, और आप पूरी तरह से भूल गए हैं कि आपने क्या किया।

अपने बैश इतिहास के माध्यम से खोज करना कुछ ऐसा है जो हर किसी को समय-समय पर करना पड़ता है। यदि आप ठीक से जानते हैं कि आप क्या खोज रहे हैं, तो आप अपने इतिहास के माध्यम से रिवर्स खोज करने के लिए Ctrl+R का उपयोग कर सकते हैं, लेकिन कभी-कभी आप उस सटीक कमांड को याद नहीं कर सकते जिसे आप ढूंढना चाहते हैं।

यहां उस कार्य को थोड़ा आसान बनाने के लिए एक एलियास है:

alias gh='history|grep'

इसका उपयोग करने का एक उदाहरण यहां दिया गया है:

$ gh bash
482 cat ~/.bashrc | grep _alias
498 emacs ~/.bashrc
530 emacs ~/.bash_aliases
531 source ~/.bashrc

संशोधन समय के अनुसार सॉर्ट करें

यह हर सोमवार को होता है: आप काम पर पहुंचते हैं, आप अपने कंप्यूटर पर बैठते हैं, आप एक टर्मिनल खोलते हैं, और आप पाते हैं कि आप भूल गए हैं कि आप पिछले शुक्रवार को क्या कर रहे थे। आपको सबसे हाल ही में संशोधित फाइलों को सूचीबद्ध करने के लिए एक एलियास की आवश्यकता है।

आप ls कमांड का उपयोग एक एलियास बनाने के लिए कर सकते हैं जो आपको यह ढूंढने में मदद करेगा कि आप कहां छोड़ गए थे:

alias left='ls -t -1'

आउटपुट सरल है, हालांकि आप इसे --long विकल्प के साथ विस्तारित कर सकते हैं यदि आप पसंद करते हैं। एलियास, जैसा कि सूचीबद्ध है, यह प्रदर्शित करता है:

$ left
demo.jpeg
demo.xcf
design-proposal.md
rejects.txt
brainstorm.txt
query-letter.xml

फाइलें गिनें

यदि आपको यह जानने की आवश्यकता है कि किसी डायरेक्टरी में कितनी फाइलें हैं, तो समाधान UNIX कमांड निर्माण के सबसे क्लासिक उदाहरणों में से एक है: आप ls कमांड के साथ फाइलों को सूचीबद्ध करते हैं, -1 विकल्प के साथ इसके आउटपुट को केवल एक कॉलम तक नियंत्रित करते हैं, और फिर उस आउटपुट को wc (वर्ड काउंट) कमांड में पाइप करते हैं ताकि सिंगल फाइलों की कितनी लाइनें हैं, यह गिना जा सके।

यह UNIX फिलॉसफी का एक शानदार प्रदर्शन है जो उपयोगकर्ताओं को छोटे सिस्टम घटकों का उपयोग करके अपने स्वयं के समाधान बनाने की अनुमति देता है। यह कमांड संयोजन भी बहुत टाइप करने वाला है यदि आप इसे दिन में कई बार करते हैं, और यह -R विकल्प का उपयोग किए बिना डायरेक्टरी की डायरेक्टरी के लिए बिल्कुल काम नहीं करता है, जो आउटपुट में नई लाइनें पेश करता है और अभ्यास को बेकार बना देता है।

इसके बजाय, यह एलियास प्रक्रिया को आसान बनाता है:

alias count='find . -type f | wc -l'

यह फाइलों को गिनता है, डायरेक्टरी को अनदेखा करता है, लेकिन डायरेक्टरी की सामग्री को नहीं। यदि आपके पास एक प्रोजेक्ट फोल्डर है जिसमें दो डायरेक्टरी हैं, जिनमें से प्रत्येक में दो फाइलें हैं, तो एलियास चार लौटाता है, क्योंकि पूरे प्रोजेक्ट में चार फाइलें हैं।

$ ls
foo bar
$ count
4

पायथन वर्चुअल एनवायरनमेंट बनाएं

क्या आप पायथन में कोड करते हैं?

क्या आप पायथन में बहुत कोड करते हैं?

यदि आप करते हैं, तो आप जानते हैं कि पायथन वर्चुअल एनवायरनमेंट बनाने के लिए, कम से कम, 53 कीस्ट्रोक्स की आवश्यकता होती है।

यह 49 बहुत अधिक हैं, लेकिन दो नए एलियास ve और va के साथ आसानी से टाला जा सकता है:

alias ve='python3 -m venv ./venv'
alias va='source ./venv/bin/activate'

ve चलाने से venv नामक एक नई डायरेक्टरी बनती है, जिसमें पायथन3 के लिए सामान्य वर्चुअल एनवायरनमेंट फाइलसिस्टम होता है। va एलियास आपके वर्तमान शेल में एनवायरनमेंट को सक्रिय करता है:

$ cd my-project
$ ve 
$ va
(venv) $ 

कॉपी प्रोग्रेस बार जोड़ें

हर कोई प्रोग्रेस बार का मज़ाक उड़ाता है क्योंकि वे कुख्यात रूप से गलत होते हैं। और फिर भी, गहराई से, हम सभी उन्हें चाहते प्रतीत होते हैं। UNIX cp कमांड में कोई प्रोग्रेस बार नहीं है, लेकिन इसमें वर्बोसिटी के लिए -v विकल्प है, जिसका अर्थ है कि यह कॉपी की जा रही प्रत्येक फाइल के नाम को आपके टर्मिनल पर इको करता है। यह एक बहुत अच्छा हैक है, लेकिन यह तब अच्छा काम नहीं करता जब आप एक बड़ी फाइल कॉपी कर रहे हों और यह संकेत चाहते हों कि फाइल का कितना हिस्सा अभी ट्रांसफर होना बाकी है।

pv कमांड कॉपी के दौरान एक प्रोग्रेस बार प्रदान करता है, लेकिन यह डिफ़ॉल्ट एप्लिकेशन के रूप में आम नहीं है। दूसरी ओर, rsync कमांड लगभग हर POSIX सिस्टम के डिफ़ॉल्ट इंस्टॉलेशन में शामिल है, और इसे स्थानीय और रिमोट दोनों तरह से फाइलों को कॉपी करने के सबसे स्मार्ट तरीकों में से एक के रूप में व्यापक रूप से मान्यता प्राप्त है।

इससे भी बेहतर, इसमें एक अंतर्निहित प्रोग्रेस बार है।

alias cpv='rsync -ah --info=progress2'

इस एलियास का उपयोग cp कमांड का उपयोग करने जैसा ही है:

$ cpv bigfile.flac /run/media/seth/audio/
3.83M 6% 213.15MB/s 0:00:00 (xfr#4, to-chk=0/4)

इस कमांड का उपयोग करने का एक दिलचस्प साइड इफेक्ट यह है कि rsync cp द्वारा अन्यथा आवश्यक -r फ्लैग के बिना फाइलों और डायरेक्टरी दोनों को कॉपी करता है।

फाइल हटाने की दुर्घटनाओं से खुद को बचाएं

आपको rm कमांड का उपयोग नहीं करना चाहिए। rm मैनुअल भी ऐसा ही कहता है:

चेतावनी: यदि आप किसी फाइल को हटाने के लिए 'rm' का उपयोग करते हैं, तो आमतौर पर उस फाइल की सामग्री को पुनर्प्राप्त करना संभव है। यदि आप अधिक आश्वासन चाहते हैं कि सामग्री वास्तव में अप्राप्य है, तो 'shred' का उपयोग करने पर विचार करें।

यदि आप किसी फाइल को हटाना चाहते हैं, तो आपको फाइल को अपने ट्रैश में ले जाना चाहिए, ठीक वैसे ही जैसे आप डेस्कटॉप का उपयोग करते समय करते हैं।

POSIX इसे आसान बनाता है, क्योंकि ट्रैश आपके फाइलसिस्टम में एक सुलभ, वास्तविक स्थान है। वह स्थान आपके प्लेटफॉर्म के आधार पर बदल सकता है: एक FreeDesktop पर, ट्रैश ~/.local/share/Trash पर स्थित है, जबकि MacOS पर यह ~/.Trash है, लेकिन किसी भी तरह से, यह केवल एक डायरेक्टरी है जिसमें आप उन फाइलों को रखते हैं जिन्हें आप तब तक नज़र से दूर रखना चाहते हैं जब तक आप उन्हें हमेशा के लिए मिटाने के लिए तैयार न हों।

यह सरल एलियास आपके टर्मिनल से फाइलों को सिस्टम ट्रैश बिन में फेंकने का एक तरीका प्रदान करता है:

alias tcn='mv --force -t ~/.local/share/Trash '

यह एलियास एक कम-ज्ञात mv फ्लैग का उपयोग करता है जो आपको उस फाइल को अंतिम आर्गुमेंट के रूप में प्रदान करने में सक्षम बनाता है जिसे आप स्थानांतरित करना चाहते हैं, उस फाइल को पहले सूचीबद्ध करने की सामान्य आवश्यकता को अनदेखा करते हुए। अब आप अपने नए कमांड का उपयोग फाइलों और फोल्डरों को अपने सिस्टम ट्रैश में ले जाने के लिए कर सकते हैं:

$ ls 
foo bar
$ tcn foo
$ ls
bar 

अब फाइल "चली गई," लेकिन केवल तब तक जब तक आपको ठंडे पसीने में एहसास नहीं होता कि आपको अभी भी इसकी आवश्यकता है। उस बिंदु पर, आप अपने सिस्टम ट्रैश से फाइल को बचा सकते हैं; रास्ते में बैश और mv डेवलपर्स को टिप देना सुनिश्चित करें।

नोट: यदि आपको बेहतर FreeDesktop अनुपालन के साथ एक अधिक मजबूत Trash कमांड की आवश्यकता है, तो Trashy देखें।

अपने Git वर्कफ़्लो को सरल बनाएं

हर किसी का एक अनूठा वर्कफ़्लो होता है, लेकिन आमतौर पर दोहराए जाने वाले कार्य होते हैं चाहे कुछ भी हो। यदि आप नियमित आधार पर Git के साथ काम करते हैं, तो शायद कुछ क्रम है जिसे आप खुद को काफी बार दोहराते हुए पाते हैं। शायद आप खुद को मास्टर ब्रांच पर वापस जाकर दिन भर में बार-बार नवीनतम बदलावों को खींचते हुए पाते हैं, या शायद आप खुद को टैग बनाते और फिर उन्हें रिमोट पर पुश करते हुए पाते हैं, या शायद यह कुछ पूरी तरह से अलग है।

कोई फर्क नहीं पड़ता कि आप किस Git मंत्र को टाइप करने से थक गए हैं, आप बैश एलियास के साथ कुछ दर्द कम कर सकते हैं। बड़े पैमाने पर हुक में आर्गुमेंट पास करने की इसकी क्षमता के लिए धन्यवाद, Git में आत्मनिरीक्षण कमांड का एक समृद्ध सेट है जो आपको बैश में अलौकिक करतब करने से बचाता है।

उदाहरण के लिए, जब आप बैश में किसी प्रोजेक्ट के टॉप-लेवल डायरेक्टरी का पता लगाने के लिए संघर्ष कर सकते हैं (जो, जहां तक बैश का संबंध है, एक पूरी तरह से मनमाना पदनाम है, क्योंकि कंप्यूटर के लिए पूर्ण टॉप लेवल रूट डायरेक्टरी है), Git एक सरल क्वेरी के साथ अपने टॉप लेवल को जानता है। यदि आप Git हुक का अध्ययन करते हैं, तो आप खुद को सभी प्रकार की जानकारी पता लगाने में सक्षम पाएंगे जो बैश कुछ नहीं जानता, लेकिन आप उस जानकारी का लाभ बैश एलियास के साथ उठा सकते हैं।

यहां एक एलियास है जो एक Git प्रोजेक्ट के टॉप लेवल को ढूंढता है, चाहे आप उस प्रोजेक्ट में वर्तमान में कहीं भी काम कर रहे हों, और फिर उसमें डायरेक्टरी बदलता है, मास्टर ब्रांच में बदलता है, और एक Git pull करता है:

alias startgit='cd `git rev-parse --show-toplevel` && git checkout master && git pull'

इस तरह का एलियास किसी भी तरह से सार्वभौमिक रूप से उपयोगी एलियास नहीं है, लेकिन यह दर्शाता है कि कैसे एक अपेक्षाकृत सरल एलियास बहुत सारे श्रमसाध्य नेविगेशन, कमांड, और प्रॉम्प्ट की प्रतीक्षा को समाप्त कर सकता है।

एक सरल, और शायद अधिक सार्वभौमिक, एलियास आपको Git प्रोजेक्ट के टॉप लेवल पर लौटाता है। यह एलियास उपयोगी है क्योंकि जब आप किसी प्रोजेक्ट पर काम कर रहे होते हैं, तो वह प्रोजेक्ट कमोबेश आपकी "अस्थायी होम" डायरेक्टरी बन जाता है। अपने वास्तविक होम पर जाना जितना सरल होना चाहिए, उतना ही सरल होना चाहिए, और यहां एक एलियास है जो इसे करता है:

alias cg='cd `git rev-parse --show-toplevel`'

अब cg कमांड आपको आपके Git प्रोजेक्ट के टॉप पर ले जाती है, चाहे आप इसकी डायरेक्टरी संरचना में कितने भी गहरे उतरे हों।

डायरेक्टरी बदलें और साथ ही सामग्री देखें

एक प्रमुख वैज्ञानिक द्वारा एक बार (कथित तौर पर) प्रस्तावित किया गया था कि हम ग्रह की कई ऊर्जा समस्याओं को हल कर सकते हैं गीक्स द्वारा cd के बाद ls टाइप करने में खर्च की गई ऊर्जा का उपयोग करके।

यह एक सामान्य पैटर्न है, क्योंकि आम तौर पर जब आप डायरेक्टरी बदलते हैं, तो आपके पास यह देखने की इच्छा या आवश्यकता होती है कि आसपास क्या है।

लेकिन अपने कंप्यूटर के डायरेक्टरी ट्री को "चलना" एक शुरू-और-रुको प्रक्रिया नहीं होनी चाहिए।

यह धोखा है, क्योंकि यह बिल्कुल भी एलियास नहीं है, लेकिन यह बैश फंक्शन का पता लगाने का एक शानदार बहाना है। जबकि एलियास त्वरित प्रतिस्थापन के लिए महान हैं, बैश आपको अपने .bashrc फाइल में (या एक अलग फंक्शन फाइल में जिसे आप .bashrc में लोड करते हैं, ठीक वैसे ही जैसे आप अपनी एलियास फाइल के साथ करते हैं) लोकल फंक्शन जोड़ने की अनुमति देता है।

चीजों को मॉड्यूलर रखने के लिए, ~/.bash_functions नामक एक नई फाइल बनाएं और फिर अपने .bashrc को इसे लोड करने दें:

if [ -e $HOME/.bash_functions ]; then
source $HOME/.bash_functions
fi

फंक्शन फाइल में, यह कोड जोड़ें:

function cl() {
DIR="$*";
# यदि कोई DIR नहीं दिया गया, तो होम जाएं
if [ $# -lt 1 ]; then 
DIR=$HOME;
fi;
builtin cd "${DIR}" && \
# अपने पसंदीदा ls कमांड का उपयोग करें
ls -F --color=auto
}

फंक्शन को अपने बैश सत्र में लोड करें और फिर इसे आज़माएं:

$ source ~/.bash_functions
$ cl Documents
foo bar baz
$ pwd
/home/seth/Documents
$ cl ..
Desktop Documents Downloads
[...]
$ pwd
/home/seth

फंक्शन एलियास की तुलना में बहुत अधिक लचीले हैं, लेकिन उस लचीलेपन के साथ यह जिम्मेदारी आती है कि आप यह सुनिश्चित करें कि आपका कोड समझ में आता है और वह करता है जो आप अपेक्षा करते हैं। एलियास सरल होने के लिए बने हैं, इसलिए उन्हें आसान लेकिन उपयोगी रखें। बैश के व्यवहार में गंभीर संशोधन के लिए, अपने PATH में किसी स्थान पर सेव किए गए फंक्शन या कस्टम शेल स्क्रिप्ट का उपयोग करें।

रिकॉर्ड के लिए, cd और ls अनुक्रम को एलियास के रूप में लागू करने के कुछ चतुर हैक्स हैं, इसलिए यदि आप पर्याप्त धैर्यवान हैं, तो विनम्र एलियास का उपयोग करके भी आकाश सीमा है।

एलियासिंग और फंक्शनिंग शुरू करें

अपने एनवायरनमेंट को अनुकूलित करना वही है जो लिनक्स को मजेदार बनाता है, और अपनी दक्षता बढ़ाना वही है जो लिनक्स को जीवन-परिवर्तनकारी बनाता है। सरल एलियास से शुरू करें, फंक्शन तक स्नातक करें, और टिप्पणियों में अपने अवश्य-होने-चाहिए एलियास पोस्ट करें!