Como tengo la costumbre de convertir en arrays todo lo que saco de las bases de datos antes de combinarlo con el html, una buena parte del camino ya la tenía hecha.

El método que voy a proponer a continuación no es nada del otro mundo y sólo pretende ser un punto de partida para que cada cual lo adapte y complique a su gusto.

Cuando me di cuenta de que un array como este:

$a = array(
	type=>"text",
	name=>"nombre",
	value=>"Pepe",
	)

era fácilmente convertible, vía php, en un html como este:

<input
	type="<?=$a[type];?>"
	name="<?=$a[name];?>"
	value="<?=$a[value];?>"
/>

Decidí hacer una función que resolviera la construcción de cualquier formulario simplemente recibiendo los datos necesarios en forma de arrays.

Antes de nada traté de agrupar más o menos los diferentes elementos que componen un formulario: Los <input> tipo text, password y hidden tienen una sintaxis muy parecida. A <textarea> hay que darle de comer aparte y lo mismo con los <select>. Los <input> tipo radio y checkbox se portan de una manera muy similar, y luego quedan los <input> tipo submit.

En el ejemplo de este artículo presento la función f, que resuelve los <input> tipo text, password, hidden y submit, los <textarea> y los <select> y los botones de submit. El resto lo dejo para una pŕoxima ocasión.

El ejemplo resuelve de paso los <label> y permite aplicar class o style particulares a cada elemento. Por cierto: Tengo la costumbre en los formularios de utilizar siempre el mismo valor en name y en id. No sé si eso es bueno o malo (al menos el validador del W3C no protesta), pero si a alguien no le gusta eso no tiene más que crear una nueva variable para uno de ellos.

Ah! La parte en la que se construye el menú desplegable tipo <select> es la que ya presenté en el artículo Construir un menú Select con PHP publicado el 25|09|2009.

Bueno, probadlo y a ver qué os parece. En este link he colgado una demo con CSS y todo.

<?php
$colores = array( // Array de valores para el select
		1=>Azul,
		2=>Negro,
		3=>Naranja,
		4=>Violeta,
		5=>Granate,
		);

$qq=array(
	f=>array( // Datos generales del formulario
		fN=>"loginForm", // name
		fM=>"post", // method
		fA=>"form.php", // action
		fB=>"Enviar", // texto del botón submit
		),
	ff=>array(
			array( // Datos del input id
				fN=>"id",
				fV=>123,
				fT=>"hidden", // Tipo hidden
				),
			array( // Datos del input nombre
				fN=>"nombre", // Variable
				fV=>"Perico", // Valor
				fL=>"Nombre", // Texto para el label
				fT=>"text", // Tipo text
				fC=>"special", // Class CSS (dato opcional)
				fS=>"width:100px;", // Style CSS (dato opcional)
				),
			array( // Datos del input apellidos
				fN=>"apellidos",
				fV=>"Los Palotes",
				fL=>"Apellidos",
				fT=>"text",
				fC=>"readonly", // Class CSS (dato opcional)
				fS=>"width:200px;",
				rO=>true, // queremos que sea 'readonly'
				),
			array( // Datos del input contrasena
				fN=>"contrasena",
				fV=>"123456",
				fL=>"Contraseña",
				fT=>"password", // Tipo password
				),
			array( // Datos del textarea direccion
				fN=>"direccion",
				fV=>"Calle de Los Desamparados s/n",
				fL=>"Dirección",
				fT=>"textarea", // Tipo textarea
				fC=>"login",
				fW=>"10|3", // Width | Height
				fS=>"width:200px;height:100px;",
				),
			array( // Datos del select desplegable color
				fN=>"color",
				fV=>3, // Valor (numérico en este caso)
				fL=>"Color favorito",
				fT=>"select", // Tipo select (desplegable)
				fC=>"login",
				fZ=>$colores, // Array de valores
				),
		),
	);

function f($x)
	{
	extract($x);
	$r="<form name=\"{$f[fN]}\" id=\"{$f[fN]}\" method=\"{$f[fM]}\" action=\"{$f[fA]}\">\n";
	for($i=0;$i<count($ff);++$i)
		{
		if(in_array($ff[$i][fT],array("text","password","hidden",))){$r.="\t".($ff[$i][fT]!="hidden"?"<label for=\"{$ff[$i][fN]}\">{$ff[$i][fL]}</label>":"")."<input type=\"{$ff[$i][fT]}\" name=\"{$ff[$i][fN]}\" id=\"{$ff[$i][fN]}\" value=\"{$ff[$i][fV]}\"".($ff[$i][fT]!="hidden"?($ff[$i][fC]?" class=\"{$ff[$i][fC]}\"":"").($ff[$i][fS]?" style=\"{$ff[$i][fS]}\"":""):"").($ff[$i][rO]?" readonly=\"readonly\"":"")." />".($ff[$i][fT]!="hidden"?"<br />":"")."\n";}
		if(in_array($ff[$i][fT],array("textarea",))){$r.="\t<label for=\"{$ff[$i][fN]}\">{$ff[$i][fL]}</label><textarea name=\"{$ff[$i][fN]}\" id=\"{$ff[$i][fN]}\"";$w=explode('|',$ff[$i][fW]);$r.=" cols=\"{$w[0]}\" rows=\"{$w[1]}\"".($ff[$i][fC]?" class=\"{$ff[$i][fC]}\"":"").($ff[$i][fS]?" style=\"{$ff[$i][fS]}\"":"").">{$ff[$i][fV]}</textarea><br />\n";}
		if(in_array($ff[$i][fT],array("select",))){$r.="\t<label for=\"{$ff[$i][fN]}\">{$ff[$i][fL]}</label><select name=\"{$ff[$i][fN]}\" id=\"{$ff[$i][fN]}\">";foreach($ff[$i][fZ] as $x=>$v){$r.="<option value=\"$i\"";$r.=$ff[$i][fV]==$x?" selected=\"selected\"":"";$r.=">".$v."</option>";}$r.="</select><br />\n";}
		}
	$r.="<input type=\"submit\" value=\"{$f[fB]}\" />";
	$r.="</form>";
	return $r;
	}

echo f($qq);
?>

la función permite que uno de los elementos del desplegable ya esté seleccionado previamente.

<?php
$dias = array(
		1=>Lunes,
		2=>Martes,
		3=>Miércoles,
		4=>Jueves,
		5=>Viernes,
		6=>Sábado,
		7=>Domingo
		);

function doSelect($n,$d,$s=null)
	{
	$doSelect = "<select name=\"$n\">\n";
	foreach($d as $i=>$v)
		{
		$doSelect.="\t<option value=\"$i\"";
		$doSelect.=$s==$i?" selected":"";
		$doSelect.=">".$v."</option>\n";
		}
	$doSelect.="</select>";
	return $doSelect;
	}

// El miércoles, pre-seleccionado
echo doSelect("dias",$dias,3);
?>

La función devuelve el siguiente html:

<select name="dias">
	<option value="1">Lunes</option>
	<option value="2">Martes</option>
	<option value="3" selected>Miércoles</option>
	<option value="4">Jueves</option>
	<option value="5">Viernes</option>
	<option value="6">Sábado</option>
	<option value="7">Domingo</option>
</select>

Si no quisiéramos ningún elemento pre-seleccionado en el desplegable, sólo tenemos que omitir el tercer parámetro de la función.

<?php
// Ningún día pre-seleccionado
echo doSelect("dias",$dias);
?>

Del mismo modo que puedo utilizar variables dentro de una cadena de texto:

<?php
	$nombre = "Manolo";
	$alias = "El del bombo";
	echo "Me llamo $nombre ($alias)";

//	Bien: Devuelve 'Me llamo Manolo (El del bombo)'
?>

Hasta donde yo sé, no es posible hacer nada parecido con las constantes:

<?php
	define("NOMBRE", "Manolo");
	define("ALIAS", "El del bombo");
	echo "Me llamo NOMBRE (ALIAS)";

//	Mal: Devuelve 'Me llamo NOMBRE (ALIAS)'
?>

El único modo posible sería este:

<?php
	echo "Me llamo ".NOMBRE ."(".ALIAS.")";

//	Bien: Devuelve 'Me llamo Manolo (El del bombo)'
?>

Pero a mi siempre me resultó bastante incómoda esta sintaxis:

”texto ”.$variable_o_CONSTANTE.” siguiente texto”

Así que hoy decidí apartar un poco de tiempo para buscar un modo de incluir constantes dentro de una cadena de texto con misma libertad que tengo cuando uso variables. Y creo que lo encontré

Para empezar, define() no es la única manera de definir una constante. En php.net he visto que las constantes se pueden definir dentro de clases, y que lo hacen con una sintaxis un poco diferente:

<?php
	class constantes
	{
	const NOMBRE = "Manolo";
	const ALIAS = "El del bombo";
	}
?>

Y a estas constantes puedes llamarlas así:

<?php echo constantes::NOMBRE; ?>

Hasta ahí, estupendo, pero el problema viene cuando quiero llamar a la constante desde una instancia:

<?php
	$c = new constantes();
	echo "Me llamo $c::NOMBRE ($c::ALIAS)";

//	Mal: Devuelve 'Me llamo ()'
?>

Tirando de Google, encontré en cristalab.com una solución que me ha parecido elegante. Ellos publicaron en marzo de 2007 el artículo Cómo usar y acceder a constantes en clases de PHP y en él proponían añadir una función privada que permitiera llamar a cualquiera de esas constantes. La cosa queda así

<?php
	class constantes
	{
	const NOMBRE = "Manolo";
	const ALIAS = "El del bombo";

	private function __get($name)
		{
		if(defined("self::$name"))
			{
			return constant("self::$name");
			}
		trigger_error("$name isn't defined");
		}
	}
?>

De modo que ahora ya puedo hacer esto:

<?php
	$c = new constantes();
	echo "Me llamo $c->NOMBRE ($c->ALIAS)";

//	Bien: Devuelve 'Me llamo Manolo (El del bombo)'
?>

SELECT * FROM tapas WHERE meGusta=true

Esto daría más de 200 resultados (soy un goloso)

Tengo una función para paginar (ya escribiré sobre ella más adelante) pero hoy quiero rendir homenaje a la imprescindible función de mySQL SELECT FOUND_ROWS().

Supongamos que quiero paginar un listado de más de 200 resultados. Ya tengo claro que quiero mostrar 25 registros por página así que añado a la consulta SELECT la cláusula LIMIT

SELECT * FROM tapas WHERE meGusta=true ORDER BY importancia LIMIT 0,25

Y así, vale, listo los 25 primeros y luego con

SELECT * FROM tapas WHERE meGusta=true ORDER BY importancia LIMIT 25,25

listo los 25 siguientes y así consecutivamente, pero: ¡quiero paginarlo! Quiero saber de antemano cuántos van a ser en total y poder calcular así cuántas páginas necesitaré.

A priori parece inevitable hacer antes de nada una consulta con SELECT COUNT para hacer el recuento y luego la consulta SELECT ‘oficial’, pero advierto: *este no es el camino*.

<?php
// Primer SELECT sólo para contar el total
$q = mysql_query("SELECT COUNT(*) AS rt FROM tapas WHERE meGusta=true");
$r = mysql_fetch_array($q);
$rp = 25; // Resultados por página
$rt = $r[rt]; // Total de registros
$tp = $rt/$rp; // Total de páginas

// Segundo SELECT para generar el listado
$p = isset($_GET['p'] && $_GET['p']<=$tp)?$_GET['p']:0; // A qué página vamos
$q = mysql_query("SELECT * FROM tapas WHERE meGusta=true ORDER BY importancia LIMIT ".$p*$rp.",".$rp);
while($r=mysql_fetch_array($q))
	{
//	bla, bla, bla...
	}
?>

Pero NO. No debemos hacerlo así. Estaríamos consumiendo recursos inútilmente. Para esto tenemos el dúo SELECT SQL_CALC_FOUND_ROWS y SELECT FOUND_ROWS()

Este SÍ es el camino

<?php
// Todo con un único SELECT
$rp = 25; // Resultados por página
$p = (isset($_GET['p']) && $_GET['p']<=$tp)?$_GET['p']:0; // A qué página vamos
$q = mysql_query("SELECT SQL_CALC_FOUND_ROWS * FROM tapas WHERE meGusta=true ORDER BY importancia LIMIT ".$p*$rp.",".$rp);
$rt = mysql_fetch_row(mysql_query("SELECT FOUND_ROWS()")); // Total de registros
$tp = $rt[0]/$rp; // Total de páginas
echo "<ul>";
while($r=mysql_fetch_array($q))
	{
	echo "<li>$r[tapa]</li>;
	}
echo "</ul>";
?>

Todo en esta web es exactamente igual en los tres idiomas salvo naturalmente, los textos. Así que vamos a ser organizados desde el principio y no caeremos en aquello de ‘hacer la misma web tres veces’.

Esta simple función devuelve el texto en el idioma correspondiente para cada palabra o cadena de texto solicitada.

<?php
function l($t,$i="es")
	{
	$l = array();
	$l['enviar'] =	array(
					"es"=>"Enviar",
					"en"=>"Send",
					"de"=>"Senden",
					);
	$l['cancelar'] = array(
					"es"=>"Cancelar",
					"en"=>"Cancel",
					"de"=>"Abbrechen",
					);
	$l['despedida'] = array(
					"es"=>"Hasta luego",
					"en"=>"See you later",
					"de"=>"Tschüs",
					);
	return $l[$t][$i];
	}

$i = "de"; // El idioma elegido.
?>
<p><?=l("despedida",$i);?></p>
<input type="submit" value="<?=l("enviar",$i);?>">
<input type="button" value="<?=l("cancelar",$i);?>">

La función l($t,$i) es muy fácil de manejar. Sin complicación podemos incorporar palabras o frases nuevas, o añadir un idioma más. Lo de dar en la función un valor predeterminado a $i es simplemente para tener un idioma por defecto, mientras el usuario no elige el suyo.

Supongamos que tengo una web en la que utilizo el sistema de plantillas más simple del mundo (probablemente). Mediante ese sistema podemos generar diferente HTML en cada plantilla, pero ¿cómo aplicaríamos una hoja de estilos propia para cada plantilla?.

Una solución sin complicarnos mucho sería crear diferentes hojas de estilo y llamar a la que corresponda en cada caso. Supongamos que la variable $tpl contiene el nombre de la plantilla:

<?php
$tpl = "moderna";
echo "
<link rel='stylesheet'
type='text/css'
href='".$tpl.".css' />";
?>

Pero a mi no me gusta la idea de tener varios archivos CSS esperando en una carpeta y elegir ‘el que toca’ en cada caso. Me recuerda a aquellos tiempos feos (pre-PHP o pre-ASP) en que hacíamos sitios web estáticos, con decenas o incluso cientos de documentos HTML prácticamente iguales. ¿Si ahora creamos HTML dinámicamente, por qué no estamos creando también CSS dinámicamente? Esta es mi propuesta:

<?php
$tpl = "moderna";
echo "
<link rel='stylesheet'
type='text/css'
href='estilos.php?tpl=$tpl' />";
?>

LLama la atención que nuestra página de estilos ya no lleva la extensión .css, sino que se trata de un archivo PHP en toda regla. Este es el archivo estilos.php:

<?php
header('Content-type:text/css');
switch ($_GET['tpl'])
{
case "clasica" :$f="'Times New Roman'";$c="#0000cc";break;
case "moderna" :$f="Verdana";          $c="#cc0000";break;
default        :$f="Arial";            $c="#00cc00";break;
}
print <<<_CSS
h1{font-family:{$f};color:{$c};}
_CSS;
?>

Así, con un simple switch ajustamos el valor de las variables $f (para font-family) o $c (para color) en este sencillo ejemplo, de modo que los estilos para h1 se construyen dinámicamente en función de la plantilla elegida.

<html>
<head>[NOMBRE] [APELLIDO]</head>
<body>
	<h1>Ficha número    [ID]</h1>
	<p><b>Nombre:</b>   [NOMBRE] [APELLIDO]</p>
	<p><b>Edad:</b>     [EDAD] años</p>
	<p><b>Teléfono:</b> [TELÉFONO]</p>
	<p><b>eMail:</b>    <a href="mailto:[EMAIL]">[EMAIL]</a></p>
</body>
</html>

Y ahora convierto las variables a sintaxis PHP básica, manteniendo el HTML intacto:

<html>
<head><?=$nombre.' '.$apellido;?></head>
<body>
	<h1>Ficha número    <?=$id;?></h1>
	<p><b>Nombre:</b>   <?=$nombre.' '.$apellido;?></p>
	<p><b>Edad:</b>     <?=$edad;?> años</p>
	<p><b>Teléfono:</b> <?=$telefono;?></p>
	<p><b>eMail:</b>    <a href="mailto:<?=$eMail;?>"><?=$eMail;?></a></p>
</body>
</html>

LLamo a esta plantilla «ficha.php» y la guardo en una carpeta «plantillas», por ejemplo. A continuación, en un documento nuevo (que llamaré «index.php», para ser original) declaro la función que sirve para crear contenidos en base a plantillas.

<?php
function tpl($p,$d=array())
	{
	extract($d);
	ob_start();
	require('plantillas/'.$p.'.php');
	return ob_get_clean();
	}
?>

Y ya está: No tengo más que llamar a esa función con la info obtenida de la base de datos cada vez que quiera volcarla en pantalla utilizando esa plantilla.

<?php
echo tpl('ficha',
			array(
				'id'=>      123,
				'nombre'=>  'Juan',
				'apellido'=>'Gómez',
				'edad'=>    33,
				'telefono'=>'987654321',
				'eMail'=>   'foo@bar.es'
				)
		);
?>

Con ese PHP generamos este HTML:

<html>
<head>Juan Gómez</head>
<body>
	<h1>Ficha número    123</h1>
	<p><b>Nombre:</b>   Juan Gómez</p>
	<p><b>Edad:</b>     33 años</p>
	<p><b>Teléfono:</b> 987654321</p>
	<p><b>eMail:</b>    <a href="mailto:foo@bar.es">foo@bar.es</a></p>
</body>
</html>

La principal ventaja que presenta este método es que estoy separando en la medida de lo posible la forma del contenido. El documento «ficha.php» es fácilmente editable por un diseñador web sin conocimientos de programación PHP (Tan sólo ha de comprender la sintaxis <?=$variable;?>, que no es mucho pedir), mientras que el documento «index.php» sólo contiene programación PHP, sin una sola etiqueta HTML molestando por medio, de modo que el programador se centra exclusivamente en la programación.

<?php
function qq($a,$b=2)
	{
	return $a+$b;
	}

echo qq(3);		// Devuelve 5
echo qq(3,3);	// Devuelve 6
?>

Vemos que si no asignamos un valor a $b, la función tiene reservado para $b un valor por defecto.

Lamentablemente en javaScript no es posible declarar un argumento por defecto en una función de un modo tan directo. El siguiente ejemplo **no funciona**:

<script type="text/javascript">
function qq(a,b=2)	// Esto no va a funcionar
	{
    return a+b;
	}
</script>

¿Cómo podemos conseguirlo? Pues con un poco de ingenio es posible expresar la idea de «argumento por defecto en funciones javaScript» de la siguiente manera:

<script type="text/javascript">
function qq(a,b)
	{
	if(!b){var b=2;} // Si no hay b, b=2
	return a+b;
	}

document.write(qq(3));		// Devuelve 5
document.write(qq(3,3));	// Devuelve 6
</script>

¿Fácil, no?

Actualización
Como muy bien apunta Jonathan en el primer comentario, la función no devuelve el valor correcto si usamos por ejemplo qq(3,3). La razón es !b sólo comprueba si b es true o false, y entiende que el valor cero es false. Para subsanarlo, retocamos la línea 4 de la función de este modo:

	if(b==null){var b=2;} // Si no hay b, b=2

<?php
function utfChCase($s,$u=false)
	{
	$s=utf8_decode($s);
	$s=$u?strtoupper($s):strtolower($s);
	$s=utf8_encode($s);
	return $s;
	}
?>

Así, para hacer minúsculas:

<?= utfChCase("Hola"); ?>

Y para hacer mayúsculas:

<?= utfChCase("Hola",true); ?>

<?php
function s2His($s)
	{
	$r=sprintf("%02d",intval(intval($s)/3600)).":".
	sprintf("%02d",bcmod((intval($s)/60),60)).":".
	sprintf("%02d",bcmod(intval($s),60));
	return $r;
	}
?>