Dependiendo de la situación específica, los desarrolladores promedio suelen ser entre un 10% y un 20% menos eficientes que los desarrolladores excelentes. Los buenos desarrolladores son más eficientes porque tienen amplia experiencia y buenos hábitos de programación. Los malos hábitos de programación afectarán la eficiencia. Este artículo le ayudará a convertirse en un mejor programador al demostrarle algunos buenos hábitos de programación.
Estos buenos hábitos de programación no sólo aumentan la eficiencia, sino que también le permiten escribir código que sea fácil de mantener durante todo el ciclo de vida de su aplicación. El código que escriba puede requerir mucho mantenimiento. El mantenimiento de la aplicación es un gasto importante. Desarrollar buenos hábitos de programación puede mejorar la calidad del diseño (como la modularidad), haciendo que el código sea más fácil de entender y, por lo tanto, de mantener, al tiempo que reduce los costos de mantenimiento.
Los malos hábitos de programación provocarán defectos en el código, lo que dificultará su mantenimiento y modificación, y es probable que introduzcan otros defectos al modificar. Los siguientes son cinco buenos hábitos de programación que pueden ayudar al código PHP a evitar estos errores:
◆ Utilice buenos nombres.
◆Dividir en partes más pequeñas.
◆Agregar comentarios al código.
◆ Manejar condiciones de error.
◆No utilice copiar y pegar.
Estos hábitos se detallan a continuación:
Utilice buenos nombres
El uso de buenos nombres es el hábito de programación más importante porque los nombres descriptivos hacen que el código sea más fácil de leer y comprender. Que el código sea fácil de entender depende de si se puede mantener en el futuro. Incluso si el código no está comentado, facilitará enormemente cambios futuros si es fácil de entender. El objetivo de este hábito es hacer que el código que escriba sea tan fácil de leer y comprender como un libro.
Mal hábito: nombres vagos o sin sentido
El código del Listado 1 contiene nombres de variables que son demasiado cortos, abreviaturas ilegibles y nombres de métodos que no reflejan la funcionalidad del método. Si el nombre del método da la impresión de que se supone que debe hacer una cosa, pero en realidad hace otra cosa, esto causará serios problemas porque será engañoso.
Listado 1. Malos hábitos: nombres vagos o sin sentido
<?php
function getNBDay($d){
cambiar($d) {
caso 5:
caso 6:
caso 7:
devolver 1;
por defecto:
retorno ($d + 1);
}
}
$día = 5;
$próximoDía = getNBDay($día);
echo ("El día siguiente es: " . $próximoDía . "n")
;
Buenas prácticas: nombres descriptivos y concisos
El código del Listado 2 demuestra buenas prácticas de programación. Los nombres de los nuevos métodos son altamente descriptivos y reflejan el propósito del método. Asimismo, los nombres de las variables modificados son más descriptivos. La única variable que sigue siendo la más corta es $i, que en este listado es una variable de bucle. Aunque muchas personas desaprueban el uso de nombres demasiado cortos, es aceptable (e incluso beneficioso) usarlos en variables de bucle porque indican claramente la función del código.
Listado 2. Buenas prácticas: nombres descriptivos y concisos
<?php
definir ('LUNES', 1);
definir ('MARTES', 2);
definir ('MIÉRCOLES', 3);
definir ('JUEVES', 4);
definir ('VIERNES', 5);
definir ('SÁBADO', 6);
definir ('DOMINGO', 7);
/*
*
* @param $díaDeSemana
* @return int Día de la semana, siendo 1 el lunes y así sucesivamente.
*/
función encontrarNextBusinessDay($dayOfWeek){
$siguienteDíaEmpresa = $díaDeLaSemana;
cambiar ($ día de la semana) {
caso VIERNES:
caso SÁBADO:
caso DOMINGO:
$nextBusinessDay = LUNES;
romper;
por defecto:
$siguienteDíaBusical += 1;
romper;
}
devolver $nextBusinessDay;
}
$día = VIERNES;
$siguienteBusDay = findNextBusinessDay($día);
echo ("El día siguiente es:" . $nextBusDay . "n");
?＞
Le recomendamos que divida las condiciones grandes en un método y luego nombre el método con un nombre que describa la condición. Esta técnica puede mejorar la legibilidad del código y concretar la condición para que pueda extraerse e incluso reutilizarse. También es fácil actualizar los métodos si las condiciones cambian. Debido a que un método tiene un nombre significativo, refleja el propósito del código y hace que el código sea más fácil de leer.
en partes más pequeñas
antes de continuar con la programación. Si continúa programando mientras resuelve un problema urgente, la función será cada vez más larga. A la larga, esto no es un problema, pero querrás recordar volver atrás y refactorizarlo en partes más pequeñas.
Refactorizar es una buena idea, pero deberías acostumbrarte a escribir código más corto y centrado. Los métodos breves se pueden leer en una ventana y son fáciles de entender. Si un método es demasiado largo para leerlo en una ventana, resulta difícil seguirlo porque no se puede seguir rápidamente la idea completa de principio a fin.
Al crear métodos, debe adquirir el hábito de que cada método haga solo una cosa. Este es un buen hábito porque: en primer lugar, si un método sólo hace una cosa, es más probable que se reutilice; en segundo lugar, dicho método es fácil de probar; y en tercer lugar, dicho método es fácil de entender y cambiar;
Mal hábito: métodos demasiado largos (hacer demasiadas cosas)
El Listado 3 muestra una función muy larga que tiene muchos problemas. Hace muchas cosas, por lo que no es lo suficientemente compacto. También es más fácil de leer, depurar y probar. Las cosas que hace incluyen iterar sobre un archivo, crear una lista, asignar valores a cada objeto, realizar cálculos y más.
Listado 3. Mal hábito: función demasiado larga
<?php
función writeRssFeed($usuario)
{
//Obtener la información de conexión a la base de datos
// busca las preferencias del usuario...
$enlace = mysql_connect('mysql_host', 'mysql_user', 'mysql_password')
O morir(mysql_error());
// Consulta
$perfsQuery = sprintf("SELECCIONE max_stories DESDE user_perfs DONDE usuario= '%s'",
mysql_real_escape_string($usuario));
$resultado = mysql_query($consulta, $enlace);
$max_stories = 25; // por defecto es 25;
si ($fila = mysql_fetch_assoc($resultado)) {
$max_historias = $fila['max_historias'];
}
// ve a buscar mis datos
$perfsQuery = sprintf("SELECCIONAR * DE historias DONDE post_date = '%s'",
mysql_real_escape_string());
$resultado = mysql_query($consulta, $enlace);
$feed = "＜rss version="2.0"＞" .
"<canal>".
"＜título＞Mi gran feed＜/título＞".
"＜enlace＞ http://www.example.com/feed.xml ＜/enlace＞" .
"＜descripción＞El mejor feed del mundo＜/descripción＞".
"＜idioma＞en-us＜/idioma＞" .
"＜pubDate＞martes, 20 de octubre de 2008 10:00:00 GMT＜/pubDate＞".
"＜lastBuildDate＞martes, 20 de octubre de 2008 10:00:00 GMT＜/lastBuildDate＞" .
"＜docs＞ http://www.example.com/rss ＜/docs＞" .
"<generador>Mi generador de feeds</generator>".
"＜managingEditor＞ [email protected] ＜/managingEditor＞" .
"＜webMaster＞ [email protected] ＜/webMaster＞" .
"<ttl>5</ttl>";
// construir el feed...
mientras ($fila = mysql_fetch_assoc($resultado)) {
$título = $fila['título'];
$enlace = $fila['enlace'];
$descripción = $fila['descripción'];
$fecha = $fila['fecha'];
$guid = $fila['guid'];
$feed .= "<elemento>";
$feed .= "<título＞" $título .
$feed .= "<enlace>" $enlace .= "</enlace>";
$feed .= "＜descripción＞ " . $descripción "＜/descripción＞";
$feed .= "<fechapub>" $fecha "</fechapub>";
$alimentación .= "<guid>" .
$feed .= "＜/item＞";
}
$feed .= "＜/rss";
// escribe el feed en el servidor...
echo($feed);
}
?>Si escribe algunos métodos más como este, el mantenimiento se convertirá en un verdadero problema.
Buen hábito: lista de métodos manejables y específicos de funciones
4 Reescriba el método original en un método más compacto y legible. En este ejemplo, un método largo se divide en varios métodos cortos y cada método corto es responsable de una cosa. Este código es muy útil para futuras reutilizaciones y pruebas.
Listado 4. Buenas prácticas: enfoque específico de función y fácil de administrar
<?php
function createRssHeader()
{
devolver "<rss versión="2.0">" .
"<canal>".
"＜título＞Mi gran feed＜/título＞".
"＜enlace＞ http://www.example.com/feed.xml ＜/enlace＞" .
"＜descripción＞El mejor feed del mundo＜/descripción＞".
"＜idioma＞en-us＜/idioma＞" .
"＜pubDate＞martes, 20 de octubre de 2008 10:00:00 GMT＜/pubDate＞".
"＜lastBuildDate＞martes, 20 de octubre de 2008 10:00:00 GMT＜/lastBuildDate＞" .
"＜docs＞ http://www.example.com/rss ＜/docs＞" .
"<generador>Mi generador de feeds</generator>".
"＜managingEditor＞ [email protected] ＜/managingEditor＞" .
"＜webMaster＞ [email protected] ＜/webMaster＞" .
"<ttl>5</ttl>";
}
función crearRssFooter()
{
devolver "＜/canal＞＜/rss＞";
}
función createRssItem($título, $enlace, $desc, $fecha, $guid)
{
$artículo .= "＜artículo＞";
$elemento .= "<título＞" $título .
$elemento .= "<enlace＞" $enlace .
$elemento .= "＜descripción＞ " . $descripción "＜/descripción＞";
$elemento .= "<fechapub>" $fecha "</fechapub>";
$elemento .= "<guid>" .
$artículo .= "＜/artículo＞";
devolver $artículo;
}
función getUserMaxStories($db_link, $predeterminado)
{
$perfsQuery = sprintf("SELECCIONE max_stories DESDE user_perfs DONDE usuario= '%s'",
mysql_real_escape_string($usuario));
$resultado = mysql_query($perfsQuery, $db_link);
$max_stories = $predeterminado;
si ($fila = mysql_fetch_assoc($resultado)) {
$max_historias = $fila['max_historias'];
}
devolver $max_stories;
}
función escribirRssFeed($usuario)
{
//Obtener la información de conexión a la base de datos
$configuración = parse_ini_file("rss_server.ini");
// busca las preferencias del usuario...
$enlace = mysql_connect($configuración['db_host'], $configuración['usuario'],
$configuración['contraseña']) O morir(mysql_error());
$max_stories = getUserMaxStories($enlace, 25);
// ve a buscar mis datos
$newsQuery = sprintf("SELECCIONAR * DE historias DONDE post_date = '%s'",
mysql_real_escape_string(tiempo()));
$resultado = mysql_query($noticiasQuery, $enlace
$feed = createRssHeader();
$yo = 0;
// construir el feed...
mientras ($fila = mysql_fetch_assoc($resultado)) {
si ($i < $max_stories) {
$título = $fila['título'];
$enlace = $fila['enlace'];
$descripción = $fila['descripción'];
$fecha = $fila['fecha'];
$guid = $fila['guid'];
$feed .= createRssItem($título, $enlace, $descripción, $fecha, $guid);
$yo++;
} demás {
romper;
}
}
mysql_close($link);
$feed .= createRssFooter()
// escribe el feed en el servidor...
eco ($ alimentación);
}
?> También existen limitaciones para dividir métodos largos en métodos cortos, y una división excesiva será contraproducente. Por tanto, no abuses de este buen hábito. Dividir el código en fragmentos grandes puede hacer que la lectura sea tan difícil como no dividir el código largo.
Agregar comentarios a su código
Agregar buenos comentarios a su código a veces puede parecer tan difícil como escribir el código. No es fácil saber qué anotar porque a menudo tendemos a anotar lo que el código está haciendo actualmente. Es una buena idea comentar el propósito de su código. En el bloque de encabezado menos obvio de la función, se informa al lector sobre las entradas y salidas del método, así como el objetivo original del método.
Es común comentar lo que el código está haciendo actualmente, pero esto no es necesario. Si el código es complejo y tiene que comentar lo que está haciendo actualmente, esto le sugerirá que debe reescribir el código para que sea más fácil de entender. Aprenda a utilizar buenos nombres y métodos más breves para hacer que su código sea más legible sin proporcionar comentarios que expliquen su propósito.
Mal hábito: funciones con comentarios excesivos o insuficientes
Los comentarios en el Listado 5 solo le dicen al lector qué está haciendo el código: iterar a través de un bucle o agregar un número. Pero ignora por qué hace su trabajo actual. Esto deja a las personas que mantienen el código sin saber si el código se puede cambiar de forma segura (sin introducir nuevos defectos).
Listado 5. Mal hábito: demasiados o insuficientes comentarios de funciones
<?php
clase Mensaje de resultado
{
gravedad $ privada;
mensaje $ privado;
función pública __construct($sev, $msg)
{
$this->severidad = $sev;
$este->mensaje = $mensaje;
}
función pública getSeverity()
{
devolver $this->severidad;
}
función pública setSeverity($severity)
{
$this->severidad = $severidad;
}
función pública getMessage()
{
devolver $este->mensaje;
}
función pública setMessage ($msg)
{
$este->mensaje = $mensaje;
}
}
función cntMsgs($mensajes)
{
$norte = 0;
/* iterar a través de los mensajes... */
foreach($mensajes como $m) {
si ($m->getSeverity() == 'Error') {
$n++; // agrega uno al resultado;
}
}
devolver $n;
}
$mensajes = array(new ResultMessage("Error", "¡Esto es un error!"),
nuevo ResultMessage("Advertencia", "¡Esto es una advertencia!"),
new ResultMessage("Error", "¡Este es otro error!"));
$errs = cntMsgs($messages);
echo("Hay " . $errs . " errores en el resultado.n");
?>
Buena práctica: funciones y clases anotadas
Los comentarios del Listado 6 informan al lector sobre las clases y los métodos. objetivo. Este comentario explica por qué el código está haciendo su trabajo actual, lo que puede resultar útil a la hora de mantener el código en el futuro. Es posible que sea necesario modificar el código a medida que cambian las condiciones, pero las modificaciones son fáciles si el propósito del código se comprende fácilmente.
Listado 6. Buenas prácticas: funciones y clases anotadas
<?php
/**
* La clase ResultMessage contiene un mensaje que se puede devolver
* como resultado de un proceso. El mensaje tiene una gravedad y
* mensaje.
*
* @autor nagood
*
*/
clase MensajeResultado
{
gravedad $ privada;
mensaje $ privado;
/**
* Constructor para el ResultMessage que permite asignar
* severidad y mensaje.
* @param $sev Ver {@link getSeverity()}
* @param $mensaje
* @return tipo_desconocido
*/
función pública __construct($sev, $msg)
{
$this->severidad = $sev;
$este->mensaje = $mensaje;
}
/**
* Devuelve la gravedad del mensaje. Debe ser uno.
* "Información", "Advertencia" o "Error".
* @return string Gravedad del mensaje
*/
función pública getSeverity()
{
devolver $this->severidad;
}
/**
* Establece la gravedad del mensaje.
* @param $severidad
* @retorno nulo
*/
función pública setSeverity($severity)
{
$this->severidad = $severidad;
}
función pública getMessage()
{
devolver $este->mensaje;
}
función pública setMessage ($msg)
{
$este->mensaje = $mensaje;
}
}
/*
* Cuenta los mensajes con la gravedad dada en la matriz
* de mensajes.
*
* @param $messages Una matriz de ResultMessage
* @return int Recuento de mensajes con una gravedad de "Error"
*/
función contarErrores($mensajes)
{
$cuentacoincidente = 0;
foreach($mensajes como $m) {
si ($m->getSeverity() == "Error") {
$matchingCount++;
}
}
devolver $matchingCount;
}
$mensajes = array(new ResultMessage("Error", "¡Esto es un error!"),
nuevo ResultMessage("Advertencia", "¡Esto es una advertencia!"),
new ResultMessage("Error", "¡Este es otro error!"));
$errs = countErrors($messages);
echo("Hay " . $errs . " errores en el resultado.n")
;
Manejo de errores
Como regla general, si desea escribir aplicaciones sólidas, siga la regla 80/20 para el manejo de errores: el 80% de su código se usa para manejar excepciones y validaciones, y el 20% de su código se usa para hacer el trabajo real. Esto se hace a menudo al codificar la lógica básica (camino feliz) de un programa. Esto significa escribir código que funcione internamente, que todos los datos estén disponibles y que todas las condiciones sean las esperadas. Dicho código puede resultar frágil durante el ciclo de vida de la aplicación. En el otro extremo, se necesita mucho tiempo para escribir código para condiciones que nunca antes había encontrado.
Este hábito requiere que escriba suficiente código de manejo de errores, en lugar de escribir código para manejar todos los errores, de modo que el código nunca se complete.
Malos hábitos: ningún manejo de errores El código
del Listado 7 demuestra dos malos hábitos. Primero, los parámetros de entrada no se verifican, aunque se sabe que los parámetros en ciertos estados causarán excepciones en el método. En segundo lugar, el código llama a un método que puede generar una excepción pero no la maneja. Cuando ocurre un problema, el autor del código o la persona que lo mantiene solo puede adivinar el origen del problema.
Listado 7. Mal hábito: no manejar condiciones de error
<?php
// Obtener el nombre real del
función convertirDíaDeLaSemanaToNombre($día)
{
$nombresdeldía = matriz(
"Domingo",
"Lunes",
"Martes",
"Miércoles",
"Jueves",
"Viernes",
"Sábado");
return $nombresdeldía[$día];
}
echo("El nombre del día 0 es: " . convertDayOfWeekToName(0) . "n");
echo("El nombre del décimo día es: " . convertDayOfWeekToName(10) . "n");
echo("El nombre del día 'naranja' es: " . convertDayOfWeekToName('orange'). "n")
;
Buena práctica: Manejo de excepciones
El Listado 8 demuestra cómo lanzar y manejar excepciones de manera significativa. El manejo de errores adicional no solo hace que el código sea más robusto, sino que también mejora la legibilidad del código, haciéndolo más fácil de entender. La forma en que se manejan las excepciones es una buena indicación de la intención del autor original al escribir el método.
Listado 8. Buenas prácticas: manejo de excepciones
<?php
/**
* Esta es la excepción que se produce si el día de la semana no es válido.
* @autor nagood
*
*/
clase InvalidDayOfWeekException extiende la excepción { }
clase InvalidDayFormatException extiende la excepción { }
/**
* Obtiene el nombre del día dado el día de la semana Will.
* devuelve un error si el valor proporcionado está fuera de rango.
*
* @param $día
* @return tipo_desconocido
*/
función convertirDíaDeLaSemanaToNombre($día)
{
si (! is_numeric($día)) {
throw new InvalidDayFormatException('El valor '' . $day . '' es un ' .
'formato no válido para un día de la semana.');
}
si (($día ＞ 6) || ($día ＜ 0)) {
throw new InvalidDayOfWeekException('El número del día '' . $día . '' es un ' .
'día de la semana no válido. Se espera 0-6.');
}
$nombresdeldía = matriz(
"Domingo",
"Lunes",
"Martes",
"Miércoles",
"Jueves",
"Viernes",
"Sábado");
return $nombresdeldía[$día];
}
El
nombre del día 0 es: " . convertDayOfWeekToName(0). "n");
echo("El nombre del décimo día es: " . convertDayOfWeekToName(10) . "n");
} captura (InvalidDayOfWeekException $e) {
echo ("Se produjo un error al intentar convertir el valor: " . $e->getMessage() . "n");
}
intentar {
echo("El nombre del día 'naranja' es: " . convertDayOfWeekToName('orange') . "n");
} captura (InvalidDayFormatException $e) {
echo ("Se produjo un error al intentar convertir el valor: " . $e->getMessage() . "n");
}
?>
Aunque verificar los parámetros es una confirmación (si requiere que los parámetros estén en un estado determinado, será útil para las personas que usan el método), debe verificarlos y generar excepciones significativas:
◆ Manejar las excepciones lo más estrechamente posible
.que surgen están estrechamente relacionados.
◆ Manejo dedicado de cada excepción.
No utilice copiar y pegar.
Puede copiar y pegar código desde otro lugar en su editor de código, pero hacerlo tiene ventajas y desventajas. Lo bueno es que copiar código de un ejemplo o plantilla puede evitar muchos errores. La desventaja es que esto conduce fácilmente a muchos métodos de programación similares.
Tenga cuidado de no copiar y pegar código de una parte de la aplicación a otra. Si es así, abandone este mal hábito y considere reescribir este código para que sea reutilizable. En términos generales, colocar el código en un lugar hace que sea más fácil de mantener en el futuro porque solo es necesario cambiarlo en un lugar.
Malos hábitos: fragmentos de código similares
en el Listado 9 muestran varios métodos que son casi idénticos, pero con valores diferentes. Existen herramientas que pueden ayudar a encontrar código copiado y pegado (ver Recursos).
Listado 9. Malos hábitos: fragmentos de código similares
<?php
/**
* Cuenta el número de mensajes encontrados en la matriz de
* ResultMessage con el valor getSeverity() de "Error"
*
* @param $messages Una matriz de ResultMessage
* @return tipo_desconocido
*/
función contarErrores($mensajes)
{
$cuentacoincidente = 0;
foreach($mensajes como $m) {
si ($m->getSeverity() == "Error") {
$matchingCount++;
}
}
devolver $matchingCount;
}
/**
* Cuenta el número de mensajes encontrados en la matriz de
* ResultMessage con el valor getSeverity() de "Advertencia"
*
* @param $messages Una matriz de ResultMessage
* @return tipo_desconocido
*/
función contarAdvertencias($mensajes)
{
$cuentacoincidente = 0;
foreach($mensajes como $m) {
if ($m->getSeverity() == "Advertencia") {
$matchingCount++;
}
}
devolver $matchingCount;
}
/**
* Cuenta el número de mensajes encontrados en la matriz de
* ResultMessage con el valor getSeverity() de "Información"
*
* @param $messages Una matriz de ResultMessage
* @return tipo_desconocido
*/
función contarInformación($mensajes)
{
$cuentacoincidente = 0;
foreach($mensajes como $m) {
if ($m->getSeverity() == "Información") {
$matchingCount++;
}
}
devolver $matchingCount;
}
$mensajes = array(new ResultMessage("Error", "¡Esto es un error!"),
nuevo ResultMessage("Advertencia", "¡Esto es una advertencia!"),
new ResultMessage("Error", "¡Este es otro error!"));
$errs = countErrors($messages);
echo("Hay " . $errs . " errores en el resultado.n");
?>
Buena práctica: Funciones reutilizables con parámetros
El Listado 10 muestra el código modificado, que coloca el código copiado en un método. También se cambió otro método y ahora delega tareas al nuevo método. Crear un enfoque común requiere tiempo para diseñarlo, y hacerlo le permite detenerse y pensar, en lugar de copiar y pegar instintivamente. Pero el tiempo invertido en un enfoque común dará sus frutos cuando sean necesarios cambios.
Listado 10. Buenas prácticas: funciones reutilizables con parámetros
<?php
/*
* Cuenta los mensajes con la gravedad dada en la matriz
* de mensajes.
*
* @param $messages Una matriz de ResultMessage
* @return int Recuento de mensajes que coinciden con $withSeverity
*/
función contarMensajes($mensajes, $conSeveridad)
{
$cuentacoincidente = 0;
foreach($mensajes como $m) {
if ($m->getSeverity() == $withSeverity) {
$matchingCount++;
}
}
devolver $matchingCount;
}
/**
* Cuenta el número de mensajes encontrados en la matriz de
* ResultMessage con el valor getSeverity() de "Error"
*
* @param $messages Una matriz de ResultMessage
* @return tipo_desconocido
*/
función contarErrores($mensajes)
{
return countMessages($mensajes, "Errores");
}
/**
* Cuenta el número de mensajes encontrados en la matriz de
* ResultMessage con el valor getSeverity() de "Advertencia"
*
* @param $messages Una matriz de ResultMessage
* @return tipo_desconocido
*/
función contarAdvertencias($mensajes)
{
return countMessages($mensajes, "Advertencia");
}
/**
* Cuenta el número de mensajes encontrados en la matriz de
* ResultMessage con el valor getSeverity() de "Advertencia"
*
* @param $messages Una matriz de ResultMessage
* @return tipo_desconocido
*/
función contarInformación($mensajes)
{
return countMessages($mensajes, "Información");
}
$mensajes = array(new ResultMessage("Error", "¡Esto es un error!"),
nuevo ResultMessage("Advertencia", "¡Esto es una advertencia!"),
new ResultMessage("Error", "¡Este es otro error!"));
$errs = countErrors($messages);
echo("Hay " . $errs . " errores en el resultado.n");
Conclusión
Si
desarrolla los buenos hábitos discutidos en este artículo al escribir código PHP, lo hará. Ser capaz de crear código que sea fácil de leer, comprender y mantener. El código mantenible creado de esta manera reducirá el riesgo de depurar, corregir y ampliar el código.
El uso de buenos nombres y métodos más cortos mejora la legibilidad del código. El propósito de comentar el código es facilitar la comprensión y expansión del código. Manejar los errores de manera adecuada hace que su código sea más sólido. Finalmente, deje de usar copiar y pegar para mantener su código limpio y mejorar la reutilización.