Miscellaneous
Send email
En Español por favor

Valid XHTML 1.0! ¡Valid CSS 2.1!

Readings - PHP in miniature

This section is under development and unifinished.

Mezclando HTML/XHTML y PHP

Buena parte de PHP consiste en mezclar código PHP con código HTML, para insertar código PHP existen los siguientes métodos:

  1. <? ...código PHP... ?>
  2. <?= ...código PHP que retorna una cadena de texto que será mostrada como si fuera la instrucción echo... ?>
  3. <?php ...código PHP... ?>
  4. <script language="php"> ...código PHP, ésta forma es útil para los que usan editores como el FrontPage... </script>
  5. <% ...código PHP... %>
  6. <%= ...código PHP que retorna una cadena de texto que será mostrada como si fuera la instrucción echo... %>

Todo el texto fuera de dichos marcadores es tratado como un comando "echo", ésto quiere decir que es afectado por expresiones condicionales y estructuras de control.

Separación de instrucciones y comentarios

Al igual que C, Perl y algunos otros lenguajes, PHP utiliza el punto y coma ';' para separar o terminar una instrucción de otra.
Además también se asume una terminación de instrucción implícita al cerrar un bloque de código PHP con ?>, por lo tanto el último punto y coma es opcional en dichos casos.

Para agrupar instrucciones y formar bloques se utilizan las llaves '{' para comenzar el bloque y '}' para indicar su final.

Para incluir comentarios en el código que no es HTML, existen tres formas:

  1. Al estilo C utilizando '/*' y '*/' englobando el comentario, permitiendo marcar comentarios de múltiples líneas.
  2. Al estilo C++ utilizando '//' para señalar el inicio de un comentario que dura hasta el final de la línea.
  3. Al estilo Shell Script de Unix utilizando '#' de forma análoga a 2.

El primero permite incluso comentar entre diferentes bloques de PHP y HTML.
El segundo y el tercero tienen efecto sólo dentro del bloque actual de PHP y en la terminación de éste dejan de comentar.

Tipos y variables

PHP es un lenguaje no tipado, ésto quiere decir que las variables no tienen un tipo fijo y definido, sino que éste cambia dinámicamente con la ejecución del programa y no es necesario declarar las variables.

Siempre que se hace referencia a una variable, se utiliza el símbolo de pesos '$' seguido del nombre, como por ejemplo '$var=1; echo($var);'. El nombre de una variable es sensitivo a las mayúsculas y minúsculas y debe comenzar con letras o underscore.

También existen referencias, que permiten que una variable en realidad haga referencia a otra o se comporte como un alias a otra, como por ejemplo en '$ref=&$var;' donde cualquier cambio a $var será reflejado en $ref y cualquier cambio de $ref cambiará a $var.

Las variables variantes son interesantes, '$varnormal="varvariante"; $$varnormal="datos variable variante";' hace que halla una variable llamada varnormal que contiene un string con el texto 'varvariante' y que halla una variable llamada varvariante que contiene un string con el texto 'datos variable variante'.

Los tipos de datos primitivos soportados son ocho, pudiendose agrupar en escalares, compuestos y especiales:

Escalares:
  1. boolean: Indica un valor verdadero o falso, el cual se puede evaluar en una condición y setear a partir de las palabras clave 'true' y 'false' (no sensibles a las mayúsculas/minúsculas) o del resultado de una evaluación condicional, y también a partir de la conversión de otros tipos de datos.
  2. integer: Contiene un valor entero con signo generalmente de 32 bits o superior. Se puede especificar de forma decimal normalmente (1234), o de forma octal con un cero a la izquierda (0777) o de forma hexadecimal escribiendo 0x al inicio (0xbeaf2234) al igual que en el lenguaje C. Al evaluarlo o convertirlo a boolean, si es 0 se evaluará como falso y de lo contrario a verdadero. Al hacer overflow se convierte a double y lo mismo en el resultado de una división entre no divisibles (es decir, 1/2 retorna el double 0.5), al obtenerlo a partir de un double el número será redondeado hacia cero.
  3. double: Contiene un valor real con coma flotante, por lo gral. utiliza el formato IEEE de 64 bits, se puede especificar así 1.234, así 1.2e3 o así 7e-10, y al evaluarlo o convertirlo a boolean, es falso si es 0.0.
  4. string: Contiene una serie de caracteres, como es un tipo de dato importante y complejo, está explicado mas adelante.
Compuestos:
  1. array: En PHP un array es asociativo y por lo tanto tiene una clave y un dato asociado a dicha clave. Se puede especificar de varias formas, una es la siguiente: 'array( [clave =>] dato , ...)', los paréntesis rectos indican que la clave es opcional y en caso de no especificarla es equivalente al valor de la última clave entera mas uno o cero si no había ninguna clave entera. La otra forma es: '$arr[clave] = dato; $arr[] = dato;' donde $arr es el nombre de la array y como se puede observar también aquí se puede omitir la clave. La clave puede ser un entero positivo o de lo contrario un string y el dato puede ser cualquier tipo, incluso otro array. Si está vacío, se evalúa como falso.
  2. object: Contiene una instancia de una clase, mas adelante se detallan las clases y los objetos.
Especiales:
  1. resource: Es una variable especial creada y usada por funciones especiales, que por lo gral. se usa para referirse a un recurso externo o datos especiales.
  2. null: Indica que una variable no tiene un valor y se puede setear a través de la palabra clave null insensitiva a las mayúsculas o minúsculas.

PHP soporta castings o conversiones explícitas al estilo del lenguaje C, como por ejemplo '$numentero=(integer)1.362;'.

Strings

Son secuencias de caracteres de un byte de tamaño cada uno. PHP tiene un soporte muy flexible y un poco complejo para los strings, que si es bien utilizado ahorra tiempo y simplifica. Hay tres formas de especificar un string:

  1. Comilla simple: $var='Texto y \' una comilla simple, una barra invertida \ y otra barra invertida \\ (sólo una), y no hay nueva línea al poner el \n, esto es $unavar porque no hay expansión de variables.'.
  2. Comilla doble: $var="Texto y una \" comilla doble, una barra invertida \\, una nueva línea con \n, y se toma el contenido de $unavar o también así con texto${unavar}alrededor, y un símbolo de pesos \$, también se puede usar {$array['elem'][1]} para especificar expresiones complejas y en éste caso acceder al contenido de un elemento de un array, y así se escapa \{$ o sino así {\$.".
  3. Here document:
    $var= <<<FINDOC
    Acá va cualquier texto, sin necesidad de escapar las " o las ', sin embargo se usan los mismos códigos de escape y expansión de variables que en los strings especificados con comillas dobles.
    FINDOC;

    En vez de FINDOC puede usarse cualquier identificador que pueda delimitar el texto. FINDOC debe comenzar en la primer columna de una línea vacía que sólo contiene FINDOC; sin espacio en el punto y coma.

Se pueden agregar strings mediante el operador punto '.', como por ejemplo '$hola_mundo="hola" . " mundo";' y además se puede obtener un caracter en una posición especifica '$h=$hola_mundo{0}; $m=$hola_mundo{5};'.

Al evaluar un string, éste es falso si no contiene ningún caracter, y al convertirlo a un double se toman todos los digitos válidos de un número comenzando desde la izquierda hasta encontrar un caracter o secuencia inválida para ser convertida.

Obteniendo datos externos

Hay varios datos que son externos al script de PHP, como ser datos de un formulario con método GET o POST, variables de entorno, cookies HTTP, variables de sesión, datos del servidor WEB, etc.
PHP brinda varias formas de obtener dichos datos según opciones de configuración y de donde provengan los mismos. Lo mejor es mostrarlo en forma de ejemplo:
echo($HTTP_GET_VARS["nombre_variable_get"]);
echo($HTTP_POST_VARS["nombre_variable_post"]);
echo($HTTP_COOKIE_VARS["nombre_variable_cookie"]);
echo($HTTP_SESSION_VARS["nombre_variable_de_sesion"]);
echo($HTTP_ENV_VARS["nombre_variable_de_entorno"]);
echo("El nombre de éste script es: '$PHP_SELF'.");
echo($HTTP_SERVER_VARS["alguna_variable_del_servidor"]);

Dependiendo de la configuración de la instalación de PHP, algunas de éstas variables pueden estar disponibles como variables globales sin necesidad de accederlas mediante los array asociativos.

Las variables GET y las variables POST provienen de formularios HTML dependiendo si el método de éste (atributo method) es GET o POST respectivamente, y su nombre es el mismo nombre de la propiedad name de los tags.

Las variables COOKIE provienen de cookies definidas en el navegador del usuario y son una forma de tener variables que se pueden acceder entre múltiples páginas, scripts e instancias de los mismos; otra forma de variables persistentes son las denominadas variables de sesión (SESSION variables). Ambas se setean mediante funciones detalladas mas adelante.

Las variables del servidor (SERVER variables) contienen información sobre el servidor WEB, la conexión, etc.

La mejor forma de visualizar las variables definidas en un script junto con sus valores y otros datos útiles es realizando una llamada a la función phpinfo().

Todas las variables externas que tengan un punto en su nombre, el mismo será reemplazado por un underscore '_' ya que el punto no es un caracter válido para una variable de PHP.

Constantes

Las constantes contienen un valor de tipo escalar (boolean, integer, double o string) el cual permanece inmodificable y es accesible globalmente.

Para definir una constante se utiliza una función de la siguiente forma: 'define("CONSTANTE", "El dato");', y se accede simplemente con el nombre sin ponerle el símbolo '$' al inicio: 'echo(CONSTANTE);'.

Algunas de las constantes predefinidas por PHP son:

  • __FILE__: nombre del archivo, si es un archivo incluido es el nombre del archivo incluido y no el del que lo incluye.
  • __LINE__: número de línea donde está dicha constante.
  • PHP_VERSION: versión de PHP por ejemplo '4.0.4'.
  • PHP_OS: sistema operativo como por ejemplo 'AIX', 'Darwin', 'Linux', 'SunOS', 'WIN32', 'WINNT', etc.

El lector atento se dará cuenta que __FILE__ y __LINE__ en realidad no son constantes ya que una cambia por cada archivo y la otra por cada línea, pero la forma de utilizarlas es idéntica al de las constantes y su valor no es modificable por el programador.

Operadores

Es mejor mostrarlos en forma de ejemplo:

Aritméticos:
echo(2 + 2); //4
echo(3 - 2); //1
echo(2 * 3); //Llueve o el número 6.
echo(3 / 2); //1.5
echo(20 % 7); echo(21 % 7); /* 6 y 0 respectivamente (resto de la división entera). */
Asignación:
$a = 1; //$a vale 1.
$a += 2; /* $a vale 3 y es equivalente a hacer $a = $a + 2, además puede usarse cualquier otro operador en vez del +. */
$b = ($c = 2000) + 2; //$b vale 2002 y $c vale 2000.
Binarios:
echo(0xf0 & 0x0f); /* 0 ya que es la operación AND, bits que están seteados en ambos operandos quedaran seteados, el resto serán reseteados. */
echo(0xf0 | 0x0f); // 255 ya que es la operación OR.
echo(2 ^ 7); /* 5 y corresponde a la operación XOR, en binario: 010 XOR 111 = 101. */
echo(~0xffffff00); /* 255 y corresponde a la operación NOT, FIXME: sin embargo me da cualquier verdura, es mas, un printf("%x", 0xffffff00); da cualquier cosa, no entiendo, haciendo lo mismo en C da resultados correctos. */
echo(2 << 1); //4, porque corre un lugar a la izquierda los bits.
echo(2 >> 1); //1, porque corre un lugar a la derecha los bits.
Condicionales:
$cond = 10=="10"; /* $cond será verdadero, operador "igual que" (verdadero si datos son coincidentes). */
$cond = 10==="10"; /* $cond será falso, operador "idéntico a" (verdadero si datos y tipo son coincidentes). */
$cond = 10!="10"; /* $cond será falso, operador "no igual a". */
$cond = 10!=="10"; /* $cond será verdadero, operador "no idéntico a". */

FIXME: seguir con language.operators.comparison.html y luego en adelante.
FIXME: variable scope después de hablar de funciones.
FIXME: sección de clases y objetos.