Apunte a dividir los programas en componentes más pequeños
Una de las cosas de las que los programadores suelen hablar es el deseo de dividir los programas en componentes o funciones más pequeños, para que sea más fácil de rastrear, leer y depurar.
Pero no es tan raro ver funciones monolíticas con muchos comentarios de código para ayudar a explicar lo que está pasando en el programa.
No estoy criticando esto, realmente, porque no conozco las restricciones bajo las cuales trabajaba un programador. Eso es:
- ¿Cuál fue el presupuesto que tenía al construir el programa?
- ¿Cuánto tiempo se dio para completar el proyecto?
- ¿Había mucha gente trabajando en el proyecto?
- ¿Se le dio tiempo al programador para escribir el código para que pudiera probarlo unitariamente, refactorizarlo o simplemente hacerlo más fácil de leer?
En resumen, hay muchas razones, creo, por las que podemos leer "código incorrecto", y no siempre tiene que ser culpa del programador (eso es lo más natural que tenemos que descartar cuando leemos algo que no nos gusta).
Sin embargo, ¿significa esto que no debemos esforzarnos por refactorizar o escribir código de tal manera que sea más fácil de entender? Por supuesto que no. Suponiendo que tenemos el tiempo para hacerlo, ¿cómo podríamos hacerlo?
Divida los programas en componentes más pequeños
Cuando se trata de escribir sobre un tema como este, especialmente en una economía tan activa como el comercio electrónico en WordPress, puede ser un desafío.
«Seamos específicos, Bob".
Es decir, puedo escribir sobre ello a un nivel muy detallado utilizando un conjunto de complementos, observando los datos, diseccionando consultas y mostrando cómo hacerlo. O puedo escribirlo a un nivel ligeramente superior con el objetivo final de mostrar cómo dividir los programas en componentes más pequeños.
Debido a que hay tantas formas en que se puede lograr lo primero, estoy optando por lo segundo. Es decir, esto no necesariamente usará complementos específicos, son consultas directas. Sin embargo, utilizará ejemplos de alto nivel para ayudarlo a recorrer lo que podría ser una serie de consultas y bucles y dividirlos en funciones más pequeñas.
Un ejemplo genérico
Por ejemplo, supongamos que estoy trabajando en una característica de un complemento de WordPress cuyo objetivo final es recuperar todos los diversos métodos de pago que un usuario ha almacenado y que están relacionados con su cuenta.
El desafío es que esta información está dispersa en varias tablas de la base de datos (debido a los diversos complementos que se utilizan), por lo que hay algunas consultas que deben ejecutarse y luego recuperarse.
Los pasos para hacer tales consultas podrían ser algo como esto:
- obtener el ID de cliente del usuario actual,
- obtener todos los números de identificación del pedido del cliente
- determinar qué métodos de pago se utilizaron para cada pedido
- recuperar dichos métodos de pago y luego enviar la información al cliente
Según cómo esté configurada la base de datos, según su nivel de destreza en SQL y según cómo funcionen en conjunto los diversos complementos para manejar todos los datos anteriores, puede ser fácil escribir una consulta grande para recuperar esta información.
Pero si ha trabajado con comercio electrónico en WordPress y varios complementos, sabe que no siempre es tan fácil.
En cambio, estás viendo algo como:
- necesitamos obtener el perfil de un cliente de los metadatos del usuario,
- necesitamos encontrar todos los pedidos que ha realizado el usuario, y esto a menudo se puede asociar con la publicación o la tabla de metadatos de la publicación,
- los métodos de pago muy probablemente pueden almacenarse en su tabla asociada al usuario a través de algún tipo de token,
- el token anterior se encuentra en una tabla y está relacionado con una información determinada en otra tabla de la que luego debe deducir al observar los datos que existen en toda la base de datos.
En última instancia, debe crear un conjunto de consultas solo al comprender primero cómo consultar los datos que está buscando. Ya es bastante desafiante. Pero cuando pueda hacer eso, digamos que está escribiendo sus consultas secuencialmente y luego usando los resultados de cada una para obtener el resultado deseado.
Esto puede resultar en algo como esto :
<?php
// First, read the user ID and meta value to get authorization information
global $wpdb;
$results = $wpdb->get_results(
$wpdb->prepare(
"
SELECT
user_id, meta_value
FROM $wpdb->usermeta
WHERE meta_key LIKE %s
AND user_id = %d
",
'%customer_profile_id%',
filter_input(INPUT_GET, 'customer_id')
),
ARRAY_A
);
$result = isset($results[0])? array_column($results[0], 'meta_value'): [];
if (empty($result)) {
return $result;
}
// Get the ID of the current customer.
$customers = $wpdb->get_results(
$wpdb->prepare(
"", // Your custom query goes here.
filter_input(INPUT_GET, 'customer_id')
),
ARRAY_A
);
$customer = isset($customers[0])? array_column($customers[0], 'customer_id'): [];
if (empty($customer)) {
return $customer;
}
// Get all of the order IDs from the set of orders returned from the previous query.
$orderIds = $wpdb->get_results(
$wpdb->prepare(
"", // Your custom query goes here.
$customer
),
ARRAY_A
);
return $orderIds;
// Finally, get all of the payment methods for the orders based on their Ids.
$orders = [];
foreach ($orderIds as $orderId) {
$results = $wpdb->get_results(
$wpdb->prepare(
"" // The query for retrieving various payment method information based on the $orderId
),
ARRAY_A
);
if (empty($results)) {
continue;
}
$orders[$orderId] = $results;
}
// Now send the information back to the user.
wp_send_json_success($orders);
Pero no tiene por qué ser así.
En primer lugar, todas estas son consultas independientes con conjuntos de resultados independientes, aunque deben usarse en conjunto. Esto significa que podemos separarlos y evaluar los resultados de cada uno antes de continuar con el siguiente paso.
Además, nos permite escribir funciones más pequeñas y más cohesivas. Aunque pueden depender unos de otros, podemos configurar cada función para que acepte un argumento (o un conjunto de argumentos de los que podemos recuperar toda la información).
Quizás el resultado final sea algo como esto :
<?php
public function getPaymentMethods()
{
$authInfo = $this->getAuthorizationInformation();
$currentCustomerId = $this->getCurrentCustomerId($authInfo);
$orders = $this->getCustomerOrders($currentCustomerId);
$paymentMethods = $this->getPaymentMethodsFromOrders($orders);
wp_send_json_success($orders);
}
private function getAuthorizationInformation()
{
global $wpdb;
$authInfo = $wpdb->get_results(
$wpdb->prepare(
"
SELECT
user_id, meta_value
FROM $wpdb->usermeta
WHERE meta_key LIKE %s
AND user_id = %d
",
'%customer_profile_id%',
filter_input(INPUT_GET, 'customer_id')
),
ARRAY_A
);
return isset($authInfo[0])? array_column($authInfo[0], 'meta_value'): [];
}
private function getCurrentCustomerIdFromAuthInfo($authInfo)
{
global $wpdb;
$customers = $wpdb->get_results(
$wpdb->prepare(
"", // Your custom query goes here.
$authInfo;
),
ARRAY_A
);
return isset($customerId[0])? array_column($customerId[0], 'meta_value'): [];
}
private function getCustomerOrders($customerId)
{
global $wpdb;
$orderIds = $wpdb->get_results(
$wpdb->prepare(
"", // Your custom query goes here.
$customerId
),
ARRAY_A
);
return empty($orderIds)? []: $orderIds;
}
private function getPaymentMethodsFromOrders($orderIds)
{
$paymentMethods = [];
foreach ($orderIds as $orderId) {
$results = $wpdb->get_results(
$wpdb->prepare(
"" // The query for retrieving various payment method information based on the $orderId
),
ARRAY_A
);
if (empty($results)) {
continue;
}
$paymentMethods[$orderId] = $results;
}
return $paymentMethods;
}
Por supuesto, no puedo mostrar ningún SQL real, bueno, al menos no en todas partes, porque no conozco la configuración general ni sé exactamente qué complementos o esquemas son con los que está trabajando.
Pero ese nunca ha sido el punto de esta publicación.
En cambio, el punto final que estoy tratando de transmitir es este: aunque podemos estar trabajando bajo restricciones muy limitadas, aún podemos dividir los programas en componentes más pequeños que nos ayuden a describir lo que está sucediendo, comprender cómo se hace y luego enviar datos de ida y vuelta entre varias funciones y hacia y desde el usuario.