Existe algo que você não pode viver sem e tornará minha vida muito mais fácil? Aqui estão algumas que eu uso ('diskspace' e 'folders' são particularmente úteis).

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

Eu tenho um pequeno script que extrai arquivos, encontrei-o em algum lugar na rede:

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 eu uso tantas máquinas diferentes, o meu .bashrcsempre define o prompt de comando para incluir, entre outras coisas, o nome do servidor no qual estou conectado no momento. Dessa forma, quando eu tenho três níveis de profundidade no telnet / ssh, não digito a coisa errada na janela errada. É realmente uma merda rm -rf .na janela errada! (Nota: Em casa, o telnet está desativado em todas as máquinas. No trabalho, o ssh nem sempre está ativado e não tenho acesso root a muitas máquinas.)

Eu tenho um script ~/bin/setpromptque é executado pelo meu .bashrc, que contém:

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

Esse script define o prompt como o nome do host, seguido por :)se o último comando foi bem-sucedido e :(se o último comando falhou.

A cor das páginas de manual em menos facilita a leitura das páginas de manual:

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'

Páginas de manual coloridas também podem ser obtidas instalando a maioria e usando-a como variável de ambiente MANPAGER. Se você deseja usar este pager não apenas para o homem, use a variável PAGER, assim:

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

Não há mais cd ../../../ .. mas até 4

Aumenta muitos diretórios conforme o número passado como argumento, se nenhum aumenta 1 por padrão (encontrado em um link em um comentário no stackoverflow.com e modificado um pouco)

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
}

Eu lido com muitas máquinas diferentes, então uma das minhas favoritas são aliases para cada máquina que eu preciso fazer SSH frequentemente para:

alias claudius="ssh dinomite@claudius"

Também é útil configurar teclas boas .ssh/confige ssh para tornar o salto entre máquinas ainda mais fácil.

Outro dos meus apelidos favoritos é para mover diretórios:

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

E alguns para variações comumente usadas de ls(e erros de digitação):

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"

O histórico pode ser muito útil, mas, por padrão, na maioria das distribuições, seu histórico é deslumbrado com a saída de cada shell e, para começar, não é muito importante. Eu gosto de ter 10.000 linhas de história:

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"

Dessa forma, se eu souber que já fiz algo antes, mas não consigo lembrar os detalhes, um rápido history | grep fooajudará a estimular minha memória.

Muitas vezes eu me via canalizando a saída awkpara obter uma determinada coluna da saída, como df -h | awk '{print $2}'para encontrar o tamanho de cada um dos meus discos. Para facilitar isso, criei uma função fawkno meu .bashrc:

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

Agora posso executar o df -h|fawk 2que economiza um pouco de digitação.

Se você precisar especificar um delimitador ( por exemplo , awk -F:para /etc/passwd), essa função obviamente não pode lidar com isso. A versão ligeiramente revisada nesta essência pode lidar com awkargumentos arbitrários antes do número do campo (mas ainda requer a entrada de stdin).

Bashrc criptografado em GPG

Tenho certeza de que todos temos coisas que gostaríamos de colocar em nosso bashrc que não queremos que sejam facilmente legíveis por sudoers. Minha solução para isso é:

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

Eu tenho um agente GPG que faz isso, então só tenho que digitar a senha da minha chave privada uma vez a cada poucas horas. Você ainda precisa confiar um pouco nos usuários do sistema, porque suas variáveis, funções e aliases que você define podem ser extraídos da RAM. No entanto, eu uso isso principalmente para o meu laptop. Se for roubado, não quero que alguém veja facilmente coisas como:

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

este é um recurso incrível para isso:

mostre-nos seu .bashrc

Eu costumava configurá-las em todo o lugar, mas depois percebi que era melhor lembrar como fazê-las 'manualmente', porque isso significava que 1) entenderia completamente o que estava acontecendo e 2) teria acesso a esses recursos, mesmo que meu .bashrc personalizado não foi instalado.

A única coisa que uso aliases atualmente é reduzir a digitação repetitiva de linhas realmente longas (por exemplo, alias myhost='ssh -T user@my.remote.host screen -dAr')

Os liners e pequenos scripts por aí poderiam continuar para sempre. Eu recomendo o homem bash e escrever as coisas você mesmo. Algumas boas coisas curtas sobre bash em http://www.commandlinefu.com . Aqui estão algumas coisas.

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

Uma pequena dica para o Bash se você é um administrador de sistemas e trabalha muito com privilégios de root:

shopt -o noclobber

Isso impedirá que você destrua acidentalmente o conteúdo de um arquivo já existente, se você redirecionar a saída (> nome do arquivo). Você sempre pode forçar a substituição com> | filename.

Eu tenho o seguinte no meu 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

Em uma máquina local, ele se parece com:

[17:57][user:~]$

mas em um controle remoto (através do ssh) é:

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

Eu tive isso no meu .bashrc por um tempo e achei útil. Se você estiver entrando na caixa, a tela é iniciada automaticamente quando você faz o login, assim quando sua conexão de rede é interrompida ou o que quer que seja, você não perde o que estava fazendo. Deve ser colocado no 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

Quantos aliases fortunevocê precisa, afinal?

Eu gosto de criar um cddalias que me leve a onde quer que eu esteja atualmente trabalhando mais nesse servidor.

PATHredefinição realmente pertence .bash_profile, não .bashrc.

Em um servidor em que eu uso rotineiramente um grande conjunto de screens, meu .bashrcterá:

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

(Os screens foram configurados com, por exemplo screen -U -S chaos1,.)

Entre outras coisas, defino alguns padrões por menos, evito fechar acidentalmente meu terminal e habilito a navegação direta no histórico:

# 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

Eu tenho alguns 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"

Adapte todos os logs em / 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 ter cores para todos os comandos grep, como grep, egrep e zgrep, tenho o seguinte no meu .bashrc

export GREP_OPTIONS='--color=auto'

O alias das 'pastas' é ótimo! Eu o modifiquei um pouco para que diretórios com espaços não causem erros.

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

Eu ecoaria o comentário do @ pjz sobre saber as coisas manualmente, em vez de configurá-las. Especialmente se você acessar várias máquinas, como eu sempre pareço fazer.

Então, um que eu definitivamente conheço é set -o viporque conheço os comandos de edição do vi no bash e não conheço os do emacs (além disso, Ctrl + A interfere screen). Em minhas próprias caixas, eu coloquei isso.bashrc

Também acho que tenho que incluir, export EDITOR=vimporque várias distribuições recentes são padronizadas para nano, o que é mais irritante para ser jogado por um utilitário que precisa que você edite algo, quando eu esperava o vi. : - /

Eu também altero meu prompt. Descobri há muito tempo que adicionar o último código de erro é útil o suficiente para que eu goste. E eu gosto do nome completo do caminho no prompt. E o screennúmero atual também. E faz sentido incluir o usuário e o nome do host atuais. Meu prompt éPS1='\u@\h $PWD $WINDOW [$?] \$ '

Faça uma verificação do bash para ver se o tamanho da janela mudou (evita que a edição de linhas fique estranha se você redimensionar a janela do terminal)

shopt -s checkwinsize

Este é meu favorito. Faz com que o bash seja anexado ao histórico em vez de substituí- lo. Normalmente, quando você inicia o bash, ele carrega o histórico na memória e, quando você o fecha, o grava. Isso significa que, se você carregar duas conchas, use as duas e feche as duas, a última que você fechou substituirá todas as alterações.

Esse trecho faz com que, antes de tudo, apenas acrescente alterações (em vez de sobrescrever com todo o buffer) e, em seguida, faça com que, após cada comando, escreva as alterações. Na verdade, você obtém um .bash_history com atualização ao vivo; portanto, se você iniciar um novo terminal, terá todos os comandos do histórico de outras sessões em execução.

shopt -s histappend
PROMPT_COMMAND='history -a'

Shell-fu.org .bashrc 's coleção

Aqui estão as 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'

Estes são os meus favoritos:

export HISTFILESIZE=1000000000
export HISTSIZE=1000000

Eu gosto de ter um histórico de linha de comando que nunca esquece.

Infelizmente, algum tempo atrás, lancei um shell do cron que não lia .bashrc de alguma forma e reduzi tudo para 500 linhas, destruindo ao longo de um ano de história. Então, eu recomendo que eles usem / etc / bashrc.

Aqui estão alguns dos meus 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'

Eu uso isso cerca de 20 vezes por dia para entrar no último diretório alterado:

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

Esses dois mantêm marcadores permanentes de diretórios usados ​​com freqüência:

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 Automatizando a Administração Linux e Unix por Kirk Bauer (ótimo livro!)

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

A nova linha no início é minha, eu gosto de ter uma linha clara entre a saída anterior e o prompt. O resto é:

\ u = nome de usuário

\ h = host

\ w = diretório de trabalho

$? = último código de retorno

Eu compilo várias coisas manualmente em $ HOME / local, então tenho este pequeno trecho:

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

Eu também tenho meu cliente IRC no meu servidor rodando na tela, então eu tenho isso (não é uma coisa .bashrc, mas ainda é útil)

#!/usr/bin/env bash

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

Eu uso meu bashrc em várias máquinas, então eu tenho esse pequeno trecho para garantir que o LS seja colorido. Isso irá corrigi-lo em máquinas OSX, talvez até * BSD se você ajustar a linha de uname.

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

Além disso, eu tenho um comando para fazer backup de um arquivo, útil se você estiver prestes a alterar um arquivo de configuração e quiser fazer uma cópia rápida antes da mão.

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

Este é um dos meus favoritos:

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

Se eu esqueci de me autenticar, isso permite que eu faça isso sem ter que desperdiçar minha digitação fazendo o ssh-add após a sessão ssh.

Alguns bons

Faça com que o SSH complete automaticamente o nome do host para o qual você ssh (se estiver em sua configuração ou histórico)

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

Algumas configurações úteis de conclusão do 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

Alguns úteis para o 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'