Wiem, że niektórzy ludzie mają pewne skrypty startowe, a niektórzy personalizują monit. Jeden programista używa krótkich aliasów dla długiej ścieżki, którą często odwiedza, i częstych poleceń, które wykonuje.

Jakie są efektywne dostosowania dokonane w profilu UNIX w celu zwiększenia wydajności i łatwości użytkowania?

.vimrc

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

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

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

Zwraca krótki adres URL w schowku; możesz dołączyć ?whatever-langdo zwracanego adresu URL, aby wyróżnić jego składnię i ponumerować wiersze.

.inputrc

set editing-mode vi
set keymap vi

utwórz katalog i cd jednym poleceniem

W większości przypadków mkdirmoje następne polecenie brzmi cd <that dir>.

Oszczędza to trochę pisania:

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

na przykład:

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

Kolejną rzeczą, która jest dla mnie przydatna, jest łatwy sposób na utworzenie katalogu typu „wyrzucany”. np. jeśli kompiluję program lub nawet jeśli próbuję odtworzyć problem na tej stronie. Czasami mogę zapomnieć o uporządkowaniu katalogu.

# 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
}

pokazując, że działa:

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

Opieram się na czyszczeniu systemu /tmppo ponownym uruchomieniu, ale można to poprawić, np. Usunąć katalog temp po wyjściu z powłoki.

Chciałbym, aby mój komunikat bash wyświetlał kod wyjścia poprzedniego polecenia, jeśli było niezerowe. Podoba mi się też moja skorupa, która dodaje mi otuchy, gdy go używam, więc dodałem trochę głupoty:

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

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

więc kiedy uruchamiam polecenia, otrzymuję ładne wizualne informacje zwrotne:

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

edycja : jest to coś, co umieściłem w moim ~ / .bashrc

w górę N.

przeskocz N katalogów w górę w drzewie katalogów

Zamiast pisać

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

po prostu piszesz

up 4

i a

cd -    

przywiezie cię z powrotem

Umieść funkcję w swoim .bashrc, aby z niej skorzystać.

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

.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

(Zamień klawisze Escape i Caps Lock).

Mam problem z moim bashrc, ponieważ często używam terminala (dzięki temu uczę się szybko i uczę ciekawych rzeczy do użycia, a także interesujących narzędzi). Zwykle definiuję wiele funkcji w moim bashrc. Przykłady:

Wyodrębnij archiwa:

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
}

zmień nazwy plików i folderów:

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
}

i tak do dzielenia dużych plików na kilka małych:

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
}

Zredagowałem też wiele aliasów, ponieważ uważam, że o wiele łatwiej jest użyć jednego polecenia z argumentami jako domyślnymi w niektórych przypadkach (np. W ls, grep i małych poleceniach), a następnie wpisywać to wszystko za każdym razem.

(Społeczność wiki, więc każda sztuczka należy do osobnej odpowiedzi).

bezpieczne wylogowanie

Ctrl+ Djest najprostszym sposobem na wyjście z powłoki, ale jeśli nadal masz uruchomione zadania, i tak z przyjemnością opuści powłokę. Domyślnie oznacza to, że wszystkie programy uruchomione z poziomu tej powłoki zostaną zabite.

Niektóre powłoki pozwolą ci się wylogować dopiero po dwukrotnym naciśnięciu Ctrl+ D, ale nadal zbyt łatwo jest to zrobić przypadkowo.

Więc zamiast dodawać to .bashrcczy .zshrclub którykolwiek config plik wolisz.

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
}

(Społeczność wiki, więc każda sztuczka należy do osobnej odpowiedzi).

przeszukaj swoją historię pod kątem wszystkich sposobów uruchomienia polecenia

Być może już wiesz o Ctrl+ R, ale w ten sposób IMHO jest znacznie płynniejsze.

Skonfiguruj Alt+, Paby przeszukać historię poleceń, które zaczynają się od tego, co już wpisałeś.

np. ls Alt+ P, Alt+ P, Alt+ P przeszuka wstecz wszystkie twoje lspolecenia.

Musisz to umieścić w swoim /etc/inputrclub .inputrcdla bash:

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

i to w twoim .zshrcprzypadku zsh:

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

Możesz nawet pójść o krok dalej i sprawić, że zrobi to strzałka w górę.

prosty kalkulator

Możesz użyć $(( ... ))lub expr ...wykonać bardzo podstawowe obliczenia, ale dokonuje podziału na liczby całkowite, np

$ expr 3 / 2
1

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

Lepszym sposobem jest użycie bc.

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

następnie:

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

lepsze uzupełnianie kart

Nie sądzę, żeby ktokolwiek jeszcze wspomniał o dostosowaniu Tabukończenia.

Oto co mam.

Dwie główne rzeczy, które robi:

• każde polecenie zostanie zakończone tabulacją w zależności od tego, czego ono oczekuje,
  np. cd <Tab>sugeruje tylko katalogi
• zignoruj ​​przypadek,
  np. d<Tab>nadal będzie kompletny DesktopiDownloads

Do bash:

# 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

Dla 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}'

Bezpieczna kompresja

Programy kompresujące domyślnie usuwają oryginalny plik. Nie lubie tego

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

Monit o wielu wierszach

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

• Pokazuje bieżący katalog w osobnym wierszu. Przydatne przy obsłudze głębokiego drzewa katalogów na terminalu z 80 kolumnami.
• Posiadanie zegara w rogu to świetna rzecz, jeśli używasz środowiska graficznego. Ten monit pokazuje czas. Niestety musisz nacisnąć Enter, aby go zaktualizować.

• Możesz wyświetlać „tagi” ze zmiennymi środowiskowymi. Przykład:

  tag 'DONT SHTUDOWN!!'
  reset_tags

• Kod jest przynajmniej częściowo oparty na tym .

Ustawienia historii

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

• Bezwstydnie skradziony stąd .
• Dodałem obsługę jawnego wyłączania rejestrowania. Przydatne, jeśli masz do czynienia z programami, które oczekują haseł jako argumentu CLI.

• bashrc : Jestem użytkownikiem zsh, więc w moim bashrc mam kilka linii, które uruchamiają zsh, jeśli jest dostępny w systemie.
• zshrc : Zamiast kopiować mój zshrc z czegoś takiego jak grml (chociaż tam zshrc jest całkiem dobry, więc jeśli nie chcesz tworzyć własnych, prawdopodobnie jest to jeden z najlepszych) piszę własny zshrc.
  • Mam spersonalizowany monit. Między innymi pokazuje kod powrotu ostatniego polecenia, jeśli było nierówne do 0.
  • Mam jakieś pseudonimy. Ponieważ mam konta na wielu serwerach, czasami muszę sprawdzać, która wersja polecenia jest dostępna w systemie i odpowiednio ustawić alias.
  • Ustawiam zmienną PATH.
  • Ustawiłem inne zmienne środowiskowe (na przykład $ EDITOR)
• vimrc : Jestem użytkownikiem vim, więc mam spersonalizowany i niestandardowy schemat kolorów.
• screenrc : Używam ekranu GNU, aby uniknąć konieczności otwierania wielu terminali i zachowania historii bez zalogowania się, więc mam swój własny screenrc.

Jeśli możesz WŁĄCZYĆ AUTOCOMPLETE I NAZWĘ PLIKU KOREKCJA PISANIA! To prawdopodobnie dwie rzeczy, które pozwolą Ci zaoszczędzić najwięcej czasu. Następnie naucz się ich używać - Bash i Zsh mają tabulatory. Ksh ma nieefektywny ukośnik ucieczki, więc odradzam Ksh.

Używam Zsh, ale takie aliasy działałyby w prawie każdej powłoce oprócz 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'

Wygląda na to, że powinien istnieć alias dla „ps”, ale używam ps na wiele różnych sposobów i jak dotąd niczego nie znalazłem.

W Zsh skonfiguruj zmienną RPROMPT (nie literówka!):

RPROMPT='%d'

Cały katalog pojawia się po prawej stronie wiersza poleceń, gotowy do wycinania i wklejania. Więcej o tym później.

Powinieneś użyć poprawnie skompilowanego nowoczesnego Vima, ponieważ możesz mieć wiele vim-okien w pliku i wiele buforów. Twój plik .vimrc może zawierać takie rzeczy:

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

Wiele z nich jest osobistymi preferencjami, ale zdarza mi się wierzyć, że 8-spacja powoduje, że kod jest mniej czytelny, i istnieje badanie, aby to udowodnić.

Ważne jest także „mouse = c”. Nie należy używać myszy do poruszania się po pliku. Odrywanie rąk od klawiatury, dotykanie myszy i przesuwanie ich do tyłu jest powolne. Użyj ruchu kursora „hjkl” oraz innych klawiszy stronicowania i klawiszy ruchów kursora.

Jeśli używasz X11, powinieneś zrobić kilka rzeczy w swojej konfiguracji Xterm. To pochodzi z mojego pliku .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)

Daj Xtermowi domyślnie pasek przewijania, zapisz 1000 linii tekstu w buforze, co jest dość standardowe.

Dyrektywa charClass sprawia, że ​​„słowo” obejmuje takie rzeczy jak „.”, „/” I „*”. Dwukrotne kliknięcie dowolnej części nazwy pliku oddzielonej „/”, a otrzymasz całość, mniej znaków „:”.

cutToBeginningOfLine działa z Zsh RPROMPT powyżej. Trzykrotnie kliknij ścieżkę bieżącego katalogu roboczego, który pojawia się w RHS wiersza poleceń, a ty wybierzesz tylko ścieżkę: kopiowanie zatrzymuje się na początku słowa. Bardzo wydajny, gdy już się do tego przyzwyczaisz.

Powyższe zasoby X tworzą również klucz do wklejania. W ten sposób po skopiowaniu (prawdopodobnie za pomocą myszy) możesz wkleić bez przesuwania dłoni z powrotem do myszy, aby kliknąć.

Dodanie niezerowej wartości zwrotnej ostatniego polecenia jest świetnym pomysłem. Myślę, że oryginalny plakat konkretnie pytał o .profile / .cshrc / .bashrc. Warto wspomnieć o liście innych powszechnie dostosowywanych plików RC, ale chciałbym trzymać się tylko modyfikacji powłoki dla tego pytania.

Niedawno dodałem także flagę, która wyświetla się, gdy powłoka działa pod ekranem. Używa komendy solaris „ptree” do przeszukiwania procesów przodków, ale możesz użyć komendy „pstree” w Linuksie, aby zrobić to samo.

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

Kilka minut zajęło mi ustalenie, jak osadzić kod powrotu ostatniego polecenia, więc opublikuję go tutaj.

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

Jestem pewien, że to może być piękniejsze. :-)

Wskazówka dotycząca przyszłości, bądź ostrożny z czytaniem $? po użyciu „if [”. Jeśli lewy nawias jest wbudowany, nie zastąpi wartości $ ?. Ale jeśli użyjesz powłoki, w której [nie jest wbudowany, to zresetuje wartość $? po testach. Bezpieczniej jest przypisać $? na zmienną tymczasową od razu, a następnie przetestuj tę zmienną.

pokaż ostatnio zmieniony plik

Często chcę spojrzeć na najnowszy plik. np. mogę być w katalogu logs i chcę zobaczyć, który plik jest najnowszy, ponieważ jest to pierwsze miejsce, aby sprawdzić, dlaczego coś nie działa.

ls -lt | head jest nieporęczne do pisania, więc oto alternatywa:

# 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
}

Pobiera również symbol wieloznaczny lub listę plików, np

$ latest mail* syslog*
syslog

co jest szczególnie przydatne, jeśli wszystkie pliki dziennika mają znacznik czasu w nazwie. Możesz znaleźć najnowszy dziennik dla tego programu, nie martwiąc się, w jakim formacie znajduje się znacznik czasu.

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

A oto rozszerzona wersja, która obsługuje -<number>opcję drukowania <number>linii zamiast jednej.

# 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
}