Consejos de Bash para el día a día en la línea de comandos

Como shell predeterminado para muchas de las variantes de Linux y Unix, Bash incluye una amplia variedad de funciones infrautilizadas, por lo que fue difícil decidir qué discutir. Finalmente, decidí centrarme en los consejos de Bash que facilitan las actividades diarias.

Como consultor, veo una pluralidad de entornos y estilos de trabajo diversos. Me basé en esta experiencia para reducir los consejos a cuatro categorías amplias:trucos de terminal y línea, navegación y archivos, historial y comandos útiles. Estas categorías son completamente arbitrarias y sirven más para organizar mis propios pensamientos que como una especie de clasificación definitiva. Muchos de los consejos incluidos aquí pueden encajar subjetivamente en más de una categoría.

Sin más preámbulos, estos son algunos de los trucos de Bash más útiles que he encontrado.

Trabajar con el historial de Bash

Una de las mejores maneras de aumentar su productividad es aprender a usar el historial de Bash de manera más efectiva. Con eso en mente, quizás uno de los ajustes más importantes que puede hacer en un entorno multiusuario es habilitar el histappend opción a su caparazón. Para hacer eso, simplemente ejecute el siguiente comando:

shopt -s histappend 

Esto permite que varias sesiones de terminal escriban en el historial al mismo tiempo. En la mayoría de los entornos, esta opción no activado. Eso significa que los historiales a menudo se pierden si tiene más de una sesión de Bash abierta (ya sea localmente o a través de SSH).

Otra tarea común es repetir el último comando con sudo . Por ejemplo, suponga que desea crear un directorio mkdir /etc/ansible/facts.d . A menos que sea root, este comando fallará. Por lo que he observado, la mayoría de los usuarios presionan up flecha, desplácese hasta el principio de la línea y agregue sudo dominio. Hay una manera más fácil. Simplemente ejecute el comando de esta manera:

sudo !!

Bash ejecutará sudo y luego la totalidad del comando anterior. Esto es exactamente lo que parece cuando se ejecuta en secuencia:

[user@centos ~]$ mkdir -p /etc/ansible/facts.d

mkdir: cannot create directory ‘/etc/ansible’: Permission denied



[user@centos ~]$ sudo !!

sudo mkdir -p /etc/ansible/facts.d

Cuando el !! se ejecuta, el comando completo se repite en la terminal para que sepa qué se acaba de ejecutar.

Similar pero usado con mucha menos frecuencia es el !* atajo. Esto le dice a Bash que quieres todos los *argumentos* del comando anterior para que se repita en el comando actual. Esto podría ser útil para un comando que tiene muchos argumentos que desea reutilizar. Un ejemplo simple es crear un montón de archivos y luego cambiarles los permisos:

[user@centos tmp]$ touch file1 file2 file3 file4

[user@centos tmp]$ chmod 777 !*

chmod 777 file1 file2 file3 file4

Es útil solo en un conjunto específico de circunstancias, pero puede ahorrarle algunas pulsaciones de teclas.

Hablando de guardar pulsaciones de teclas, hablemos de encontrar comandos en su historial. La mayoría de los usuarios harán algo como esto:

history |grep <some command>

Sin embargo, hay una manera más fácil de buscar en su historial. Si presionas

ctrl + r

Bash hará una búsqueda inversa de su historial. A medida que comience a escribir, los resultados comenzarán a aparecer. Por ejemplo:

(reverse-i-search)`hist': shopt -s histappend

En el ejemplo anterior, escribí hist y coincidió con el shopt comando que cubrimos anteriormente. Si continúa presionando ctrl + r , Bash continuará buscando hacia atrás en todas las demás coincidencias.

Nuestro último truco no es tanto un truco como un comando útil que puede usar para contar y mostrar los comandos más utilizados en su historial.

[user@centos tmp]$ history | awk 'BEGIN {FS="[ \t]+|\\|"} {print $3}' | sort | uniq -c | sort -nr | head 

81 ssh

50 sudo

46 ls

45 ping

39 cd

29 nvidia-xrun

20 nmap

19 export

En este ejemplo, puedes ver que ssh es, con mucho, el comando más utilizado en mi historia en este momento.

Navegación y nomenclatura de archivos

Más recursos de Linux

• Hoja de trucos de los comandos de Linux
• Hoja de trucos de comandos avanzados de Linux
• Curso en línea gratuito:Descripción general técnica de RHEL
• Hoja de trucos de red de Linux
• Hoja de trucos de SELinux
• Hoja de trucos de los comandos comunes de Linux
• ¿Qué son los contenedores de Linux?
• Nuestros últimos artículos sobre Linux

Probablemente ya sepa que si escribe un comando, un nombre de archivo o un nombre de carpeta, puede presionar la pestaña tab clave una vez para completar la redacción para usted. Esto funciona si hay una sola coincidencia exacta. Sin embargo, es posible que no sepa que si presiona tab dos veces, le mostrará todas las coincidencias según lo que haya escrito. Por ejemplo:

[user@centos tmp]$ cd /lib <tab><tab>

lib/ lib64/ 

Esto puede ser muy útil para la navegación del sistema de archivos. Otro truco útil es habilitar cdspell en tu caparazón. Puede hacer esto emitiendo el shopt -s cdspell dominio. Esto ayudará a corregir sus errores tipográficos:

[user@centos etc]$ cd /tpm

/tmp

[user@centos tmp]$ cd /ect

/etc

No es perfecto, ¡pero todo ayuda!

Una vez que haya cambiado de directorio con éxito, ¿qué sucede si necesita volver a su directorio anterior? Esto no es gran cosa si no está muy adentrado en el árbol de directorios. Pero si está en una ruta bastante profunda, como /var/lib/flatpak/exports/share/applications/ , podría escribir:

cd /va<tab>/lib/fla<tab>/ex<tab>/sh<tab>/app<tab>

Afortunadamente, Bash recuerda su directorio anterior y puede regresar allí simplemente escribiendo cd - . Así es como se vería:

[user@centos applications]$ pwd

/var/lib/flatpak/exports/share/applications



[user@centos applications]$ cd /tmp

[user@centos tmp]$ pwd

/tmp



[user@centos tmp]$ cd -

/var/lib/flatpak/exports/share/applications

Eso está muy bien, pero ¿qué sucede si tiene un montón de directorios en los que desea navegar fácilmente? Bash también lo tiene cubierto allí. Hay una variable que puede configurar que lo ayudará a navegar de manera más efectiva. Aquí hay un ejemplo:

[user@centos applications]$ export CDPATH='~:/var/log:/etc'

[user@centos applications]$ cd hp

/etc/hp



[user@centos hp]$ cd Downloads

/home/user/Downloads



[user@centos Downloads]$ cd ansible

/etc/ansible



[user@centos Downloads]$ cd journal

/var/log/journal

En el ejemplo anterior, establecí mi directorio de inicio (indicado con la tilde:~ ), /var/log y /etc . Todo lo que se encuentre en el nivel superior de estos directorios se completará automáticamente cuando haga referencia a ellos. Directorios que no están en la base de los directorios listados en CDPATH no se encontrará Si, por ejemplo, el directorio que busca es /etc/ansible/facts.d/ esto no se completaría escribiendo cd facts.d . Esto se debe a que mientras el directorio ansible se encuentra en /etc , facts.d no es. Por lo tanto, CDPATH es útil para llegar a la parte superior de un árbol al que accede con frecuencia, pero puede resultar engorroso de administrar cuando navega por una estructura de carpetas grande.

Finalmente, hablemos de dos casos de uso comunes que todo el mundo hace en algún momento:cambiar la extensión de un archivo y cambiar el nombre de los archivos. A primera vista, esto puede parecer lo mismo, pero Bash ofrece algunos trucos diferentes para realizar estas tareas.

Si bien puede ser una operación "incompleta", la mayoría de los usuarios en algún momento necesitan crear una copia rápida de un archivo en el que están trabajando. La mayoría copiará el nombre del archivo exactamente y simplemente agregará una extensión de archivo como .old o .bak . Hay un atajo rápido para esto en Bash. Suponga que tiene un nombre de archivo como spideroak_inotify_db.07pkh3 del que desea conservar una copia. Podría escribir:

cp spideroak_inotify_db.07pkh3 spideroak_inotify_db.07pkh3.bak

Puede hacer esto rápidamente usando operaciones de copiar/pegar, usando la pestaña completa, posiblemente usando uno de los accesos directos para repetir un argumento, o simplemente escribiendo todo. Sin embargo, el siguiente comando debería ser aún más rápido una vez que te acostumbres a escribirlo:

cp spideroak_inotify_db.07pkh3{,.old}

Esto (como puede adivinar) copia el archivo agregando .old extensión de archivo al archivo. Eso es genial, se podría decir, pero quiero cambiar el nombre de una gran cantidad de archivos a la vez. Claro, podrías escriba un ciclo for para lidiar con esto (y de hecho, a menudo hago esto por algo complicado), pero ¿por qué lo haría cuando hay una utilidad útil llamada rename? ? Hay alguna diferencia en el uso de esta utilidad entre Debian/Ubuntu y CentOS/Arch. El cambio de nombre basado en Debian usa una sintaxis similar a SED:

user@ubuntu-1604:/tmp$ for x in `seq 1 5`; do touch old_text_file_${x}.txt; done



user@ubuntu-1604:/tmp$ ls old_text_file_*

old_text_file_1.txt old_text_file_3.txt old_text_file_5.txt

old_text_file_2.txt old_text_file_4.txt



user@ubuntu-1604:/tmp$ rename 's/old_text_file/shiney_new_doc/' *.txt



user@ubuntu-1604:/tmp$ ls shiney_new_doc_*

shiney_new_doc_1.txt shiney_new_doc_3.txt shiney_new_doc_5.txt

shiney_new_doc_2.txt shiney_new_doc_4.txt

En un cuadro de CentOS o Arch se vería similar:

[user@centos /tmp]$ for x in `seq 1 5`; do touch old_text_file_${x}.txt; done



[user@centos /tmp]$ ls old_text_file_*

old_text_file_1.txt old_text_file_3.txt old_text_file_5.txt

old_text_file_2.txt old_text_file_4.txt



[user@centos tmp]$ rename old_text_file centos_new_doc *.txt



[user@centos tmp]$ ls centos_new_doc_*

centos_new_doc_1.txt centos_new_doc_3.txt centos_new_doc_5.txt

centos_new_doc_2.txt centos_new_doc_4.txt

Asociaciones de teclas Bash

Bash tiene muchos atajos de teclado integrados. Puede encontrar una lista de ellos escribiendo bind -p . Pensé que sería útil destacar varios, aunque algunos pueden ser muy conocidos.

• ctrl + _ (deshacer)
• ctrl + t (intercambiar dos caracteres)
• ALT + t (intercambiar dos palabras)
• ALT + . (imprime el último argumento del comando anterior)
• ctrl + x + * (expandir globo/estrella)
• ctrl + flecha (avanzar una palabra)
• ALT + f (avanzar una palabra)
• ALT + b (mover hacia atrás una palabra)
• ctrl + x seguido de ctrl + e (abre la cadena de comando en un editor para que pueda editarla antes de la ejecución)
• ctrl + e (mover el cursor al final)
• ctrl + a (mueva el cursor para comenzar)
• ctrl + xx (mover al extremo opuesto de la línea)
• ctrl + u (corta todo antes del cursor)
• ctrl + k (corta todo después del cursor)
• ctrl + y (pega del búfer)
• ctrl + l (L minúscula, borra la pantalla)

No discutiré los más obvios. Sin embargo, algunos de los atajos más útiles que he encontrado son los que te permiten borrar palabras (o secciones de texto) y deshacerlas. Suponga que va a detener un montón de servicios usando systemd , pero solo quería iniciar algunos de ellos después de que se haya completado alguna operación. Podrías hacer algo como esto:

systemctl stop httpd mariadb nfs smbd

<hit the up button to get the previous command>

<use 'ctrl + w' to remove the unwanted arguments>

Pero, ¿y si quitas uno de más? No hay problema, simplemente usa ctrl + _ para deshacer la última edición.

Los otros comandos de corte le permiten eliminar rápidamente todo, desde el cursor hasta el final o el principio de la línea (usando Ctrl + k y Ctrl + u , respectivamente). Esto tiene el beneficio adicional de colocar el texto cortado en el búfer de la terminal para que pueda pegarlo más tarde (usando ctrl + y ). Estos comandos son difíciles de demostrar aquí, por lo que le recomiendo que los pruebe por su cuenta.

Por último, pero no menos importante, me gustaría mencionar una combinación de teclas que rara vez se usa y que puede ser extremadamente útil en entornos confinados, como contenedores. Si alguna vez tiene un comando que parece distorsionado por la salida anterior, hay una solución:presione ctrl + x + ctrl + e abrirá el comando en cualquier editor que esté configurado en la variable de entorno EDITOR. Esto le permitirá editar un comando largo o ilegible en un editor de texto que (potencialmente) puede ajustar el texto. Guardar su trabajo y salir, tal como lo haría al trabajar en un archivo normal, ejecutará el comando al salir del editor.

Consejos varios

Puede encontrar que mostrar colores en su shell Bash puede mejorar su experiencia. Si está utilizando una sesión que no tiene habilitada la coloración, a continuación hay una serie de comandos que puede colocar en su .bash_profile para agregar color a su sesión. Estos son bastante sencillos y no deberían requerir una explicación detallada:

# enable colors

eval "`dircolors -b`"



# force ls to always use color and type indicators

alias ls='ls -hF --color=auto'



# make the dir command work kinda like in windows (long format)

alias dir='ls --color=auto --format=long'



# make grep highlight results using color

export GREP_OPTIONS='--color=auto'



# Add some colour to LESS/MAN pages

export LESS_TERMCAP_mb=$'\E[01;31m'

export LESS_TERMCAP_md=$'\E[01;33m'

export LESS_TERMCAP_me=$'\E[0m'

export LESS_TERMCAP_se=$'\E[0m' 

export LESS_TERMCAP_so=$'\E[01;42;30m'

export LESS_TERMCAP_ue=$'\E[0m'

export LESS_TERMCAP_us=$'\E[01;36m'

Además de ajustar las diversas opciones dentro de Bash, también puede usar algunos trucos ingeniosos para ahorrar tiempo. Por ejemplo, para ejecutar dos comandos seguidos, independientemente del estado de salida de cada uno, use el ; para separar los comandos, como se ve a continuación:

[user@centos /tmp]$ du -hsc * ; df -h

Esto simplemente calcula la cantidad de espacio que ocupa cada archivo en el directorio actual (y lo suma), luego consulta al sistema el uso del disco por dispositivo de bloque. Estos comandos se ejecutarán independientemente de los errores generados por du comando.

¿Qué sucede si desea que se realice una acción al completar con éxito el primer comando? Puedes usar el && abreviatura para indicar que desea ejecutar el segundo comando solo si el primer comando devuelve un estado de salida exitoso. Por ejemplo, suponga que desea reiniciar una máquina solo si las actualizaciones son exitosas:

[root@arch ~]$ pacman -Syu --noconfirm && reboot

A veces, al ejecutar un comando, es posible que desee capturar su salida. La mayoría de la gente conoce la tee comando, que copiará la salida estándar tanto en el terminal como en un archivo. Sin embargo, si desea capturar una salida más compleja de, digamos, strace , deberá comenzar a trabajar con la redirección de E/S. Los detalles de la redirección de E/S están más allá del alcance de este breve artículo, pero para nuestros propósitos nos preocupamos por STDOUT y STDERR . La mejor manera de capturar exactamente lo que está viendo es combinar los dos en un solo archivo. Para hacer esto, use el 2>&1 redirección.

[root@arch ~]$ strace -p 1140 > strace_output.txt 2>&1

Esto pondrá toda la salida relevante en un archivo llamado strace_output.txt para verlo más tarde.

A veces, durante un comando de ejecución prolongada, es posible que deba pausar la ejecución de una tarea. Puede usar el acceso directo 'detener' ctrl + z para detener (pero no matar) un trabajo. El trabajo se agrega a la cola de trabajos, pero ya no verá el trabajo hasta que lo reanude. Este trabajo se puede reanudar más adelante usando el comando de primer plano fg .

Además, también puede simplemente pausar un trabajo con ctrl + s . El trabajo y su salida permanecen en el primer plano de la terminal, y el uso del shell no devuelto al usuario. El trabajo se puede reanudar presionando ctrl + q .

Si está trabajando en un entorno gráfico con muchos terminales abiertos, puede que le resulte útil tener atajos de teclado para copiar y pegar resultados. Para hacerlo, use los siguientes atajos:

# Copies highlighted text

ctrl + shift + c 



# Pastes text in buffer

ctrl + shift + v

Suponga que en la salida de un comando de ejecución ve que se está ejecutando otro comando y desea obtener más información. Hay algunas maneras de hacer esto. Si este comando se encuentra en algún lugar de su camino, puede ejecutar el which comando para averiguar dónde se encuentra ese comando en su disco:

[root@arch ~]$ which ls

/usr/bin/ls

Con esta información, puede inspeccionar el binario con el file comando:

[root@arch ~]$ file /usr/bin/ls

/usr/bin/ls: ELF 64-bit LSB pie executable x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, for GNU/Linux 3.2.0, BuildID[sha1]=d4e02b88e596e4f82c6cc62a5bc4ce5827209a49, stripped

Puede ver todo tipo de información, pero la más importante para la mayoría de los usuarios es el ELF 64-bit LSB disparates. Básicamente, esto significa que es un binario precompilado en lugar de un script u otro tipo de ejecutable. Una herramienta relacionada que puede usar para inspeccionar comandos es el command herramienta en sí. Simplemente ejecutando command -V <command> le dará diferentes tipos de información:

[root@arch ~]$ command -V ls

ls is aliased to `ls --color=auto` 



[root@arch ~]$ command -V bash

bash is /usr/bin/bash



[root@arch ~]$ command -V shopt

shopt is a shell builtin

Por último, pero definitivamente no menos importante, uno de mis trucos favoritos, especialmente cuando trabajo con contenedores o en entornos donde tengo poco conocimiento o control, es el echo dominio. Este comando se puede usar para hacer de todo, desde verificar para asegurarse de que su for loop ejecutará la secuencia esperada para permitirle verificar si los puertos remotos están abiertos. La sintaxis es muy simple para verificar si hay un puerto abierto:echo > /dev/<udp or tcp>/<server ip>/<port> . Por ejemplo:

user@ubuntu-1604:~$ echo > /dev/tcp/192.168.99.99/222

-bash: connect: Connection refused

-bash: /dev/tcp/192.168.99.99/222: Connection refused



user@ubuntu-1604:~$ echo > /dev/tcp/192.168.99.99/22

Si el puerto está cerrado para el tipo de conexión que intenta realizar, obtendrá un Connection refused mensaje. Si el paquete se envía con éxito, no habrá salida.

Espero que estos consejos hagan que Bash sea más eficiente y agradable de usar. Hay muchos más trucos ocultos en Bash de los que he enumerado aquí. ¿Cuáles son algunos de tus favoritos?

Apéndice 1. Lista de consejos y trucos cubiertos

# History related 

ctrl + r (reverse search)

!! (rerun last command)

!* (reuse arguments from previous command)

!$ (use last argument of last command)

shopt -s histappend (allow multiple terminals to write to the history file)

history | awk 'BEGIN {FS="[ \t]+|\\|"} {print $3}' | sort | uniq -c | sort -nr | head (list the most used history commands)



# File and navigation

cp /home/foo/realllylongname.cpp{,-old}

cd -

rename 's/text_to_find/been_renamed/' *.txt

export CDPATH='/var/log:~' (variable is used with the cd built-in.)



# Colourize bash



# enable colors

eval "`dircolors -b`"

# force ls to always use color and type indicators

alias ls='ls -hF --color=auto'

# make the dir command work kinda like in windows (long format)

alias dir='ls --color=auto --format=long'

# make grep highlight results using color

export GREP_OPTIONS='--color=auto'



export LESS_TERMCAP_mb=$'\E[01;31m'

export LESS_TERMCAP_md=$'\E[01;33m'

export LESS_TERMCAP_me=$'\E[0m'

export LESS_TERMCAP_se=$'\E[0m' # end the info box

export LESS_TERMCAP_so=$'\E[01;42;30m' # begin the info box

export LESS_TERMCAP_ue=$'\E[0m'

export LESS_TERMCAP_us=$'\E[01;36m'



# Bash shortcuts

    shopt -s cdspell (corrects typoos)

    ctrl + _ (undo)

    ctrl + arrow (move forward a word)

    ctrl + a (move cursor to start)

    ctrl + e (move cursor to end)

    ctrl + k (cuts everything after the cursor)

    ctrl + l (clears screen)

    ctrl + q (resume command that is in the foreground)

    ctrl + s (pause a long running command in the foreground)

    ctrl + t (swap two characters)

    ctrl + u (cuts everything before the cursor)

    ctrl + x + ctrl + e (opens the command string in an editor so that you can edit it before it runs)

    ctrl + x + * (expand glob/star)

    ctrl + xx (move to the opposite end of the line)

    ctrl + y (pastes from the buffer)

    ctrl + shift + c/v (copy/paste into terminal)



# Running commands in sequence

&& (run second command if the first is successful)

; (run second command regardless of success of first one)



# Redirecting I/O

2>&1 (redirect stdout and stderr to a file)



# check for open ports

echo > /dev/tcp/<server ip>/<port>

`` (use back ticks to shell out)



# Examine executable

which <command>

file <path/to/file>

command -V <some command binary> (tells you whether <some binary> is a built-in, binary or alias)