Hay ciertos comandos o trucos que empiezas a usar como administrador de sistemas, que simplemente incorporas a tu arsenal y nunca te detienes a analizar en profundidad todas las opciones o alternativas a ellos.
Para mí, uno de esos trucos es el operador de backtick. Lo usé con bastante frecuencia cuando programé en Perl (que no uso hoy en día, pero parece que todavía tiene un club de fans leales; consulte esta encuesta). En mis secuencias de comandos de Perl, usaría el operador de acento grave para ejecutar un comando en el sistema operativo y devolver el resultado para continuar con la lógica en la secuencia de comandos.
[ También te puede interesar: Bash scripting:cómo escribir datos en archivos de texto]
El operador de acento grave también está disponible en los scripts de shell, y como es tan fácil de combinar con otros comandos, comencé a usarlo mucho. Sin embargo, hay una forma más "recomendada" de hacer lo mismo, usando el $ operador de paréntesis (paréntesis).
En este artículo, te muestro los pros y los contras de cada uno para usar en scripts de shell.
La funcionalidad básica de los acentos graves
El Open Group tiene una definición para el operador de acento grave, oficialmente denominado sustitución de comando. Este operador es no el carácter de comilla simple, pero otro carácter conocido como el acento grave (` ).
La idea es simple:
❯ echo "There are `ls | wc -l` files in this directory"
There are 3 files in this directory
Tengo un grupo de comandos muy simple, ls | wc -l que uso para enumerar y contar la cantidad de archivos en el directorio actual. Puedo hacer esto fácilmente de forma interactiva y ver exactamente cuál es el resultado. Luego puedo incrustarlo en mi echo principal comando.
En un script de shell, ciertamente podría hacer lo mismo, asignando el resultado de mi comando de conteo a una variable y luego usar la variable más tarde.
❯ file_count=`ls | wc -l`
❯ echo "There are $file_count files in this directory"
There are 3 files in this directory Y por supuesto, sería mejor si la idea fuera reutilizar el valor o si la operación a realizar no fue tan sencilla como en mi ejemplo.
Incrustar los comandos usando acentos graves es lo que yo clasificaría como "trucos rápidos y sucios".
Los padres $
Puedes conseguir el mismo resultado reemplazando los acentos graves por $ padres, como en el siguiente ejemplo:
❯ echo "There are $(ls | wc -l) files in this directory"
There are 3 files in this directory Aquí hay otro ejemplo, todavía muy simple pero un poco más realista. Necesito solucionar algo en mis conexiones de red, por lo que decido mostrar mis conexiones totales y en espera minuto a minuto.
❯ cat netinfo.sh
#!/bin/bash
while true
do
ss -an > netinfo.txt
connections_total=$(cat netinfo.txt | wc -l)
connections_waiting=$(grep WAIT netinfo.txt | wc -l)
printf "$(date +%R) - Total=%6d Waiting=%6d\n" $connections_total $connections_waiting
sleep 60
done
❯ ./netinfo.sh
22:59 - Total= 2930 Waiting= 977
23:00 - Total= 2923 Waiting= 963
23:01 - Total= 2346 Waiting= 397
23:02 - Total= 2497 Waiting= 541 No parece un enorme diferencia, ¿verdad? Solo tuve que ajustar la sintaxis. Bueno, hay algunas implicaciones que involucran los dos enfoques. Si eres como yo, que usa automáticamente los acentos graves sin siquiera parpadear, sigue leyendo.
Rechazo y recomendaciones
Desactivación suena como una mala palabra y, en muchos casos, podría ser realmente mala.
Cuando estaba investigando las explicaciones para el operador de acento grave, encontré algunas discusiones sobre "¿están en desuso los operadores de acento grave?"
La respuesta corta es:no en el sentido de "a punto de quedarse sin soporte y dejar de funcionar". Sin embargo, los acentos graves deben evitarse y reemplazarse por $ sintaxis de los padres.
Las principales razones para ello son (sin ningún orden en particular):
1. Los operadores de backticks pueden volverse complicados si los comandos internos también usan backticks.
- Tendrá que escapar de los acentos graves internos, y si tiene comillas simples como parte de los comandos o parte de los resultados, la lectura y la solución de problemas del script pueden resultar difíciles.
- Si empiezas a pensar en anidar operadores de acento grave dentro de otros operadores de acento grave, las cosas no funcionarán como se esperaba o no funcionarán en absoluto. No te molestes.
2. El $ El operador parens es más seguro y más predecible.
- Lo que codificas dentro del
$El operador parens se trata como un script de shell. Sintácticamente, es lo mismo que tener ese código en un archivo de texto, por lo que puede esperar que todo lo que codifique en un script de shell aislado funcione aquí.
Estos son algunos ejemplos de las diferencias de comportamiento entre los acentos graves y $ padres:
❯ echo '\$x'
\$x
❯ echo `echo '\$x'`
$x
❯ echo $(echo '\$x')
\$x
Puede encontrar ejemplos adicionales de las diferencias entre acentos graves y $ comportamiento de los padres aquí.
[ Hoja de referencia gratuita:obtenga una lista de utilidades y comandos de Linux para administrar servidores y redes. ]
Conclusión
Si compara los dos enfoques, parece lógico pensar que siempre/solo debe usar el $ acercamiento de los padres. Y podrías pensar que los operadores de acento grave solo los usan los administradores de sistemas de una era anterior.
Bueno, eso podría ser cierto, ya que a veces uso cosas que aprendí hace mucho tiempo, y en situaciones simples, mi "memoria muscular" simplemente lo codifica para mí. Para esos comandos ad-hoc que sabe que no contienen caracteres desagradables, es posible que esté bien usando acentos graves. Pero para cualquier cosa que sea más perenne o más compleja/sofisticada, vaya con $ acercamiento de los padres.