Actualmente soy mucho menos exigente con el estilo de código de otros que cuando empecé a programar. Soy más tolerante, y respeto todos los estilos de programación siempre y cuando sean coherentes.

Es evidente que algunos me gustan más, o los encuentro mejores que otros, pero lo primordial para mantener código escrito por otros, es que ese código siga siempre el mismo estilo.

Si la estructura se ciñe a algunas convenciones, sean las que sean, tras un período de aprendizaje con ese estilo, empezaremos a habituarnos sin problemas.

Las dificultades comienzan cuando ese estilo no es rígido, y a veces se sigue y otras veces no. Esto complica los Buscar y Reemplazar, y en general dificulta la legibilidad.

A continuación os pongo un trozo de código en PHP y después mis comentarios.

Original
require_once('includes/common.inc.php');
$idConnect=clsDb::DoConnect();
$sep1="<!$!>"; // entre atributs de la familia
$sep2="<#!#>"; // entre paraules clau de la mateixa familia
$sep3="<$#$>"; // entre families
$sep4="<$!$>"; // entre atributs de la paraula clau de la familia
$texte= "";
// paraules clau
$query = "SELECT pc.taxopc_id, pc.taxopc_name_ca, pc.taxopc_desc_ca,";
$query.= "IF ((itempc.itempc_pc IS NULL),0,count(itempc.itempc_pc )) as us ";
$query.= "FROM t_mstr_taxopc pc LEFT JOIN t_rltn_item_pc itempc ON pc.taxopc_id = itempc.itempc_pc ";
$query.= "GROUP BY pc.taxopc_id, pc.taxopc_name_ca ";
$query.= "ORDER BY pc.taxopc_id ASC ";
$id_query=clsDb::query($query,$idConnect);
$firstpc=true;
while ($pc=clsDb::fetch_array($id_query)) {
if ($firstpc) $firstpc=false;
else $texte.= $sep3;
$texte.= $pc['taxopc_id'].$sep1.$pc['taxopc_name_ca'].$sep1.$pc['taxopc_desc_ca'].$sep1.$pc['us'].$sep1;
$query = "SELECT pcfs_fs ";
$query.= "FROM t_rltn_pc_fs ";
$query.= "WHERE pcfs_pc=".$pc['taxopc_id'];
$query.= " ORDER BY pcfs_fs ASC ";
$id_query2=clsDb::query($query,$idConnect);
$firstfs=true;
while ($fs=clsDb::fetch_array($id_query2)) {
if ($firstfs) $firstfs=false;
else $texte.= $sep2;
$texte.= $fs['pcfs_fs'];
}
}

if ((ini_get("zlib.output_compression")!=1) && (ini_get("zlib.output_compression")!="On") && (extension_loaded('zlib'))) {
ob_start(array("ob_gzhandler", 9));
}

//echo "========== paraules clau: ".$i."======families en paraules clau ".$j." <br> <br> <br> <br> <br> <br> <br> <br>";
echo "resposta=".urlencode(utf8_encode($texte));
clsDb::DoDisconnect($idConnect);

Supongo que visto esto, os habeis dado cuenta de ciertos criterios que no son homogeneos.
Aquí van algunos comentarios míos al respecto:

– Es recomendable utilizar alguna variación de la notación húngara, de forma que cada variable lleve información acerca del tipo de datos a contener en su nombre. Lo que no es admisible es que algunas la lleven idConnect y otras no sep1.
– A nivel de diseño no se recomienda el uso de flags o banderas en el caso de que sean evitables. En este código firstpc y firstfs indican el primer elemento, lo que obliga a diferentes operaciones booleanas. Es mucho mejor utilizar un contador, y comparar con el primer elemento.
– Si se decide no poner llaves cuando solo han de englobar una linea (opción que no recomiendo), se debe seguir siempre ese criterio.
– Mantener código de depuración comentado, no es una buena opción. Si la función ya funciona debe desaparecer, sino el programador que ha de mantener el código puede pensar que no está suficientemente probada, además de dificultar su lectura.

Al final todo esto no es más que definir nuestro propio estilo de codificación y aplicarlo sin excepción. Por ejemplo si establecemos que despues de la apertura de paréntesis va un espacio, se debe seguir siempre.

Este es el código unificado bajo mi propio criterio. El estilo puede o no gustar, o ser o no adecuado a vuestro gusto, pero lo que no es criticable es la coherencia. Las convenciones que se asumen se siguen siempre.

Con coherencia
require_once('includes/common.inc.php');

$cnnConnection=clsDb::DoConnect();
$sSep1="<!$!>"; // Entre atributs de la familia
$sSep2="<#!#>"; // Entre paraules clau de la mateixa familia
$sSep3="<$#$>"; // Entre families
$sSep4="<$!$>"; // Entre atributs de la paraula clau de la familia
$sResultado= "";

// Listar palabras
$sSQL="SELECT ";
$sSQL=$sSQL . "t_mstr_taxopc.taxopc_id, ";
$sSQL=$sSQL . "t_mstr_taxopc.taxopc_name_ca, ";
$sSQL=$sSQL . "t_mstr_taxopc.taxopc_desc_ca, ";
$sSQL=$sSQL . "IF ((t_rltn_item_pc.itempc_pc IS NULL), 0, count(t_rltn_item_pc.itempc_pc)) taxopc_usage ";
$sSQL=$sSQL . "FROM ";
$sSQL=$sSQL . "t_mstr_taxopc, ";
$sSQL=$sSQL . "t_rltn_item_pc, ";
$sSQL=$sSQL . "t_mstr_item ";
$sSQL=$sSQL . "WHERE ";
$sSQL=$sSQL . "t_mstr_taxopc.taxopc_id=t_rltn_item_pc.itempc_pc AND ";
$sSQL=$sSQL . "t_mstr_item.item_id=t_rltn_item_pc.itempc_item AND ";
$sSQL=$sSQL . "(t_mstr_item.item_status=3 OR t_mstr_item.item_status=2) ";
$sSQL=$sSQL . "GROUP BY ";
$sSQL=$sSQL . "t_mstr_taxopc.taxopc_id, t_mstr_taxopc.taxopc_name_ca ";
$sSQL=$sSQL . "ORDER BY ";
$sSQL=$sSQL . "t_mstr_taxopc.taxopc_id ASC ";

$rstPalabras=clsDb::query($sSQL, $cnnConnection);
$iPalabra=0;
while ($asPalabras=clsDb::fetch_array($rstPalabras))
{
// Listar familias de cada palabra
if ($iPalabra>0)
{
$sResultado=$sResultado . $sSep3;
}
$sResultado=$sResultado . $asPalabras['taxopc_id'] . $sSep1 . $asPalabras['taxopc_name_ca'] . $sSep1 . $asPalabras['taxopc_desc_ca'] . $sSep1 . $asPalabras['taxopc_usage'] . $sSep1;
$sSQL="SELECT pcfs_fs ";
$sSQL=$sSQL . "FROM t_rltn_pc_fs ";
$sSQL=$sSQL . "WHERE pcfs_pc=" . $asPalabras['taxopc_id'] . " ";
$sSQL=$sSQL . "ORDER BY pcfs_fs ASC ";
$rstFamilias=clsDb::query($sSQL,$cnnConnection);
$iFamilia=0;
while ($asFamilias=clsDb::fetch_array($rstFamilias))
{
if ($iFamilia>0)
{
$sResultado=$sResultado . $sSep2;
}
$sResultado=$sResultado . $asFamilias['pcfs_fs'];
$iFamilia++;
}
$iPalabra++;
}

if ((ini_get("zlib.output_compression")!=1) && (ini_get("zlib.output_compression")!="On") && (extension_loaded('zlib')))
{
ob_start(array("ob_gzhandler", 9));
}

print("resposta=" . urlencode(utf8_encode($sResultado)));
clsDb::DoDisconnect($cnnConnection);

Es muy difícil exigir que el código de otros siga el mismo estilo, si nosotros mismos no somos capaces de seguir el nuestro.