Logo vectorizado de Imperial Stormtroopers (en sus dos versiones válidas), para quien lo pueda necesitar.

Si quieres crear un elemento promocional del Imperial Stormtroopers (un cartel, una pegatina, un diseño de camiseta, etc, etc) ya puedes incluir el logo oficial. Tienes permiso para usarlo, siempre que no lo modifiques, no te lucres por ello y sólo lo uses para promocionar el evento Imperial Stormtroopers. No es necesario que menciones al autor del logo, pues el propio logo es una URL y con eso ya queda todo dicho.

Ah! Si creas algún elemento promocional para el Imperial Stormtroopers, acuérdate de sacarle una foto y colgarla de Internet para que lo veamos todos.

Los directorios virtuales son comodísimos a la hora de desarrollar sitios web sobre Apache. Lo hago a menudo y por eso lo recomiendo. Doy por hecho que Apache está correctamente instalado y configurado.

En mi directorio de usuario creo un directorio llamado http (donde pongo username has de poner tu nombre de usuario, obviamente)

$ mkdir /home/username/http

En ese directorio voy a construir mis proyectos web. Creo el directorio de mi primer proyecto web (donde pongo proyecto1 has de poner el nombre de tu proyecto, obviamente).

$ mkdir /home/username/http/proyecto1

Recomiendo, para no complicarnos la vida, dar a este tipo de directorios nombres sin eñes, tildes ni espacios.

Y sólo por tener algo, creo el clásico index.html conteniendo el típico saludo:

$ echo "<h1>Hola mundo</h1>" > /home/username/http/proyecto1/index.html

Bueno. Como este directorio no está donde Apache espera que estén sus directorios web, lo primero que tengo que hacer es notificar a Apache esta situación especial. Le diré a Apache que no es el típico directorio web sino un directorio virtual: Un directorio web creado donde me dió la gana

Doy de alta proyecto1 como directorio virtual:

$ cd /etc/apache2/sites-available
$ sudo cp default proyecto1
$ sudo gedit proyecto1

En el documento que se abre, para no complicarnos, sustituyo el texto por este otro (adáptalo según tus necesidades, claro):

<VirtualHost *:80>
ServerAdmin aqui.tu@email.com
ServerName proyecto1
DocumentRoot /home/username/http/proyecto1
  <Directory />
  Options FollowSymLinks
  AllowOverride None
  </Directory>
  <Directory /home/username/http/proyecto1 >
    Options Indexes FollowSymLinks MultiViews
    AllowOverride All
    Order deny,allow
    Allow from all
  </Directory>
</VirtualHost>

Y activo este directorio virtual:

$ sudo a2ensite proyecto1

Edito el archivo hosts en conformidad:

$ sudo gedit /etc/hosts

añadiendo esta línea:

127.0.0.1 proyecto1

Reinicio Apache

$ sudo /etc/init.d/apache2 reload

Y ya está. En http://proyecto1 puedo ver mi página Hola mundo. Ahora, ¡a trabajar!

1. Los derechos de autor no pueden situarse por encima de los derechos fundamentales de los ciudadanos, como el derecho a la privacidad, a la seguridad, a la presunción de inocencia, a la tutela judicial efectiva y a la libertad de expresión.
2. La suspensión de derechos fundamentales es y debe seguir siendo competencia exclusiva del poder judicial. Ni un cierre sin sentencia. Este anteproyecto, en contra de lo establecido en el artículo 20.5 de la Constitución, pone en manos de un órgano no judicial -un organismo dependiente del ministerio de Cultura-, la potestad de impedir a los ciudadanos españoles el acceso a cualquier página web.
3. La nueva legislación creará inseguridad jurídica en todo el sector tecnológico español, perjudicando uno de los pocos campos de desarrollo y futuro de nuestra economía, entorpeciendo la creación de empresas, introduciendo trabas a la libre competencia y ralentizando su proyección internacional.
4. La nueva legislación propuesta amenaza a los nuevos creadores y entorpece la creación cultural. Con Internet y los sucesivos avances tecnológicos se ha democratizado extraordinariamente la creación y emisión de contenidos de todo tipo, que ya no provienen prevalentemente de las industrias culturales tradicionales, sino de multitud de fuentes diferentes.
5. Los autores, como todos los trabajadores, tienen derecho a vivir de su trabajo con nuevas ideas creativas, modelos de negocio y actividades asociadas a sus creaciones. Intentar sostener con cambios legislativos a una industria obsoleta que no sabe adaptarse a este nuevo entorno no es ni justo ni realista. Si su modelo de negocio se basaba en el control de las copias de las obras y en Internet no es posible sin vulnerar derechos fundamentales, deberían buscar otro modelo.
6. Consideramos que las industrias culturales necesitan para sobrevivir alternativas modernas, eficaces, creíbles y asequibles y que se adecuen a los nuevos usos sociales, en lugar de limitaciones tan desproporcionadas como ineficaces para el fin que dicen perseguir.
7. Internet debe funcionar de forma libre y sin interferencias políticas auspiciadas por sectores que pretenden perpetuar obsoletos modelos de negocio e imposibilitar que el saber humano siga siendo libre.
8. Exigimos que el Gobierno garantice por ley la neutralidad de la Red en España, ante cualquier presión que pueda producirse, como marco para el desarrollo de una economía sostenible y realista de cara al futuro.
9. Proponemos una verdadera reforma del derecho de propiedad intelectual orientada a su fin: devolver a la sociedad el conocimiento, promover el dominio público y limitar los abusos de las entidades gestoras.
10. En democracia las leyes y sus modificaciones deben aprobarse tras el oportuno debate público y habiendo consultado previamente a todas las partes implicadas. No es de recibo que se realicen cambios legislativos que afectan a derechos fundamentales en una ley no orgánica y que versa sobre otra materia.

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);
?>

<script type="text/javascript" src="js/jquery-1.3.2.min.js"></script>

Sin embargo un artículo que leí hace algún tiempo [Encosia.com] recomienda evitar esa práctica, y utilizar el jQuery que Google cuelga de sus servidores y usa para sus propios sitios web. De esta manera:

<script type="text/javascript" src="http://ajax.googleapis.com/ajax/libs/jquery/1.3.2/jquery.min.js"></script>

Dave Ward, el autor, lo razonaba con tres sólidos argumentos:

• Tu página cargará antes. jQuery es una librería pesada y, asúmelo, siempre se cargará antes desde un servidor de Google (un señor servidor) que desde el tuyo.
• ¿He dicho ya que tu página cargará antes? Mientras el navegador lee jQuery desde el servidor de Google, puede ir cargando el resto de la web que sí están en tu servidor. Simultáneamente. Eso es un gran ahorro de tiempo.
• Tu página (y todas nuestras páginas) cargarán antes. Cuando forzamos la carga de un jQuery nuevo en cada web, estamos llenando la caché de los navegadores de material redundante. Pero si en vez de eso llamamos siempre al mismo jQuery de Google, si todos los hiciéramos, los navegadores no necesitarían cargar jQuery porque ya lo tienen.

Me convenció aquel artículo así que de un tiempo a esta parte procuro no apuntar hacia un jQuery en mi servidor, sino al que alberga Google en sus servidor de APIs.

No obstante, con un proyecto web en el que uso esta técnica me pasó una cosa curiosa el otro día. Durante un viaje en tren aproveché para programar un rato y al no tener acceso a Internet el jQuery de Google, claro, no cargaba y por consiguiente no podía trabajar.

La solución fue obvia: Temporalmente cambié esa línea, dejando de apuntar al servidor de Google para apuntar a un jQuery local.
Y viendo que esto podía sucederme de nuevo en el futuro, opté por algo también obvio, que es mantener ambas líneas en el código de la página y comentar la que sobra según la situación. Nada del otro mundo.

Pero luego me empeñé en perfeccionar un poco la cosa y salió esto:

<script type="text/javascript" src="https://ajax.googleapis.com/ajax/libs/jquery/1.3.2/jquery.min.js"></script>
<script type="text/javascript">if(typeof jQuery==='undefined'){document.write(unescape("<scri"+"pt src='js/jquery-1.3.2.min.js' type='text/javascript'></scri"+"pt>"));}</script>

Utilizando este código me despreocupo totalmente del tema. ¿Que encuentra el jQuery de Google? Lo usa. ¿Que no? Pues usa el jQuery local.

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
 "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="content-type" content="text/html;charset=utf-8" />
<title>TinyCSS</title>
<style type="text/css">
*{margin:0;padding:0;}
h1{font-size:1em;}
.header{border-bottom:1px solid #aaa;}
.container{overflow:hidden;height:100% !important;}
.main{width:500px;margin-bottom:-1000px;padding-bottom:1000px;float:left;}
.sideBar{margin-bottom:-1000px;padding-bottom:1000px;float:right;}
.s1{width:160px;border-left:1px solid #aaa;}
.s2{width:300px;border-left:1px solid #aaa;}
.footer{border-top:1px solid #aaa;}
</style>
</head>
<body>
<div class="header"><h1>Header</h1></div>
<div class="container">
	<div class="sideBar s2"><h1>Sidebar 2</h1></div>
	<div class="sideBar s1"><h1>Sidebar 1</h1></div>
	<div class="main"><h1>Main</h1></div>
</div>
<div class="footer"><h1>Footer</h1></div>
</body>
</html>

Si bien el resultado final es bastante feo (puedes ver una demo aquí) el peso de este documento es de menos de 1Kb. y es compatible con Internet Explorer (versión 6 incluída), Firefox, Chrome, Opera y Safari (Browsershots.org).

No será difícil para un diseñador hábil con las CSS partir de este esqueleto para crear algo mucho más agradable a la vista.

Lo que más me gusta es que los <div> de las columnas pueden crecer al alto tanto como quieras sin preocuparte por sus vecinas, que se prolongarán en lo vertical para que todas sean iguales (con unos ejemplos me explico mejor). Para ello no he usado ni javaScript ni el conocido método Faux Columns, sino un truco CSS que consiste en atribuir

margin-bottom:-1000px; padding-bottom:1000px;

a cada una de las columnas, y

overflow:hidden;

al <div> que las contiene.

Y para terminar, es importante recordar que en la línea

.container{overflow:hidden;height:100% !important;}

height:100% !important; son necesarios para que el sistema sea compatible con IE6. El glorioso día en que IE6 sea desterrado ya no será necesario incluir ese código.

Me ha ayudado mucho un viejo post de Ed Elliot. Gracias Ed!

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);
?>

Logo vectorizado de Coren, para quien lo pueda necesitar:

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>";
?>