¡Hola, compañeros desarrolladores! ? Hoy, profundicemos en un aspecto crucial de escribir JavaScript limpio y fácil de mantener: administrar argumentos de funciones

El problema de demasiados argumentos

¿Alguna vez has encontrado una función que se parece a esta?

function createMenu(title, body, buttonText, cancellable, theme, fontSize, callback) {
  // ...a whole lot of logic here
}

Si es así, conoces el dolor de tratar de recordar el orden de los argumentos, o peor aún, depurarlos cuando alguien inevitablemente los confunde. ?

La regla de los dos argumentos

Aquí tienes una regla de oro: Intenta limitar tus funciones a dos argumentos o menos.
¿Por qué? Aquí hay algunas razones de peso:

• Capacidad de prueba mejorada: Menos argumentos significa menos casos de prueba para cubrir todas las posibilidades.
• Lectura mejorada: es más fácil entender el propósito de una función de un vistazo.
• Carga cognitiva reducida: menos malabarismos mentales con los parámetros para los desarrolladores que utilizan la función.

Pero ¿qué pasa si necesito más parámetros?

¡Gran pregunta! Aquí es donde entra en juego la magia de la desestructuración de objetos. Mira esto:

function createMenu({ title, body, buttonText, cancellable, theme = 'light', fontSize = 16, callback = () => {} }) {
  // Your implementation here
}

// Usage
createMenu({
  title: "Settings",
  body: "Adjust your preferences",
  buttonText: "Save",
  cancellable: true
});

Los beneficios de este enfoque

• Simula parámetros con nombre: Puede proporcionar argumentos en cualquier orden. Autodocumentación: la firma de la función muestra claramente qué propiedades se esperan. Valores predeterminados: establece fácilmente valores predeterminados para parámetros opcionales. Previene efectos secundarios: La desestructuración de clones valores primitivos, ayudando a evitar mutaciones accidentales. Linter-Friendly: Las herramientas pueden advertirle sobre propiedades no utilizadas.

Consejo profesional: impulso de TypeScript

Si estás usando TypeScript, puedes ir un paso más allá:

interface MenuOptions {
  title: string;
  body: string;
  buttonText: string;
  cancellable: boolean;
  theme?: 'light' | 'dark';
  fontSize?: number;
  callback?: () => void;
}

function createMenu(options: MenuOptions) {
  // Implementation
}

¡Esto agrega seguridad de tipos y autocompletado, lo que hace que su código sea aún más sólido!

Concluyendo

Al adoptar este patrón, descubrirá que sus funciones se vuelven más flexibles, más fáciles de usar y de mantener. Es un pequeño cambio que puede tener un gran impacto en la calidad de su código.

¿Qué piensas sobre este enfoque? ¿Tiene algún otro consejo para gestionar los argumentos de funciones? ¡Discutamos en los comentarios!

¡Feliz codificación! ?