Web y PHP

Sintaxis ^

PHP es muy similar a C y otros lenguajes. Las instrucciones se separan con ; y los cambios de línea son equivalentes a los espacios en blanco (fuera de las cadenas, claro). Debemos respetar las reglas de identación buscando la claridad. Los comenrarios se delimitan con // o # para una línea, y con /* y */ para bloques de líneas.

Las variables en PHP explotan al máximo las características que ofrece un lenguaje interpretado, pudiendo hacer operaciones totalmente impensables para un lenguaje compilado. Las variables siempre comienzan con el signo $ y su nombre sigue las reglas habituales de otros lenguajes. La asignación de un valor se realiza con el signo =. Las variables no se declaran y pueden tomar diversos tipos de datos en tiempo de ejecución, cambiando de uno a otro según el valor que se les asigne. Los nombres de las variables son sensibles ante mayúsculas y minúsculas. Veamos este ejemplo: <?
  // variable declarada explícitamente
  $v1 = 50;
  // imprimimos una de las variables del sistema
  echo $_SERVER ["DOCUMENT_ROOT"] ;
  //definimos una constante
  define ("VARIABLE_CONSTANTE" , 80) ;
  echo VARIABLE_CONSTANTE;
  // copia el valor
  $v2=$v1;
  $v1=3+5;
  // se convierten ambas variables a string y se concatenan
  $v1=$v1.$v2;
  // error de sintaxis
  $2v = 5;
  ?> Hemos definido la variable $v1 y le hemos asignado el entero 50. Después mostramos uan variable del sistema y definimos una constante, cuyo uso es de escaso interés a mi juicio. La asignación se realiza siempre por valor, es decir copiando. En PHP existen las referencias, pero deben usarse con mucho cuidado, teniendo en cuenta que no son direcciones como en C.

Una variable puede tener que separarse de su entorno, por ejemplo dentro de una cadena, entonces puede usarse el formato ${variable}.

El formato $$ es una forma simplificada de evaluación, en el sentido que $$x significa la variable cuyo nombre esta en $x: <?
  $nom="variable";
  $variable=6;
  echo "La variable '$nom' lleva un '".$$nom."'";?>

PHP tiene distintos niveles de error. A veces se producen eventos simplemente informativos, otros de atención y otros de error. Normalmente los eventos informativos no se muestran, pero puede configurarse para que así sea con ánimo de depurar código. Los avisos de atención pueden esconderse en llamadas a funciones precediendo la llamada con una @, lo debe hacerse sólo cuando estamos seguros de que no es importante el aviso que ignoramos. Cuando se produce un error, la ejecución del código se para, el mensaje de error también puede esconderse con @, aunque probablemente es una mala idea hacerlo.

Por ejemplo, si quiero obtener el contenido de un archivo, y detectar si no existe o está vacío, puedo hacer: <?
  if ($x=@file_get_contents("unarchivo"))
    echo "Existe y no está vacío";
  else
    echo "La cosa ha ido mal";?>

Al no existir unarchivo, se produce un warning (mensaje de atención), pero no lo vemos porque @ ha anulado la visibilidad del mensaje. Si file_get_contents produjera error en lugar de warning, no hubiésemos leído ningún mensaje, pues la ejecución del código se hubiera parado.

Tipos de datos ^

Los tipos boolean, integer y float no requieren demasiada atención, simplemente debemos ir en cuidado al manejarlos, por ejemplo: <?  if (!$x) echo "Sí" ?> escribirá Sí tanto si $a no está definida, como si contiene la cadena nula "", como si contiene la cadena "0", como si contiene un integer o float de valor 0 o un boolean de valor false. Si queremos saber realmente si $a no está definida, podemos usar la función isset. Los tipos pueden compararse usando, por ejemplo, el operador === que dice si dos expresiones evalúan igual y son del mismo tipo. El habitual operador de comparación == no compara el tipo, sólo el valor, y la condición 0 == "0" es cierta.

El tipo resource es empleado para operaciones de entrada salida, no tiene un interés especial, simplemente se usa cuando se debe. De los tipos array y object nos ocuparemos expresamente, por sus peculiaridades. Ahora nos detendremos en el tipo string.

Las cadenas merecen cierta atención. Una cadena en PHP viene delimitada por comillas imples (') o dobles ("). Las comillas simples producen literalidad: cualquier caracter dentro de ellas es interpretado como tal, excepto la propia comilla que debe ser escapada: <?
  echo 'Martin\'s House';
?>

La doble comilla produce la evaluación de las variables y la interpretación de secuencias especiales como \n o \014: <?
  $x=2300;
  echo "Somos $x";
?>

Para delimitar una variable cuando va pegada a una cadena, podemos emplear la forma ${variable}, pero es mejor usar {$variable}: <?
  $x=23;
  echo "Somos $x00\n";    // falla
  echo "Somos ${x}00\n";
  echo "Somos {$x}00\n";
?>

La forma $a[ejemplo] implica la definición de una constante de nombre ejemplo, que no estando previamente definida, toma el valor 'ejemplo'. Esta forma no debería usarse, exite por compatibilidad con las primeras versiones de PHP.

Estructuras de control ^

Creo que estas estructuras se comprenden sin más, pero haré algunas aclaraciones.

El término acción; hace referencia a una sentencia cualquiera (o colección de sentencias agrupadas con { y }).

El término condición se refiere a cualquier expresión que se evaluará como un boolean. Es decir que será false tanto la cadena vacía, como un 0 numérico como una cadena que contiene un "0", como un array vacío. Una array que contenga al menos un elemento, aunque sea array(false), evalúa como true.

Respecto a switch, hay que tener en cuenta que para cada case pueden ponerse varias acciones sin {}. La última de las mencionadas acciones suele ser break. Si break no está presente, la ejecución sigue con el siguiente grupo de acciones: <?
  switch(5) {
    case 5: echo "Hola ";
    case 6: echo "soy yo";
  }?>

Respecto a while, la acción se ejecuta 0 o más veces, pues la condición se evalúa antes. En cambio do ... while ejecuta la acción al menos una vez, pues la condición se evaúa después.

La sentencia foreach permite ejecutar la acción para cada uno de los elementos del array, que es copiado en la variable que he etiquetado como $valor. Si $indice está presente, se accede, además, a cada uno de los índices. Observa la ejecución de este código: <?
  foreach($a=array("lun","mar") as $dia) {
    $dia="dom";
    echo $dia."\n";
  }
  print_r($a);
  foreach($a as $i => $dia)
    $a[$i]="dom";
  print_r($a);
  ?>

La sentencia break se usa no sólo en el ámbito de switch, sino principalmente para romper bucles. Aunque los puristas opinan que es una forma poco estructurada de programación, sí que lo es si se usa correctamente, es decir para tratar, por ejemplo, excepciones o errores. También es necesaria si se usa para cualquier ruptura con foreach. El siguiente código Busca un elemento en un array usando foreach: <?
  unset($donde);
  foreach($a as $i => $v)
    if ($v == buscado) {
      $donde=$i;
      break;
    }
  if (isset($donde)) // no puedo usar if ($donde) pues podría ser 0
    echo "Está en $donde";
  ?>

Igualmente la sentencia continue, mucho menos util que break, causa que, dentro de un bucle, no se procesen el resto de instrucciones y se pase a la siguiente iteración.

Por último, la sentencia return, que se usa para establecer el valor devuelto por una función, causa también el fin de la ejecución del código de la función, dando una funcionalidad similar a break, pero sólo dentro de funciones, o en el caso especial de la sentencia eval.

Arrays. ^

También es típica la autoasignación de índice mediante el uso de []: <?
  $a["clave1"]="hola" ;
  $a["clave2"]="adios" ;
  $a[]=1;
  $a[]=2;
  $a[20]= 3;
  $a[]= 4;
  print_r($a) ; ?>

El constructor array() permite formar un array de un tirón. Observemos este ejemplo: <?
  $v=array("coche" => "bmw", "moto" => "honda");
  print_r($v);
  $v[coche]="audi";
  print_r($v);
  define("coche","moto");
  $v[coche]="ferrari";
  print_r($v); ?>

El ejemplo ilustra como construir un array usando array(). Al mismo tiempo ilustra el peligro de usar constantes como índices de arrays si se usan también sentencias define.

Los arrays multidimensionales no existen como tales, son simplemente arrays de arrays y se manejan así: <?
  $a[8][3][5][3]=22;
  print_r($a); ?>

Parece obvio que los índices de un array son únicos, lo que me puede ser útil. Por ejemplo, para saber qué (y cuántas veces) elementos HTML aparecen en un archivo, puedo usar: <?
  preg_match_all('%<([^/]\w+)%',
      file_get_contents($_SERVER['SCRIPT_FILENAME']),$mat);
  $eles=array();
  foreach ($mat[1] as $ele)
    $eles[$ele]++;
  ksort($eles); // si no ordeno, el orden es el de la primera aparición
  print_r($eles); ?>

Un uso del constructor array() es la generación de listas sobre la marcha para ahorrar y dar claridad al código. En el siguiente ejemplo, para añadir más días sólo tengo que modificar el array: <?
  setlocale(LC_TIME,"es_ES");
  $f=time();
  foreach(array("mon" => "cansado",
                "tue" => "aburrido",
                "fri" => "contento"
               ) as $d => $que)
    echo strftime("El %A %e de %b estaré $que\n",$f=strtotime($d,$f));
    ?>

Funciones ^

Si se invoca a una función que no existe se produce un error fatal. Una función no puede redefinirse.

Los parámetros admiten dos variantes además del formato clásico. Por una parte los parámetros por defecto permiten que ciertos parámetros tengan un valor preestablecido si no se pasa a la función: <?
  function defecto($color,$fondo="negro") {
    echo "$color sobre fondo $fondo\n";
  }
  defecto("amarillo");
  defecto("azul","naranja"); ?>

Por supuesto las funciones admiten parámetros por referencia, usando el operador &: <?
  function referencia(&$variable) {
    $variable="sí";
  }
  $modi="no";
  referencia($modi);
  echo "La variable $modi ha sido modificada"; ?>

Si en una variable de tipo string almacenamos el nombre de una función, podemos llamar a ésta usando la variable: <?
  function uno() { echo "Una\n"; }
  function dos() { echo "Dos\n"; }
  $func="uno"; $func();
  $func="dos"; $func(); ?>

PCRE ^

Variables predefinidas ^

• $_SERVER contiene las variables que el servidor define, algunas muy interesnates como $_SERVER['SCRIPT_NAME'], que es la URL parcial de nuestro script o $_SERVER['HTTP_HOST'] que es el nombre de nuestro servidor: <?
  echo "Mi URL: http://{$_SERVER['HTTP_HOST']}{$_SERVER['SCRIPT_NAME']}<br>";
  echo "Tu IP: {$_SERVER['REMOTE_ADDR']} o {$_SERVER['HTTP_X_FORWARDED_FOR']}"; ?>
  Mi URL: http://doc.nisu.org/web.php
  Tu IP: 38.107.191.109 o
• $_GET y $_POST contienen lo que el script recibe por GET o por POST respectivamente. Cuando hablemos de los formularios veremos numerosos ejemplos.
• $_REQUEST es la combinación de $_GET y $_POST.
• $_ENV es el entorno del programa.
• $_SESSION: variables de sesión, la trataremos como un caso especial.

La instalación ^

Es interesante hacer notar que PHP puede usarse desde línea de comando. Los arrays $argc y $argv están disponibles para acceder a los parámetros.

Formularios ^

Prestemos atención a ciertas cuestiones:

• El formulario puede enviarse pulsando intro. En ese caso, el navegador enviará los mismos campos. Pero, si hay más de un botón submit (puede ser interesante para realizar operaciones distintas) se enviará el primero de ellos. Si hay varios botones submit, y se pulsa uno de ellos, el navegador sólo envía el pulsado.
• El array $_POST contiene los campos del formulario que PHP recibe del navegador. Si se enviaran mediante el método GET, estarían en el array $_GET. Existe un array $_REQUEST que equivale a la unión de ambos y es muy correcto emplearlo.
• El atributo value de un campo contiene el valor que se envía. Si en el HTML ya hay un valor pre-cargado, el navegador nos lo muestra. Hay que ser cuidadoso en que no contenga el carácter " para no generar un HTML incorrecto.
• Si varios campos tiene el mismo nombre, o hay un campo de tipo select multiple, el navegador enviará el mismo nombre de campo varias veces, con sus respectivos valores. PHP sólo cogerá el último, a no ser que tomemos preacauciones, como explicaré a continuación.

Para resolver el problema de los nombres iguales (que, insisto, es un problema de PHP, no del navegador) debemos adaptar el HTML y llamar a los campos repetidos como si fueran arrays. Obviamente para el HTML no son arrays, pero PHP sí que los interpretará como tales:
  <form method="post" action="procform.php">
    Escribe: <input name="prueba[]" value="pre&quot;escrito">
    <input name="prueba[]" value="otro igual"><br>
    <input name="con_indice[33]"><input name="con_indice[66]">
    <select name="multi[]" multiple size=4>
    <option>1<option>2<option>3<option>4<option>5<option>6
    </select>
    <input type=submit name="env" value="Enviar">
  </form>

Obsérvese lo antiestético del formulario.

El aprendizaje del procesado de formularios se completa necesariamente leyendo aquí .

Subida de archivos ^

Notemos que el formulario debe llevar codificación multipart/form-data (la codificación por defecto de los formularios es application/x-www-form-urlencoded, que envía los datos en codificación urlencoded, muy ineficiente para grandes volúmenes). El método debe ser necesariamente POST.

PHP es capaz de interpretar la codificación multipart/form-data, de modo que el programador no nota diferencia en lo que encuentra en $_POST respecto a un formulario "normal". Pero el campo input de tipo file no es almacenado en la variable $_POST, pues un archivo grande desbordaría la memoria (realmente, versiones antiguas de PHP cargaban el archivo enviado en memoria antes de procesarlo, esto ha sido corregido en las versiones actuales). En su lugar, la variabe $_FILES contiene lo que necesitamos. Desafortunadamente los navegadores no suelen incluir barras de progreso del envío del archivo, por lo que envíos grandes suelen desesperar al usuario. El campo oculto de nombre MAX_FILE_SIZE debería ser interpretado por el navegador para no dejar enviar archivos de un tamaño mayor. Obviamente esto no debe usarse con propósitos de seguridad, pues el navegador puede no hacer caso o el usuario modificar el HTML. PHP tiene su propio límite de tamaño de archivo admitido, que es un límite insalvable y puede obtenerse mediante ini_get. Éste límite debe ser menor que el límite establecido para un POST: <?
    echo "El tamaño máximo de archivo en este servidor es ".ini_get("upload_max_filesize")."\n";
    echo "El POST más grande posible es ".ini_get("post_max_size"); ?>

Probemos el ejemplo:

El archivo es recibido por cojearchivo.php que contiene: <?
  echo '<pre>';
  print_r($_FILES);
  echo '</pre>';
?>


Y produce:

Observamos que la variable $_FILES contiene información del archivo recibido, indexada por el nombre del campo (en este caso fich). Nos suministra el nombre original (name), el tipo MIME del archivo (type), el nombre con que se ha grabado en el servidor (tmp_name), el posible error, y el tamaño del archivo. Con esta información, lo habitual será comprobar si el tamaño esta en los límites esperados, si es de un tipo esperado, y en ese caso cambiarlo de ubicación y probablemente de nombre, con la función move_uploaded_file. Es importante hacer notar que el nombre original del archivo debería usarse sólo como dato informativo, no debería renombrarse el archivo recibido a su nombre original, pues puede ser incompatible con el sistema de archivos o producir problemas de seguridad graves.

Este podría ser un uso normal: <?
  foreach ($_FILES as $cmp => $fic) {
    if ($fic["size"] > 100000) {
      echo "Tamaño de archivo (campo $cmp) excesivo";
      continue;
    }
    if (substr($fic["type"],0,6) != "image/") {
      echo "Esperaba una imagen en el campo $cmp";
      continue;
    }
    $minombre=strftime("Archivo_subido_el_%Y_%m_%d_%H_%M");
    if (!move_uploaded_file($fic["tmp_name"],"midirectorio/$minombre"))
      echo "Algo ha pasado con el archivo del campo $cmp";
  }?>

Campos de entrada ^

Pulsa Continuar repetidas veces:

Para resolver esto, veamos este ejemplo: <?
  $v=$_GET['test'] or $v="'\"";
  if (get_magic_quotes_gpc())
    $v=stripslashes($v);
  // aquí podríamos hacer algo con el valor correcto de $v
  // en algunos casos deberíamos usar addslashes
  echo '<form>'.
       '<input name=test value="'.htmlspecialchars($v,ENT_COMPAT).'">'.
       '<input type=submit value=Continuar>'.
       '</form>';
?>


Sesiones ^

Codificación ^

Las reglas básicas para alcanzar un buen resultado son:

1. Definir en nuestro proyecto la codificación que vamos a usar, pues si no, se empleará la que ponga el servidor web por defecto e impedirá la portabilidad del mismo a otros servidores.
2. Definirla en todos los programas, usando por ejemplo header('Content-type: text/html; charset="UTF-8"'); y también en la base de datos: al crear las tablas definir el juego de caracteres (el cotejamiento es de menor importancia), por ejemplo: CREATE TABLE .... CHARSET=utf8 COLLATE=utf8_spanish_ci.
3. Usar la misma codificación para todo, no deben usarse funciones de conversión, excepto si no queda más remedio: sólo cuando nuestros progrmamas toman datos de fuentes externas que vienen en otra codificación.

Fundamentos

Ejemplos con formularios ^

Esta es la forma en que normalmente trabajaremos con BdD y formularios. Pero para nuestro ejemplo, el inconveniente de este método es que, hecho el post, PHP se encontrará con una serie de arrays, pero no hay una forma de saber cuales son sin volver ha hacer la consulta. En su lugar puedo usar nombres de campos input del tipo vals[$col][$idx], de modo que lo que recibirá PHP será un único array de arrays: <?
  $ind='prim';
  echo '<form method="post">';
  if ($vals=$_POST['vals']) {
    foreach($vals as $col => $filas)
      foreach($filas as $idx => $val)
        mysql_query("update edtabla set `$col` = '$val' where $ind = '$idx'");
  }
  else {
    $qu=mysql_query("select * from edtabla");
    while ($fi=mysql_fetch_assoc($qu)) {
      $idx=$fi[$ind];
      echo "$idx:";
      foreach ($fi as $col => $val) {
       if ($col != $ind)
         echo " <input name=\"vals[$col][$idx]\" value=\"$val\">";
      }
      echo "<br>";
    }
  }
  echo '<input type=submit value="Modificar"></form>';
  ?> Si quiero hacer sólo un update por fila, el código es el siguiente, bastante enrevesado: <?
  $ind='prim';
  echo '<form method="post">';
  if ($vals=$_POST['vals']) {
    // debo trasponer $vals, ver el else
    $uno=current($vals); // primer campo, lo uso para sacar los ind
    $cols=[]; // columnas
    foreach($vals as $col => $dum)
      $cols[]=$col;
    // recorro
    foreach($uno as $idx => $dum) {
      $up="";
      echo "$idx:";
      foreach($cols as $col) {
        $val=$vals[$col][$idx];
        $up.=", `$col` = '$val'";
        echo " <input name=\"vals[$col][$idx]\" value=\"$val\">";
      }
      mysql_query("update edtabla set".substr($up,1)." where $ind = '$idx'");
      echo "<br>";
    }
  }
  else {
    $qu=mysql_query("select * from edtabla");
    while ($fi=mysql_fetch_assoc($qu)) {
      $idx=$fi[$ind];
      echo "$idx:";
      foreach ($fi as $col => $val) {
       if ($col != $ind)
         echo " <input name=\"vals[$col][$idx]\" value=\"$val\">";
      }
      echo "<br>";
    }
  }
  echo '<input type=submit value="Modificar"></form>';
  ?> Para evitar la trasposición puedo alterar la presentación del formulario y usar los nombres de los campos como índices del índice S-{, es menos intuitivo pero simplifica el código: <?

  $ind='prim'; // clave primaria de la tabla
  echo '<form method="post">';
  if ($vals=$_POST['vals']) {
    foreach($vals as $idx => $fil) {
      $up="";
      echo "$idx:";
      foreach($fil as $col => $val) {
        $up.=", `$col` = '$val'";
        echo " <input name=\"vals[$idx][$col]\" value=\"$val\">\n";
      }
      $q="update edtabla set".substr($up,1)." where $ind = '$idx'";
      echo "<br>$q";
      mysql_query($q);
      echo mysql_error();
      echo "<br>";
    }
  }
  else {
    $qu=mysql_query("select * from edtabla");
    while ($fi=mysql_fetch_assoc($qu)) {
      $idx=$fi[$ind];
      echo "$idx:";
      foreach ($fi as $col => $val) {
        if ($col != $ind)
          echo " <input name=\"vals[$idx][$col]\" value=\"$val\">\n";
      }
      echo "<br>";
    }
  }
  echo '<input type=submit value="Modificar"></form>';
?>


Un tema interesante aparece cuando las columnas de la tabla se prestan a construir campos select o checkbox en lugar de los habituales input. Por ejemplo, pensemos en el ejemplo anterior, pero con una tabla donde las columnas sólo puedan tomar los valores verdadero o falso. El código correspondiente al else del ejemplo anterior, quedaría como (sólo la parte del foreach): <?
  foreach ($fi as $col => $val) {
    if ($col != $ind) {
      echo " <input name=\"vals[$idx][$col]\" value=1";
      if ($val)
        echo ' checked';
      echo ">\n";
    }
  } ?>

O más escueto: <?
  foreach ($fi as $col => $val)
    if ($col != $ind)
      echo " <input name=\"vals[$idx][$col]\" value=1".
                 (($val) ' checked' : '').">\n";
  ?>

Puede apreciarse que el valor es siempre 1, pero el checkbox aparecerá pre-marcado si el valor era verdadero, y sin marcar si era falso. El problema aparece al procesar el formulario: el navegador no envía los nombres de los checkbox que no están marcados. Por ello no puedo utilizar el mismo código que en el ejemplo con campos text, donde recorría $_POST['vals'], sino que deberé acudir a la base de datos y ver si para cada pareja ($idx,$col) está presente (el valor será siempre 1) el correspondiente $_POST['vals'][$idx][$col].

En el caso de un campo select la programación del procesado del formulario es la misma que en el ejemplo con campos text, pues en el caso de un select, el navegador sí que envía siempre el campo, con la selección hecha por el usuario o la que hubiese por defecto. Supongamos una tabla en la que los campos sólo pudieran tomar los valores pera, manzana o naranja, el código para generar el formulario sería; <?
  foreach ($fi as $col => $val)
    if ($col != $ind) {
      echo " <select name=\"vals[$idx][$col]\">\n";
      foreach($opciones as $valor=>$texto)
        echo '<option value=\"'.htmlspecialchars($valor).'"'.
                 (($valor == $val) ? ' selected' : '').">$texto\n";
      echo "</select>\n";
    }
  ?> Previamente (al inicio del programa o justo después del else), habré definido: <?
  $opciones=array("pera" => "Una perita",
                  "manzana" => "Una manzanita",
                  "naranja" => "La naranja",);
  ?>

Programación guiada por eventos

En programación web clásica (formularios sin javascript), los formularios se envían por la pulsación de los botones de tipo submit. Por tanto nuestro programa averiguará el botón pulsado y ejecutará el código apropiado para el tratamiento de los datos que puedan estar presentes cuando se haya pulsado el botón.

Tomemos el ejempo de la multiplicación de dos números, básicamente hay 3 interfaces:

• Sería incorrecto usar otro medio que no fuera la variable de sessión para almacenar un dato temporal sin valor estructural para futuras ejecuciones de la aplicación.
  Es decir, imaginemos que tenemos una aplicación que actualiza datos de una base de datos, pero antes de realizar la actualización, son necesarios varios interfaces de usuario. Todos los datos temporales se guardarán en la sesión, no en la base de datos.
• La sesión se inicia al inicio. Esto parece obio, pero hay quien piensa que debe iniciarse sólo cuando se necesita, lo que genera complejas situaciones difíciles de programar. Por ejemplo, en nuestro programa multiplicador, necesitamos la sesión cuando entra el primer número y ya no la necesitamos al mostrar el resultado. Sería un esfuerzo baldío que la iniciásemos y la destuyésemos justo cuando hace falta. Se inicia al principio y ya se encargará de destruirla el recoge-migajas del sistema.

Un posible método ^

1. Diseñar cuidadosamente los interfaces de usuario. Marcarán toda la programación.
   1. Determinar cuantos y cuales son los interfaces.
   2. Diseñar cuidadosamente cada uno.
   3. Usar para los elementos input, select, etc. los mismos nombres que los correspondientes campos de la BdD si procede.
   4. Usar el mismo nombre con diferente índice para los botones.
2. Iniciar sesión al principio del programa.
3. Inicializar las plantillas.
4. Inicializar los idiomas si es multilingue.
5. Inicializar la base de datos.
6. Escribir el código que trate las diferentes condiciones de entrada (normalmente botones pulsados).

Plantillas ^

La plantilla es simplemente una página web, con todos los elementos de diseño que queramos introducir (o inicialmente ninguno). El programador construye una primera versión de la plantilla, de acuerdo con criterios de diseño de entornos de usuario y que cumpla los requerimientos del programa. Esta página tendrá unos datos fijos y algunos variables, que deberán ser generados por PHP. Estos elementos se marcan de alguna forma (según diga nuestro software de plantillas) para indicar su naturaleza.

Aparte, el programador construye el programa. En él, cuando quiere mostrar HTML, lee la plantilla, sustituye los datos variables por expresiones de su programa y muestra el resultado.

Cuando el programador termina la aplicación, entrega las plantillas a un diseñador, quien simplemente respetando las marcas de datos variables, que normalmente no son etiquetas HTML sino texto simple, aportará el diseño adecuado a la página y devolverá al programador las nuevas plantillas. Éste sustituirá las viejas por las nuevas y probará la aplicación.

A modo de ejemplo, implementemos nuestro propio sistema de plantillas (muy elementales). Tomamos un ejemplo clásico:
  <html>
  <body>
  Son las <? echo strftime("%H"); ?>
  horas
  </body>
  </html>

y lo sustituimos por:   <html>
  <body>
  Son las {HORA}
  horas
  </body>
  </html>


que es HTML sin PHP. Guardamos este texto en el archivo plantilla1.phtml y a continuación escribimos el programa:

El programa carga la plantilla, sustituye la etiqueta {HORA} por la hora actual y muestra el resultado.

Obviamente el caso general no es tan sencillo.

Si el resultado de la ejecución del programa es una tabla con un número indeterminado de filas, lo que corresponde es hacer el diseño para una fila y en tiempo de ejecución, replicar la fila tantas veces como sea necesario. Por ejemplo, dada la plantilla (plantilla2.html):
  <table border>
  <!-- inicio zona a replicar -->
  <tr><td>{DATO1}<td>{DATO2}</tr>
  <!-- fin zona a replicar -->
  </table>

si la ejecución del programa produce 3 filas, deberá convertirse en tiempo de ejecución en algo como:
  <table border>
  <tr><td>Un dato1<td>Un dato2</tr>
  <tr><td>Otro dato1<td>Otro dato2</tr>
  <tr><td>Otro dato1 más<td>Otro dato2 más</tr>
  </table>

lo que no se consigue trivialmente.

Un programador profesional debe tender a usar plantillas. Existen multitud de sistemas de plantillas. Uno de ellos es smarty, que lo comento el primero para descartarlo. smarty es potente, con muchas funciones ... que nadie necesita. Además la idea de separar diseño y programación no está muy clara en tanto que smarty permite (e induce a) incluir código del propio smarty en las plantillas.

Un sistema de plantillas antiguo y bastante o utlizado es FastTemplate, basado en ideas de Perl, del cual yo he testeado, con resultados satisfactorios, una de sus variantes, class.rFastTemplate.php.

PEAR incluye varios sistemas de plantillas, el más popular es HTML_Template_IT o su versión extendida HTML_Template_Sigma. La ventaja de esta última es ante todo la compilación de las plantillas, lo que mejora bastante el rendimiento (velocidad) del sistema de plantillas (o sea, de nuestro programa) comparado con sistemas de plantillas que no compilan. Compilar significa que la primera vez que se carga la plantilla (o si se modifica), el sistema de plantillas realiza una copia procesada de la misma, de modo que cuando se vuelve a usar no hay que procesarla y por ello carga más deprisa.

La gran ventaja de usar PEAR es la facilidad de instalación: pear search HTML_Templatenos muestra la lista de sistemas de plantillas, que instalamos simplemente haciendo:pear install HTML_Template_Sigma

Escribamos nuestro primer programa con plantillas: <?
  /*1*/ require_once "HTML/Template/Sigma.php";
  /*2*/ $tpl= & new HTML_Template_Sigma("plantillas","plantillas-compiladas");
  /*3*/ $tpl->loadTemplateFile("plantilla1.html");
  /*4*/ $tpl->setVariable("HORA",strftime("%H"));
  /*5*/ $tpl->show();
  ?>

En la línea 1 incluimos el código de HTML_Template_Sigma y en la 2 creamos un objeto plantilla, indicando que las plantillas las encontrará en el directorio plantillas y que guarde las plantillas compiladas en plantillas-compiladas. En la 3, cargamos la misma plantilla de antes, plantilla1.html. En la 4 establecemos el valor de la variable y en la 5 la mostramos.

Ahora, resolvamos el problema planteado anteriormente con plantilla2.html:   <html>
  <body>
  <table border>
  <!-- BEGIN fila -->
    <tr><td>{nombre}<td>{apellidos}</tr>
  <!-- END fila -->
  </table>
  </body>
  </html>


Usemos el siguiente código: <?
        require_once "HTML/Template/Sigma.php";
        $tpl= & new HTML_Template_Sigma("plantillas","plantillas-compiladas");

  /*1*/ $tpl->loadTemplateFile("plantilla2.html");

  /*2*/ $datos=array(array("nom"=>"Manuel","ape"=>"Mollar Villanueva"),
                     array("nom"=>"Lucas","ape"=>"Grijander"),);

  /*4*/ foreach ($datos as $persona) {
          $tpl->setVariable(array("nombre" => $persona["nom"],
                          "apellidos" => $persona["ape"],));
  /*5*/   $tpl->parse("fila");
        }
  /*6*/ $tpl->show();
  ?>

Es importante insistir en la consideración de rendimiento. Procesar una plantilla no es inmediato. Representa cargar un texto, analizarlo (con un programa escrito normalmente en PHP) y realizar las sustituciones. Esto requiere un tiempo de ejecución no despreciable que hay que tener en cuenta. Por eso algunos sistemas de plantilas las pre-compilan, pero aun así hay un coste. Un sistema con una carga tremenda se verá afectado por las plantillas, especialmente por plantillas dinámicas donde, por ejemplo, se repliquen filas de una tabla. La consecuencia es que a veces acaba siendo necesario combinar plantillas con la tradicional inclusión de HTML por razón de prestaciones.

Por último veamos un ejemplo con doble anidación (fila/columna), donde las consideraciones de rendimiento son todavía más importantes:   <html>
  <body>
  <table border>
  <!-- BEGIN fila -->
    <tr>
    <!-- BEGIN columna -->
      <td>{dato}
    <!-- END columna -->
    </tr>
  <!-- END fila -->
  </table>
  </body>
  </html>


Y el código: <?
  require_once "HTML/Template/Sigma.php";
  $tpl= & new HTML_Template_Sigma("plantillas","plantillas-compiladas");
  $tpl->loadTemplateFile("plantilla3.html");
  $datos=array(array("nom"=>"Manuel","ape"=>"Mollar Villanueva"),
               array("nom"=>"Lucas","ape"=>"Grijander"),);
  foreach ($datos as $persona) {
    foreach ($persona as $dato) {
      $tpl->setVariable("dato",$dato);
      $tpl->parse("columna");
    }
    $tpl->parse("fila");
  }
  $tpl->show();
  ?>

Ejemplos ^

En las aplicaciones web es habitual mostrar una cabecera de identificación de la aplicación y un menú con las principales acciones posibles. Para no repetir esta estructura se emplean a veces frames, pero generan problemas complicados de recargas. Vamos a aprovechar las plantillas para no usar frames. Construiremos una plantilla, digamos, global y dentro de ella colocaremos el resto de plantillas.

Los interfaces serán: uno de autenticación, otro de registro de cliente, otro de búsqueda de títulos (con muestra de novedades), otro de reserva y otro de consulta de reservas. Realmente para mejor programación y facilidad de uso, la consulta de reservas se integra con la de reserva y la de búsqueda.

La estructura de la base de datos es sencilla:

• clientes: tabla obvia.
• pelis, gente, pel_gen: información sobre las películas.
• soportes: ejemplares de películas, apunta a pelis y establece la fecha hasta la que queda reservada o la fecha hasta la que está alquilada (el alquiler se establece desde el mostrador).
• reservas: relaciona clientes con soportes.

Esto es un esbozo de lo que sería el programa: <?
  get_magic_quotes_gpc() or die();
  session_start();

  require_once "HTML/Template/Sigma.php";
  $tpl= & new HTML_Template_Sigma("plantillas-cine");

  //!
  $host="";
  //!
  $user="cine";
  //!
  $pas="cine";
  mysql_connect($host,$user,$pas) or
       error('No pude conectar con el servidor de BDD');
  //!
  $bdd="cine";
  mysql_select_db($bdd) or
       error('Error al acceder a la base de datos');

  $idus=$_SESSION['idus'];
  switch (@key($_POST['boton'])) {
    case 'entrar':
      $idus=mysql_fetch_assoc(mysql_query("select * from clientes".
                 " where dni='{$_POST['dni']}' and tel='{$_POST['tel']}'"));
      if (!$idus) {
        $tpl->loadTemplateFile("inicio.html");
        $tpl->setVariable("MENS",'Tas colao');
        break;
      }
      $_SESSION['idus']=$idus;
      $tpl->loadTemplateFile("busca.html");
      break;
    case 'edtcli':
      if (!identificado($idus))
        break;
      $tpl->loadTemplateFile("edtcli.html");
      foreach(array('nombre','dni','tel','direcc') as $cmp)
        $tpl->setVariable(strtoupper($cmp),
          htmlspecialchars($idus[$cmp]));

    default:
      if ($_SESSION['idus'])
        $tpl->loadTemplateFile("busca.html");
      else
        $tpl->loadTemplateFile("inicio.html");
      break;
  }

  $ifz=$tpl->get();
  $tpl->loadTemplateFile("global.html");
  $tpl->setVariable("INTFZ",$ifz);
  $tpl->show();

  function error($m) {
    global $tpl;
    $tpl->loadTemplateFile("error.html");
    $tpl->setVariable("MENS",$m);
    $tpl->show();
    die();
  }
  function identificado($idus) {
    if (!$idus) {
      $tpl->loadTemplateFile("inicio.html");
      $tpl->setVariable("MENS",
                'Primero identifíquese');
    }
  }
?>

Como puedes observar, lo primero es, independientemente de las acciones, iniciar sesión, preparar la plantilla y conectar con la BdD. A continuación se han implementado algunas de las funciones más básicas. Como puedes ver, hay dos funciones útiles, una que muestra un error fatal y otra, más útil, que verifica si el usuario está autenticado y si no lo está le propone hacerlo. Esta función será necesario llamarla antes de todas las operaciones que requieran estar previamente autenticado.

Concurrencia ^

Portabilidad ^

Un elemento de portabilidad es controlar los parámetros de php.ini que afectan fuertemente al programa. Lo más grave para la seguridad (y el buen funcionamento) es el estado de magic_quotes_gpc, parámetro que si está a ON (por defecto hasta php5 inclusive), provoca el escapado de ciertos signos, es decir que un signo " se convierta en \', como vimos. Si queremos que nuestro proyecto funcione independientemente de este parámetro, debemos, comprobar siempre el estado de magic_quotes_gpc, lo cual es engorroso, pero necesario.

Otra situación típica de falta de portabilidad es cuando desde nuesros programas hacemos referencia a URLs y usamos valores absolutos que pueden cambiar, en concreto la de nuestro proyecto. Un ejemplo muy típico es cuando mandamos un correo con una enlace a nuestra web e introducimos directamente nuestra URL. Lo correcto es usar la variable $_SERVER, como se muestra en el ejemplo de autenticación por mail.
Otra situación típica de URL es cuando se quiere cambiar a modo seguro la propia URL, debe usarse igualmente $_SERVER.

Cuando no podamos evitar una dependencia, como por ejemplo un path a un include o similar, podemos establecerlo como un parámetro de distribución/instalación de nuestra aplicación como explicamos aquí.

Internacionalización ^

Distribución ^

Una opción -- un tanto partidista :-) -- es usar una pequeña herramienta de mi construcción que construye un programa php con autoextracción que instala un proyecto completo. La herramienta se denomina mkInstaller, y lo primero es instalarlo. Es un único script, si soy administrador lo puedo instalar en /usr/local/bin según: wget -O /usr/local/src/mkInstaller.php \
        "http://dwnl.nisu.org/dwnl/mkInstaller.php/si"
echo $'#!/bin/bash\nphp /usr/local/src/mkInstaller.php "$@"' >/usr/local/bin/mkInstaller
chmod a+x /usr/local/bin/mkInstaller


Código cerrado ^

Afortunadamente existe remedio. Están disponibles una serie de productos que permiten ocultar el codigo fuente PHP. Existen varias técnicas para realizarlo:

• Los programas de tipo "compilador" traducen el php a un código intermedio denominado código Zend, que es el código de bajo nivel de la máquina virtual PHP, y que llamaré código compilado a partir de ahora. Justamente Zend comercializa, bastante caro, un producto de este tipo, que es además cache y optimizador.
• Los ofuscadores modifican el código fuente mediante sustituciones de nombres de funciones y variables y la deformaciópn del estilo de programación (por ejemplo meter el programa en una sola línea). Su principal inconveniente es que pueden fallar en proyectos muy complejos.
• Los codificadores realizan un cifrado del código fuente. El objeto generado se descifra mediante un cargador precompilado (escrito normalmente en C). En contra de lo que se ha dicho muchas veces y es desgraciadamente, opinión generalizada, éstos programas son completamente inútiles. El descifrado lo realiza automáticamente el módulo precompilado, obteniendo el código fuente que evalua y ejecuta. Si el módulo puede descifrarlos sin necesidad de ninguna clave, cualquiera puede hacerlo (esto es como el supuesto cifrado del DVD). En este caso es especialmente fácil hacerlo, no explicaré como por no perjudicar a nadie.

Obsérvese pues, que tener uno de estos compiladores/aceleradores en nuestro servidor web, vale la pena sólo por el hecho de acelerar la ejecución de php, incluso si no queremos dar el programa compilado a otros.

Autenticación ^

Almacenamiento de imágenes ^

• Es habitual guardarlas en archivos, y la ruta de cada archivo guardarla en la base de datos. En este caso debemos tener en cuenta la ineficiencia de algunos sistemas de atrchivos (por ejemplo ext2/3) para manejar directorios con muchos archivos. Lo que suele hacerse es generar un nombre aleatorio para la imágen, por ejemplo cf38ac800b64a0 y convertirlo en c/f/3/8/ac800b64a0, con lo que se genera un árbol de directorios que mejora mucho el acceso a disco.

• También es una opción guardar las imágenes en la base de datos. En este caso, debemos tener en cuenta que la base de datos crecerá considerablemente. Sus prestaciones no disminuirán, pero el tamaño debe de tenerse en cuenta en las copias de seguridad. A nivel de prestaciones, el acceso a la base de datos es probablemente menos costoso que al sistema de archivos, al menos si se accede con frecuencia. El único detalle es saber cómo mostrar la imágen. Para ello hay que cambiar el Content-type que PHP pone por defecto a "image/tipo, algo tan simple como: <?
  list($img)=@mysql_fetch_row(mysql_query("select img from ...."));
  header("Content-type: image/jpeg");
  if $(img)
    echo $img;
  else
    echo $imagen_por_defecto; // no se deben mostrar mensajes de error
?>

Mejores URLs

Continuación de descargas