resueltos - scripts bash ejemplos

¿Cuál es tu truco de línea de comandos más favorito usando Bash?

Question

Todos sabemos cómo usar <ctrl>-R para realizar una búsqueda inversa a través de la historia, pero ¿sabía que puede usar <ctrl>-S para reenviar la búsqueda si establece stty stop "" ? Además, ¿alguna vez ha intentado ejecutar bind -p para ver todos sus atajos de teclado en la lista? Hay más de 455 en Mac OS X de manera predeterminada.

¿Cuál es tu truco, atajo de teclado o configuración de shopt más preferidos usando bash?

Answer 1

Expande las líneas complicadas antes de golpear el temido enter

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

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

&do.

Answer 2

¿Cómo enumerar solo subdirectorios en el actual?

ls -d */

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

Answer 3

A menudo tengo alias para vi, ls, etc. pero a veces quieres escapar del alias. Solo agrega una barra invertida al comando al frente:

P.ej:

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

Genial, ¿no?

Answer 4

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

~/.inputrc :

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

Esto funciona igual que ^R pero utilizando las teclas de flecha en su lugar. Esto significa que puedo escribir (p. Ej.) cd /media/ luego presionar la flecha hacia arriba para ir a la última cosa que hice al interior de la carpeta /media/ .

(Utilizo Gnome Terminal, puede que necesite 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á completar las pestañas por programa (por ejemplo, intentar completar la pestaña cuando la línea de comando comience con evince solo mostrará los archivos que se muestran pueden abrir, y también completará con pestañas las opciones de línea de comando).

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

Answer 5

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

Por ejemplo, digamos que quiero asegurarme de que mi script me dé el resultado que espero. Puedo envolver mi script en <() y pasarlo a diff para obtener una prueba unitaria 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 la misma lista de RPM instalados. En lugar de enviar un mensaje a cada servidor, escribir cada lista de RPM en archivos separados y hacer un diff en esos archivos, puedo hacer la diff desde 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 Bash-Scripting en http://tldp.org/LDP/abs/html/process-sub.html .

Answer 6

Cuando descargo un archivo grande, a menudo lo hago:

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

Y luego solo ctrl + c cuando termine (o si ls devuelve un valor distinto de cero). Es similar al programa de watch , pero usa 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 use la dirección IP de la computadora que ejecuta netcat. Cuando se envía el trabajo de impresión, el equipo que ejecuta netcat lo recibe y lo descarga a printjob.prn .

Answer 7

Cuando ejecuto comandos, a veces deseo ejecutar un comando con los argumentos anteriores. Para hacer eso, puedes usar este atajo:

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

Ocasionalmente, en lugar de utilizar find, voy a dividir un ciclo de una línea si necesito ejecutar una serie de comandos en una lista de archivos.

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

Configurar las opciones de historial de línea de comandos en mi .bash_login (o .bashrc) es realmente útil. El siguiente es un cuadro de configuración que utilizo en mi Macbook Pro.

Al configurar lo siguiente, bash borra los comandos duplicados en su historial:

export HISTCONTROL="erasedups:ignoreboth"

También tomé mi tamaño de historia 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 quiere establecer histappend. De lo contrario, bash sobrescribe su historial cuando sale.

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

Por último, en Mac OS X (si no está utilizando el modo vi), querrá restablecer <CTRL> -S de ser scroll stop. Esto evita que bash pueda interpretarlo como búsqueda directa.

stty stop ""

Answer 8

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

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

o

kill -9 1111 && ./start.sh

Answer 9

Más de una novedad, pero es inteligente ...

Los 10 comandos principales utilizados:

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

Muestra de salida:

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

Answer 10

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 más importante para acciones destructivas o irrevocables.

Answer 11

Mi comando favorito es "ls -thor"

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

Answer 12

Mi favorito es ''^ string ^ string2'' que toma el último comando, reemplaza la cadena con string2 y la ejecuta

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

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

Answer 13

Otro favorito:

!!

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

sudo !!

Answer 14

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

Answer 15

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

Answer 16

Siempre he sido parcial a:

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

También uso shopt -s cdable_vars , luego puedes crear variables bash para directorios comunes. Entonces, para el árbol fuente de mi compañía, creo un conjunto de variables como:

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

entonces puedo cambiar a ese directorio por cd Dcentmain .

Answer 17

Similar a muchos más arriba, mi favorito actual es la pulsación de tecla [alt]. (Teclas Alt y "." 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].

Answer 18

Soy fanático de !$ ,! !^ Y !* Expandos, regresando, desde la línea de comando enviada más reciente: el último elemento, el primer elemento que no pertenece al comando y todos los elementos que no están bajo el comando. 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 útil cuando usted dice ls filea fileb y desea editar uno de ellos: vi !$ O ambos: vimdiff !* . También se puede generalizar a "el noveno argumento" como sigue:

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

Finalmente, con los nombres de las rutas, puede acceder a partes de la ruta al agregar :h y :t a cualquiera de las expansiones anteriores:

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

Answer 19

Tengo un arma secreta: shell-fu.

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

Una que me encanta (pero hago trampa un poco ya que uso el hecho de que Python está instalado en la mayoría del sistema 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 es bueno cuando quiere compartir archivos con amigos en una red local sin la tecla USB o directorio remoto. La transmisión de videos y música también funcionará.

Y, por supuesto, la bomba tenedor clásica que es completamente inútil, pero sigue siendo muy divertida:

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

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

Answer 20

Una forma preferida de navegar cuando estoy usando múltiples directorios en lugares ampliamente separados en una jerarquía de árbol es usar acf_func.sh (enumerado 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

Answer 21

Usando ''set -o vi'' desde la línea de comando, o mejor, en .bashrc, te pone en el modo de edición vi en la línea de comando. Empiezas en el modo ''insertar'' para que puedas escribir y retroceder como es normal, pero si cometes un error ''grande'' puedes presionar la tecla Esc y luego usar ''b'' y ''f'' para moverte como lo haces en vi. cw para cambiar una palabra. Particularmente útil después de que haya mencionado un comando de historial que desea cambiar.

Answer 22

Uso mucho lo siguiente:

El modificador :p para imprimir un resultado del historial. P.ej

!!:p

Imprimirá el último comando para que pueda verificar que sea correcto antes de volver a ejecutarlo. ¡Solo entra !! para ejecutarlo.

En un sentido similar:

!?foo?:p

Buscará en su historial el comando más reciente que contenía la cadena ''foo'' e imprimirlo.

Si no necesita imprimir,

!?foo

hace la búsqueda y la ejecuta de inmediato.

Answer 23

^ R búsqueda inversa. Pulse ^ R, escriba un fragmento de un comando anterior con el que quiera hacer coincidir y pulse ^ R hasta encontrar 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.

Answer 24

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

Answer 25

pbcopy

Esto copia al portapapeles del sistema Mac. Puede canalizar comandos ... intente:

pwd | pbcopy

Answer 26

pushd y popd casi siempre son útiles

Answer 27

ESC .

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

cp file /to/some/long/path

cd ESC .

Answer 28

$ 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

Answer 29

cd -

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

Answer 30

type -a PROG

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