4 cosas que debes desaprender para convertirte en un mejor programador
¡Quítese las ruedas de entrenamiento de codificación!
Mi pareja se inscribió recientemente en un campo de entrenamiento de codificación virtual.
Mientras la veía abordar sus primeras lecciones de programación, me sorprendió descubrir cuánto de lo que aprendí en la escuela no se traducía en trabajo.
En este artículo, identificaremos cuatro construcciones de programación que pueden haber sido fundamentales cuando descubrió por primera vez cómo funciona la programación, pero que lo retrasarán en la siguiente etapa de su viaje.
Desaprender bucles
Los bucles son una de las primeras construcciones que aprende como estudiante de programación de computadoras. Un simple ciclo while demuestra el poder de la automatización, donde puede ejecutar repetidamente un conjunto de instrucciones hasta cumplir una condición.
Puede tener la tentación de usar un ciclo while o un ciclo for siempre que vea una colección de elementos, pero rara vez es el mejor método.
const groceries = [
{
nombre: ‘Mascarillas’,
precio: 17,50,
},
{
nombre: ‘Toallitas desinfectantes’,
precio: 24,99,
},
{
nombre: ‘Gafas’,
precio: 8,99,
},
{
nombre: ‘Guantes ‘,
precio: 25,99,
},
{
nombre:’ Desinfectantes de manos ‘,
precio: 24,99,
},
];
Por ejemplo, dada una matriz de objetos, donde cada objeto representa un artículo de comestibles.
¿Qué haría si quisiera imprimir el nombre de cada artículo de la tienda?
let index = 0;while (index <groceries.length) {
console.log (ultramarinos [índice] .name);
índice = índice + 1;
}
Este bucle while ciertamente logra lo que desea, pero debe realizar un seguimiento de un índice para acceder a la variedad de comestibles cada vez que desee agarrar un artículo. También existe el riesgo de entrar en un bucle infinito si olvida incrementar su índice.
Considere este enfoque alternativo:
groceries.forEach ((item) => {
console.log (item.name);
});
forEach es una función de orden superior que toma otra función como argumento y ejecuta la función proporcionada una vez para cada elemento de la matriz. Al aprovechar forEach, eliminamos el código extraño para rastrear y acceder a la matriz usando un índice, y acercamos la carne de nuestra lógica: imprime el nombre de cada artículo de la tienda.
Los bucles while y for son generalmente demasiado amplios para captar la intención de nuestro código. Si desea escribir un mejor código, comience reemplazando sus bucles con funciones con más especificidad.
A continuación se muestran algunos ejemplos más relacionados para mutar una lista y resumir una lista.
// Antes de:let index = 0;
precios constantes = [];while (índice <groceries.length) {
precios.push (comestibles [índice] .price);
índice = índice + 1;
}// Después:groceries.map ((artículo) => {
devolver artículo.precio;
});
// Antes de:let index = 0;
deje total = 0;while (índice <comestibles.longitud) {
total = total + comestibles [índice] .precio;
índice = índice + 1;
}// Después:comestibles.reducir ((suma, artículo) => {
devolver suma + = artículo.precio;
}, 0);
Desaprender condicionales
Cada vez que agrega una declaración else, aumenta la complejidad de su código al doble. Las construcciones condicionales como las sentencias if-else y switch son bloques fundamentales en el mundo de la programación.
Pero también pueden interponerse cuando desee escribir código limpio y extensible.
Afortunadamente, existen algunos trucos para deshacerse de los condicionales.
Estructuras de datos
Considere la siguiente función para calcular el descuento:
descuento constante = (monto, código) => {
interruptor (código) {
caso ‘DIJFNC’:
monto devuelto * 0.80;
caso ‘XPFJVM’:
monto devuelto * 0.75;
caso ‘FJDPCX’:
cantidad devuelta * 0.50;
}
};
Debe agregar un nuevo caso en la declaración de cambio cada vez que desee agregar un nuevo código de descuento. Y si comete un error, rompe todo el cálculo.
Ahora reemplacemos el condicional con un objeto.
const DISCOUNT_MULTIPLIER = {
'DIJFNC': 0.80,
'XPFJVM': 0.75,
'FJDPCX': 0.50,
};descuento constante = (monto, código) => {
monto devuelto * DISCOUNT_MULTIPLIER [código];
};
Esta reescritura desacopla eficazmente los datos de la lógica de cálculo central, lo que hace que sea más fácil modificarlos de forma independiente.
Polimorfismo
La segunda forma de reemplazar los condicionales es aprovechando una característica clave de los lenguajes de programación orientados a objetos: el polimorfismo.
const checkout = (amount, paymentMethod) => {
switch (paymentMethod) {
case 'credit-card':
// Código complejo para cargar $ {amount} a la tarjeta de crédito.
descanso;
case 'debit-card':
// Código complejo para cargar $ {amount} a la tarjeta de débito.
descanso;
case 'cash':
// Código complejo para poner $ {amount} en la caja registradora.
descanso;
}
};clientes constantes = [
{
monto: 75.00,
método de pago: 'tarjeta de crédito',
},
{
monto: 50,00,
método de pago: 'tarjeta de débito',
},
{
monto: 25,00,
método de pago: 'efectivo',
},
];clientes.paraCada (({monto, método de pago}) => {
pago (monto, método de pago);
});
Las líneas de código para manejar varios métodos de pago intercaladas con la declaración de cambio hacen que el código sea difícil de leer. Y para colmo de males, cada vez que desee modificar la lógica de un método de pago específico, corre el riesgo de romper los otros dos porque todos viven dentro de la misma función.
class CreditCardCheckout {
cargo estático (monto) {
// Código complejo para cargar $ {monto} a la tarjeta de crédito.
}
}class DebitCardCheckout {
cargo estático (monto) {
// Código complejo para cargar $ {monto} a la tarjeta de débito.
}
}class CashCheckout {
cargo estático (monto) {
// Código complejo para poner $ {monto} en la caja registradora.
}
}clientes constantes = [
{
monto: 75.00,
método de pago: pago con tarjeta de crédito,
},
{
monto: 50,00,
método de pago: pago con tarjeta de débito,
},
{
monto: 25,00,
método de pago: pago en efectivo,
},
];clientes.paraCada (({monto, método de pago}) => {
método de pago.cargo (monto);
});
El polimorfismo nos ayuda a romper la larga declaración del cambio. Cada clase es responsable de exactamente un método de pago.
Desaprender nombres de variables literales
Los tutoriales de programación están plagados de nombres pésimos de variables y funciones, en parte porque los ejemplos de código a menudo no necesitan proporcionar el contexto completo para ilustrar cualquier punto que esté tratando de explicar.
Por ejemplo:
const arr = [
'Cereal de desayuno',
'Dulces y bocadillos',
'Lácteos',
'Productos de papel y suministros de limpieza',
];const func = (n) => {
const i = arr.findIndex (i => i === n);
console.log (i);
};func ('Lácteos');
Este bloque de código hace un buen trabajo al demostrar el uso de findIndex, pero es completamente inapropiado en un proyecto real.
Los nombres de las variables no nos dicen nada sobre por qué existen. Es difícil para el lector y aún más difícil de modificar cuando no tenemos pistas sobre para qué sirven.
Para escribir mejores nombres, tenemos que empezar por conocer el contexto. Hay una lista de nombres comunes en los pasillos de las tiendas de comestibles.
Los nombres de los pasillos están ordenados de manera significativa, de modo que cuando llamemos a la función con un nombre de pasillo determinado, devolveremos su posición en esta lista, que representa el número de pasillo. Podemos reescribir el código de la siguiente manera:
pasillos const = [
'Cereal de desayuno',
'Dulces y bocadillos',
'Lácteos',
'Productos de papel y suministros de limpieza',
];const printAisleNumber = (nombre) => {
const número = pasillos.findIndex ((pasilloNombre) => {
retorno pasilloNombre === nombre;
}); console.log (número);
};printAisleNumber ('Lácteos');
Cuando se le ocurre el nombre de variable correcto, muestra que realmente comprende el contexto del problema que resuelve su código.
Los nombres de variables con propósito elevarán su código de meras instrucciones computacionales a una guía de usuario que ayuda a los lectores a aprender sobre su trabajo.
Desaprender el alcance global
Cuando empiece a programar, probablemente comience con un hello worldprograma simple . Y a partir de ahí, aprende a escribir código en un solo archivo y observa cómo el programa ejecuta su código línea por línea de arriba a abajo.
Nunca sospechará que una variable que declaró al principio del archivo no estará disponible en otro lugar.
Esta idea de todo lo que escribe vive dentro de un espacio global accesible para todos; es un obstáculo para trabajar de manera efectiva con abstracciones. No tienes ningún ímpetu para crear abstracciones que encapsulen tu código.
Mi consejo sería olvidarse del alcance global. Trate cada función, objeto y clase como un nuevo universo. Concéntrese en cómo crear resúmenes para representar sus ideas y cómo esas ideas interactúan entre sí.
TL; DR
- Reemplazar bucles con funciones de orden superior
- Reemplazar condicionales con estructuras de datos y polimorfismo
- Reemplazar nombres de variables literales con nombres de variables con propósito
- Olvídese del alcance global que existe
