0Pricing
Linux Command Line & Bash Scripting Mastery · Lección

Buenas prácticas y linting en scripts

Aprenda sobre convenciones de código, comentarios y herramientas como ShellCheck para escribir scripts de Bash limpios, legibles y sin errores.

Buenas prácticas y linting en scripts es una lección gratuita de Linux Command Line & Bash Scripting Mastery en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Linux Command Line & Bash Scripting Mastery, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Linux Command Line & Bash Scripting Mastery incluye 4 lecciones en total.

¿Por qué aplicar buenas prácticas de scripting?

Escribir scripts de Bash es potente, pero sin buenos hábitos pueden resultar difíciles de entender, mantener y depurar.

Las buenas prácticas son pautas que le ayudan a escribir código limpio, robusto y legible. Hacen que sus scripts sean:

  • Más fáciles de leer: Para usted y para otras personas.
  • Más fáciles de mantener: Más sencillos de actualizar o corregir.
  • Menos propensos a errores: Al prevenir errores habituales.
  • Mejores para la colaboración: Al estandarizar el aspecto y el comportamiento del código.

Comente para mejorar la claridad

Los comentarios son fundamentales para explicar por qué el código hace algo, no solo qué hace. Funcionan como notas para usted en el futuro o para otros desarrolladores.

Use comentarios para:

  • Describir el propósito general del script al principio.
  • Explicar la lógica compleja o las secciones difíciles.
  • Documentar las funciones: su propósito, argumentos y valores de retorno.

Inicie un comentario con el símbolo # (almohadilla).

#!/bin/bash
# This script demonstrates commenting best practices.
# Author: CoddyKit
# Date: 2023-10-27

# Function: greet_user
# Description: Prints a greeting message to the console.
# Arguments:
#   $1 - The name of the user to greet.
greet_user() {
  local name="$1" # Store the first argument in a local variable.
  echo "Hello, ${name}!" # Output the greeting message.
}

# Main script execution starts here.
echo "Script execution started."
greet_user "CoddyKit Learner" # Call the function with a specific name.
echo "Script execution finished."

Convenciones claras para los nombres

Los nombres significativos hacen que su script sea más fácil de seguir. Evite las variables de una sola letra, salvo que sean contadores de bucle habituales (como i o j).

Convenciones generales:

  • Variables: Use nombres descriptivos (por ejemplo, user_name y log_file). Use UPPERCASE para las variables de entorno o las constantes globales. Use lowercase_with_underscores para las variables locales del script.
  • Funciones: Use lowercase_with_underscores, normalmente comenzando con un verbo (por ejemplo, process_data y check_status).
  • Scripts: Use lowercase_with_hyphens (por ejemplo, backup-script.sh).

Formato y sangría coherentes

Un formato coherente, como la sangría y el espaciado, mejora enormemente la legibilidad. ¡Imagine leer un libro con sangrías de párrafo inconsistentes!

Aspectos clave:

  • Use 2 o 4 espacios para la sangría (a menudo se desaconsejan las tabulaciones).
  • Mantenga las líneas cortas (menos de 80 caracteres es una buena regla general para los terminales).
  • Use líneas en blanco para separar bloques lógicos de código.
  • Alinee los elementos relacionados cuando tenga sentido.

La coherencia es más importante que el estilo específico que elija.

Robustez: «set -u» (nounset)

La opción set -u (o set -o nounset) resulta muy útil para prevenir errores causados por erratas o variables desasignadas accidentalmente. Si su script intenta usar una variable a la que no se ha asignado ningún valor, set -u terminará inmediatamente el script con un error.

Esto ayuda a detectar los errores pronto y evita comportamientos inesperados más adelante en el script.

Pruebe a ejecutar el código siguiente. Está diseñado para terminar pronto porque UNSET_NAME no está definida.

#!/bin/bash
# Demonstrating 'set -u' (nounset)

set -u # Exit if an unset variable is used

MY_GREETING="Hello"
echo "${MY_GREETING}, CoddyKit!"

# This variable is NOT set. With 'set -u', the script will exit here.
echo "Your name is: ${UNSET_NAME}" 

echo "This line will NOT be reached if 'set -u' is active and UNSET_NAME is indeed unset."

Robustez: «set -o pipefail»

Cuando conecta comandos mediante tuberías (por ejemplo, cmd1 | cmd2 | cmd3), Bash normalmente solo informa del estado de salida del último comando de la tubería. Esto significa que, si cmd1 falla, pero cmd2 y cmd3 se ejecutan correctamente, ¡la tubería aún podría indicar que todo se ejecutó correctamente!

set -o pipefail cambia este comportamiento. Si falla cualquier comando de una tubería (es decir, devuelve un estado de salida distinto de cero), el estado de salida de toda la tubería será ese valor distinto de cero.

Esto hace que sus canalizaciones sean más fiables, ya que indica de inmediato si ha fallado un comando inicial.

#!/bin/bash
# Demonstrating 'set -o pipefail'

set -o pipefail # Ensures pipe's exit status is the last non-zero command

echo "Running a failing command in a pipe:"
echo "---"

# 'false' command always fails (exit status 1).
# 'cat /dev/null' always succeeds (exit status 0).
# With 'set -o pipefail', the pipe's overall exit status will be 1 from 'false'.
false | cat /dev/null

# This line will only be reached if the pipe above succeeds.
echo "---"
echo "Script finished successfully (this line won't show if pipe failed with set -o pipefail)."

Introducción a ShellCheck

Incluso aplicando buenas prácticas, es fácil pasar por alto pequeños errores de sintaxis o problemas habituales. ¡Ahí es donde entra en juego ShellCheck!

ShellCheck es una herramienta de análisis estático (un «linter») para scripts de shell. Lee su script y señala:

  • Errores de sintaxis.
  • Errores habituales de principiantes.
  • Problemas semánticos sutiles.
  • Problemas de portabilidad entre distintos shells.

Ofrece sugerencias útiles, a menudo con enlaces a explicaciones más detalladas.

ShellCheck en acción: un script incorrecto

Veamos un script con algunos problemas habituales. Es posible que no hagan que el script se bloquee de inmediato, pero son malas prácticas o posibles errores.

Imagine que tiene este script guardado como bad_script.sh. Para ejecutar ShellCheck sobre él, escribiría: shellcheck bad_script.sh

¡Intente detectar los problemas antes de ejecutar ShellCheck!

#!/bin/bash
# A script with some common issues

MY_NAME=coddykit # Variable assignment needs no space, but quoting is good for values
echo "Hello $MY_NAME!" # Missing quotes around variable expansion

if [ $1 = "admin" ]; then # Missing quotes around $1
  echo "Welcome, administrator."
fi

# A simple loop with potential issues
for file in *.txt; do # Unquoted glob could expand to multiple arguments
  echo File: $file # Missing quotes around $file
done

Corregir las advertencias de ShellCheck

ShellCheck mostraría algo como: SC2086: Double quotes missing around "$MY_NAME". A menudo proporciona un código específico (como SC2086) que puede consultar para obtener más detalles.

Este es el script anterior, corregido según las recomendaciones de ShellCheck y las prácticas recomendadas generales:

Observe el uso de comillas dobles "" alrededor de las expansiones de variables y las sustituciones de comandos para evitar la división de palabras y la expansión de comodines, que son fuentes habituales de errores.

#!/bin/bash
# A script with issues fixed by ShellCheck

MY_NAME="CoddyKit" # Quote variable assignment values
echo "Hello ${MY_NAME}!" # Always quote variable expansions

if [ "$1" = "admin" ]; then # Quote positional parameters like $1
  echo "Welcome, administrator."
fi

# A simple loop with corrected quoting
for file in *.txt; do 
  echo "File: ${file}" # Quote variable expansions, especially in loops
done

Comprobación de buenas prácticas

¿Cuáles de las siguientes se consideran buenas prácticas al escribir scripts de Bash?

Recapitulación: scripting profesional

¡Enhorabuena! Ha aprendido a llevar sus scripts de Bash de un nivel funcional a uno profesional.

Hemos visto lo siguiente:

  • La importancia de las prácticas recomendadas para facilitar la legibilidad y el mantenimiento.
  • El uso de comentarios y convenciones de nomenclatura para mejorar la claridad.
  • Cómo hacer que los scripts sean robustos con set -u y set -o pipefail.
  • La utilidad de ShellCheck para encontrar problemas automáticamente y mejorar el código.

Al aplicar estos principios, escribirá scripts de Bash más fiables, comprensibles y fáciles de mantener en equipo. ¡Siga practicando!

Preguntas frecuentes

¿La lección «Buenas prácticas y linting en scripts» es gratis?

Sí — el texto completo de «Buenas prácticas y linting en scripts» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Linux Command Line & Bash Scripting Mastery, actualiza a CoddyKit PRO. El curso de Linux Command Line & Bash Scripting Mastery incluye 4 lecciones en total.

¿Qué aprenderé en «Buenas prácticas y linting en scripts»?

Aprenda sobre convenciones de código, comentarios y herramientas como ShellCheck para escribir scripts de Bash limpios, legibles y sin errores. Practicas Linux Command Line & Bash Scripting Mastery con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Linux Command Line & Bash Scripting Mastery?

No se requiere experiencia previa. Linux Command Line & Bash Scripting Mastery en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.

¿Cuánto tiempo toma la lección «Buenas prácticas y linting en scripts»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Linux Command Line & Bash Scripting Mastery?

Sí. Cada lección de Linux Command Line & Bash Scripting Mastery incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Depuración de scripts de Bash (set -x, trap)
  2. Gestión de errores y estado de salida
  3. Buenas prácticas y linting en scripts
  4. Pruebas de scripts de Bash con Bats
← Volver a Linux Command Line & Bash Scripting Mastery