¿Cuál es tu truco de línea de comandos más favorito con Bash? [cerrado]

Todos sabemos cómo usar <ctrl>-Rla búsqueda inversa en el historial, pero ¿sabía que puede usar la <ctrl>-Sbúsqueda hacia adelante si configura stty stop ""? Además, ¿alguna vez has intentado ejecutar bind -p para ver todos los atajos de teclado enumerados? Hay más de 455 en Mac OS X por defecto.

¿Cuál es tu truco oscuro favorito, atajo de teclado o configuración de shopt usando bash?

Renombrar / mover archivos con sufijos rápidamente:
cp /home/foo/realllylongname.cpp{,-old}

Esto se expande a:
cp /home/foo/realllylongname.cpp /home/foo/realllylongname.cpp-old

cd -

Es el equivalente de la línea de comandos del botón Atrás (lo lleva al directorio anterior en el que estaba).

Otro favorito:

!!

Repite tu último comando. Más útil en la forma:

sudo !!

Mi favorito es '^ string ^ string2' que toma el último comando, reemplaza string por string2 y lo ejecuta

$ ehco foo bar baz
bash: ehco: command not found
$ ^ehco^echo
foo bar baz

Guía de historial de línea de comando Bash

rebautizar

Ejemplo:

$ ls
this_has_text_to_find_1.txt
this_has_text_to_find_2.txt
this_has_text_to_find_3.txt
this_has_text_to_find_4.txt

$ rename 's/text_to_find/been_renamed/' *.txt
$ ls
this_has_been_renamed_1.txt
this_has_been_renamed_2.txt
this_has_been_renamed_3.txt
this_has_been_renamed_4.txt

Tan útil

Soy un fan de los !$, !^y !*expandos, volviendo, desde la línea de comando más reciente presentado: el último elemento, el primer elemento no mando, y todos los elementos de mando no. A saber (tenga en cuenta que el shell imprime el comando primero):

$ echo foo bar baz
foo bar baz
$ echo bang-dollar: !$ bang-hat: !^ bang-star: !*
echo bang-dollar: baz bang-hat: foo bang-star: foo bar baz
bang-dollar: baz bang-hat: foo bang-star: foo bar baz

Esto es muy útil cuando, por ejemplo ls filea fileb, y desea editar uno de ellos: vi !$o los dos de ellos: vimdiff !*. También se puede generalizar al " nargumento th" así:

$ echo foo bar baz
$ echo !:2
echo bar
bar

Finalmente, con los nombres de ruta, puede llegar a partes de la ruta agregando :hy :ta cualquiera de los expandos anteriores:

$ ls /usr/bin/id
/usr/bin/id
$ echo Head: !$:h  Tail: !$:t
echo Head: /usr/bin Tail: id
Head: /usr/bin Tail: id

Al ejecutar comandos, a veces querré ejecutar un comando con los argumentos anteriores. Para hacer eso, puede usar este acceso directo:

$ mkdir /tmp/new
$ cd !!:*

Ocasionalmente, en lugar de usar find, romperé un bucle de una línea si necesito ejecutar un montón de comandos en una lista de archivos.

for file in *.wav; do lame "$file" "$(basename "$file" .wav).mp3" ; done;

Configurar las opciones del historial de la línea de comandos en mi .bash_login (o .bashrc) es realmente útil. El siguiente es un cuadro de configuraciones que uso en mi Macbook Pro.

Establecer lo siguiente hace que bash borre comandos duplicados en su historial:

export HISTCONTROL="erasedups:ignoreboth"

También aumento el tamaño de mi historial bastante alto también. Por qué no? No parece ralentizar nada en los microprocesadores de hoy.

export HISTFILESIZE=500000
export HISTSIZE=100000

Otra cosa que hago es ignorar algunos comandos de mi historial. No es necesario recordar el comando de salida.

export HISTIGNORE="&:[ ]*:exit"

Definitivamente desea establecer histappend. De lo contrario, bash sobrescribe su historial cuando salga.

shopt -s histappend

Otra opción que uso es cmdhist. Esto le permite guardar comandos de varias líneas en el historial como un solo comando.

shopt -s cmdhist

Finalmente, en Mac OS X (si no está usando el modo vi), querrá restablecer <CTRL> -S para que no se detenga. Esto evita que bash pueda interpretarlo como búsqueda hacia adelante.

stty stop ""

¿Cómo enumerar solo subdirectorios en el actual?

ls -d */

Es un truco simple, ¡pero no sabrías cuánto tiempo necesito para encontrarlo!

ESC.

Inserta los últimos argumentos de su último comando bash. Es más útil de lo que piensas.

cp file /to/some/long/path

discos compactos ESC.

Claro, puede " diff file1.txt file2.txt", pero Bash admite la sustitución de procesos , lo que le permite diffla salida de comandos.

Por ejemplo, digamos que quiero asegurarme de que mi script me dé el resultado que espero. Simplemente puedo envolver mi script en <() y alimentarlo diffpara obtener una prueba de unidad rápida y sucia:

$ cat myscript.sh
#!/bin/sh
echo -e "one\nthree"
$
$ ./myscript.sh 
one
three
$
$ cat expected_output.txt
one
two
three
$
$ diff <(./myscript.sh) expected_output.txt
1a2
> two
$

Como otro ejemplo, digamos que quiero verificar si dos servidores tienen instalada la misma lista de RPM. En lugar de enviar mensajes a cada servidor, escribir cada lista de RPM para separar los archivos y hacer una copia de diffesos archivos, puedo hacer lo mismo diffdesde mi estación de trabajo:

$ diff <(ssh server1 'rpm -qa | sort') <(ssh server2 'rpm -qa | sort')
241c240
< kernel-2.6.18-92.1.6.el5
---
> kernel-2.6.18-92.el5
317d315
< libsmi-0.4.5-2.el5
727,728d724
< wireshark-0.99.7-1.el5
< wireshark-gnome-0.99.7-1.el5
$

Hay más ejemplos en la Guía avanzada de secuencias de comandos Bash en http://tldp.org/LDP/abs/html/process-sub.html .

Mi comando favorito es "ls-thor"

Invoca el poder de los dioses para enumerar los archivos modificados más recientemente en un formato convenientemente legible.

Más novedad, pero es inteligente ...

Los 10 principales comandos utilizados:

$ history | awk '{print $2}' | awk 'BEGIN {FS="|"}{print $1}' | sort | uniq -c | sort -nr | head

Salida de muestra:

 242 git
  83 rake
  43 cd
  33 ss
  24 ls
  15 rsg
  11 cap
  10 dig
   9 ping
   3 vi

^ R búsqueda inversa. Presione ^ R, escriba un fragmento de un comando anterior con el que desee hacer coincidir y presione ^ R hasta que encuentre el que desea. Entonces no tengo que recordar los comandos usados ​​recientemente que todavía están en mi historial. No exclusivamente bash, sino también: ^ E para el final de la línea, ^ A para el comienzo de la línea, ^ U y ^ K para eliminar antes y después del cursor, respectivamente.

A menudo tengo alias para vi, ls, etc. pero a veces quieres escapar del alias. Simplemente agregue una barra diagonal inversa al comando en frente:

P.ej:

$ alias vi=vim
$ # To escape the alias for vi:
$ \vi # This doesn't open VIM

Genial, ¿no es así?

Aquí hay un par de ajustes de configuración:

~/.inputrc:

"\C-[[A": history-search-backward
"\C-[[B": history-search-forward

Esto funciona igual que ^Rpero usando las teclas de flecha en su lugar. Esto significa que puedo escribir (por ejemplo) y cd /media/luego presionar la flecha hacia arriba para ir a lo último que quiero cddentro de la /media/carpeta.

(Yo uso Gnome Terminal, es posible que deba cambiar los códigos de escape para otros emuladores de terminal).

La finalización de Bash también es increíblemente útil, pero es una adición mucho más sutil. En ~/.bashrc:

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

Esto permitirá por programa para rellenar la ficha (por ejemplo, el intento del tabulador cuando la línea de comandos se inicia con evincesólo mostrará los archivos que evince puede abrir, y que también opciones de línea de comandos de la ficha completa).

Funciona muy bien con esto también en ~/.inputrc:

set completion-ignore-case on
set show-all-if-ambiguous on
set show-all-if-unmodified on

Yo uso mucho lo siguiente:

El :pmodificador para imprimir un resultado del historial. P.ej

!!:p

Imprimirá el último comando para que pueda verificar que es correcto antes de ejecutarlo nuevamente. Simplemente ingrese !!para ejecutarlo.

En un sentido similar:

!?foo?:p

Buscará en su historial el comando más reciente que contenga la cadena 'foo' e lo imprimirá.

Si no necesita imprimir,

!?foo

realiza la búsqueda y la ejecuta de inmediato.

Tengo un arma secreta: shell-fu.

Hay miles de consejos inteligentes, trucos geniales y recetas eficientes que la mayoría de las veces encajan en una sola línea.

Uno que me encanta (pero hago trampa un poco ya que uso el hecho de que Python está instalado en la mayoría de los sistemas Unix ahora):

alias webshare='python -m SimpleHTTPServer'

Ahora, cada vez que escriba "webshare", el directorio actual estará disponible a través del puerto 8000. Realmente agradable cuando desee compartir archivos con amigos en una red local sin clave usb o directorio remoto. La transmisión de videos y música también funcionará.

Y, por supuesto, la clásica bomba de horquilla que es completamente inútil pero muy divertida:

$ :(){ :|:& };:

No intentes eso en un servidor de producción ...

Puede usar el comando watch junto con otro comando para buscar cambios. Un ejemplo de esto fue cuando estaba probando mi enrutador, y quería obtener números actualizados sobre cosas como la relación señal / ruido, etc.

watch --interval=10 lynx -dump http://dslrouter/stats.html

type -a PROG

para encontrar todos los lugares donde PROG está disponible, generalmente en algún lugar en ~ / bin en lugar de en / usr / bin / PROG que podría haberse esperado.

Me gusta construir comandos con echo y canalizarlos al shell:

$ find dir -name \*~ | xargs echo rm
...
$ find dir -name \*~ | xargs echo rm | ksh -s

¿Por qué? Porque me permite ver lo que se va a hacer antes de hacerlo. De esa manera, si tengo un error horrible (como eliminar mi directorio de inicio), puedo detectarlo antes de que ocurra. Obviamente, esto es lo más importante para acciones destructivas o irrevocables.

Cuando descargo un archivo grande, a menudo lo hago:

while ls -la <filename>; do sleep 5; done

Y luego solo ctrl + c cuando haya terminado (o si lsdevuelve un valor distinto de cero). Es similar al watchprograma, pero utiliza el shell en su lugar, por lo que funciona en plataformas sin watch.

Otra herramienta útil es netcat, o nc. Si lo haces:

nc -l -p 9100 > printjob.prn

Luego puede configurar una impresora en otra computadora, pero en su lugar usar la dirección IP de la computadora que ejecuta netcat. Cuando se envía el trabajo de impresión, la computadora que ejecuta netcat lo recibe y lo descarga printjob.prn.

pushdy popdcasi siempre son útiles

Una forma preferida de navegar cuando estoy usando varios directorios en lugares muy separados en una jerarquía de árbol es usar acf_func.sh (que se enumera a continuación). Una vez definido, puedes hacer

discos compactos --

para ver una lista de directorios recientes, con un menú numérico

cd -2

para ir al segundo directorio más reciente.

Muy fácil de usar, muy útil.

Aquí está el código:

# do ". acd_func.sh"
# acd_func 1.0.5, 10-nov-2004
# petar marinov, http:/geocities.com/h2428, this is public domain

cd_func ()
{
  local x2 the_new_dir adir index
  local -i cnt

  if [[ $1 ==  "--" ]]; then
    dirs -v
    return 0
  fi

  the_new_dir=$1
  [[ -z $1 ]] && the_new_dir=$HOME

  if [[ ${the_new_dir:0:1} == '-' ]]; then
    #
    # Extract dir N from dirs
    index=${the_new_dir:1}
    [[ -z $index ]] && index=1
    adir=$(dirs +$index)
    [[ -z $adir ]] && return 1
    the_new_dir=$adir
  fi

  #
  # '~' has to be substituted by ${HOME}
  [[ ${the_new_dir:0:1} == '~' ]] && the_new_dir="${HOME}${the_new_dir:1}"

  #
  # Now change to the new dir and add to the top of the stack
  pushd "${the_new_dir}" > /dev/null
  [[ $? -ne 0 ]] && return 1
  the_new_dir=$(pwd)

  #
  # Trim down everything beyond 11th entry
  popd -n +11 2>/dev/null 1>/dev/null

  #
  # Remove any other occurence of this dir, skipping the top of the stack
  for ((cnt=1; cnt <= 10; cnt++)); do
    x2=$(dirs +${cnt} 2>/dev/null)
    [[ $? -ne 0 ]] && return 0
    [[ ${x2:0:1} == '~' ]] && x2="${HOME}${x2:1}"
    if [[ "${x2}" == "${the_new_dir}" ]]; then
      popd -n +$cnt 2>/dev/null 1>/dev/null
      cnt=cnt-1
    fi
  done

  return 0
}

alias cd=cd_func

if [[ $BASH_VERSION > "2.05a" ]]; then
  # ctrl+w shows the menu
  bind -x "\"\C-w\":cd_func -- ;"
fi

Expande líneas complicadas antes de golpear el temido enter

• Alt+ Ctrl+ e- shell-expand-line (puede necesitar usar Esc, Ctrl+ een su teclado)
• Ctrl+ _- deshacer
• Ctrl+ x, *- palabra-expand-glob

$ echo !$ !-2^ * Alt+ Ctrl+ e
$ echo aword someotherword * Ctrl+ _
$ echo !$ !-2^ * Ctrl+ x, *
$echo !$ !-2^ LOG Makefile bar.c foo.h

&C.

Siempre he sido parcial a:

ctrl-E # move cursor to end of line
ctrl-A # move cursor to beginning of line

También lo uso shopt -s cdable_vars, luego puedes crear variables bash en directorios comunes. Entonces, para el árbol fuente de mi empresa, creo un montón de variables como:

export Dcentmain="/var/localdata/p4ws/centaur/main/apps/core"

entonces puedo cambiar a ese directorio por cd Dcentmain.

pbcopy

Esto se copia en el portapapeles del sistema Mac. Puede canalizar comandos a él ... intente:

pwd | pbcopy

$ touch {1,2}.txt
$ ls [12].txt
1.txt  2.txt
$ rm !:1
rm [12].txt
$ history | tail -10
...
10007  touch {1,2}.txt
...
$ !10007
touch {1,2}.txt
$ for f in *.txt; do mv $f ${f/txt/doc}; done

El uso de 'set -o vi' desde la línea de comandos, o mejor, en .bashrc, lo pone en modo de edición vi en la línea de comandos. Comienza en el modo 'insertar' para poder escribir y retroceder de forma normal, pero si comete un error 'grande' puede presionar la tecla esc y luego usar 'b' y 'f' para moverse como lo hace en vi. cw para cambiar una palabra. Particularmente útil después de abrir un comando de historial que desea cambiar.

Similar a muchos anteriores, mi favorito actual es la pulsación de tecla [alt]. (Alt y "." Teclas juntas) esto es lo mismo que $! (Inserta el último argumento del comando anterior) excepto que es inmediato y para mí más fácil de escribir. (Simplemente no se puede usar en scripts)

p.ej:

mkdir -p /tmp/test/blah/oops/something
cd [alt].

Encadena múltiples comandos juntos usando el comando && :

./run.sh && tail -f log.txt

o

kill -9 1111 && ./start.sh