¿Hay algo sin lo que no puedas vivir y que haga mi vida MUCHO más fácil? Aquí hay algunos que uso ('espacio en disco' y 'carpetas' son particularmente útiles).

# some more ls aliases
alias ll='ls -alh'
alias la='ls -A'
alias l='ls -CFlh'
alias woo='fortune'
alias lsd="ls -alF | grep /$"

# This is GOLD for finding out what is taking so much space on your drives!
alias diskspace="du -S | sort -n -r |more"

# Command line mplayer movie watching for the win.
alias mp="mplayer -fs"

# Show me the size (sorted) of only the folders in this directory
alias folders="find . -maxdepth 1 -type d -print | xargs du -sk | sort -rn"

# This will keep you sane when you're about to smash the keyboard again.
alias frak="fortune"

# This is where you put your hand rolled scripts (remember to chmod them)
PATH="$HOME/bin:$PATH"

Tengo un pequeño script que extrae archivos, lo encontré en algún lugar de la red:

extract () {
   if [ -f $1 ] ; then
       case $1 in
           *.tar.bz2)   tar xvjf $1    ;;
           *.tar.gz)    tar xvzf $1    ;;
           *.bz2)       bunzip2 $1     ;;
           *.rar)       unrar x $1       ;;
           *.gz)        gunzip $1      ;;
           *.tar)       tar xvf $1     ;;
           *.tbz2)      tar xvjf $1    ;;
           *.tgz)       tar xvzf $1    ;;
           *.zip)       unzip $1       ;;
           *.Z)         uncompress $1  ;;
           *.7z)        7z x $1        ;;
           *)           echo "don't know how to extract '$1'..." ;;
       esac
   else
       echo "'$1' is not a valid file!"
   fi
 }

Como uso tantas máquinas diferentes, mi .bashrcsiempre establece el símbolo del sistema para incluir, entre otras cosas, el nombre del servidor en el que estoy conectado actualmente. De esta manera, cuando tengo tres niveles de profundidad en telnet / ssh, no escribo lo incorrecto en la ventana incorrecta. ¡Realmente apesta rm -rf .en la ventana equivocada! (Nota: en casa, telnet está deshabilitado en todas las máquinas. En el trabajo, ssh no siempre está habilitado y no tengo acceso de root a muchas máquinas).

Tengo un script ~/bin/setpromptque ejecuta my .bashrc, que contiene:

RESET="\[\017\]"
NORMAL="\[\033[0m\]"
RED="\[\033[31;1m\]"
YELLOW="\[\033[33;1m\]"
WHITE="\[\033[37;1m\]"
SMILEY="${WHITE}:)${NORMAL}"
FROWNY="${RED}:(${NORMAL}"
SELECT="if [ \$? = 0 ]; then echo \"${SMILEY}\"; else echo \"${FROWNY}\"; fi"

# Throw it all together 
PS1="${RESET}${YELLOW}\h${NORMAL} \`${SELECT}\` ${YELLOW}>${NORMAL} "

Esta secuencia de comandos establece la solicitud en el nombre de host seguido de :)si el último comando fue exitoso y :(si el último comando falló.

El color de las páginas de manual en menos hace que las páginas de manual sean un poco más fáciles de leer:

export LESS_TERMCAP_mb=$'\E[01;31m'
export LESS_TERMCAP_md=$'\E[01;31m'
export LESS_TERMCAP_me=$'\E[0m'
export LESS_TERMCAP_se=$'\E[0m'
export LESS_TERMCAP_so=$'\E[01;44;33m'
export LESS_TERMCAP_ue=$'\E[0m'
export LESS_TERMCAP_us=$'\E[01;32m'

Las páginas de manual en color también se pueden obtener instalando la mayoría y utilizándola como variable env del MANPAGER Si desea utilizar este buscapersonas no solo para hombre, use la variable PAGER, así:

export PAGER="/usr/bin/most -s"

No más cd ../../../ .. pero hasta 4

Sube muchos directorios a medida que pasa el número como argumento, si ninguno sube 1 por defecto (se encuentra en un enlace en un comentario en stackoverflow.com y se modifica un poco)

up(){
  local d=""
  limit=$1
  for ((i=1 ; i <= limit ; i++))
    do
      d=$d/..
    done
  d=$(echo $d | sed 's/^\///')
  if [ -z "$d" ]; then
    d=..
  fi
  cd $d
}

Trato con muchas máquinas diferentes, por lo que uno de mis favoritos es el alias para cada máquina que necesito frecuentemente para SSH para:

alias claudius="ssh dinomite@claudius"

También es útil configurar unas teclas buenas .ssh/configy ssh para que el salto entre máquinas sea aún más fácil.

Otro de mis alias favoritos es para subir directorios:

alias ..="cd .."
alias ...="cd ../.."
alias ....="cd ../../.."
alias .....="cd ../../../.."

Y algunos para variaciones comúnmente utilizadas de ls(y errores tipográficos):

alias ll="ls -l"
alias lo="ls -o"
alias lh="ls -lh"
alias la="ls -la"
alias sl="ls"
alias l="ls"
alias s="ls"

El historial puede ser muy útil, pero de manera predeterminada en la mayoría de las distribuciones, cada historial que sale se desvanece, y para empezar no tiene mucho. Me gusta tener 10,000 líneas de historia:

export HISTFILESIZE=20000
export HISTSIZE=10000
shopt -s histappend
# Combine multiline commands into one in history
shopt -s cmdhist
# Ignore duplicates, ls without options and builtin commands
HISTCONTROL=ignoredups
export HISTIGNORE="&:ls:[bf]g:exit"

De esa manera, si sé que he hecho algo antes pero no puedo recordar los detalles, un rápido history | grep fooayudará a refrescar mi memoria.

A menudo me encontraba canalizando la salida awkpara obtener una determinada columna de la salida, como df -h | awk '{print $2}'para encontrar el tamaño de cada uno de mis discos. Para facilitar esto, creé una función fawken mi .bashrc:

function fawk {
    first="awk '{print "
    last="}'"
    cmd="${first}\$${1}${last}"
    eval $cmd
}

Ahora puedo ejecutar lo df -h|fawk 2que ahorra un poco de tipeo.

Si necesita especificar un delimitador ( por ejemplo , awk -F:para /etc/passwd), esta función obviamente no puede manejar eso. La versión ligeramente revisada en este resumen puede manejar awkargumentos arbitrarios antes del número de campo (pero aún requiere la entrada de stdin).

GPG cifrado bashrc

Estoy seguro de que todos tenemos cosas que nos gustaría poner en nuestro bashrc que no queremos que los sudoers puedan leer fácilmente. Mi solución a esto es:

if [ -f ~/.bash_private.gpg ]; then
   eval "$(gpg --decrypt ~/.bash_private.gpg 2>/dev/null)"
fi

Tengo un agente GPG que lo hace, así que solo tengo que ingresar la contraseña de mi clave privada una vez cada pocas horas. Aún debe confiar en los usuarios del sistema porque sus variables, funciones y alias que defina podrían extraerse de la RAM. Sin embargo, uso esto principalmente para mi computadora portátil. Si se lo roban, no quiero que alguien vea fácilmente cosas como:

alias MYsql='mysql -uadmin -psecret'
wglatest(){ wget -O https://admin:secret@server.com/latest; }

Este es un recurso increíble para esto:

muéstranos tu .bashrc

Solía ​​configurarlos en todo el lugar, pero luego me di cuenta de que era mejor recordar cómo hacerlos 'manualmente' porque significaba que 1) entendería completamente lo que estaba sucediendo y 2) tendría acceso a estas capacidades incluso si mi .bashrc personalizado no estaba instalado.

Lo único que uso alias para estos días es reducir el tipeo repetitivo de líneas realmente largas (por ejemplo alias myhost='ssh -T user@my.remote.host screen -dAr') .

Los liners y los pequeños guiones por ahí podrían continuar para siempre. Recomiendo man bash y escribir cosas tú mismo. Algunas buenas cosas cortas de bash en http://www.commandlinefu.com . Aquí hay algunas cosas.

#use extra globing features. See man bash, search extglob.
shopt -s extglob
#include .files when globbing.
shopt -s dotglob
#When a glob expands to nothing, make it an empty string instead of the literal characters.
shopt -s nullglob
# fix spelling errors for cd, only in interactive shell
shopt -s cdspell
# vi mode
set -o vi

s() { # do sudo, or sudo the last command if no argument given
    if [[ $# == 0 ]]; then
        sudo $(history -p '!!')
    else
        sudo "$@"
    fi
}

prompt_command() {
    p=$PWD  # p is much easier to type in interactive shells
    # a special IFS should be limited to 1 liners or inside scripts.
    # Otherwise it only causes mistakes.
    unset IFS
}
PROMPT_COMMAND=prompt_command


# smart advanced completion, download from
# http://bash-completion.alioth.debian.org/
if [[ -f $HOME/local/bin/bash_completion ]]; then
    . $HOME/local/bin/bash_completion
fi


extract () { # extract files. Ignore files with improper extensions.
    local x
    ee() { # echo and execute
        echo "$@"
        $1 "$2"
    }
    for x in "$@"; do
        [[ -f $x ]] || continue
        case "$x" in
            *.tar.bz2 | *.tbz2 )    ee "tar xvjf" "$x"  ;;
            *.tar.gz | *.tgz ) ee "tar xvzf" "$x"   ;;
            *.bz2 )             ee "bunzip2" "$x"   ;;
            *.rar )             ee "unrar x" "$x"   ;;
            *.gz )              ee "gunzip" "$x"    ;;
            *.tar )             ee "tar xvf" "$x"   ;;
            *.zip )             ee "unzip" "$x"     ;;
            *.Z )               ee "uncompress" "$x" ;;
            *.7z )              ee "7z x" "$x"      ;;
        esac
    done
}

Un pequeño consejo para Bash si eres un administrador de sistemas y trabajas mucho con privilegios de root:

shopt -o noclobber

Esto evitará que destruyas accidentalmente el contenido de un archivo ya existente si redirige la salida (> nombre de archivo). Siempre puede forzar la sobrescritura con> | nombre de archivo.

Tengo lo siguiente en mi bashrc

function __setprompt {
  local BLUE="\[\033[0;34m\]"
  local NO_COLOUR="\[\033[0m\]"
  local SSH_IP=`echo $SSH_CLIENT | awk '{ print $1 }'`
  local SSH2_IP=`echo $SSH2_CLIENT | awk '{ print $1 }'`
  if [ $SSH2_IP ] || [ $SSH_IP ] ; then
    local SSH_FLAG="@\h"
  fi
  PS1="$BLUE[\$(date +%H:%M)][\u$SSH_FLAG:\w]\\$ $NO_COLOUR"
  PS2="$BLUE>$NO_COLOUR "
  PS4='$BLUE+$NO_COLOUR '
}
__setprompt

En una máquina local se ve así:

[17:57][user:~]$

pero en un control remoto (a través de ssh) es:

[17:57][user@machine:~]$

He tenido esto en mi .bashrc por un tiempo y lo he encontrado útil. Si está entrando en la casilla, la pantalla de inicio se inicia automáticamente cuando inicia sesión, de esa manera cuando su conexión de red se interrumpe o lo que sea, no pierde lo que estaba haciendo. Debe colocarse al final.

if [ "$PS1" != "" -a "${STARTED_SCREEN:-x}" = x  -a "${SSH_TTY:-x}" != x ]
then
STARTED_SCREEN=1 ; export STARTED_SCREEN
[ -d $HOME/lib/screen-logs ] || mkdir -p $HOME/lib/screen-logs

sleep 1
screen -U -RR && exit 0

echo "Screen failed! continuing with normal bash startup"
fi

¿Cuántos alias fortunenecesitas, de todos modos?

Me gusta hacer un cddalias que me lleve a donde sea que esté trabajando en ese servidor.

PATHLa redefinición realmente pertenece .bash_profile, no .bashrc.

En un servidor donde uso habitualmente un gran conjunto de screens, mi .bashrctendrá:

alias s1="screen -dr chaos1"
alias s2="screen -dr chaos2"
alias s3="screen -dr chaos3"
# ... and so on

(Los screens se configuraron con, por ejemplo, screen -U -S chaos1).

Entre otras cosas, configuro algunos valores predeterminados por menos, evito cerrar accidentalmente mi terminal y habilito la navegación hacia adelante a través del historial:

# ignore case, long prompt, exit if it fits on one screen, allow colors for ls and grep colors
export LESS="-iMFXR"

# must press ctrl-D 2+1 times to exit shell
export IGNOREEOF="2"

# allow ctrl-S for history navigation (with ctrl-R)
stty -ixon

Tengo algunos bits:

# stop the pc speaker ever annoying me :)
setterm -bfreq 0

# don't put duplicate lines in the history. See bash(1) for more options
HISTCONTROL=ignoredups
# ... and ignore same sucessive entries.
HISTCONTROL=ignoreboth

# Expand the history size
HISTFILESIZE=10000 
HISTSIZE=100

# commands with leading space do not get added to history
HISTCONTROL=ignorespace

# am I on the internet?
alias p4='ping 4.2.2.2 -c 4'

# pwsafe
alias pw='pwsafe -p'

# ls aliases
alias ll='ls -l'
alias la='ls -A'
alias l='ls -CF'
alias lt='ls -laptr' #oldest first sort
alias labc='ls -lap' #alphabetical sort

# cd aliases
alias ..='cd ..'
alias ...='cd ../..'
alias ....='cd ../../..'

# cd into the old directory
alias bd='cd "$OLDPWD"'

# install a package and automatically respond yes to confirmation prompt
alias ins="sudo aptitude install"

# remove a package and its configuration files
alias remp="sudo aptitude purge"

# search for a package - apt-cache and aptitude search in different ways
# so have both
alias searchc="apt-cache search"
alias search="aptitude search"
alias show="aptitude show"

Cola todos los registros en / var / log

alias logs="find /var/log -type f -exec file {} \; | grep 'text' | cut -d' ' -f1 | sed -e's/:$//g' | grep -v '[0-9]$' | xargs tail -f"

Para tener colores para todos los comandos grep como grep, egrep y zgrep, tengo lo siguiente en mi .bashrc

export GREP_OPTIONS='--color=auto'

¡El alias de 'carpetas' es genial! Lo modifiqué un poco para que los directorios con espacios no causen errores.

alias folders='find . -maxdepth 1 -type d -print0 | xargs -0 du -sk | sort -rn'

Me gustaría repetir el comentario de @ pjz sobre saber las cosas manualmente en lugar de configurarlas. Especialmente si accedes a numerosas máquinas, como siempre parece que hago.

Entonces, uno que definitivamente sé es set -o viporque conozco los comandos de edición de vi en bash y no sé los de emacs (además, Ctrl + A interfiere con screen). En mis propias cajas, puse eso en.bashrc

También encuentro que tengo que incluir export EDITOR=vimporque una serie de distribuciones recientes están predeterminadas en nano, lo que es más molesto para una utilidad que necesita que edites algo, cuando esperaba vi. : - /

También modifico mi aviso. Descubrí hace mucho tiempo que agregar el último código de error es lo suficientemente útil como para que me guste. Y me gusta la ruta completa en el indicador. Y el screennúmero actual también. Y tiene sentido incluir el usuario actual y el nombre de host. Mi aviso esPS1='\u@\h $PWD $WINDOW [$?] \$ '

Haga que Bash compruebe si el tamaño de la ventana ha cambiado (evita que la edición de línea se vuelva extraña si cambia el tamaño de la ventana de su terminal)

shopt -s checkwinsize

Esta es mi favorita. Hace que bash se agregue al historial en lugar de sobrescribirlo . Por lo general, cuando inicia bash, carga el historial en la memoria y, cuando lo cierra, lo escribe. Esto significa que si carga dos shells, use ambos, luego cierre ambos, el último que cerró sobrescribe todos los cambios.

Este fragmento hace que, en primer lugar, solo agregue cambios (en lugar de sobrescribir con todo el búfer) y luego haga que, después de cada comando, escriba los cambios. En efecto, obtienes una actualización en vivo .bash_history, por lo que si comienzas una nueva terminal, tienes todos los comandos del historial de tus otras sesiones en ejecución.

shopt -s histappend
PROMPT_COMMAND='history -a'

Shell-fu.org .bashrc 's colección

Aquí hay minas:

export HISTCONTROL=ignoredups
export HISTIGNORE="&:ls:bg:fg"

# set variable identifying the chroot you work in (used in the prompt below)
if [ -z "$debian_chroot" ] && [ -r /etc/debian_chroot ]; then
    debian_chroot=$(cat /etc/debian_chroot)
fi

# shows you if you are in a chroot or in a git repository
PS1='${debian_chroot:+($debian_chroot)}\[\033[01;30m\]\h\[\033[00m\]:\[\033[01;34m\]\W\[\033[00m\]$(__git_ps1)\$ '


if [ -f /etc/bash_completion ]; then
    . /etc/bash_completion
fi

# two handy single-letter aliases

alias u='ls -hltr'
alias e='du * -cs | sort -nr | head'
alias g='grep -C5 --color=auto'

# creates a temp dir and cds into it
alias td='pushd $(mktemp -d)'

# find <dir> <file name regexp> <file contents regexp>
function fing { find "$1" -name "$2" -exec grep -H "$3" "{}" \; }

# shows "git diff" across any project in any subdirectory
alias git-differ='for g in $(find . -name ".git"); do g=${g%%.git};printf "$g\t\t\t";pu $g >/dev/null && git diff |wc -l; p >/dev/null; done'

# does git house keeping across any project in any subdirectory
alias git-housekeep='for g in $(find . -name ".git"); do g=${g%%.git};echo $g;pu $g && git repack && git gc --auto && p;done'

# Debian update
alias apg='aptitude update && aptitude dist-upgrade && aptitude clean'

# Quick way to serve files in HTTP from the local dir
alias webs='python -m SimpleHTTPServer'

Estos son mis favoritos:

export HISTFILESIZE=1000000000
export HISTSIZE=1000000

Me gusta tener un historial de línea de comandos que nunca se olvida.

Desafortunadamente, hace un tiempo lancé un shell de cron que no leía .bashrc de alguna manera, y corté todo a 500 líneas, destruyendo la historia de un año. Así que recomiendo que vayan en / etc / bashrc.

Aquí están algunos de mis favoritos:

alias ls='ls -F --color=auto'
alias l='ls'
alias ll='ls -ahl'
alias ..='cd ..'
alias ...='cd ../..'
alias mv='mv -i'

mkcd() {
        if [ $# != 1 ]; then
                echo "Usage: mkcd <dir>"
        else
                mkdir -p $1 && cd $1
        fi
}

# Git related
alias gs='git status'
alias gc='git commit'
alias ga='git add'
alias gd='git diff'
alias gb='git branch'
alias gl='git log'
alias gsb='git show-branch'
alias gco='git checkout'
alias gg='git grep'
alias gk='gitk --all'
alias gr='git rebase'
alias gri='git rebase --interactive'
alias gcp='git cherry-pick'
alias grm='git rm'

Lo uso aproximadamente 20 veces al día para crear un CD en el último directorio modificado:

cl()
{
        last_dir="$(ls -Frt | grep '/$' | tail -n1)"
        if [ -d "$last_dir" ]; then
                cd "$last_dir"
        fi
}

Estos dos mantienen marcadores permanentes de directorios de uso frecuente:

rd(){
    pwd > "$HOME/.lastdir_$1"
}

crd(){
        lastdir="$(cat "$HOME/.lastdir_$1")">/dev/null 2>&1
        if [ -d "$lastdir" ]; then
                cd "$lastdir"
        else
                echo "no existing directory stored in buffer $1">&2
        fi
}

De la automatización de la administración de Linux y Unix por Kirk Bauer (¡gran libro!)

PS1='\n[\u@\h]: \w\n$?> '

La nueva línea al principio es mía, me gusta tener una línea clara entre la salida anterior y la solicitud. El resto es:

\ u = nombre de usuario

\ h = host

\ w = directorio de trabajo

PS = último código de retorno

Compilo varias cosas manualmente en $ HOME / local, así que tengo este pequeño fragmento:

for prog in $HOME/local/*
do
    if [ -d "$prog/bin" ]; then
        export PATH=$prog/bin:$PATH
    fi
    if [ -d "$prog/include" ]; then
        export C_INCLUDE_PATH=$prog/include:$C_INCLUDE_PATH
    fi
    if [ -d "$prog/lib" ]; then
        export LD_LIBRARY_PATH=$prog/lib:$LD_LIBRARY_PATH
        export LIBRARY_PATH=$prog/lib:$LIBRARY_PATH
    fi
    if [ -d "$prog/man" ]; then
        export MANPATH=$prog/man:$MANPATH
    fi
    if [ -d "$prog/share/man" ]; then
        export MANPATH=$prog/share/man:$MANPATH
    fi
done

También tengo mi cliente IRC en mi servidor ejecutándose en la pantalla, así que tengo esto (no es una cosa .bashrc, pero aún es útil)

#!/usr/bin/env bash

RUNNING=`screen -ls | grep irc`
if [ "" = "$RUNNING" ]; then
   screen -S irc irssi
else
   screen -dr irc
fi

Utilizo mi bashrc en numerosas máquinas, así que tengo este pequeño fragmento para asegurarme de que el LS esté coloreado. Esto lo solucionará en máquinas OSX, tal vez incluso * BSD si ajusta la línea uname.

if [ "$TERM" != "dumb" ]; then
    if [ `uname` == "Darwin" ]; then
       alias ls='ls -G'
    else
       eval "`dircolors -b`"
       alias ls='ls --color=auto'
    fi
fi

Además, tengo un comando para hacer una copia de seguridad de un archivo, útil si está a punto de cambiar un archivo de configuración y desea hacer una copia rápida de antemano.

bu () { cp $1 ~/.backup/`basename $1`-`date +%Y%m%d%H%M`.backup ; }

Este es uno de mis favoritos:

alias ssh='if [ "$(ssh-add -l)" = "The agent has no identities." ]; then ssh-add; fi; /usr/bin/ssh "$@"'

Si olvidé autenticar, me permite hacerlo sin tener que desperdiciar mi escritura haciendo ssh-add después de la sesión ssh.

Un par de buenos

Haga que SSH complete automáticamente el nombre de host al que ssh (si está en su configuración o historial)

complete -o default -o nospace -W "$(/usr/bin/env ruby -ne 'puts $_.split(/[,\s]+/)[1..-1].reject{|host| host.match(/\*|\?/)} if $_.match(/^\s*Host\s+/);' < $HOME/.ssh/config)" scp sftp ssh

Algunas configuraciones útiles para completar bash

bind "set completion-ignore-case on" # note: bind used instead of sticking these in .inputrc
bind "set bell-style none" # no bell
bind "set show-all-if-ambiguous On" # show list automatically, without double tab

Algunos útiles para Mac OS X

alias nospotlight='sudo mdutil -a -i off'
alias cleardnscache='sudo killall -HUP mDNSResponder'
alias ldd='otool -L'
alias seq='jot - '
alias eject='drutil eject'