So che alcune persone hanno alcuni script di avvio e alcune persone personalizzano il prompt. Uno sviluppatore utilizza alias brevi per il lungo percorso che visita spesso e per i frequenti comandi che esegue.

Quali sono tutte le personalizzazioni efficaci che hai fatto sul tuo profilo UNIX per aumentare la produttività e la facilità d'uso?

.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'

Restituisce un breve url negli appunti; puoi aggiungere ?whatever-langl'URL restituito per evidenziarlo e sintetizzare le righe.

.inputrc

set editing-mode vi
set keymap vi

crea una directory e cd con un solo comando

Il più delle volte lo faccio mkdir, il mio prossimo comando è cd <that dir>.

Questo salva un po 'di battitura:

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

per esempio:

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

Un'altra cosa che trovo utile è un modo semplice per creare una directory usa e getta. ad esempio se sto compilando un programma o anche se sto cercando di riprodurre un problema su questo sito. A volte potrei dimenticare di ripulire la directory.

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

mostrandolo funzionante:

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

Mi affido al sistema di pulizia /tmpdopo un riavvio, ma sarebbe possibile migliorarlo, ad es. Farlo cancellare la directory temporanea dopo essere uscito dalla shell.

Mi piace che il mio prompt di bash mostri il codice di uscita del comando precedente se era diverso da zero. Mi piace anche il mio guscio che mi rallegri quando lo uso, quindi ho aggiunto un po 'di stupidità:

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

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

quindi quando eseguo i comandi, ottengo un bel feedback visivo:

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

modifica : questo è qualcosa che ho inserito nel mio ~ / .bashrc

su N

salta N directory nella struttura delle directory

Invece di scrivere

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

scrivi e basta

up 4

e a

cd -    

ti riporterà indietro

Inserisci la funzione nel tuo .bashrc per usarla.

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

(Tasti Scambia Escape e Caps Lock).

Ho sbagliato con il mio bashrc poiché uso molto il terminale (mi fa imparare velocemente e apprendere cose interessanti da usare e strumenti interessanti). Di solito definisco molte funzioni nel mio bashrc. Esempi:

Estrai archivi:

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
}

rinominare file e cartelle:

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
}

e in questo modo per suddividere file di grandi dimensioni in diversi file di piccole dimensioni:

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
}

Inoltre ho modificato molti alias poiché trovo che sia molto più facile usare un comando con argomenti come predefinito in alcuni casi (come in ls, grep e piccoli comandi), poi scriverlo ogni volta.

(Community wiki, quindi ogni trucco appartiene a una risposta separata.)

logout sicuro

Ctrl+ Dè il modo più semplice per uscire dalla shell, ma se hai ancora dei lavori in esecuzione, uscirà comunque felicemente dalla shell. Per impostazione predefinita, questo significa che tutti i programmi in esecuzione all'interno di quella shell verranno eliminati.

Alcune shell ti permetteranno di disconnetterti solo dopo aver premuto Ctrl+ Ddue volte, ma è ancora troppo facile farlo accidentalmente.

Quindi, invece, aggiungi questo a .bashrc o .zshrco qualsiasi altro file di configurazione che si preferisce.

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
}

(Community wiki, quindi ogni trucco appartiene a una risposta separata.)

cerca nella cronologia tutti i modi in cui hai eseguito un comando

Potresti già sapere di Ctrl+ R, ma in questo modo IMHO è molto più fluido.

Impostare Alt + Pper cercare nella cronologia i comandi che iniziano con ciò che hai già digitato.

ad es. ls Alt+ P, Alt+ P, Alt+P cercherà all'indietro attraverso tutti i tuoi lscomandi.

Devi metterlo nel tuo /etc/inputrco .inputrcper bash:

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

e questo nel tuo .zshrcper zsh:

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

Potresti anche fare un ulteriore passo avanti e fare in modo che la freccia Su lo faccia.

calcolatrice semplice

Puoi usare $(( ... ))o expr ...fare calcoli molto semplici, ma fa una divisione intera, ad es

$ expr 3 / 2
1

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

Un modo migliore è usare bc.

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

poi:

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

migliore completamento della scheda

Non credo che nessuno abbia ancora menzionato il Tabcompletamento della personalizzazione .

Ecco cosa ho.

Le due cose principali che fa sono:

• ogni comando verrà completato in base alle aspettative del comando,
  ad esempio cd <Tab>suggerirà solo directory
• ignora caso,
  ad es. d<Tab>sarà ancora completo DesktopeDownloads

Per 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

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

Compressione sicura

I programmi di compressione eliminano il file originale per impostazione predefinita. Non mi piace.

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

Richiesta multilinea

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

• Mostra la directory corrente in una riga separata. Utile quando si maneggia un albero di directory profondo su un terminale a 80 colonne.
• Avere un orologio nell'angolo è un'ottima cosa se usi un ambiente grafico. Questo prompt mostra l'ora. Sfortunatamente devi premere Invio per aggiornarlo.

• È possibile visualizzare "tag" con variabili di ambiente. Esempio:

  tag 'DONT SHTUDOWN!!'
  reset_tags

• Il codice si basa almeno in parte su questo .

Impostazioni della cronologia

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

• Spudoratamente rubato da qui .
• Ho aggiunto il supporto per disabilitare esplicitamente la registrazione. Utile se hai a che fare con programmi che prevedono password come argomento CLI.

• bashrc : Sono un utente zsh, quindi ho alcune righe nel mio bashrc che avviano zsh se è disponibile su un sistema.
• zshrc : Invece di copiare il mio zshrc da qualcosa come grml (anche se lì zshrc è abbastanza buono, quindi se non vuoi girare il tuo è probabilmente uno dei migliori) scrivo il mio zshrc.
  • Ho un prompt personalizzato. Tra le altre cose mostra il codice di ritorno dell'ultimo comando se era diverso da 0.
  • Ho degli alias. Poiché ho account su un numero piuttosto elevato di server, a volte devo eseguire controlli per quale versione di un comando è disponibile su un sistema e impostare l'alias di conseguenza.
  • Ho impostato la mia variabile PATH.
  • Ho impostato alcune altre variabili d'ambiente (ad esempio $ EDITOR)
• vimrc : sono un utente vim, quindi ho una combinazione di colori personalizzata e personalizzata.
• screenrc : uso lo schermo GNU per evitare di dover aprire più terminali e per preservare la cronologia mentre non ho effettuato l'accesso, quindi ho il mio screenrc.

Se riesci A ATTIVARE LA CORREZIONE DELL'ortografia del nome file e del file automatico! Queste sono probabilmente le due cose che ti faranno risparmiare più tempo. Quindi, impara ad usarli: Bash e Zsh hanno il completamento con le schede. Ksh ha una backslash di escape inefficiente, quindi consiglierei contro Ksh.

Uso Zsh, ma alias come questo funzionerebbero in quasi tutte le shell tranne 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'

Sembra che dovrebbe esserci un alias per "ps", ma mi trovo ad usare "ps" in una grande varietà di modi, e finora non ho trovato nulla.

In Zsh, imposta la tua variabile RPROMPT (non un errore di battitura!):

RPROMPT='%d'

L'intera directory appare sulla destra lato della riga di comando, pronta per il taglia e incolla. Ne parleremo più avanti.

Dovresti usare un Vim moderno correttamente compilato, a causa della possibilità di avere più vim-windows in un file e più buffer. Il tuo .vimrc potrebbe contenere cose come questa:

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

Molte di queste sono preferenze personali, ma mi capita di credere che le schede a 8 spazi rendano il codice meno leggibile, e c'è uno studio che fluttua intorno per dimostrarlo.

Inoltre, il "mouse = c" è importante. Non dovresti usare il mouse per spostarti all'interno di un file. Togliere le mani dalla tastiera, toccare il mouse e spostarle indietro è lento. Utilizzare il movimento del cursore "hjkl" e altri tasti di paginazione e movimento del cursore della tastiera.

Se stai usando X11, dovresti fare alcune cose per la tua configurazione Xterm. Questo viene fuori dal mio file .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)

Dai a Xterm una barra di scorrimento per impostazione predefinita, salva 1000 righe di testo nel buffer, è piuttosto standard.

La direttiva charClass fa una "parola" includendo cose come '.', '/' E '*'. Facendo doppio clic su qualsiasi parte di un nome di file separato da '/', otterrai tutto, meno caratteri ':'.

cutToBeginningOfLine funziona con Zsh RPROMPT sopra. Fai triplo clic sul percorso della directory di lavoro corrente che appare nell'RHS della tua riga di comando e prendi solo il percorso: la copia si ferma all'inizio della parola. Altamente efficiente una volta che ci sei abituato.

Le risorse X sopra fanno anche diventare una chiave incolla. In questo modo, una volta copiato (probabilmente usando il mouse) puoi incollarlo senza spostare la mano sul mouse per fare clic.

L'aggiunta del valore di ritorno diverso da zero dell'ultimo comando è un'ottima idea. Penso che il poster originale chiedesse specificamente di .profile / .cshrc / .bashrc. Vale la pena menzionare l'elenco di altri file RC comunemente personalizzati, ma mi limiterei a personalizzare le shell solo per questa domanda.

Di recente ho anche aggiunto un flag nel mio prompt che viene visualizzato quando la shell è in esecuzione sotto lo schermo. Utilizza il comando "ptree" di solaris per cercare i processi degli antenati, ma è possibile utilizzare il comando "pstree" su Linux per fare la stessa cosa.

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

Mi ci sono voluti alcuni minuti per capire come incorporare il codice di ritorno dell'ultimo comando, quindi lo posterò qui.

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

Sono sicuro che potrebbe essere reso più bello. :-)

Consiglio per il futuro, stai attento a leggere $? dopo aver usato "if [". Se la parentesi di sinistra è incorporata, non sovrascriverà il valore di $ ?. Ma se usi una shell in cui [non è integrato, ripristinerà il valore di $? dopo il test. È più sicuro assegnare $? in una variabile temporanea immediatamente e quindi testare quella variabile.

mostra il file modificato più di recente

Spesso, voglio guardare il file più recente. ad esempio, potrei essere nella directory dei registri e voler vedere quale file è più recente perché quello è il primo posto in cui cercare per capire perché qualcosa non funziona.

ls -lt | head è un tipo ingombrante da digitare, quindi ecco un'alternativa:

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

Prende anche un carattere jolly o un elenco di file, ad es

$ latest mail* syslog*
syslog

che è particolarmente utile se tutti i file di registro hanno un timestamp nel loro nome. Puoi trovare il registro più recente per quel programma, senza preoccuparti del formato in cui si trova il timestamp.

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

Ed ecco una versione estesa che supporta -<number>un'opzione per stampare <number>linee anziché una.

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