Je sais que certaines personnes ont des scripts de démarrage et certaines personnes personnalisent l'invite. Un développeur utilise des alias courts pour le long chemin qu'il visite souvent et les commandes fréquentes qu'il exécute.

Quelles sont toutes les personnalisations effectives que vous avez effectuées sur votre profil UNIX pour augmenter la productivité et la facilité d'utilisation?

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

Il renvoie une courte URL dans votre presse-papiers; vous pouvez ajouter ?whatever-langà l'URL renvoyée pour que sa syntaxe soit mise en surbrillance et les lignes numérotées.

.inputrc

set editing-mode vi
set keymap vi

créer un répertoire et un cd en une seule commande

La plupart du temps mkdir, ma prochaine commande est cd <that dir>.

Cela vous évite de taper:

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

par exemple:

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

Une autre chose que je trouve utile est un moyen facile de créer un répertoire jetable. par exemple si je compile un programme ou même si j'essaye de reproduire un problème sur ce site. Parfois, je pourrais oublier de nettoyer le répertoire.

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

montrant qu'il fonctionne:

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

Je compte sur le nettoyage du système /tmpaprès un redémarrage, mais il serait possible d'améliorer cela, par exemple en lui faisant supprimer le répertoire temp après avoir quitté le shell.

J'aime que mon invite bash affiche le code de sortie de la commande précédente s'il était différent de zéro. J'aime aussi ma coquille pour me remonter le moral quand je l'utilise, j'ai donc ajouté un peu de bêtise:

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

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

donc quand j'exécute des commandes, j'obtiens de bons retours visuels:

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

edit : c'est quelque chose que je mets dans mon ~ / .bashrc

en haut N

sauter N répertoires dans l'arborescence des répertoires

Au lieu de taper

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

vous tapez simplement

up 4

et un

cd -    

vous ramènera

Mettez la fonction dans votre .bashrc pour l'utiliser.

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

(Échange les touches d'échappement et de verrouillage des majuscules).

Je me trompe avec mon bashrc car j'utilise beaucoup le terminal (cela me fait apprendre rapidement et apprendre des trucs intéressants à utiliser ainsi que des outils intéressants). Je définis généralement un grand nombre de fonctions dans mon bashrc. Exemples:

Extraire les archives:

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
}

renommer des fichiers et des dossiers:

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
}

et comme ceci pour diviser de gros fichiers en plusieurs petits:

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
}

J'ai également édité beaucoup d'alias car je trouve qu'il est beaucoup plus facile d'utiliser une commande avec des arguments par défaut dans certains cas (comme dans ls, grep et petites commandes) puis de taper tout cela à chaque fois.

(Wiki communautaire, chaque astuce appartient donc à une réponse distincte.)

déconnexion en toute sécurité

Ctrl+ Dest le moyen le plus simple de quitter le shell, mais si vous avez encore des travaux en cours, il quittera volontiers le shell de toute façon. Par défaut, cela signifie que tous les programmes que vous exécutiez depuis l'intérieur de ce shell seront tués.

Certains shells ne vous permettront de vous déconnecter qu'après avoir appuyé deux fois sur Ctrl+ D, mais il est toujours trop facile de le faire accidentellement.

Donc à la place, ajoutez ceci à .bashrcou .zshrcou selon le fichier de configuration que vous préférez.

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
}

(Wiki communautaire, chaque astuce appartient donc à une réponse distincte.)

recherchez dans votre historique toutes les façons dont vous avez exécuté une commande

Vous connaissez peut-être déjà Ctrl+ R, mais cette méthode est beaucoup plus fluide à mon humble avis.

Configurez Alt+ Ppour rechercher dans l'historique des commandes commençant par ce que vous avez déjà tapé.

par exemple ls Alt+ P, Alt+ P, Alt+ P effectuera une recherche en arrière dans toutes vos lscommandes.

Vous devez mettre cela dans votre /etc/inputrcou .inputrcpour bash:

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

et ceci dans votre .zshrcpour zsh:

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

Vous pouvez même aller plus loin et faire faire la flèche Haut.

calculatrice simple

Vous pouvez utiliser $(( ... ))ou expr ...pour faire des calculs très basiques, mais il fait une division entière, par exemple

$ expr 3 / 2
1

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

Une meilleure façon est d'utiliser bc.

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

puis:

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

meilleure complétion des onglets

Je ne pense pas que quiconque ait mentionné la personnalisation de l' Tabachèvement pour le moment.

Voici ce que j'ai.

Les deux choses principales qu'il fait sont:

• chaque commande sera complétée par tabulation en fonction de ce que la commande attend,
  par exemple cd <Tab>, ne suggérera que des répertoires
• ignorer le cas,
  par exemple, d<Tab>sera toujours terminé DesktopetDownloads

Pour 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

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

Compression sûre

Les programmes de compression suppriment le fichier d'origine par défaut. Je n'aime pas ça.

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

Invite multiligne

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

• Affiche le répertoire actuel sur une ligne distincte. Utile lors de la gestion d'une arborescence de répertoires approfondie sur un terminal à 80 colonnes.
• Avoir une horloge dans le coin est une bonne chose si vous utilisez un environnement graphique. Cette invite affiche l'heure. Malheureusement, vous devez appuyer sur Entrée pour le mettre à jour.

• Vous pouvez afficher des "balises" avec des variables d'environnement. Exemple:

  tag 'DONT SHTUDOWN!!'
  reset_tags

• Le code est basé au moins partiellement sur cela .

Paramètres d'historique

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

• Sans vergogne volé d' ici .
• J'ai ajouté la prise en charge de la désactivation explicite de la journalisation. Utile si vous utilisez des programmes qui attendent des mots de passe comme argument CLI.

• bashrc : Je suis un utilisateur zsh, donc j'ai quelques lignes dans mon bashrc qui démarrent zsh s'il est disponible sur un système.
• zshrc : Au lieu de copier mon zshrc à partir de quelque chose comme grml (bien que zshrc soit assez bon, donc si vous ne voulez pas rouler le vôtre, c'est probablement l'un des meilleurs) j'écris mon propre zshrc.
  • J'ai une invite personnalisée. Entre autres choses, il affiche le code retour de la dernière commande s'il était différent de 0.
  • J'ai quelques alias. Parce que j'ai des comptes sur un certain nombre de serveurs, je dois parfois vérifier la version d'une commande disponible sur un système et définir l'alias en conséquence.
  • J'ai défini ma variable PATH.
  • J'ai défini d'autres variables d'environnement (par exemple $ EDITOR)
• vimrc : Je suis un utilisateur de vim, j'ai donc un schéma de couleurs personnalisé et personnalisé.
• screenrc : J'utilise l'écran GNU pour éviter d'avoir à ouvrir plusieurs terminaux et pour conserver l'historique sans être connecté, j'ai donc mon propre screenrc.

Si vous pouvez ACTIVER LA CORRECTION D'orthographe AUTOCOMPLETE ET NOM DE FICHIER! Ce sont probablement les deux choses qui vous feront gagner le plus de temps. Ensuite, apprenez à les utiliser - Bash et Zsh sont complétés par tabulation. Ksh a une barre oblique inverse inefficace, donc je recommanderais contre Ksh.

J'utilise Zsh, mais des alias comme celui-ci fonctionneraient dans presque tous les shell sauf 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'

Il semble qu'un alias pour «ps» devrait être là, mais je me retrouve à utiliser «ps» de nombreuses façons, et je n'ai rien trouvé jusqu'à présent.

Dans Zsh, configurez votre variable RPROMPT (pas une faute de frappe!):

RPROMPT='%d'

Le répertoire entier apparaît à droite côté de la ligne de commande, prêt à couper-coller. Plus sur cela plus tard.

Vous devez utiliser un Vim moderne correctement compilé, en raison de la possibilité d'avoir plusieurs fenêtres vim dans un fichier et plusieurs tampons. Votre .vimrc pourrait contenir des éléments comme celui-ci:

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

Beaucoup de ceux-ci sont des préférences personnelles, mais je pense que les onglets à 8 espaces rendent le code moins lisible, et il existe une étude qui le prouve.

De plus, le "mouse = c" est important. Vous ne devez pas utiliser votre souris pour vous déplacer dans un fichier. Retirer vos mains du clavier, toucher la souris et les faire reculer est lent. Utilisez le mouvement du curseur "hjkl" et d'autres touches de pagination du clavier et de déplacement du curseur.

Si vous utilisez X11, vous devez apporter quelques modifications à votre configuration Xterm. Cela sort de mon fichier .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)

Donnez à Xterm une barre de défilement par défaut, enregistrez 1000 lignes de texte dans le tampon, c'est assez standard.

La directive charClass fait qu'un "mot" inclut des choses comme '.', '/' Et '*'. Double-cliquez sur n'importe quelle partie d'un nom de fichier séparé par '/', et vous obtenez le tout, moins les caractères ':'.

cutToBeginningOfLine fonctionne avec le Zsh RPROMPT ci-dessus. Triple clic sur le chemin du répertoire de travail courant qui apparaît sur le RHS de votre ligne de commande, et vous ne prenez que le chemin: la copie s'arrête au début du mot. Très efficace une fois que vous y êtes habitué.

Les ressources X ci-dessus en font également une clé de collage. De cette façon, une fois que vous avez copié (probablement à l'aide de la souris), vous pouvez coller sans déplacer votre main vers la souris pour cliquer.

Ajouter la valeur de retour non nulle de la dernière commande est une excellente idée. Je pense que l'affiche originale posait spécifiquement des questions sur .profile / .cshrc / .bashrc. Il vaut la peine de mentionner la liste des autres fichiers RC couramment personnalisés, mais je m'en tiendrai aux seules personnalisations du shell pour cette question.

J'ai également récemment ajouté un indicateur dans mon invite qui s'affiche lorsque le shell s'exécute sous l'écran. Il utilise la commande solaris "ptree" pour rechercher les processus ancêtres, mais vous pouvez utiliser la commande "pstree" sur Linux pour faire la même chose.

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

Il m'a fallu quelques minutes pour comprendre comment incorporer le code retour de la dernière commande, donc je le posterai ici.

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

Je suis sûr que cela pourrait être rendu plus beau. :-)

Astuce future, faites attention à lire $? après avoir utilisé "if [". Si le crochet gauche est intégré, il ne remplacera pas la valeur de $ ?. Mais si vous utilisez un shell où [n'est pas intégré, il réinitialisera la valeur de $? après les tests. Il est plus sûr d'attribuer $? dans une variable temporaire tout de suite, puis testez cette variable.

afficher le fichier modifié le plus récemment

Souvent, je veux regarder le fichier le plus récent. par exemple, je suis peut-être dans le répertoire logs et je veux voir quel fichier est le plus récent car c'est le premier endroit où chercher pour voir pourquoi quelque chose ne fonctionne pas.

ls -lt | head est un mais lourd à taper, voici donc une alternative:

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

Il prend également un caractère générique ou une liste de fichiers, par exemple

$ latest mail* syslog*
syslog

ce qui est particulièrement pratique si tous vos fichiers journaux ont un horodatage à leur nom. Vous pouvez trouver le dernier journal de ce programme, sans vous soucier du format de l'horodatage.

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

Et voici une version étendue qui prend en charge une -<number>option pour imprimer des <number>lignes au lieu d'une.

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