Comparta sus características y trucos de la línea de comandos para Unix/Linux. Intente mantenerlo agnóstico de Shell/distro si es posible. Interesado en ver alias, líneas simples, atajos de teclado, pequeños scripts de Shell, etc.
Esto se expande un poco en el !!
truco mencionado en esta respuesta . En realidad, hay un montón de comandos relacionados con la historia que tienden a olvidarse (las personas tienden a apuñalar Up 100 veces buscando un comando que saben que escribieron).
history
mostrará una lista de comandos ejecutados recientemente con un designador de eventos a la izquierda!N
sustituirá el comando asociado con el designador de eventos N
!-N
sustituirá a N
th comando más reciente; p.ej. !-1
sustituirá el comando más reciente, !-2
el segundo más reciente, etc.!!
es la abreviatura de !-1
, para sustituir rápidamente el último comando!string
sustituirá el comando más reciente que comienza con string
!?string?
sustituirá el comando más reciente que contiene string
Los designadores de palabras se pueden agregar a un !
comando de historial para modificar los resultados. Los dos puntos separan el evento y los designadores de Word, p. !!:0
. El designador del evento !!
se puede abreviar a solo !
cuando se usa un designador de Word, entonces !!:0
es equivalente a !:0
.
!:0
obtendrá el comando que se ejecutó!:1
obtendrá el primer argumento (y !:2
el segundo, etc.)!:2-3
obtendrá el segundo y tercer argumento!:^
es otra forma de obtener el primer argumento. !:$
obtendrá el último!:*
obtendrá todos los argumentos (pero no el comando)Los modificadores también se pueden agregar a un !
comando de historial, cada uno precedido por dos puntos. Se puede apilar cualquier número (por ejemplo, !:t:r:p
).
h
- En línea con el nombre del archivo baset
- Solo el nombre de archivo baser
- En línea con la extensión del nombre del archivoe
- Solo la extensión del nombre del archivos/search/replacement
- Reemplace la primera aparición de search
con replacement
gs/search/replacement
- Reemplace todas las apariciones de search
con replacement
bash - inserta el parámetro final de la línea anterior
alt-. la combinación de teclas más útil que haya existido, pruébela y vea, por alguna razón, nadie sabe sobre esta.
presiónelo una y otra vez para seleccionar los últimos parámetros anteriores.
genial cuando quieres hacer algo más al argumento/archivo que usaste hace un momento.
Mi favorito es
man 7 ascii
Simple y muy útil.
Oct Dec Hex Char Oct Dec Hex Char
────────────────────────────────────────────────────────────────────────
000 0 00 NUL '\0' (null character) 100 64 40 @
001 1 01 SOH (start of heading) 101 65 41 A
002 2 02 STX (start of text) 102 66 42 B
003 3 03 ETX (end of text) 103 67 43 C
004 4 04 EOT (end of transmission) 104 68 44 D
005 5 05 ENQ (enquiry) 105 69 45 E
006 6 06 ACK (acknowledge) 106 70 46 F
007 7 07 BEL '\a' (bell) 107 71 47 G
010 8 08 BS '\b' (backspace) 110 72 48 H
011 9 09 HT '\t' (horizontal tab) 111 73 49 I
012 10 0A LF '\n' (new line) 112 74 4A J
013 11 0B VT '\v' (vertical tab) 113 75 4B K
014 12 0C FF '\f' (form feed) 114 76 4C L
015 13 0D CR '\r' (carriage ret) 115 77 4D M
016 14 0E SO (shift out) 116 78 4E N
017 15 0F SI (shift in) 117 79 4F O
020 16 10 DLE (data link escape) 120 80 50 P
021 17 11 DC1 (device control 1) 121 81 51 Q
022 18 12 DC2 (device control 2) 122 82 52 R
023 19 13 DC3 (device control 3) 123 83 53 S
024 20 14 DC4 (device control 4) 124 84 54 T
025 21 15 NAK (negative ack.) 125 85 55 U
026 22 16 SYN (synchronous idle) 126 86 56 V
027 23 17 ETB (end of trans. blk) 127 87 57 W
030 24 18 CAN (cancel) 130 88 58 X
031 25 19 EM (end of medium) 131 89 59 Y
032 26 1A SUB (substitute) 132 90 5A Z
033 27 1B ESC (escape) 133 91 5B [
034 28 1C FS (file separator) 134 92 5C \ '\\'
035 29 1D GS (group separator) 135 93 5D ]
036 30 1E RS (record separator) 136 94 5E ^
037 31 1F US (unit separator) 137 95 5F _
040 32 20 SPACE 140 96 60 `
041 33 21 ! 141 97 61 a
042 34 22 " 142 98 62 b
043 35 23 # 143 99 63 c
044 36 24 $ 144 100 64 d
045 37 25 % 145 101 65 e
046 38 26 & 146 102 66 f
047 39 27 ' 147 103 67 g
050 40 28 ( 150 104 68 h
051 41 29 ) 151 105 69 i
052 42 2A * 152 106 6A j
053 43 2B + 153 107 6B k
054 44 2C , 154 108 6C l
055 45 2D - 155 109 6D m
056 46 2E . 156 110 6E n
057 47 2F / 157 111 6F o
060 48 30 0 160 112 70 p
061 49 31 1 161 113 71 q
062 50 32 2 162 114 72 r
063 51 33 3 163 115 73 s
064 52 34 4 164 116 74 t
065 53 35 5 165 117 75 u
066 54 36 6 166 118 76 v
067 55 37 7 167 119 77 w
070 56 38 8 170 120 78 x
071 57 39 9 171 121 79 y
072 58 3A : 172 122 7A z
073 59 3B ; 173 123 7B {
074 60 3C < 174 124 7C |
075 61 3D = 175 125 7D }
076 62 3E > 176 126 7E ~
077 63 3F ? 177 127 7F DEL
Echa un vistazo a este sitio web commandlinefu.com .
También puedes echar un vistazo a estos cuatro artículos de Peteris Krumins en su blog.
Ejecute el último comando como root:
Sudo !!
No estoy seguro si esto cuenta como un "truco", pero la gente parece desconocer las teclas de acceso rápido estándar de readline. De uso particular en conchas:
CTRL+R en BASH para buscar/activar comandos ejecutados previamente (el contenido de ~/.bash_history).
Esto a menudo es extremadamente útil. Ejecutar este alias servirá el PWD a través de HTTP (indexado) en el puerto 8000:
alias webserver="python -m SimpleHTTPServer"
Y debido a que corro make todo el tiempo, y spaz y tecleo demasiado rápido, estos alias son probablemente los más utilizados (en serio):
alias maek=make
alias mkae=make
alias meak=make
alias amka=make
alias akme=make
Y probablemente mi pieza más utilizada de BASH es un script simple que llamo upload. Lo uso para enviar cualquier tipo de contenido a mi Linode, y copia la URL HTTP resultante en mi portapapeles (clic central). Muy útil para pegar cosas a personas en IRC:
scp -r $* [email protected]$Host:public_html && {
URL="http://$Host/~$user/$(basename $1)"
echo "$URL"
xselection -replace PRIMARY "$URL"
}
Solo un par. Puedo publicar mucho más tarde, ¡debo volver al trabajo!
diff
la salida de dos comandos sin crear un archivo temporal manualmente (bash):
diff <(ls dir1) <(ls dir2)
Bastante básico, pero la gente no parece saberlo, te devuelve al directorio anterior:
cd -
La expansión de llaves es un mecanismo por el cual se pueden generar cadenas arbitrarias.
Le permite reemplazar líneas tediosas como:
mv loong/and/complex/file/name loong/and/complex/file/name.bacukup
con una instancia más corta
mv loong/and/complex/file/name{,backup}
¡algunos otros usos
# to display the diff between /etc/rc.conf and /etc/rc.conf.pacsave
diff /etc/rc.conf{,.pacsave}
# to list files in both /usr/share and /usr/local/share
ls /usr/{,local}/share
Expansión aritmética :
La expansión aritmética permite la evaluación de una expresión aritmética y la sustitución del resultado. El formato para la expansión aritmética es:
$((expression))
La expresión se trata como si estuviera entre comillas dobles, pero una comilla doble entre paréntesis no se trata especialmente. Todos los tokens en la expresión experimentan expansión de parámetros, expansión de cadena, sustitución de comandos y eliminación de comillas. Las expansiones aritméticas pueden estar anidadas.
$ a=1
$ b=2
$ echo $(( a+(b*2) ))
5
Esto suele estar en mi script de inicio (.bashrc, .profile, lo que sea)
shopt
bondad, revisa los comentarios:
shopt -s cdspell # try to correct typos in path
shopt -s dotglob # include dotfiles in path expansion
shopt -s hostcomplete # try to autocomplete hostnames
Un alias que guarda las pulsaciones de teclas: mkdir
y cd
en él:
mkcd () { mkdir -p "[email protected]" && cd "[email protected]"; }
Y por último, pero no menos importante, he renunciado a memorizar la sintaxis del alquitrán, así que:
extract () {
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 ;;
*) echo "'$1' cannot be extracted via extract()" ;;
esac
else
echo "'$1' is not a valid file"
fi
}
Dos funciones bash que me ahorran muchas pulsaciones de teclas.
Haga automáticamente un ls después de cada cd exitoso:
function cd {
builtin cd "[email protected]" && ls
}
Sube n niveles:
# Usage .. [n]
function .. (){
local arg=${1:-1};
local dir=""
while [ $arg -gt 0 ]; do
dir="../$dir"
arg=$(($arg - 1));
done
cd $dir #>&/dev/null
}
Como generalmente estoy a mitad de camino en una línea de comando antes de querer buscar (CTRL-R en bash) tengo lo siguiente en mi .bashrc
bind '"\e[A"':history-search-backward
bind '"\e[B"':history-search-forward
Esto significa que si escribo cd y luego presiono arriba/abajo, puedo ver todas las opciones a las que he hecho cd. Básicamente, uso esto para directorios de uso frecuente. Como "cd w" y termino revisando todos los espacios de trabajo que uso mucho.
Una cosa que me ahorra mucho tiempo son los comandos pushd/popd. Estos chicos te permiten crear una pila de directorios y reducir mucho la escritura:
/foobar/ > pushd /src/whatever/foo/test
/foobar/src/whatever/foo/test > make run
/foobar/src/whatever/foo/test > popd
/foobar/ > make
El screen
comando . Básicamente guarda su sesión de línea de comando para cuando regrese. Es una especie de administrador de terminales, como un administrador de ventanas. De esa manera, en una sola sesión de terminal, puede tener múltiples terminales virtuales en funcionamiento. Es muy genial.
Si uno usa screen
, esta función Shell (póngala en .bashrc
) es extremadamente útil:
function scr {
if screen -ls | grep -q Main; then
# reattach to Main:
screen -xr Main
else
# name session "Main":
screen -S Main
fi
}
al escribir scr
, verificará si su sesión principal existe y se adjuntará a ella. De lo contrario, lo creará.
Si necesita editar una línea de comando particularmente larga en bash
^X^E (Ctrl-X Ctrl-E)
lo abrirá en el editor ($ EDITOR).
En zsh puede obtener el mismo comportamiento agregando esto a .zshrc:
autoload edit-command-line
zle -N edit-command-line
bindkey '^X^e' edit-command-line
Si usted es un mecanógrafo rápido, estos son útiles:
alias grpe='grep --color=tty'
alias gpre='grep --color=tty'
alias rgep='grep --color=tty'
alias gerp='grep --color=tty'
Esta macro le ayuda a calcular los totales de una columna de salida: tamaños de archivo, bytes, paquetes, todo lo que tiene que hacer es especificar la columna que desea agregar:
total ()
{
if [ x$1 = x ]; then set `echo 1`; fi
awk "{total += \$$1} END {print total}"
}
Lo usa así, por ejemplo, sin argumentos, agrega el total de la primera columna:
du | total
Si proporciona el argumento, sumará esa columna, por ejemplo, esto le da el número total de bytes utilizados por todos los archivos C # en/tmp:
ls -l /tmp/*cs | total 5
A veces, su consola se estropea porque accidentalmente vio un archivo binario (cat/bin/ls, por ejemplo), puede restaurar el terminal con esta función de Shell:
restaura ()
{
Perl -e 'print "\e)B";'
}
Me gusta que mi ls use caracteres para distinguir la clase de archivos y también para ocultar los archivos de respaldo generados por mi editor (los archivos de respaldo terminan con el carácter ~):
alias ls='ls -FB'
alias s='Sudo'
alias r='rake' # i'm a Ruby developer
alias ..='cd ..' # although with autocd feature for zsh this comes packed.
Uno de mis favoritos cuando olvido s
:
$ s !! # last command with super user priviledges
Si un comando toma una entrada estándar, puede leer la entrada de un archivo con <filename
. Esto puede aparecer en cualquier parte del comando, por lo que estas líneas son equivalentes:
cat filename
cat <filename
<filename cat
Esto es particularmente útil para grep, ya que le permite colocar la expresión al final de la línea, para que pueda modificar rápidamente un comando grep presionando Up, sin necesidad de desplazarse hacia la izquierda para pasar el nombre del archivo:
<filename grep 'expression'
Puede usar CDPATH
para configurar el directorio equivalente a PATH
; si intentas cd foo
y no hay foo
en el directorio actual, el Shell verificará cada uno de los directorios en CDPATH
buscando foo
en ellos, y cambiará al primero encuentra:
export CDPATH="/usr"
cd bin # switches to 'bin' if there is one in the current directory, or /usr/bin otherwise
vi `which scriptname`
Para cuando no sabes dónde vive algo y tampoco te importa.
El ampersand. Pone su comando en segundo plano, para que pueda seguir escribiendo.
$> Sudo updatedb &
Trabajando juntos, y después de un tiempo ves:
[1] 17403
¡Y tu proceso está hecho! Ideal para cosas en las que no necesita esperar a que terminen.
Completar pestaña. ¿Qué tan mal sería tener que escribir todos los caracteres de cada ruta?
Tengo esto en mi .bashrc
#shortcut for CTRL+C and CTRL+V
alias c-c='xclip -sel clip'
alias c-v='xclip -o -sel clip'
function find-all() {
python -c "import re
import sys
for i in re.findall('$1', sys.stdin.read()):
if type(i) == type(''):
print i
else:
print i[0]"
}
Y cuando tengo el código fuente HTML en el portapapeles y quiero encontrar todos los enlaces que uso
c-v | find-all 'href="([^"]*)"' | c-c
Y tengo todas las URL en el portapapeles
También tengo esta función
function lsq(){
ls -lh [email protected] | tr -s ' ' | cut -d' ' -f5,8
}
qué tamaño de pantalla (legible por humanos) y nombre de archivo.
alias temp='cat /proc/acpi/thermal_zone/THRM/temperature'
este alias es para mostrar la temperatura
function separate() {
python -c "import sys,re; print '$1'.join(re.split('\s*', sys.stdin.read().strip()))";
}
con esta función puedo calcular el producto o la suma de argumentos.
alias sum='separate + | bc'
alias product='separate * | bc'
function split-join() {
python -c "import sys,re; print '$2'.join(re.split('$1', sys.stdin.read().strip()))";
}
Esta es una función útil que divide la entrada estándar separada por expresiones regulares y luego une el resultado.
function factorial() {
seq -s* $1 | bc
}
función factorial
function wiki() { Dig +short txt $1.wp.dg.cx; }
Esta función muestra el texto wiki sobre DNS
También tengo tres funciones de color.
function blue() {
echo -e "\x1b[34m\x1b[1m"[email protected]"\x1b[0m";
}
function green() {
echo -e "\x1b[32m\x1b[1m"[email protected]"\x1b[0m";
}
function red() {
echo -e "\x1b[31m\x1b[1m"[email protected]"\x1b[0m";
}
function md5check() {
test `md5sum $2 | cut -d' ' -f1` = "$1" && green [OK] || red [FAIL]
}
Esta función valida el archivo md5 hash.
esto mostrará un mensaje de error para un código dado
function strerror() { python -c "import os; print os.strerror($1)"; }
Puede imprimir todos los mensajes con
alias all-errors='for i in `seq 131`; do echo -n "$i: "; strerror $i; done'
Desmontar el último dispositivo montado:
mount /media/whatever
...
u!mo
!mo
se expande al último comando que comenzó con mo
(al menos en bash). A veces uno hace mv
en el medio, entonces u!m
no funcionará tan a menudo.
Otro truco útil de ZSH:
Trate la salida de un comando como un archivo:
emacs =(hg cat -r 100 somefile)
Esto abre una versión anterior de un archivo con seguimiento de Mercurial en emacs para una visualización resaltada de sintaxis. Sin eso, tendría que perder el tiempo con hg revert
, hg archive
, o enviar explícitamente hg cat
salida a un archivo temporal.
Por supuesto, esto funciona con cualquier programa que abra archivos y cualquier programa que imprima a la salida estándar.
Una característica específica de ZSH son los alias de sufijo, que se establecen dando alias
the -s
bandera:
alias -s ext=program
Si una extensión dada tiene un alias de sufijo, puede ejecutar un archivo con esa extensión directamente, y ZSH iniciará el programa dado y pasará el nombre del archivo como argumento. Entonces, si el alias anterior está vigente, estas líneas son equivalentes:
/path/to/foo.ext
program /path/to/foo.ext
Una de mis características favoritas de todos los tiempos de ZSH son los directorios con nombre. Puede exportar una variable con un nombre dado, con un valor que apunta a una ruta determinada:
export foo=/usr/bin
Ahora puedes usar ~foo
en un comando para referirse a /usr/bin
:
cd ~foo
~foo/ls
cat ~foo/filename
El comando no hacer nada :
como en
while :; do :; done
Expansión de abrazaderas en combinación con bucles for:
for c in {1..3}; do :; done
!
operador y operadores de cortocircuito ||
y &&
[ -d /tmp/dir ] || mkdir /tmp/dir
if ! ping 34.41.34.1; then :; fi
usando sub shells en lugar de pop/Push (es útil en scripts)
~$ ( cd /tmp; echo $PWD )
/tmp
~$
the kind-of what-is command type
~$ type type
type is a Shell builtin
~$ type ls
ls is aliased to `ls --color=auto'
~$ f(){ :; }
~$ type f
f is a function
f ()
{
:
}
también muy agradable: cuerdas aquí
~$ cat <<<"here $PWD"
here /home/yourname
~$
y mi favorito: redirección en una lista de comandos
{ w; ps; ls /tmp; } 2>/dev/null |less
Vea esto pregunta.
Cuando corres ps ax | grep string
:
[[email protected] ~]$ ps ax | grep 'openbox'
3363 ? Ss 0:00 /usr/bin/openbox
3382 ? Ss 0:00 /usr/bin/ssh-agent -- /usr/bin/openbox-session
3386 ? S 0:00 /bin/sh /usr/bin/openbox-session
3388 ? S 0:00 /bin/sh /usr/bin/openbox-session
3389 ? S 0:00 /bin/sh /usr/bin/openbox-session
3390 ? S 0:00 /bin/sh /usr/bin/openbox-session
5100 pts/0 S+ 0:00 grep openbox
la última línea que contiene grep
es algo un poco molesto
Puedes deshacerte de esto ejecutando ps ax | grep '[s]tring'
:
[[email protected] ~]$ ps ax | grep '[o]penbox'
3363 ? Ss 0:00 /usr/bin/openbox
3382 ? Ss 0:00 /usr/bin/ssh-agent -- /usr/bin/openbox-session
3386 ? S 0:00 /bin/sh /usr/bin/openbox-session
3388 ? S 0:00 /bin/sh /usr/bin/openbox-session
3389 ? S 0:00 /bin/sh /usr/bin/openbox-session
3390 ? S 0:00 /bin/sh /usr/bin/openbox-session
actualizar : o simplemente ejecutar pgrep string
A veces, la configuración de bash es tal que rm
tiene un alias de rm -i
y, por lo tanto, requiere confirmación para cada archivo que se elimina. Cuando trabajo ocasionalmente en dicha cuenta, uso \rm
para recuperar el comportamiento original de rm
sin cambiar la configuración del usuario.
Me encanta meter tantas cosas como puedo en mi PS1. Algunas cosas útiles para recordar:
\e[s
y \e[u
guardar y dejar de guardar la posición del cursor respectivamente. Lo uso para crear una 'barra de información' en la parte superior de la pantalla, un par de líneas de largo, que puede caber más cosas. Ejemplo:
PS1='\[\e[s\e[7m\e[1;1H\]\w\n\t \j / \! / \#\[\e[u\e[0m\e[33;1m\][\[email protected]\h \[\e[34m\]\W]\[\e[0m\]\$ '
Combinar con alias clear='echo -e "\e[2J\n"'
. ¡Pruébalo!
También el Prompt_COMMAND
variable define un comando para ejecutar antes de la PS1 cada vez.
Otro es el comando bg
. Si olvidas poner &
al final de un comando, solo presione ^Z y escriba bg
, y se ejecuta en segundo plano.
Mostrar la rama y el estado de Git en el indicador
exportar GIT_PS1_SHOWDIRTYSTATE = verdadero if ["$ color_Prompt" = yes]; luego PS1 = '$ {debian_chroot: + ($ debian_chroot)}\[\ 033 [01; 32m \]\u @\h\[\ 033 [00m \]:\[\ 033 [01; 34m \]\w\[\ 033 [00m \] $ (__ git_ps1 "#% s")\$ ' Else PS1 =' $ {debian_chroot: + ($ debian_chroot)}\u @\h:\w $ (__ git_ps1 "#% s")\$ ' fi
Mi comando favorito es 'buscar', lo uso en todas partes ... ejemplos:
find . -name "*.log" -exec ls -l {} \; | grep "$(find . -name "*.log" -exec ls -l {} \;| nawk '{print $5}' | sort -n | tail )"
Simplemente muestre los archivos más pesados en formato ls -l (largo).
Luego, si necesita su código con permisos 0640, simplemente busque:
find . \( \( ! -perm 0640 \) -a \( -name "*.cpp" -o -name "*.h" \) \) -ls | nawk '{print $3"\t"$11}'
o reemplazar:
find . \( -name "*.cpp" -o -name "*.h" \) | xargs chmod 640
Entonces, ¿necesitas un símbolo y no sabes dónde está?
(
for myObj in $(find . -name "*.o"); do
gotSym=$(dump -Xany -t $myObj | grep .MY_SYMBOL)
if ! test "x$gotSym" = "x"
then
echo "OBJECT [$myObj] ========================"
echo "$gotSym"
echo "^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^"^
fi
done
)
¿Archivos más nuevos que XFILE?
find . -newer XFILE -type f
Sí, "encontrar" rulez!
Una vez tan a menudo, cuando ha escrito un comando largo y antes de terminarlo, se ha dado cuenta de que no funcionará de inmediato, porque necesita ejecutar otra cosa antes (por ejemplo, ingresó git commit -m "long commit message here"
), puedes presionar ^A^K
para ir al inicio de la línea y matarla (guardar en un búfer), luego ejecutar un comando para arreglar las cosas y finalmente ^Y
para pegar el comando eliminado y continuar. Ahorra mucho reescribiendo. Todo esto, por supuesto, es cuando readline
está en modo Emacs.
Otro ahorro de tiempo: mkdir -p some/nested/dirs/to/be/created
crea todos los directorios en una ruta si faltan.
Muestra un buen arte ascii del árbol de proceso actual, con el proceso más intensivo de CPU resaltado.
while true; do
clear;
pstree $( ps -eo pid --sort %cpu | tail -n 1 );
sleep 1;
done
¡Mátalo con Ctrl + C
Vea la salida del comando actualizada cada n segundos
watch -n 60 df -h (displays df -h every 60 seconds)
Mostrar estadísticas sobre el dispositivo de red wlan0
ip -s link ls wlan0
Mostrar tabla de enrutamiento para el dispositivo eth1
ip route ls dev eth1
Mostrar estadísticas de todos los enrutadores que viajan los paquetes para llegar al Host
mtr --interval 5 HOSTNAME
Consultar registros DNS inversos para nombres de host en RED
nmap -sL NETWORK
Benchmark de un sitio web
ab
Obtenga todos los enlaces de una página web
lynx -dump http://www.yahoo.com | awk '/http/{print $2}'
Mostrar puerta de enlace predeterminada
netstat -rn | awk '/UG/{print $2}'
Escribir error estándar en un archivo
foo 2> errors.txt
Redirigir stderr a stdout
foo 2>&1
Redireccionar stderr y stdout al mismo archivo.
foo > file.txt 2>&1
# change chmod to file dowloaded --> $_
wget -c http://link/to/file -O /path/to/save/namefile && chmod 0755 $_
# extract tar.bz2 or tar.gz whit less work
# this avoids having to unpack and then move the files to another location, in this case have # already extracted in the desired location
tar jxvf file.tar.bz2 -C /pat/to/extract
# calculator with bc - in bashrc
calc(){ echo "scale=2;[email protected]" | bc;}
# set magic-space in bashrc
bind Space:magic-space # !pin<space> expand last cmd pin...
# alias to open last edited file in vim
alias lvim="vim -c \"normal '0\""
# alias to show your path set
alias path='echo -e ${PATH//:/\\n}'
Reemplazar partes del comando anterior:
^
buscar^
reemplazar
$ echo a b c d
a b c d
$ ^b c^X
echo a X d
a X d
Ideal para errores tipográficos:
$ mkae
-bash: mkae: command not found
$ ^ka^ak
make
[...]
Resume el tamaño del directorio, con tamaño humano descendente
du -hs */ | sort -hr
p.ej.
10.2G foo/
4M bar/
expansión de doble estrella con zsh (que recursivamente desciende el árbol de directorios, no solo un nivel, algo similar a $(find ! -type d)
:
grep string **/*.cc
¡Mi característica favorita es SIN COLORES! =)
TERM = xterm-mono o TERM = linux-m depende del sistema operativo ...
Me gusta mucho IRSSI en blanco y negro, mc y cualquier otra herramienta de "interfaz de usuario de texto"
ZSH tiene alias globales. Expande el alias en cualquier lugar de la línea de comando. He encontrado esto útil para los nombres de host:
P.ej.:
alias -g sub='sub.domain.tld'
Entonces, puedo hacer, por ejemplo:
sftp sub
ssh sub
etc.
Realmente no es una frase, pero creo que es útil. Convierta muchos archivos a mayúsculas, por ejemplo file_to_upper *php *c
. Hay muchos casos similares, como convertir a menor, cambiar el nombre de todos los archivos por sufijo/prefijo, etc.
file_to_upper ()
{
for file in "[email protected]"
do
if [ ! -f "$file" ]; then
echo "File $file does not exist";
else
mv -f "$file" "`echo "$file" | tr '[a-z]' '[A-Z]'`"
fi
done
return 0
}
obtener el nombre del archivo con la marca de tiempo más reciente en el directorio actual:
latest () { ls -lrt | tail -1 | awk '{print $NF}' }
function calc() { echo $* p | dc }
dc es una calculadora RPN; Esta función me permite escribir la expresión como argumentos de comando:
$ calc 5 3 +
8
Mostrar un mensaje donde el nombre de host es negrita. Probé las indicaciones de color por un tiempo, pero el color a veces se veía mal dependiendo del fondo. Bold funciona para mí para fondo claro, fondo oscuro, fondos azules, etc.
Esto está en mi .bashrc:
bold=$(tput bold)
reset=$(tput sgr0)
export PS1="\[email protected]\[$bold\]\h\[$reset\]:\w \$ "
Encontré lo siguiente útil al cambiar constantemente entre Windows y Unix/Linux:
alias dir="ls -l"
alias copy="cp"
alias del="rm"
Esto es para zsh, no bash, fyi (si no lo ha usado, no se arrepentirá de haberlo probado). Esto es realmente útil para escribir rápidamente rutas largas para transferencias scp. Funciona igual que usar para completar o enumerar los nombres de archivo/directorios disponibles.
Ejemplo
scp [email protected]:/home/webdev/domains/example.com/http.public/long<tab>
completará el camino a /home/webdev/domains/example.com/http.public/longdirname
.
Soy malo con los ejemplos, pero eso debería darte la idea. Pruébelo, realmente puede evitar que sus dedos escriban.
# SSH Completion
zstyle ':completion:*:scp:*' tag-order \
files users 'hosts:-Host hosts:-domain:domain hosts:-ipaddr"IP\ Address *'
zstyle ':completion:*:scp:*' group-order \
files all-files users hosts-domain hosts-Host hosts-ipaddr
zstyle ':completion:*:ssh:*' tag-order \
users 'hosts:-Host hosts:-domain:domain hosts:-ipaddr"IP\ Address *'
zstyle ':completion:*:ssh:*' group-order \
hosts-domain hosts-Host users hosts-ipaddr
zstyle '*' single-ignored show
ReTTY , que le permite mover un programa en ejecución de un terminal a otro. De esa manera, si tiene un programa ncurses que se ejecuta fuera de la pantalla, tmux o ssh, puede adjuntarlo a una sesión ssh o una pantalla en red o sesión tmux ejecutando ReTTY dentro del terminal donde desea utilizar el programa en cuestión. En otras palabras, es similar a screen y tmux pero con las excepciones de que (a) solo puede ejecutar un programa a la vez, y (b) puede ejecutarse después de comienzas el proceso hijo.
Mi favorito es usar el comando python) para crear el servidor http temporal:
python -m SimpleHTTPServer
y acceder a los archivos de esta máquina a través de la LAN como:
Otra es descargar el archivo tar en forma extraída como:
wget -qO - http://192.168.1.70:8000/test.bz2 | tar xjvf -
Aquí el enlace puede ser cualquiera sobre www y bz2 puede ser gz, tgz o bz2 en sí mismo.
mkdir -p ~/.bashrc.d
cat<<'EOF' >> ~/.bashrc
echo ""
echo -n ".bashrc.d warming up: "
for script in ~/.bashrc.d/* ; do
if [ -x "$script" ] ; then
echo -n "${script##*/} "
. "$script"
fi
done
echo ""
echo ""
echo " All systems are go."
echo ""
EOF
rm() {
local src
local final_status=0
for src in "[email protected]"; do
# Process only non command-line arguments.
if [[ "$src" != -* ]]; then
local trash="$HOME/.Trash"
if [ ! -e "$src" ]; then
echo "Safer rm: $src: No such file or directory."
final_status=1
fi
# Create the trash directory if needed.
if [ ! -d "$trash" ]; then
# Assume Mac trash, but it'll work on *nix too.
mkdir -p "$trash"
if [ ! -d "$trash" ]; then
echo "Safer rm: Unable to create trash directory $trash"
echo ""
echo " Nothing moved or deleted. Consider carefully:"
echo ""
echo " /bin/rm -rf $src"
return 1
fi
fi
local dest="$trash/${src##*/}"
# Find a filename combination which does not already exist.
if [ -e "$dest" ]; then
# Try appending ISO datetime.
dest="$dest.$(date +%Y-%m-%dT%H-%M-%S)"
if [ -e "$dest" ]; then
local n=1
# Try increasing monotony.
while [ -e "$dest.$n" ]; do
n = $[n + 1]
done
dest="$dest.$n"
fi
fi
echo -n "Safer rm: Trashing $src to $dest ..."
/bin/mv "$src" "$dest"
echo " done."
echo ""
echo " To restore: /bin/mv '$dest' '$src'"
echo ""
echo " To purge: /bin/rm -rf '$dest'"
echo ""
echo ""
fi
done
return $final_status
}
# Don't ask why I need 15 levels of cd ..
alias ..='cd ..'
alias .2='cd ../..'
alias ...='.2'
alias .3='cd ../../..'
alias .4='cd ../../../..'
alias .5='cd ../../../../..'
alias .6='cd ../../../../../..'
alias .7='cd ../../../../../../..'
alias .8='cd ../../../../../../../..'
alias .9='cd ../../../../../../../../..'
alias .10='cd ../../../../../../../../../..'
alias .11='cd ../../../../../../../../../../..'
alias .12='cd ../../../../../../../../../../../..'
alias .13='cd ../../../../../../../../../../../../..'
alias .14='cd ../../../../../../../../../../../../../..'
alias .15='cd ../../../../../../../../../../../../../../..'
bind -p | egrep -v '(not|self)' # No existential jokes included.
Después de mirar miles de millones de fuentes, uso 14 pt Monaco
, Anti-aliased
con iTerm2
.
KeyCue (tm) (r) (c) ($) proporciona el contexto de casi CUALQUIER aplicación en ejecución simplemente manteniendo command.
función de inserción automática de zsh:
setopt autopushd
y junto con eso:
alias dirs='dirs -v'
Para que en cualquier momento, pueda escribir dirs
y obtenga el historial de dónde he estado:
0 /var/log
1 /tmp
2 /usr/local/bin
3 ~
y luego puedo cd
nuevamente en /usr/local/bin
escribiendo:
cd ~2
Ninguno de los siguientes 'trucos' es técnicamente desafiante o impresionante, pero tienen algún impacto en la otra persona. Si no podemos usar nuestros trabajos para hacer nuestras vidas más felices, entonces deberíamos pensar nuevamente en algunas cosas.
Me gusta alias
. Mi truco favorito es editar los ~/.bash_aliases en la computadora de mi novia ya que ella falta y agregar una línea como:
alias gfname='echo Myname is thinking of you'
u otra cita romántica.
Otro "truco" que me gusta especialmente es:
#!/bin/bash
xaa=123`
for ((a=1; a <= xaa; a++))
do
#sleep 1;
mail -s "Happy Birthday $a" [email protected] < mails.txt
done
exit 0`
donde 123 es la persona a la que me gustaría desear feliz cumpleaños y mails.txt contiene el mensaje que me gustaría escribir como el cuerpo del correo electrónico. Dormir 1; a veces es necesario ya que hay un límite en fork (). También puede usar argumentos de línea de comando $1
etc ...
Tengo carpetas nombradas en mi carpeta de inicio como Documento, Descargas, Temp, etc. con la primera letra en mayúscula. Cuando trabajo en el terminal, es molesto cambiar de puesto, presione la primera tecla cuando esté ingresando en un directorio. Simplemente ingrese lo siguiente en su terminal y bash corregirá automáticamente el caso por usted.
shopt -s nocaseglob
Utilizar pgrep foo
en lugar de ps aux | grep foo
si quieres saber cuántas instancias de foo se están ejecutando y sus pids:
p.ej. en lugar de ps aux | grep firefox
, utilizar pgrep firefox
No puedo vivir sin
set editing-mode vi
set blink-matching-paren on
en mi ~/.inputrc.
Los activa en todas las aplicaciones habilitadas para readline. Solo la activación de la edición de línea de comando vi en Shell funciona mediante:
set -o vi
Por lo tanto, presionar ESC o CTRL + [te da el conocido modo vi-command. ¡Y puedes usar poderosos comandos vi en todas partes!
Hay un gran sitio para esto en: http://www.commandlinefu.com/commands/browse
Mi favorito personal es
find . -name <i>filename</i> | xargs grep -in '<i>pattern to search for</i>'
Lo que hace el comando anterior es encontrar un archivo de nombre x y luego busca en dicho archivo cualquier patrón que esté buscando. Increíblemente útil si está buscando un fragmento de código en particular en un archivo que está en algún lugar de sus subdirectorios.
find path expr -exec ls -ld {} \;
Una manera fácil y agradable de ver la propiedad, los permisos, los tamaños (si son archivos) y otras características de lo que devuelva la expresión 'find'.
A menudo me doy cuenta, justo después de comenzar un comando de 15 minutos, que hubiera querido agregar algunas otras cosas a la línea de comando usando &&
. En lugar de interrumpir el trabajo que ya se está ejecutando, tiendo a usar at
para poner en cola el segundo, dándome un tiempo más largo no necesito mirar el terminal.
Generalmente, at
pone en cola los trabajos para su ejecución en un momento dado:
$ at 14:30
> myscript
> anotherscript
> <CTRL-D>
Las entradas a la cola se pueden ver con atq
y eliminar con atrm
.
Otra adición a los consejos de personalización de Bash Prompt: me gusta invertir el indicador, ya que esto proporciona buenas señales visuales donde el resultado del comando comienza y termina en largas listas de terminales. Esto funciona bien para fondos brillantes y oscuros.
export PS1="\[\e[7m\][\[email protected]\h \w]\[\e[0m\]$ "
sincronización; sincronización; sincronización; reiniciar
puede ser realmente útil a veces. Ten cuidado !
Me parece que la comprensión de las pulsaciones de teclas bash conduce a un bombardeo más eficiente, y que muchos de ellos son directamente de emacs aclara su uso (es decir, que meta-XXX
Es la versión hermano mayor del comando ctrl-XXX
Por lo general).
La tecla "meta" suele ser la tecla "alt", pero también puede ser la tecla "esc". p.ej. meta-f
Se puede obtener con alt-f
O esc f
.
Para que las asignaciones de teclas alternativas funcionen, es posible que tenga que desactivar las "teclas de acceso al menú" o su equivalente en las opciones de la consola. Básicamente, si presiona alt-f y obtiene el mensaje del menú de archivo, apague los menús de acceso de tecla alt.
ctrl-a / ctrl-e : move to start / end of line
Conceptos básicos que no puedes prescindir
ctrl-f, meta-f : forward char/Word
Al presionar alt-f salta hacia adelante "1 palabra", que en la línea de comando es más o menos un comando o argumento
ctrl-b, meta-b : backwards char/Word
Igual que alt-f, pero hacia atrás para saltar hacia atrás a través de la línea de comando
ctrl-d, meta-d : delete char/Word
Presionando alt-d eliminará (hasta el final de) la palabra actual debajo del cursor. mucho más rápido que mantener presionado eliminar durante 30 segundos. Es útil cuando la pestaña se completa en medio de algo y desea reenviar la eliminación al final de Word.
ctrl-k : kill line
Se elimina al final de la línea
ctrl-u : undo
P. escribiendo una contraseña, y sabe que se equivocó en alguna parte, en lugar de presionar la tecla de retroceso 20 veces, simplemente presione ctrl-u. También borra la línea de comando actual.
meta-# : insert comment
Esto es excelente para mantener la línea de comandos que está creando como comentario antes de ejecutarla si necesita hacer algo más primero. entrará en su historial de comandos pero no se ejecutará.
ctrl-r : reverse search
Buscando hacia atrás a través de su historial de Shell (ctrl-r repetido para la próxima coincidencia)
ctrl-g : abort
Si está en medio de ctrl-r
Y desea volver al lugar donde estaba escribiendo, ¡simplemente cancele su búsqueda con ctrl-g
meta-space / ctrl-x ctrl-x : set mark and jump to mark
Si necesita saltar rápidamente a una posición en su línea de comando, primero establezca la marca, luego vuelva a saltar con ctrl-x ctrl-x
. Tenga en cuenta que puede que tenga que usar esc-space
Para obtener la marca establecida como alt-space
A menudo está obligado a bajar el menú de la consola.
ctrl-] <char> : quick jump to <char>
Salta hacia adelante al carácter escrito después de ctrl-]
En la línea de comando. El hermano mayor Meta-ctrl-] <char>
Salta hacia atrás.
Mis favoritos están abajo. Yo uso la mayoría de ellos regularmente
df -k (verificar sistemas de archivos) kill o kill -9 (kill a process) set -o vi (configure su línea de comando en vi) topas (herramienta de rendimiento) montar/desmontar
oh sí, y cómo podría olvidar el> (para redirigir la salida a un archivo) ls> /tmp/tmp.txt
Muchos más pero algunos fuera de mi cabeza.