उत्पादकता बढ़ाने के लिए आपने अपने शेल प्रोफाइल पर क्या अनुकूलन किया है?

Question

मुझे पता है कि कुछ लोगों के पास कुछ स्टार्टअप स्क्रिप्ट हैं और कुछ लोग प्रॉम्प्ट को निजीकृत करते हैं। एक डेवलपर उस लंबे रास्ते के लिए छोटे उपनाम का उपयोग करता है जिसे वह अक्सर दौरा करता है और अक्सर चलने वाले आदेश।

उत्पादकता और उपयोग में आसानी बढ़ाने के लिए आपने अपने यूनिक्स प्रोफाइल पर क्या सभी प्रभावी अनुकूलन किए हैं?

Comments

होना चाहिए CW, खिचड़ी भाषा का जवाब दिया जाना चाहिए।

— अकीरा

मैं सहमत हूँ। हालांकि, सीडब्ल्यू के लिए कोई विकल्प नहीं था। :-(

— सैन

@akira @Michael मैं अक्सर इस स्थिति का सामना करता हूं। यह बहुत अच्छा होगा अगर मॉडरेटर्स प्रश्न को संपादित / क्रॉस-पोस्ट / रीडायरेक्ट कर सकते हैं। क्योंकि आप जो टिप्पणी छोड़ते हैं, वह उपयोगकर्ता को वास्तव में वह हासिल करने में मदद नहीं करता है जो वह वास्तव में चाहता है। कोई अपराध नहीं, सिर्फ एक सुझाव। उम्मीद है आप समझ गए होंगे।

— सैन

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

— गिलेस एसओ- बुराई को रोकना '

Answer 1

.vimrc

टाइप करके रूट अनुमतियों के साथ फाइल सेव करें w!!:

cmap w!! w !sudo tee % > /dev/null

---

.bashrc

जब उपकरणों या बाइनरी फ़ाइलों के साथ परेशान न करें grep:

alias grep='grep --color=auto --binary-files=without-match --devices=skip'

---

वेब पर शेयर कोड (जैसे पास्टबिन, लेकिन सरल) द्वारा cat 1337.sh | webshare

alias webshare='curl -F "sprunge=<-" http://sprunge.us | xclip'

यह आपके क्लिपबोर्ड में एक छोटा यूआरएल देता है ; आप इसमें दिए गए URL को जोड़?whatever-lang सकते हैं, इसमें सिंटैक्स हाइलाइट किया गया है और लाइनें क्रमांकित हैं।

---

.inputrc

वीलाइन मोड में उन सभी चीजों का उपयोग करें जो रीडलाइन लाइब्रेरी (कई प्रोग्राम) का उपयोग करती हैं:

set editing-mode vi
set keymap vi

Comments

महान युक्तियाँ जो मुझे कभी नहीं पता थीं।

— सैन

Answer 2

एक कमांड में एक डायरेक्टरी और सीडी बनाते हैं

अधिकांश समय मैं करता हूं mkdir, मेरा अगला आदेश है cd <that dir>।

यह कुछ टाइपिंग को बचाता है:

# make a directory and cd to it
mcd()
{
    test -d "$1" || mkdir "$1" && cd "$1"
}

उदाहरण के लिए:

/home/mikel$ mcd somedir
/home/mikel/somedir$ 

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

# make a temporary directory and cd to it
mtd()
{
    local dir
    dir=$(mktemp -d)
    if test -n "$dir"
    then
        if test -d "$dir"
        then
            echo "$dir"
            cd "$dir"
        else
            echo "mktemp directory $dir does not exist"
        fi
    else
        echo "mktemp didn't work"
    fi
}

यह काम कर दिखा रहा है:

/home/mikel$ mtd
/tmp/tmp.wsnZjJ2KN6
/tmp/tmp.wsnZjJ2KN6$ 

मैं /tmpरिबूट के बाद सफाई की व्यवस्था पर भरोसा कर रहा हूं , लेकिन इसे बढ़ाना संभव होगा, जैसे कि शेल से बाहर निकलने के बाद इसे अस्थायी डीआईआर को हटा दें।

Comments

मुझे mcd विकल्प बहुत पसंद था। अच्छा लगा, धन्यवाद।

— सैन

+1 मैं mcdकई वर्षों से अपने संस्करण का उपयोग कर रहा हूं और mtdजल्द ही कुछ जोड़ने जा रहा हूं ।

— मारार्टिनस

मैंने अपनी परिभाषा दी mtd() { mcd $TMP/`date +%y%m%d-%H%M%S-%N`; }। इसमें शायद पोर्टेबिलिटी की कमी है, लेकिन यह मेरे लिए काफी अच्छा है।

— मारार्टिनस

Answer 3

मुझे अपना बैश प्रॉम्प्ट गैर-शून्य होने पर पिछले कमांड का एक्जिट कोड दिखाना पसंद है। जब मैं इसका इस्तेमाल करता हूं, तो मुझे अपनी चीयर अप करने के लिए मेरा खोल भी पसंद है, इसलिए मैंने थोड़ा दुःख जताया:

smiley() {
    RC=$?
    [[ ${RC} == 0 ]] && echo ':)' || echo ":( ${RC}"
}

export PS1="\$(smiley) \h [\A] [\W] \$ "

इसलिए जब मैं कमांड चलाता हूं, मुझे कुछ अच्छी दृश्य प्रतिक्रिया मिलती है:

:) mycomputer [23:03] [~] $ sh -c 'exit 0'
:) mycomputer [23:03] [~] $ sh -c 'exit 11'
:( 11 mycomputer [23:03] [~] $ 

संपादित करें : यह कुछ ऐसा है जिसे मैंने अपने ~ / .bashrc में डाला है

Comments

काफी दिलचस्प। लेकिन, मुझे संदेह है। कोड कहाँ रहना चाहिए?

— सैन

में .bashrcशायद।

— मिकेल

हाँ, यह मेरे ~ / .bashrc

— jsbillings में

कोशिश करेंगे कि ..

— सैन

Answer 4

अप एन

छलांग एन निर्देशिका निर्देशिका पेड़ में ऊपर

टाइप करने के बजाय

cd ../../../..

आप बस टाइप करें

up 4

और एक

cd -    

आपको वापस लाएगा

फ़ंक्शन का उपयोग करने के लिए अपने .bashrc में रखें।

# (c) 2007 stefan w. GPLv3          
function up {
ups=""
for i in $(seq 1 $1)
do
        ups=$ups"../"
done
cd $ups
}

Comments

वाह .. यह एक अच्छा विचार है ..

— San

Answer 5

.zshrc:

alias l='ls -CF'
alias ll='ls -ClhF'
alias la='ls -CaF'
alias lla='ls -CalhF'
alias l.='ls -CAF --ignore=\*'
alias ll.='ls -CAlhF --ignore=\*'
alias t='tree -C'

PS1=$'%{\e[0;33m%}%m %{\e[32;1m%}%~ %{\e[0;31m%}%#%{\e[m%} '

bindkey '^[[3~' delete-char

export GREP_OPTIONS="--color"

.xmodmaprc:

clear lock
keycode 9 = Caps_Lock ISO_Next_Group Caps_Lock ISO_Next_Group
keycode 66 = Escape NoSymbol Escape
add lock = Caps_Lock

(स्वैप एस्केप और कैप्स लॉक कीज)।

Comments

कुंजी के रीमैपिंग के लिए +1, मेरे कैप्स लॉक को वापस करने के लिए मैप किया जाता है, WHO NEEDS CAPS LOCK?

— हिलाना

मैं एक विम उपयोगकर्ता हूँ। यह विम उपयोगकर्ताओं के लिए विशिष्ट है, एस्केप टू कैप्स लॉक को मैप करने के लिए। Emacs उपयोगकर्ता नियंत्रण को कैप्स लॉक में मैप करते हैं।

— पोलीमोन

Answer 6

मैं अपने bashrc के साथ गड़बड़ कर रहा हूं क्योंकि मैं टर्मिनल का उपयोग करता हूं (यह मुझे तेजी से सीखने और दिलचस्प सामानों के साथ-साथ दिलचस्प उपकरणों का उपयोग करने के लिए सीखता है)। मैं ususally अपने bashrc में बहुत सारे कार्यों को परिभाषित करता हूं। उदाहरण:

अभिलेखागार निकालें:

extract () {
libextract () {
if [ -f "$1" ] ; then
  case "$1" in
    *.tar.bz2) tar xjf "$1" ;;
    *.tar.gz)  tar xzf "$1" ;;
    *.bz2) bunzip2 "$1" ;;
    *.rar) rar x "$1" ;;
    *.gz) gunzip "$1" ;;
    *.tar) tar xf "$1" ;;
    *.tbz2) tar xjf "$1" ;;
    *.tgz) tar xzf "$1" ;;
    *.zip) unzip "$1" ;;
    *.Z) uncompress "$1" ;;
    *.7z) 7z x "$1" ;;
    *) echo "$1 ne moze biti raspakovan!" ;;
  esac
else
  echo "$1 nije validan fajl"
fi
}
 echo "Unesite putanju do direktorijuma u kome se nalaze arhive: " && read dir && dirprovera && cd $dir
  for f in *
    do
      mkdir ./$f-raspakovano && cd ./$f-raspakovano
      libextract ./../$f
      cd ./../
    done
  tipka
}

फ़ाइलों और फ़ोल्डरों का नाम बदलें:

frename () {
if [ $# -gt 0 ]
then
 dir="$(echo $1)"
  dirprovera
  cd $dir
  for f in *
    do
      mv "$f" "`echo "$f" | tr -s " " "_" | tr "A-Z" "a-z"`" 2>/dev/null &
    done
  tipka
else
 echo "Upotreba: frename [direktorijum]" >&2
fi
}

और इस तरह बड़ी फ़ाइलों को कई छोटे लोगों में विभाजित करने के लिए:

fsplit () {
if [ $# -gt 1 ]
then
 file="$(echo $1)"
 SIZE="$(echo $2)"
 PREFIX="$(echo $3)"
 if [ -z "$PREFIX" ]; then PREFIX="fsplit"; fi
  fileprovera
  split -d -a 3 -b $SIZE $file "$PREFIX-part-" || echo "Doslo je do greske!"
  tipka
else
 echo "Upotreba: fsplit [fajl] [velicina] [prefix]
Za velicinu se koriste m (MB), g (GB) ili k (KB) (15m, 650kb, 4.7g...)

Prefiks moze sadrzati brojeve, slova, i crtice (primer: moj_pre-fiks)
Ukoliko ne unesete prefiks isti ce biti dodeljen automatski u sledecem formatu:
  fsplit-part-XXX
gde XXX predstavlja broj dela fajla (001, 005, 189...)" >&2
fi
}

इसके अलावा, मैंने बहुत सारे उपनामों को संपादित किया क्योंकि मुझे लगता है कि कुछ मामलों में डिफ़ॉल्ट रूप में तर्कों के साथ एक कमांड का उपयोग करना कहीं अधिक आसान है (जैसे ls, grep और छोटे आदेशों में) फिर हर बार उस सभी को टाइप करने के लिए।

Answer 7

(सामुदायिक विकि, इसलिए प्रत्येक चाल एक अलग उत्तर में है।)

सुरक्षित लॉगआउट

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

कुछ गोले केवल आप दबाने के बाद लॉग आउट करने देगा Ctrl+ Dदो बार, लेकिन यह अभी भी ऐसा करने की गलती से भी आसान है।

इसलिए इसके बजाय, इसे .bashrcया .zshrcजिसे भी आप चाहें कॉन्फिगर करें।

alias x='_exit'

# prevent running "exit" if the user is still running jobs in the background
# the user is expected to close the jobs or disown them
_exit()
{
    case $- in *m*)
        # this way works in bash and zsh
        jobs | wc -l | grep -q '^ *0 *$'
        if test $? -eq 0
        then
            command exit "$@"
        else
            jobs
        fi
        ;;
    *)
        command exit "$@"
        ;;
    esac
}

Answer 8

(सामुदायिक विकि, इसलिए प्रत्येक चाल एक अलग उत्तर में है।)

आपके द्वारा कमांड चलाने के सभी तरीकों के लिए अपना इतिहास खोजें

आप पहले से ही Ctrl+ के बारे में जान सकते हैं R, लेकिन यह तरीका बहुत ही कम आकर्षक है।

सेट करें Alt+ Pआदेशों क्या आप पहले से लिखे के साथ शुरू करने के लिए इतिहास खोजने के लिए।

जैसे ls Alt+ P, Alt+ P, Alt+ P आपकी सभी lsआज्ञाओं को पीछे से खोजेगा ।

आपको इसे अपने /etc/inputrcया इसके .inputrcलिए रखना होगा bash:

$if mode=emacs
"\ep": history-search-backward
"\en": history-search-forward
$endif

और यह आपके .zshrcलिए है zsh:

bindkey -M emacs '^[p' history-beginning-search-backward
bindkey -M emacs '^[n' history-beginning-search-forward

आप एक कदम आगे भी जा सकते हैं और अप एरो को ऐसा कर सकते हैं।

Answer 9

साधारण कैलकुलेटर

आप बहुत ही बुनियादी गणनाओं का उपयोग $(( ... ))या कर सकते हैं expr ..., लेकिन यह पूर्णांक विभाजन, जैसे

$ expr 3 / 2
1

$ expr 1.5 \* 2
expr: non-integer argument

उपयोग करने का एक बेहतर तरीका है bc।

# do some floating point arithmetic
calc()
{
    echo "scale=3; $*" | bc
}

फिर:

$ calc 3 / 2
1.500
$ calc 1.5 \* 2
3.0

Comments

मेरे कैलकुलेटर है alias py='PYTHONSTARTUP=~/.pythonstartup python'साथ from math import *;उस फ़ाइल में। पूर्णांक-विभाजन की समस्या अनसुलझी है, लेकिन यह अधिक जटिल कार्यों के लिए अधिक उपयोगी है।

— मारार्टिनस

Answer 10

बेहतर टैब पूरा करना

मुझे नहीं लगता कि किसी ने Tabअभी तक कस्टमाइज़िंग का उल्लेख किया है।

यहाँ मेरे पास क्या है।

दो मुख्य चीजें यह करती हैं:

• प्रत्येक आदेश इच्छा पूर्ण टैब क्या आदेश उम्मीद कर रही है पर निर्भर करता है
  जैसे cd <Tab>ही निर्देशिका का सुझाव देगा
• मामले को अनदेखा करें
  उदा d<Tab>अभी भी पूरा हो जाएगा DesktopऔरDownloads

बैश के लिए:

# custom tab completions
if type complete >/dev/null 2>&1
then
    if complete -o >/dev/null 2>&1
    then
        COMPDEF="-o complete"
    else
        COMPDEF="-o default"
    fi
    complete -a alias unalias
    complete -d cd pushd popd pd po
    complete $COMPDEF -g chgrp 2>/dev/null
    complete $COMPDEF -u chown
    complete -j fg
    complete -j kill
    complete $COMPDEF -c command
    complete $COMPDEF -c exec
    complete $COMPDEF -c man
    complete -e printenv
    complete -G "*.java" javac
    complete -F complete_runner -o nospace -o default nohup 2>/dev/null
    complete -F complete_runner -o nospace -o default sudo 2>/dev/null
    complete -F complete_services service
    # completion function for commands such as sudo that take a
    # command as the first argument but should complete the second
    # argument as if it was the first
    complete_runner()
    {
        # completing the command name
        # $1 = sudo
        # $3 = sudo
        # $2 = partial command (or complete command but no space was typed)
        if test "$1" = "$3"
        then
            set -- `compgen -c "$2"`
        # completing other arguments
        else
            # $1 = sudo
            # $3 = command after sudo (i.e. second word)
            # $2 = arguments to command
            # use the custom completion as printed by complete -p,
            # fall back to filename/bashdefault
            local comps
            comps=`complete -p "$3" 2>/dev/null`
            # "complete -o default -c man" => "-o default -c"
            # "" => "-o bashdefault -f"
            comps=${comps#complete }
            comps=${comps% *}
            comps=${comps:--o bashdefault -f}
            set -- `compgen $comps "$2"`
        fi
        COMPREPLY=("$@")
    }

    # completion function for Red Hat service command
    complete_services()
    {
        OIFS="$IFS"
        IFS='
        '
        local i=0
        for file in $(find /etc/init.d/ -type f -name "$2*" -perm -u+rx)
        do
            file=${file##*/}
            COMPREPLY[$i]=$file
            i=$(($i + 1))
        done
        IFS="$OIFS"
    }
fi

Zsh के लिए:

# set command completions
compctl -a {,un}alias
compctl -b bindkey
compctl -c command
compctl -/ {c,push,pop}d
compctl -E {print,set,unset}env
#compctl -c exec
compctl -f -x "c[-1,exec]" -c -- exec
compctl -j fg
# no -g according to zshcompctl
#compctl -g {ch}grp
compctl -j kill
compctl -c man
compctl -c nohup
compctl -u {ch}own
compctl -o {set,unset}opt
compctl -f -x "c[-1,sudo]" -c -- sudo
compctl -c {whence,where,which}
compctl -M '' 'm:{a-zA-Z}={A-Za-z}'

# make file name completion case-insensitive
zstyle ':completion:*' matcher-list '' 'm:{a-zA-Z}={A-Za-z}'

Answer 11

सुरक्षित संपीड़न

संपीड़न प्रोग्राम मूल फ़ाइल को डिफ़ॉल्ट रूप से हटाते हैं। मुझे वह पसंद नहीं है।

alias gzip='gzip --keep'
alias bzip2='bzip2 --keep'
alias xz='xz --keep'
alias lzma='lzma --keep'

मल्टी-लाइन प्रॉम्प्ट

tag() {
    TAG="${TAG} [$1]" exec zsh
}

reset_tags() {
    TAG='' exec zsh
}

color='green'
if [ "${USER}" = 'root' ]; then
    color='red'
fi

export PS1="${TAG} %B%F{yellow} *** %F{blue}%~\

%F{yellow}%(1j.[%j] .)%F{red}%(?..(%?%) )%F{${color}}%n@%m %F{blue}%# %f%b"
export RPS1='%B%F{blue}%D{%Y-%m-%d} %F{green}%D{%H:%M:%S}'
export PS2='%B%F{red}%n@%m%k %B%F{blue}%_> %b%f%k'
unset color

• वर्तमान निर्देशिका को एक अलग लाइन में दिखाता है। उपयोगी जब एक 80 स्तंभ टर्मिनल पर एक गहरी निर्देशिका पेड़ से निपटने।
• यदि आप एक ग्राफिकल वातावरण का उपयोग करते हैं तो कोने में एक घड़ी होना बहुत अच्छी बात है। यह संकेत समय दिखाता है। दुर्भाग्य से आपको इसे अपडेट करने के लिए एन्टर प्रेस करना होगा।

• आप पर्यावरण चर के साथ "टैग" प्रदर्शित कर सकते हैं। उदाहरण:

  tag 'DONT SHTUDOWN!!'
  reset_tags

• कोड कम से कम आंशिक रूप से इस पर आधारित है ।

इतिहास सेटिंग्स

dont_log() {
    HISTFILE="/dev/null" TAG="${TAG} %B%F{red}[LOGGING DISABLED]" zsh
}

if [ "${HISTFILE}" != '/dev/null' ]; then
    # history
    export HISTFILE="${HOME}/.zsh/history"
    export HISTSIZE="4096"
    export SAVEHIST="4096"

    # Don't overwrite, append!
    setopt APPEND_HISTORY

    # Write after each command
    # setopt INC_APPEND_HISTORY

    # Killer: share history between multiple shells
    setopt SHARE_HISTORY

    # If I type cd and then cd again, only save the last one
    setopt HIST_IGNORE_DUPS

    # Even if there are commands inbetween commands that are the same, still only save the last one
    setopt HIST_IGNORE_ALL_DUPS

    # Pretty    Obvious.  Right?
    setopt HIST_REDUCE_BLANKS

    # If a line starts with a space, don't save it.
    setopt HIST_IGNORE_SPACE
    setopt HIST_NO_STORE

    # When using a hist thing, make a newline show the change before executing it.
    setopt HIST_VERIFY

    # Save the time and how long a command ran
    setopt EXTENDED_HISTORY

    setopt HIST_SAVE_NO_DUPS
    setopt HIST_EXPIRE_DUPS_FIRST
    setopt HIST_FIND_NO_DUPS
fi

• बेशर्मी से यहाँ से चोरी हो गई ।
• मैंने लॉगिंग को स्पष्ट रूप से अक्षम करने के लिए समर्थन जोड़ा। उपयोगी है अगर आप ऐसे प्रोग्रामों के साथ काम कर रहे हैं जो CLI तर्क के रूप में पासवर्ड की अपेक्षा करते हैं।

Answer 12

• bashrc : मैं एक zsh उपयोगकर्ता हूँ, इसलिए मेरे bashrc में कुछ पंक्तियाँ हैं जो zsh को शुरू करती हैं यदि यह एक सिस्टम पर उपलब्ध है।
• zshrc : मेरे zshrc को grml जैसी किसी चीज़ से कॉपी करने के बजाय (हालाँकि वहाँ zshrc बहुत अच्छा है, इसलिए यदि आप अपना रोल नहीं करना चाहते हैं तो शायद यह सबसे अच्छा है) मैं अपना खुद का zshrc लिखता हूँ।
  • मेरे पास एक अनुकूलित संकेत है। कुछ अन्य बातों के अलावा, यह अंतिम कमांड के रिटर्न कोड को दिखाता है यदि यह 0 पर असमान था।
  • मेरे पास कुछ उपनाम हैं। क्योंकि मेरे पास कई सर्वरों पर खाते हैं, इसलिए मुझे कभी-कभी चेक करना पड़ता है कि किसी सिस्टम पर कौन सा कमांड का संस्करण उपलब्ध है और उसी के अनुसार अलार्म सेट करें।
  • मैंने अपना पैठ चर सेट किया।
  • मैंने कुछ अन्य पर्यावरण चर (उदाहरण $ EDITOR) निर्धारित किए
• vimrc : मैं एक विम उपयोगकर्ता हूं, इसलिए मेरे पास एक अनुकूलित और एक अनुकूलित रंग योजना है।
• screenrc : मैं कई टर्मिनलों को खोलने और लॉग इन न होने के दौरान इतिहास को संरक्षित करने से बचने के लिए GNU स्क्रीन का उपयोग करता हूं, इसलिए मेरे पास अपना स्क्रीन आर्क है।

Answer 13

अगर आप AUTOCOMPLETE पर TURN कर सकते हैं और फ़ाइल का नाम बदलने का दावा कर सकते हैं! शायद यही दो चीजें हैं जो आपको सबसे अधिक समय बचाएंगी। फिर, उनका उपयोग करना सीखें - बैश और ज़श का टैब-पूरा होना है। Ksh में एक अक्षम भागने वाला बैकस्लैश है, इसलिए मैं Ksh के खिलाफ सिफारिश करूंगा।

मैं Zsh का उपयोग करता हूं, लेकिन इस तरह के उपनाम Csh को छोड़कर लगभग किसी भी शेल में काम करेंगे:

alias l='ls -FC --color=tty'
alias ls='ls -FC --color=tty'
alias h=history
alias m=more
alias vi=vim
alias cx='chmod +x'

ऐसा लगता है कि 'पीएस' के लिए एक उपनाम वहां होना चाहिए, लेकिन मैं खुद को 'पीएस' का उपयोग विभिन्न तरीकों से करता हूं, और मुझे अब तक कुछ भी नहीं मिला है।

Zsh में, अपना RPROMPT सेट करें (टाइपो नहीं!) चर:

RPROMPT='%d'

पूरी निर्देशिका कमांड लाइन के दाईं ओर दिखाई देती है , काटने-एन-चिपकाने के लिए तैयार है। उस पर और बाद में।

एक फ़ाइल में कई vim-windows और कई बफ़र्स रखने की क्षमता के कारण, आपको ठीक से संकलित आधुनिक Vim का उपयोग करना चाहिए। आपकी .vimrc में इस तरह की चीजें हो सकती हैं:

set mouse=c
set ml
set mls=5
set nowrap
set nobackup
set nonu
set showmatch
set tabstop=4
set shiftwidth=4
set showmode
set showcmd
set ruler
set notextauto
set laststatus=2
set mps=(:),{:},[:],<:>
set modelines=0

उनमें से बहुत से व्यक्तिगत पसंद हैं, लेकिन मुझे विश्वास है कि 8-स्पेस टैब कोड को कम पठनीय बनाते हैं, और इसे साबित करने के लिए एक अध्ययन चल रहा है।

इसके अलावा, "माउस = सी" महत्वपूर्ण है। आपको अपने माउस का उपयोग किसी फाइल के अंदर घूमने के लिए नहीं करना चाहिए। अपने हाथों को कीबोर्ड से हटाकर, माउस को छूते हुए और उन्हें पीछे ले जाते हुए धीमी गति से आगे बढ़ें। "Hjkl" कर्सर आंदोलन और अन्य कीबोर्ड पेजिंग और कर्सर आंदोलन कुंजी का उपयोग करें।

यदि आप X11 का उपयोग कर रहे हैं, तो आपको अपने Xterm कॉन्फ़िगरेशन के लिए कुछ चीज़ें करनी चाहिए। यह मेरे .Xresources फ़ाइल से बाहर आता है:

XTerm*VT100.scrollBar: true
XTerm*VT100.saveLines: 1000
XTerm*VT100.cutNewLine: false 
XTerm*VT100.cutToBeginningOfLine: false
XTerm*VT100.charClass: 33:48,35:48,37:48,42:48,45-47:48,64:48,95:48,126:48
XTerm*VT100*translations: #override \n\
    <Key>F2: insert-selection(PRIMARY,CUT_BUFFER0)

Xterm को डिफ़ॉल्ट रूप से एक स्क्रॉलबार दें, बफर में पाठ की 1000 पंक्तियों को सहेजें, यह बहुत मानक है।

चारक्लास निर्देश एक "शब्द" बनाता है जिसमें ',', '/' और '*' जैसी चीजें शामिल हैं। '/' - अलग फ़ाइल नाम के किसी भी भाग पर डबल क्लिक करना, और आपको पूरी चीज़ मिल जाती है, कम: '' अक्षर।

cutToBeginningOfLine ऊपर Zsh RPROMPT के साथ काम करता है। ट्रिपल अपने कमांड लाइन के आरएचएस पर दिखाई देने वाली वर्तमान कार्यशील निर्देशिका के पथ पर क्लिक करता है, और आप केवल पथ को चुनते हैं: शब्द की शुरुआत में प्रतिलिपि बंद हो जाती है। आपके द्वारा उपयोग किए जाने के बाद एक बार अत्यधिक कुशल।

उपरोक्त एक्स संसाधन भी एक पेस्ट कुंजी बनाता है। इस तरह, एक बार जब आप कॉपी कर लेते हैं (शायद माउस का उपयोग कर रहे हैं) तो आप बिना क्लिक किए अपना हाथ वापस माउस पर ले जा सकते हैं।

Comments

एफडब्ल्यूआईडब्ल्यू, फ़ाइल नाम पूरा करना Esc``Escया Esc``=में काम करता है ksh, और में Tabकाम करता है ksh93। बस अगर कोई इसके साथ फंस जाता है या इसे पसंद करता है।

— मिकेल

Answer 14

अंतिम आदेश के गैर-शून्य रिटर्न मूल्य को जोड़ना एक महान विचार है। मुझे लगता है कि मूल पोस्टर विशेष रूप से .profile / .cshrc / .bashrc के बारे में पूछ रहा था। यह अन्य अनुकूलित आरसी फ़ाइलों की सूची का उल्लेख करने योग्य है, लेकिन मैं इस प्रश्न के लिए सिर्फ शैल अनुकूलन के लिए चिपका रहूंगा।

मैंने हाल ही में अपने प्रॉम्प्ट में एक ध्वज जोड़ा है जो दिखाता है कि स्क्रीन के नीचे शेल चल रहा है या नहीं। यह पूर्वजों की प्रक्रियाओं को खोजने के लिए सोलारिस "ptree" कमांड का उपयोग करता है, लेकिन आप लिनक्स पर "pstree" कमांड का उपयोग एक ही काम करने के लिए कर सकते हैं।

SCREEN=""
if [ -f /usr/bin/ptree ]; then
   if ptree $$ | grep -v grep | grep -w screen > /dev/null 2>&1; then
       SCREEN="SCREEN "
   fi
fi

अंतिम कमांड के रिटर्न कोड को कैसे एम्बेड किया जाए, यह जानने में मुझे कुछ मिनट लगे, इसलिए मैं इसे यहां पोस्ट करूंगा।

PROMPT_COMMAND='if [ "$?" = 0 ]; \
        then RC=""; \
        else RC="RV=$? "; fi; PS1="% ${SCREEN}\h $RC\w\n% "'

मुझे यकीन है कि इसे और सुंदर बनाया जा सकता है। :-)

भविष्य की टिप, $ पढ़ने के बारे में सावधान रहें? "if" का उपयोग करने के बाद। यदि बाईं कोष्ठक एक अंतर्निहित है, तो यह $ के मूल्य को ओवरराइड नहीं करेगा। लेकिन अगर आप एक शेल का उपयोग करते हैं जहां [बिल्ट-इन नहीं है, तो यह $ का मूल्य रीसेट करेगा? परीक्षण के बाद। यह $ असाइन करने के लिए सुरक्षित है? अभी एक अस्थायी चर में और फिर उस चर का परीक्षण करें।

Comments

आपका जवाब शायद एक टिप्पणी होना चाहिए ... इस तरह!

— VxJasonxV

Answer 15

सबसे हाल ही में बदली गई फ़ाइल दिखाएं

अक्सर, मैं सबसे हाल की फ़ाइल को देखना चाहता हूं। उदाहरण के लिए, मैं लॉग निर्देशिका में हो सकता हूं, और यह देखना चाहता हूं कि कौन सी फ़ाइल सबसे हाल ही में है क्योंकि यह देखने के लिए पहली जगह है कि कुछ काम क्यों नहीं कर रहा है।

ls -lt | head टाइप करने के लिए बोझिल है, लेकिन यहाँ एक विकल्प है:

# show the most recently changed file
latest()
{
    if test $# -ne 0
    then
        /bin/ls -t -1 -d "$@" | head -n 1
    else
        /bin/ls -t -1 -d * | head -n 1
    fi
}

यह वाइल्डकार्ड या फाइलों की सूची भी लेता है, जैसे

$ latest mail* syslog*
syslog

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

$ touch -d 'Feb 1' mylog.20110201
$ touch -d 'Feb 2' mylog.20110202
$ touch -d 'Feb 3' mylog.20110203
$ latest mylog*
mylog.20110203

और यहां एक विस्तारित संस्करण है जो एक के बजाय लाइनों -<number>को प्रिंट करने के विकल्प का समर्थन करता है <number>।

# show the most recently changed file
latest()
{
    local count=1               # how many files to print
    local promptlines=5         # how many lines to leave for the prompt
                                # when printing a screenful with -s
    local usage="Usage: latest [-n <number>] [-s] [--] [pattern]"
    while test $# -gt 0
    do
        case $1 in
        # -- = stop processing options
        --)
            shift
            break
            ;;
        # -n <number> = <number> files
        -n)
            if test -n "$2"
            then
                count=$2
                shift 2
            else
                echo "$usage" 1>&2
                return 1
            fi
            ;;
        # -s = one screenful
        -s)
            count=$((LINES - promptlines))
            shift
            ;;
        # -<number> = <number> files
        -[0-9]*)
            count=${1#-}
            shift
            ;;
        # anything else starting with a minus is a usage error
        -*)
            echo "$usage" 1>&2
            return 1
            ;;
        *)
            break
            ;;
        esac
    done

    if test $# -ne 0
    then
        /bin/ls -t -1 -d "$@" | head -n $count
    else
        /bin/ls -t -1 -d * | head -n $count
    fi
}