Ejemplos de Linux Complex Bash One-Liner

Las frases básicas pueden reducir la carga de trabajo, automatizar algo rápidamente y poner el poder del control final del sistema en sus manos. Con el tiempo, es probable que aprenda a escribir frases más complejas y algunas de las cosas que terminas escribiendo como un profesional experimentado serán casi económicos por un principiante. Dicho esto, el comando BASH y el lenguaje de desarrollo están altamente estructurados, y relativamente fácil de entender, una vez que sepa sobre las entradas y outs. Realmente es como ser competente en un idioma extranjero.

En este tutorial aprenderás:

• Cómo escribir comandos y scripts más avanzados de una línea de una sola
• Comprender cómo combinar varios comandos en scripts de una línea
• Comprender cómo los códigos de salida de un comando pueden afectar otros comandos al usar && y ||
• Comprender cómo la entrada de un comando se puede modificar y luego ser utilizada por el siguiente comando
• Uso y la vida real como ejemplos de frases más avanzadas de Bash

Requisitos y convenciones de software utilizados

Ejemplo 1: Control de procesos

Comencemos con un ejemplo de cómo terminar ciertos procesos en Bash de una manera fácil de seguir:

$ Sleep 3600 y [1] 1792341 $ PS -EF | Grep 'Sleep' Roel 1792441 1701839 0 12:59 pts/13 00:00:00 Sleep 3600 Roel 1792452 1701839 0 12:59 pts/13 00:00:00 GREP -COLOR = Auto Sleep 

Primero configuramos un comando de sueño, durante 3600 segundos (una hora), y posteriormente encontramos ese proceso en la lista de procesos. Genial, pero tenemos el grep Comando como una línea adicional en la salida de listado de procesos. Filtremos eso y también extraemos la ID del proceso a continuación en lugar de la salida completa de la información del proceso:

$ PS -EF | Grep 'Sleep' | GREP -V GREP ROEL 1792441 1701839 0 12:59 PTS/13 00:00:00 SUEÑO 3600 $ PS -EF | Grep 'Sleep' | GREP -V GREP | Awk 'imprimir $ 2' 1792441 

En el primer comando, filtramos el grep grep activo. En el segundo comando, llevamos esto un paso más allá imprimiendo la segunda columna $ 2 (adentro asombrar) usando el asombrar dominio. Ahora podemos usar Take That One Step más y en realidad matar Ese proceso. Digamos que hacemos eso con señal 9 que es muy destructivo para cualquier proceso de Linux (Sigkill)

$ PS -EF | Grep 'Sleep' | GREP -V GREP | Awk 'imprimir $ 2' | Xargs Kill -9 [1]+ Sleep muerto 3600 

Y podemos ver que nuestro proceso fue asesinado correctamente. Mientras que este fue un ejemplo más simple, involucró 6 comandos diferentes: PD, grep, grep de nuevo, asombrar, Xargs y matar. Puede ver cómo las frases básicas pueden desarrollar rápidamente complejidad de muchas maneras diferentes y en muchos niveles diferentes de complejidad y capacidad de procesamiento de datos.

Y, para obtener más información sobre XARGS, consulte nuestros artículos Xargs para principiantes con ejemplos y Xargs de múltiples enhebrados con ejemplos.

Ejemplo 2: diversión con éxito y fracaso!

$ echo '0'> a && echo '1'> b && echo '2'> c && ls doesnotexist || ls a && ls b && ls c && ls d && ls e ls: no se puede acceder a 'doesnotexist': no ​​hay dicho archivo o directorio a b c ls: no se puede acceder 'd': no ​​hay dicho archivo o directorio 

Qué línea tan compleja! Sin embargo, una vez que sepa cómo leerlo, o tal vez ya lo haga, se vuelve muy fácil de leer. Demostremos que esta afirmación es válida rompiendo el comando en trozos de tamaño de bocado más pequeños que son más fáciles de entender y seguir:

$ echo '0'> a && echo '1'> b && echo '2'> c 

Todo este conjunto de comandos hace es lo mismo que el siguiente con una pequeña advertencia:

$ echo '0'> a $ echo '1'> b $ echo '2'> c 

Entonces, ¿cuál es la diferencia (y la pequeña advertencia)?

Que en esta última serie de comandos se ejecutará cada comando, sin importar cuál sea el resultado del comando anterior. La secuencia anterior (usando &&) solo procederá al segundo eco si El resultado del primer comando fue 0 (i.mi. éxito: en la bash, el éxito en un comando se indica por 0 y falla con 1 o más alto como código de salida).

Por lo tanto, la secuencia de comando usando && También podría escribirse de la siguiente manera;

$ echo '0'> a $ if [$ ? -eq 0]; luego se eco '1'> b; fi $ if [$ ? -eq 0]; luego se eco '2'> c; FI 

El ps? (o ps? En la sintaxis en resumen) la variable siempre contiene el resultado del último comando, yo.mi. el código de salida (0, 1 o más alto) generado por el último comando.

Como podemos ver, la creación de una línea de echo '0'> a && echo '1'> b && echo '2'> c Seguramente es más fácil para los ojos y la comprensión ahora, y definitivamente reduce la complejidad del código correspondiente y coincidente que se muestra arriba.

A continuación, tomemos solo un comando más:

$ echo '0'> a && echo '1'> b && echo '2'> c && ls doesnotexist ls: no se puede acceder 'doesnotexist': no ​​hay dicho archivo o directorio 

Esto ahora se lee mucho más fácil, bien?

Acabamos de agregar otro comando a saber ls no notexista siempre que el comando anterior (y en este caso toda la línea, ya que todos los comandos se unen && En una configuración similar a una cadena, donde un comando defectuoso romperá la cadena y detendrá la ejecución de la cadena en su totalidad) ha tenido éxito. Como todos los comandos tienen éxito, el LS se ejecuta y se produce un error como resultado de la misma porque el archivo, bueno, realmente no existe 🙂

Entonces, ¿qué pasaría si nos unamos a otro && al final? ¿Terminaría la cadena de comandos como dijimos?? Vamos a ajustar un poco el comando:

$ echo '0'> a && echo '1'> b && echo '2'> c && ls doesnotexist && echo 'seguramente no' ls: no puede acceder 'doesnotexist': no ​​hay dicho archivo o directorio 

Y, seguramente no se ejecutó. Luego presentemos nuestro próximo comando en nuestra cadena a partir del ejemplo original:

$ echo '0'> a && echo '1'> b && echo '2'> c && ls doesnotexist || ls a ls: no se puede acceder a 'doesnotexist': no ​​hay dicho archivo o directorio a 

¿Puedes ver lo que esta pasando?? Aquí tenemos un nuevo símbolo de sintaxis, a saber || que es diferente de && En eso se ejecuta solo si hubo un resultado distinto de cero en el comando anterior. Tenga en cuenta que ambos || y && Aplicar solo al último comando, y no a la cadena de comandos, a pesar de que uno podría pensar en ello como una cadena en general.

Por lo tanto, puedes pensar en && Como el equivalente del idioma inglés y y, hasta cierto punto el común y presente en los lenguajes de programación, pero con el giro de que aquí estamos revisando una condición antes del && y ejecutar lo que está detrás de él siempre que la condición de salida sea 0.

Otro giro es que la mayoría de los lenguajes de programación verificarán verdadero como un binario 1 cuando && Se usa la sintaxis. Por ejemplo, considere el código pseudo; Si test1_flag && test2_flag entonces .. que generalmente evaluará a verdadero en general (y así ejecutar el entonces comandos) si el binario se indica test1_flag y test2_flag son 1 o verdaderos, mientras que en Bash verdadero está indicado por un 0 (y no 1) Salir del estado del último comando!

Tu puedes pensar en || Como el equivalente del idioma inglés o (o como en o si esto falla, entonces haz .. ). En esta situación hay una conexión más fuerte con los lenguajes de programación comunes: cuando un lenguaje de programa común verifica, por ejemplo, Si test1_flag || test2_flag entonces .. , Entonces un binario positivo test1_flag (i.mi. valor 1) o test2_flag produciría que la condición general sea verdadera (y por lo tanto el entonces La cláusula se ejecutaría). Vemos lo mismo en Bash; Si el código de salida del comando no es cero (i.mi. 1 o un valor más alto en algunos casos), entonces el comando detrás del || Se ejecutará la cláusula.

Volvamos ahora al comando original y analizarlo en su totalidad:

$ echo '0'> a && echo '1'> b && echo '2'> c && ls doesnotexist || ls a && ls b && ls c && ls d && ls e ls: no se puede acceder a 'doesnotexist': no ​​hay dicho archivo o directorio a b c ls: no se puede acceder 'd': no ​​hay dicho archivo o directorio 

¿Puedes ver lo que pasa?? Porque el ls no notexista el comando falla internamente y produce una salida no cero (use ls no notexista; Echo $? en Bash para verificar; La salida es 2), el o (||) se activa la cláusula y luego ejecutamos LS. Imagínelo como una cadena que fluye hacia una dirección diferente, pero sigue siendo una cadena.

Como el ls a el comando tiene éxito, y es seguido por el y (&&) cláusula, el siguiente comando se ejecuta y así sucesivamente. Tenga en cuenta que la ejecución llega a LS D, y la salida para el mismo (ls: no se puede acceder a 'd': no ​​hay dicho archivo o directorio) se muestra, pero el LS E El comando no se ejecuta! Esto se espera, como && fue usado y el LS D Error de comando. Por eso, LS E se ejecuta nunca.

Conclusión

Cuanto más competente te vuelvas al escribir una línea de una sola vez, más rápido, mejor, menos propenso a los errores y más suaves se convertirán tus scripts de una línea de una base, y menos tiempo pasarás en escribirlos. Los desarrolladores del lenguaje bash han puesto todo el control en sus manos. ¿Qué harás con ese control hoy??

Déjenos un mensaje a continuación con sus mejores creaciones de una línea!

Tutoriales de Linux relacionados:

• Una introducción a la automatización, herramientas y técnicas de Linux
• Cosas para instalar en Ubuntu 20.04
• Cosas que hacer después de instalar Ubuntu 20.04 fossa focal Linux
• Mastering Bash Script Loops
• Recuperación de páginas web con WGET, CURL y LYNX
• Mint 20: Mejor que Ubuntu y Microsoft Windows?
• Ubuntu 20.04 Guía
• Bucles anidados en guiones Bash
• Manipulación de Big Data para la diversión y las ganancias Parte 1
• Cosas que hacer después de instalar Ubuntu 22.04 Jellyfish de Jammy ..