Ambientes de producción y desarrollo

Para escribir un programa en PHP el desarrollador web sigue normalmente la siguiente rutina. Crea un archivo de texto con extensión .php donde escribe su código dentro de etiquetas <?php ... ?>. Lo guarda en alguna carpeta que forma parte de su sitio web. Accede al archivo .php a través de un navegador escribiendo su URL. El servidor invoca al intérprete de PHP y envía el resultado al navegador. El desarrollador puede entonces ver la salida de su programa.

Dependiendo de la configuración de PHP, esta rutina se vuelve en contra del desarrollador o de la empresa cuando el programa PHP tiene errores. Si la configuración dicta que el intérprete de PHP debe informar los errores en la salida estándar, éstos aparecerán en el navegador, lo cual ayudará enormemente al desarrollador a depurar sus programas, pero podría hacer visible información sensible de la empresa a los visitantes, o confundirlos arruinando el contenido y diseño del sitio web.

Si la configuración dicta que el intérprete de PHP debe callar los errores (o a lo sumo enviarlos a una bitácora), el desarrollador difícilmente detectará que los hay, a menos de que el intérprete se niegue a ejecutar el código PHP con errores y no regrese del todo una respuesta al servidor web, el cual optará por enviar un mensaje de respuesta con un código de estado 500 Internal server error al navegador. Esto es mucho más eficiente y evita que el servidor web exponga información sensible a los visitantes, aunque estos se molestarán en todo caso.

La solución aconsejada es tener dos ambientes: uno de producción y otro de desarrollo. El ambiente de producción aloja el sitio web que atiende a los visitantes, se considera estable y los errores en el código PHP no son reportados al navegador. El ambiente de desarrollo es de uso exclusivo de los desarrolladores, en él los errores y advertencias son reportados al navegador. Estas diferencias se configuran en la sección Error handling and logging del archivo php.ini.

Los ambientes de producción y desarrollo podrían estar en computadoras diferentes, o en la misma bajo servidores virtuales distintos. Es importante que el sitio web completo se encuentre administrado por algún software de control de versiones, como Subversion o Git, lo cual además facilita el mantenimiento del código entre estos ambientes.

Antes de publicar código PHP en el sitio web o en el repositorio de control de versiones, el desarrollador siempre debería chequear sus programas con el intérprete de PHP, lo cual puede hacerse en la línea de comandos de la siguiente forma:

php /path/to/file.php

El desarrollador no puede verificar un documento .php contra los validadores del Consorcio Web (como Unicorn), pero sí su salida. Es decir, que el desarrollador deberá hacer dos verificaciones, la primera es llamar al intérprete de PHP en línea de comandos para verificar que su código PHP sea correcto, y luego la salida que su programa genera debe verificarla contra los estándares del Consorcio Web. Una tercera verificación debe hacerse si se tiene código JavaScript, inspeccionando la consola de JavaScript en el navegador.

Generalidades del lenguaje PHP

La sintaxis de PHP se basa en C y Perl; y tiene mucha familiaridad con C++ y Java. Esto implica que los comentarios, condicionales, ciclos y operadores son similares. Este material asume que el lector conoce C y JavaScript, y se concentra en los aspectos que hacen a PHP distinto a estos lenguajes. Los comentarios en PHP se pueden escribir en cualquiera de las siguientes tres formas:

// Este es un comentario de una línea con estilo BCPL

# Este es un comentario de una línea con estilo Perl

/* Este comentario
puede abarcar varias
líneas pero no anidarse */

Al igual que JavaScript, PHP diferencia mayúsculas y minúsculas (case sensitive), y la aritmética se hace en punto flotante, es decir, 5 / 2 genera 2.5 y no 2 como ocure en C. PHP permite que un string se expanda varias líneas, y en tal caso, los espacios en blanco y cambios de línea pasan a formar parte natural del string, por ejemplo:

$table = /* ... */;
$condition = /* ... */;

$query = "
    SELECT *
    FROM $table
    WHERE $condition
";

equivale a haber escrito el siguiente código en una sola línea, pero que resulta más ilegible:

$query = "\n\tSELECT *\n\tFROM $table\n\tWHERE $condition\n";

Al igual que JavaScript, las variables pueden almacenar valores de diferentes tipos de datos a lo largo de la ejecución del script, y las conversiones de tipos de datos se hacen automáticamente de acuerdo al contexto. En PHP el operador de suma (+) se utiliza sólo para valores numéricos y no hace concatenación, lo cual es responsabilidad del operador punto (.). Por ejemplo:

]]>

El lector habrá notado que en algunos ejemplos se ha utilizado print() y en otros echo para generar la salida que recibirá el navegador. No son funciones realmente, son constructos del lenguaje y por ende pueden utilizarse con o sin paréntesis. La diferencia radica en que print recibe únicamente un parámetro de tipo string y retorna siempre el entero 1; mientras que echo no tiene un valor de retorno y puede recibir un número arbitrario de parámetros de cualquier tipo separados por comas, los cuales tratará de convertir a string automáticamente. En general, print() es un constructo del lenguaje utilizado para simular una función en un contexto donde se requiere una, mientras que echo es un constructo del lenguaje que no puede utilizarse en el contexto de una función y debe obligatoriamente usarse sin paréntesis si recibe dos o más parámetros. Exceptuando esas extrañas restricciones, en la mayoría de contextos puede utilizarse cualquiera de los dos, y la escogencia la hace el programador de acuerdo a sus gustos personales o las políticas de la empresa.

Tipos de datos

Los tipos de datos que PHP dispone son: booleanos, números (enteros y flotantes), strings, arreglos, objetos, recursos (resource) y el valor especial null. Son prácticamente los mismos tipos de datos de JavaScript con algunas diferencias. Al igual que en JavaScript, una variable PHP no tiene tipo de datos, sino que puede almacenar valores de cualquiera de esos tipos de datos. Para saber el tipo de datos del valor almacenado en la variable $var invoque la función gettype($var), la cual retorna un string con el nombre del tipo de datos.

Las variables booleanas (boolean) sólo admiten los valores true y false, los cuales se pueden escribir en cualquier combinación de mayúsculas y minúsculas (case-insensitive).

Internamente PHP almacena los números utilizando enteros (int) siempre que sea posible, y cuando el número es muy grande o tiene decimales, se representa internamente como un número flotante (double). El programador no necesita preocuparse por estas diferencias. Sin embargo, ambas representaciones tienen limitaciones en cuanto a la capacidad y precisión, inadecuadas cuando se tiene que hacer cálculos precisos o manejo de dinero. En tales circunstancias el programador puede recurrir a alguna extensión matemática de PHP.

Los strings en PHP no son objetos, por tanto, no tienen propiedades ni métodos como length(); sino que deben ser manipulados en forma similar a C: a través de funciones como strlen(str) y substr(str, start, length). Sin embargo hay una diferencia importante, en C los strings son punteros mientras que en PHP son valores y por tanto, los operadores de comparación (==, ===, <, <=, >, >=) y concatenación (.) trabajan de forma esperada en PHP.

En PHP todos los arreglos son realmente arreglos asociativos, también conocidos como mapas (maps), tablas hash o diccionarios; porque almacenan parejas llave => valor. Si las llaves no se especifican, se asumen valores enteros secuenciales. Los arreglos se crean con el constructo array(v1, v2, ..., vN) que recibe una lista de valores separados por comas, e inserta esos valores en orden asociándolos con llaves enteras correspondientes a la posición del elemento. Las llaves también pueden ser strings, y en tal caso se especifican usando la notación key => value. Un arreglo que almacene varias de estas parejas se crea utilizando la notación array(k1 => v1, k2 => v2, ..., kN => vN), como se aprecia en el php_arrays_intro. Al igual que los string, los arreglos no son objetos, por lo que su manipulación se hace a través de funciones como count($arr) y sort($arr). Este tema se estudiará con más detalle adelante.

   
   


   
Arreglos secuenciales
   


   
Arreglos asociativos
   
 points
      $gameRecords = array('lvargas' => 64900, 'elpapi' => 58831, 'chema' => 9215);

      // Recorrer el arreglo
      echo "\$gameRecords == \n";
      foreach ( $gameRecords as $user => $points )
         echo '   ', $user, ': ', $points, " puntos\n";

      // Agregar un elemento al arreglo
      echo "\n\$gameRecords['pinocho'] = 64901\n";
      $gameRecords['pinocho'] = 64901;

      // Ordernar el arreglo por valores descendenemente
      arsort($gameRecords);

      // Estudiar el arreglo
      echo "\n\$gameRecords == "; var_dump($gameRecords);
   ?>


]]>

Los objetos de PHP se parecen mucho a los de Java. Un objeto es una instancia de una clase, la cual puede tener herencia y polimorfismo con otras clases. Los objetos se crean con el operador new y sus miembros se acceden con el operador ->. Este tema se explica más adelante.

El tipo de datos y valor especial null sirve para indicar que una variable no tiene valor. Si se trata de hacer referencia a una variable que no existe, PHP puede o no generar un warning de acuerdo a su configuración, y el valor de reemplazo de la variable no existente es null, el cual se puede escribir en cualquier combinación de mayúsculas y minúsculas.

Cuando se utiliza un valor de un tipo de datos en un contexto donde se espera otro, PHP trata de hacer conversiones automáticamente; lo cual funciona bien en la mayoría de casos para los valores primitivos. El programador puede forzar la conversión de datos utilizando explicit type cast, anteponiendo el tipo de datos entre paréntesis a la expresión que se quiere convertir, de la misma forma que se hace en C, como en el ejemplo del php_explicit_type_cast.

Operadores

El programador puede escribir los mismos operadores que usa en C o JavaScript sin cambios en PHP. Las diferencias son mínimas, como las que se exponen a continuación.

El operador de concatenación en PHP es el punto (.), así el operador de suma (+) pretende sólo recibir operandos numéricos, de lo contrario, tratará de convertirlos a números.

Al igual que en JavaScript, el operador de igualdad == indica si dos valores son el mismo aún después de hacer conversiones, así la expresión "+12.3" == 12.30 se evaluará como verdadera. El operador de identidad === se evalúa verdadero sólo si sus operandos son iguales sin hacer conversiones.

Los operadores lógicos clásicos && y || trabajan de la misma forma que en otros lenguajes de programación. Sin embargo, PHP introduce los operadores lógicos nombrados and y or (que también pueden escribirse en mayúsculas: AND y OR), que tienen una prioridad menor, por lo que pueden causar conflictos si se combinan operadores clásicos con los nombrados en una misma expresión. Se aconseja al programador utilizar sólo los operadores clásicos a menos de que se entienda bien el efecto del operador nombrado.

Control de flujo

Los condicionales en PHP se indican con tres cláusulas: if/else/elseif, ?: y switch. La cláusula else if se puede escribir con el espacio o sin él (elseif); su efecto es el mismo en ambos casos, como se aprecia en el php_elseif.

   
   


   
Lógica de pares
   



]]>

Los ciclos en PHP se realizan con las mismas cláusulas de C: while, do-while y for, las cuales mantienen la misma sintaxis. PHP agrega una estructura de control más: foreach, la cual sirve para iterar arreglos y objetos, como se verá más adelante en sus respectivas secciones.

Arreglos

En PHP los arreglos son contenedores asociativos, es decir, son contenedores de parejas key => value, donde las llaves (key) pueden ser números o strings, y si se omiten, PHP asume valores enteros. Un arreglo se crea simplemente asignándole valores a sus elementos o con el constructo array(). Para crear una pareja key => value y agregarla al arreglo, se emplea la siguiente notación:

$arr[key] = value;

Si se asigna un valor a una llave que ya existe dentro del arreglo, no se inserta de nuevo, si no que se reemplaza su valor anterior. Si se omite la llave en la asignación, PHP busca el último entero asociado en el arreglo y asigna el sucesor al valor. Esto se ilustra en el php_array_assign.

La segunda forma de crear un arreglo es utilizando el constructo array(k1 => v1, k2 => v2, ..., kN => vN), que recibe las parejas llave=valor utilizando la notación key => value que asemeja una asignación, pero en lugar de ser una asignación directa indica actualizar el valor del índice o llave key. En el constructo array(), si se provee un valor sin llave, se asume el próximo índice que sigue al último entero utilizado en lugar de la llave (como ocurre con el valor 'vicente' en la línea 2 del php_array_construct). El resultado final del php_array_assign se podría escribir utilizando array() como se aprecia en el php_array_construct.

 6.5, 'ana' => 10.0, 'vicente', 3 => 'diana', 'fiona');
echo "\n\$notas = "; print_r($notas);

// Se puede asociar nuevos elementos a un arreglo creado con array()
echo "\nAgregando notas para diana y fiona:";
$notas['diana'] = 8.5;
$notas['fiona'] = 5.0;

// Imprime todos los elementos del arreglo utilizando el ciclo foreach
foreach($notas as $key => $value)
   echo "\n    $key: $value";

// Calcula el promedio de la clase
$sum = 0.0;
$count = 0;
foreach($notas as $key => $value)
{
   if ( gettype($value) == 'double' )
   {
      $sum += $value;
      ++$count;
   }
}
printf("\n\nEl promedio de los $count alumnos es %.2f", $sum / $count);
]]>

PHP provee el ciclo foreach-as, el cual recorre un arreglo por cada una de sus parejas key => value y permite al programador hacer algo con ellas en cada iteración del ciclo. El orden de recorrido es el mismo en que se encuentran los elementos en el arreglo, y puede alterarse con funciones de ordenamiento.

Las llaves en un arreglo asociativo sólo pueden ser enteras o string, pero el valor puede ser de cualquier tipo de datos, incluso otro arreglo. Esto permite representar matrices o arreglos de más dimensiones.

Funciones

Las funciones en PHP se declaran con la palabra reservada function seguido por la lista de parámetros entre paréntesis, de la misma forma que se hace en JavaScript. El php_factorial_function ilustra la función factorial() y su uso para imprimir los primeros 19 factoriales.

   
   


   
Factoriales
   
 1 ? $n * factorial($n - 1) : 1;
      }

      // Imprime los primeros 20 factoriales incluyendo el 0
      for ( $i = 0; $i < 20; ++$i )
         echo "
$i! = ", factorial($i), "
\n";
   ?>


]]>

En JavaScript el manejo de valores o referencias es implícito, es decir, el lenguaje se reserva su manejo y el programador no puede alterarlo. En cambio, en PHP el manejo de valores y referencias es explícito, es decir, el programador debe indicar cuándo quiere hacer una copia de un valor o cuando quiere tener una referencia hacia el valor original. Al igual que C++, una referencia se crea antecediendo el operador ampersand (&) al nombre de una variable, de la forma &$var.

El php_byvalue_byreference declara dos funciones idénticas: incrementar_salario_1() recibe sus dos parámetros por copia, mientras que incrementar_salario_2() recibe su primer parámetro por referencia. Ambas intentan aplicar un incremento de salario a todos los empleados recibidos en un arreglo por el primer parámetro. Dado que incrementar_salario_1() recibe una copia del arreglo, hará el ajuste de salario a un arreglo temporal que es descartado al terminar el llamado a la función. Por su parte, incrementar_salario_2() recibe una referencia hacia el arreglo original (línea 9) logrando el efecto deseado para este ejemplo.

 $salario )
      $personal[$persona] = $salario * $incremento;
}

// Ajusta el incremento de salario en el personal
function incrementar_salario_2(&$personal, $incremento)
{
   foreach ( $personal as $persona => $salario )
      $personal[$persona] = $salario * $incremento;
}

// Salario del personal en dolares
$mi_personal = array('eli' => 2000, 'nuria' => 4500, 'lucrecia' => 1600, 'roy' => 3000);
echo "mi_personal = "; print_r($mi_personal);

// Hacer un incremento del 5% en el salario con la función 1
echo "\nincrementar_salario_1(\$mi_personal, 1.05):\n";
incrementar_salario_1($mi_personal, 1.05);
echo "mi_personal = "; print_r($mi_personal);

// Hacer un incremento del 5% en el salario con la función 2
echo "\nincrementar_salario_2(\$mi_personal, 1.05):\n";
incrementar_salario_2($mi_personal, 1.05);
echo "mi_personal = "; print_r($mi_personal);
]]>

Reglas de alcance de variables (variable scope)

Una importante diferencia de PHP con otros lenguajes de programación son sus reglas de alcance de variables (variable scope). PHP asume que toda referencia a variable que se haga en el cuerpo de una función, es una referencia a una variable local, a menos de que se indique lo contrario. En el php_variable_scope_error, la función print_factorials() falla en la línea 23 al tratar de acceder a $count, ya que PHP busca una variable $count local, la cual no fue declarada en ese contexto.

   
   


   
Factoriales 2
   
 1 ? $n * factorial($n - 1) : 1;
      }

      function print_factorials()
      {
         // Error: $count no esta definida localmente
         for ( $i = 0; $i < $count; ++$i )
            echo "
$i! = ", factorial($i), "
\n";
      }

      print_factorials();
   ?>


]]>

Este problema es un error común de programación, debido a PHP rompe la norma de la mayoría de lenguajes en los cuales las variables globales son accesibles desde cualquier lugar del código. PHP provee varias alternativas. Si es factible, se recomienda pasar por parámetro el valor que requiere la función, así se mantiene la modularidad del código y se reduce la dependencia de variables globales, como se hizo en las líneas 20 y 26 del php_variable_scope_fix1.

   
   


   
Factoriales 3
   
 1 ? $n * factorial($n - 1) : 1;
      }

      function print_factorials($count)
      {
         for ( $i = 0; $i < $count; ++$i )
            echo "\n\t\t
$i! = ", factorial($i), "
";
      }

      print_factorials($count);
   ?>


]]>

Si por alguna razón es imprescindible acceder directamente a las variables globales, se le puede indicar a la función que la variable $count no está definida en el contexto local si no en el global, lo cual se hace anteponiéndole la palabra reservada global, como se aprecia en la línea 20 del php_variable_scope_fix2. En todo caso, el uso de variables globales se considera una mala práctica de programación.

   
   


   
Factoriales 4
   
 1 ? $n * factorial($n - 1) : 1;
      }

      function print_factorials()
      {
         // Hace a $count accesible en el contexto local
         global $count;

         for ( $i = 0; $i < $count; ++$i )
            echo "\n\t\t
$i! = ", factorial($i), "
";
      }

      print_factorials($count);
   ?>


]]>

PHP provee algunas variables globales que son accesibles desde cualquier contexto, es decir, sin tener que declararlas primero con la palabra reservada global. Se les conocen como variables superglobales y son arreglos asociativos con información muy útil para el programa. Se listan en la php_superglobal_variables y cada uno se explica más adelante en este mismo capítulo.

Siempre que se va a usar una variable cuyo valor fue provisto por una fuente externa, como un parámetro, debe evitarse que su valor sea ejecutado por el intérprete de JavaScript o genere código (X)HTML/JavaScript, ya que permite a un atacante inyectar código maligno que podría revelar información confidencial de su sitio web u otro tipo de daño. PHP provee varias funciones que convierten código en una representación no ejecutable, como htmlspecialchars() que reemplaza los caracteres especiales (<, >, &) por sus entidades correspondientes (<, >, &). Estas funciones se estudiarán más adelante (ver php_sanitize_functions).