Notas para iniciarse en PHP, Parte 6: Clases y objetos en PHP5

Un nuevo modelo de objetos

En la versión 5 de PHP se introdujo un nuevo modelo de objetos, rehaciendo completamente el anterior, para mejorar el funcionamiento y agregar nuevas características, en beneficio del programador por fortuna.

El cambio de modelos

Como mencionamos en el artículo anterior, la definición de una clase esta integrada por un conjunto de componentes que aparecen dentro de una estructura. Para definir una clase se utilizará nuevamente la palabra "class", seguida del nombre de la clase y la apertura y cierre de corchetes, dentro de los cuales se declararán los componentes de ésta. Hasta aquí no se ve diferencia con el modelo anterior sin embargo, durante la declaración de los componentes de la clase es cuando tenemos los primeros cambios, ya que ahora se toma en cuenta la visibilidad de los campos (también llamados propiedades en el manual) y los métodos, por ejemplo si tomamos la clase Carrito del artículo anterior y la migramos a la versión 5 del lenguaje tenemos un resultado como el que sigue:

class Carrito {
    public $items;  // Ítems en nuestro carrito de compras

   // Agregar $num artículos de $artnr al carrito

   public function agregar_item($artnr, $num) {
        $this->items[$artnr] += $num;
    }

   // Tomar $num artículos de $artnr del carrito

    public function retirar_item($artnr, $num) {
        if ($this->items[$artnr] > $num) {
            $this->items[$artnr] -= $num;
            return true;
        } elseif ($this->items[$artnr] == $num) {
            unset($this->items[$artnr]);
            return true;
        } else {
            return false;
        }
    }
}

Es la clase Carrito con los métodos que ya vimos antes, sin embargo tanto al único campo como a los métodos se les antepuso la palabra public, que es un indicador de visibilidad, esto se debe a que el modelo de objetos de PHP5 tenemos que indicar el tipo de visibilidad de los métodos y propiedades de nuestras clases, la cual especifica el contexto en el que estos componentes podrán ser utilizados. La declaración public indica que el método puede ser utilizado en el contexto en el que se instancie la clase, es decir donde se cree un objeto de esta clase, por ejemplo si instanciamos la clase Carrito:

$carrito = new Carrito;
$carrito->agregar_item("10", 1);
$carrito->agregar_item("8", 3);
$carrito->agregar_item("110", 4);
$carrito->retirar_item("8", 2);

Podemos acceder a los métodos agregar_item o retirar_item debido a que su indicador de visibilidad es public, de haber utilizado protected o private esto no habría sido posible, ya que protected determina que los métodos y propiedades solo pueden ser utilizados dentro de la definición de la propia clase y en la de sus clases extendidas, mientras que private restringe el uso de los métodos y propiedades únicamente a la declaración de la misma clase .

El concepto de visibilidad se introdujo en esta versión es una de las principales diferencias que encontraremos durante el trabajo con las clases, y lo primero a lo que debemos adaptarnos al migrar nuestra programación, el resto del trabajo consiste en conocer las nuevas funcionalidades que ofrece PHP para este modelo.

Instancia de una clase

Como se vio en el ejemplo anterior, la instanciación de clases se sigue haciendo de la misma manera que en la versión 4, solo hay que notar que algunas autores recomiendan que aunque no se pasen parámetros al constructor se incluya el paréntesis durante la instanciación, es decir:

$carrito = new Carrito();

Lo cual es totalmente opcional.

Herencia

El mecanismo para la herencia sigue siendo la extensión de clases con "extends" como en la versión 4.

Autocarga de objetos

Esta es una facilidad que brinda PHP para acceder a los archivos fuente de nuestras clases, que es útil cuando el nombre del archivo es el mismo que el de la clase que contiene. Anteriormente se tenía que realizar un include para cada archivo, mientras que ahora se cuenta con una función que puede hacer ese trabajo por nosotros.

Si declaramos en nuestro programa la función __autoload() PHP la llamará automáticamente cada vez que se haga una nueva instancia a una clase que no ha sido incluida aún, esta función recibe el nombre de la clase como parámetro y dentro de ella podemos realizar la inclusión del archivo, por ejemplo:

<?php
function __autoload($class_name) {
   require_once $class_name . '.php';
}

$obj  = new MyClass1();
$obj2 = new MyClass2();
?>

En este ejemplo no existe dentro del programa la definición de la clase MyClass1, entonces al hacer la instancia PHP ejecutará por si solo la función __autoload() y le pasará como parámetro el nombre de la clase que estamos llamando, es decir que la función recibirá "MyClass1" en su parámetro $class_name, entonces teniendo el nombre de la clase y sabiendo que es el mismo nombre del archivo que la contiene, podemos incluir este archivo con la función require_once.

Constructores y destructores

La declaración de un constructor ahora es diferente, ya no se utiliza el nombre de la clase para identificarlo sino el nombre especial __contruct, de modo que la función que declaremos con este identificador será llamada cada vez que se cree un nuevo objeto de nuestra clase:

<?php
class BaseClass {
   function __construct() {
       print "In BaseClass constructor\n";
   }
}

class SubClass extends BaseClass {
   function __construct() {
       parent::__construct();
       print "In SubClass constructor\n";
   }
}

$obj = new BaseClass();
$obj = new SubClass();
?>

El ejemplo anterior nos muestra no solo la declaración de un constructor de un clase sino también que el constructor de una clase padre no es llamado implícitamente por el constructor de sus hijos, por lo que tiene que debe ser llamado explícitamente con partent::__contruct(). La principal ventaja de utilizar el mismo nombre para todos los constructores, es que al momento de cambiar el nombre de una clase no tendremos que hacer lo mismo con su contructor.

El método __destruct() es el destructor de la clase, este es un nuevo tipo de método que se incluyó como una de las novedades de PHP5, el cual es ejecutado cuando todas las referencias al objeto de la clase sean removidas, o cuando el objeto sea explícitamente destruido, o cuando llegue la finalización de un programa.

<?php
class MyDestructableClass {
   function __construct() {
       print "In constructor\n";
       $this->name = "MyDestructableClass";
   }

   function __destruct() {
       print "Destroying " . $this->name . "\n";
   }
}

$obj = new MyDestructableClass();
?>

Este método tampoco es llamado implícitamente en los destructores de las clases hijo, por lo que de querer ejecutar el destructor del padre debería llamarse con parent::__destruct().

Elementos estáticos y constantes

Dentro de los componentes de una clase pueden existir miembros estáticos, es decir propiedades y métodos accesibles fuera de la definición de la propia clase que no necesitan de un objeto para ser utilizados, sino que pueden accederse directamente con el operador de resolución de contexto '::'. Estos componentes estáticos no pueden ser redefinidos en la extensión de una clase.

<?php
class Foo {
    public static $prop = "Propiedad estática";
    public static function aStaticMethod() {
        echo "Método estático que es accesible sin un objeto";
    }
}

Foo::aStaticMethod();
echo Foo::$prop;
?>

Para acceder a una propiedad o método estático dentro de la definición de la misma clase, se utiliza la palabra 'self' junto con el operador de resolución de contexto '::' como se indica:

class Foo
{
    public static $my_static = 'foo';

    public function staticValue() {
        return self::$my_static;
    }
}

También pueden existir propiedades constantes es decir, valores que no pueden ser alterados y que tienen un identificador para acceder a ellos. Las constantes difieren de las variables normales en que no se usa el símbolo $ para declararlas o usarlas. Para leer sus valores desde el contexto de la definición de la clase se utiliza la palabra 'self' seguida del operador '::' junto con el identificador de la constante. Desde el contexto de la instancia no se puede acceder a las contantes como una propiedad de los objetos, sino que se accede directamente a ellas a través de la clase con el operador de resolución de contexto '::'.

<?php
class MyClass
{
    const constant = 'constant value';

    function showConstant() {
        echo  self::constant . "\n";
    }
}

echo MyClass::constant . "\n";

$class = new MyClass();
$class->showConstant();
// echo $class::constant;  No es una operación permitida
?>

Su modo de acceso es similar al de las propiedades estáticas como se puede ver, con la diferencia de que las propiedades constantes no pueden ser alteradas. En ambos casos si deseamos acceder a una propiedad estática o constante de la clase padre desde un método del hijo, debemos utilizar la palabra 'partent', tal como se vió su uso en las secciones anteriores.

Abstracción de datos e interfaces

Otra de las novedades de esta versión son las clases abstractas, las cuales nos permiten crear clases no instanciables que funcionan como base para las clases hijo que las extenderán. Las clases abstractas pueden contener métodos abstractos, es decir métodos de los que solo aparece su declaración en la clase base y que forsozamente tienen que ser definidos en las clases hijo.

Las clases abstractas son útiles cuando tenemos un grupo de clases que compartirán un comportamiento en común y al mismo tiempo implementarán funcionalidades particulares, para lo cual podemos crear una clase base que indique la estructura general que tendrán todos las clases extendidas. La diferencia con el tipo de herencia común es que las clases abstractas se utilizarán cuando no necesitemos implementar el comportamiento de la clase base dentro de nuestros programas.

Siguiendo con la revisión también nos encontramos que existen interfaces, que consisten en estructuras similares a las clases abstractas ya que no pueden instanciarse, y dentro de su definición también hayamos propiedades y métodos, pero tienen la gran diferencia de que en una interface solo se declaran los métodos, estos nunca se definen, de esta tarea se encargarán las clases que las implementen. Como se pueden dar cuenta, mencione que las clases implementarán las interfaces, y es que aquí se habla de implementación en lugar de extensión, a pesar de ser mecanismos similares se hace la diferencia, ya que en el caso de las interfaces las clases que las implementan nunca heredan un método funcional. Entonces estas estructuras especifican qué métodos deberán poseer las clases que los implementen, y dejarán los detalles de la implementación a estas clases.

Las interfaces tienen gran utilización dentro de los lenguajes orientados a objetos para estandarizar ciertas funciones, al establecer los comportamientos que deberán seguir los objetos que implementen alguna funcionalidad particular. Por ejemplo, dentro de Java se utilizan para implementar el manejo de eventos del usuario, ya que si deseamos que alguna de nuestras clases pueda capturar algún evento del teclado o ratón, necesitan implementar una interfase que proporciona el lenguaje para el manejo de estos eventos, de forma que sin conocer los detalles sobre el manejo de eventos, sabremos que métodos deberemos implementar dentro de nuestras clases para utilizarlo. Algo similar puede verse en otros lenguajes, incluyendo a PHP, para crear frameworks de programación, ya que de esta forma podemos establecer que comportamiento deberá tener una clase que desee implementar cierta funcionalidad contemplada en el armazón.

La palabra reservada 'final'

Cuando se desea que las clases hijo no puedan redefinir un método o modificar el valor de una propiedad de la clase padre, se puede utilizar la palabra reservada final durante su declaración, con la cual PHP interpretará que este valor no podrá ser alterado fuera del contexto de su clase, lanzando un error de querer hacerlo.

Otras funcionalidades

PHP ofrece además de lo anterior algunas opciones adicionales que podemos utilizar con nuestras clases para obtener ciertas facilidades, como son:

El acceso a miembros y sobrecarga de métodos. Se usan para registrar nuevas propiedades en los objetos en tiempo de ejecución y para implementar la sobrecarga de métodos.
La interacción con objetos. Últil para desplegar las propiedades de un objeto desde un foreach.
Patrones. Sirven para implementar funcionalidades comunes en nuestros programas que nos ahorren tiempo de programación.
Clonación de objetos. Nos permite hacer replicas de nuestros objetos.

Y con esta última revisión termino con mis anotaciones sobre el modelo de objetos de PHP5, ahora lo que queda por ver es la forma en la que podemos utilizar todo lo aprendido interactuando con las interfaces de usuario, para lo que revisaremos la lectura de datos de formularios, el manejo de sesiones y cookies, y algunas funciones que hacen varias cosas interesantes.

Hasta la próxima.

Notas para iniciarse en PHP, Parte 5: Clases y objetos en PHP4

Todo gran viaje comienza con un solo paso

La utilización de clases y objetos

PHP nos permite programar tanto de manera procedimental como con orientación a objetos, es en está última donde surgen los conceptos de clases y objetos, a los cuales nos enfocaremos en este artículo. En el viejo estilo estructurábamos nuestros programas en un conjunto de funciones que utilizábamos dentro de las secuencias de ejecución, en la programación orientada a objetos nuestras aplicaciones constarán de un conjunto de elementos llamados objetos, los cuales interactúan entre sí por medio de sus métodos. Un método es similar a una función en programación estructurada, solo que éste se encuentra asociado a un objeto específico, el cual utiliza los métodos para implementar su funcionalidad particular. Todos los objetos están basados en la definición de una clase, la cual puede verse como la estructura que especifica las características y el comportamiento que tendrá el objeto; todo objeto debe pertenecer a una determinada clase, la clase entonces es una entidad pasiva que define que hará el objeto, mientras el objeto es una entidad activa que realizará un conjunto de tareas dentro de nuestros programas. Si por ahora no ha quedado muy clara esta definición quizás con la implementación en el lenguaje se entenderá mejor.

Clases y objetos en PHP4

En PHP una clase es una colección de variables y funciones que trabajan con estas variables. El concepto de clase y objeto se introdujo en este lenguaje a partir de su versión 4, contando ya con conceptos como la herencia y los constructores, componentes que representan el mínimo necesario para considerarla orientada a objetos, sin embargo este modelo se queda corto si lo comparamos con otros lenguajes basados en objetos más maduros y versátiles como Java o C#. El modelo de la versión 4 es más parecido al de otros lenguajes basados en scripts como Javascript o Actionscript. Por todo lo anterior en la versión 5 del lenguaje se introdujoun nuevo modelo de objetos, que incluyera un mejor funcionamiento y más opciones, para el programador, pero aún así, las bases para el trabajo con clases y objetos siguen siendo los de la versión 4, por lo que es importante al iniciarse en este tema dar un repaso a las características que ofrece esta versión, además de que muchas bibliotecas libres que encontramos por la red siguen utilizándola.

Definición de una clase

La definición de una clase en PHP se realiza por medio de la palabra reservada class seguida de la apertura y cierre de llaves utilizada en las estructuras, dentro de estas llaves se escriben las variables y funciones que contiene una clase. Siguiendo una sintaxis como la que sigue:

class NombreDeLaClase {
...
}

El siguiente ejemplo nos muestra una implementación para esta sintaxis:

<?php
class Carrito {

   var $items;  // Ítems en nuestro carrito de compras

// Agregar $num artículos de $artnr al carrito

   function agregar_item($artnr, $num) {
      $this->items[$artnr] += $num;
   }

   // Tomar $num artículos de $artnr del carrito

   function retirar_item($artnr, $num) {
      if ($this->items[$artnr] > $num) {
         $this->items[$artnr] -= $num;
         return true;
      } elseif ($this->items[$artnr] == $num) {
         unset($this->items[$artnr]);
         return true;
      } else {
         return false;
      }
   }
}
?>

En este ejemplo aparece la definición de la clase Carrito, que posee una variable que contendrá un arreglo asociativo, además la clase dispone de dos funciones o métodos para agregar o eliminar items del arreglo, en un sentido más abstracto la clase representa un objeto del mundo real, en este caso un carrito de compras, al que le podemos agregar o quitar productos.

Las variables o campos (como se les llama en el lenguaje Java) de las clases se identifican anteponiendo la palabra reservada var, estos campos se pueden acceder desde cualquiera de las funciones de la clase, como si se tratara de variables globales dentro del contexto de la definición de la clase, anteponiendo al nombre del campo la expresión $this->, lo cual es muy importante ya que de otra forma PHP interpretara que se trata de una variable local de las funciones en las que se está haciendo referencia. Las funciones que aparecen, que tienen la misma definición que en la programación estructurada que vimos en artículos anteriores, reciben el nombre de métodos, que es el término que emplearemos de ahora en adelante, ya que es el nombre que reciben en la programación orientada a objetos, debido a que a través de ellos se define el comportamiento de los objetos que se crean con las definiciones de nuestras clases. Para accesar a un método contenido en la definición de la clase también se utliza la expresión $this-> seguida de la llamada al método, por ejemplo si se incluyera un tercer método en la clase Carrito el cual necesitara utilizar alguno de los otros:

   //Vaciar el carrito de compras eliminando todos los artículos

 function vaciar_carrito() {
      foreach ($this->items as $artnr=>$num)
         $this->retirar_item($artnr, $num);
   }

En el ejemplo, el nuevo método vaciar_carrito() utilizará la funcionalidad de retirar_item() para eliminar todos los elementos del arreglo.

Los métodos le permiten a los objetos interactuar con su entorno, para lo cual es necesario primero crear un objeto con la definición de la clase, lo cual es llamado instanciar una clase, y se hace de la siguiente forma:

$objeto = new NombreDeLaClase;

La instancia de la clase se realiza con la expresión new seguida del nombre de la clase y está debe ser asignada a una variable, la cual será el objeto creado a partir de esta instancia. El nombre de la clase puede llevar paréntesis si así lo deseamos, pero su uso es opcional a menos que la definición del constructor de la clase indique que tiene que recibir algún de valor, para lo cual se vuelve obligatorio el uso de paréntesis en la instanciación, el tema de los constructores lo veremos más adelante.

Siguiendo con el ejemplo del carrito de compras la instancia de la clase Carrito se realizaría de la siguiente manera:

$carrito = new Carrito;
$carrito->agregar_item("10", 1);

$otro_carrito = new Carrito;
$otro_carrito->agregar_item("0815", 3);

En el ejemplo anterior se realizan dos instancias de la clase Carrito por medio de la expresión new Carrito, con lo cual se crean los objetos $carrito y $otro_carrito, los cuales una vez creados pueden acceder a los métodos de esta clase -tanto agregar_item como retirar_item).

Herencia

Las clases pueden tener puntos de intersección en su definición, como suele ser el caso de compartir campos o métodos similares o idénticos, en ese caso sería un gasto de tiempo innecesario volver a escribir estos métodos y campos en la definición en cada clase en las que se vayan a utilizar, para facilitar la solución de este problema PHP permite la herencia entre la clases, la cual consiste en que a partir de una clase original se pueden crear otro grupo de clases que contengan los métodos y campos de la primera, pero sin tener que reescribirlos en cada una de ellas, la clase original es llamada padre mientras que a las clases derivadas se les llama hijos, entonces estos componentes son heredados de la clase padre a las clases hijo, con lo cual se consigue que compartan la definición de los campos y métodos del padre, pudiendo además incorporar nuevas funcionalidades a las ya heredadas. PHP implementa la herencia gracias a un mecanismo llamado extensión, este nombre viene del hecho de que por lo general las clases hijo extienden la funcionalidad de la clase padre, al redefinir antiguos métodos o incluir nuevos métodos y campos. Las clases extendidas o clases hijo deben incluir en su definición la palabra reservada 'extends'.

<?php
class Carrito_Con_Nombre extends Carrito {
   var $duenyo;

   function definir_duenyo ($nombre) {
      $this->duenyo = $nombre;
   }
}
?>

En este ejemplo se define una nueva clase llamada Carrito_Con_Nombre el cual extiende la clase Carrito, ya que hereda de ella todos sus métodos y campos y, además cuenta con un campo y método propio, entonces un objeto de la clase Carrito_Con_Nombre consistirá en un carrito con los métodos agregar_item como retirar_item que además posee un dueño que puede ser definido con el método definir_duenyo, como podemos verlo al instanciar la nueva clase en el siguiente ejemplo:

<?php
$carrito_n = new Carrito_Con_Nombre;  // Crear un carrito con nombre
$carrito_n->definir_duenyo("kris");// Nombrar el carrito
print $carrito_n->duenyo;          // imprimir el nombre del dueño
$carrito_n->agregar_item("10", 1); // (funcionalidad heredada de carrito)
?>

Vemos que el objeto posee los métodos de la clase padre y los métodos de su propia clase.

Constructores

El constructor de una clase es un método especial que podemos incluir en su definición, el cual es llamado al momento de hacer una nueva instancia de la clase con new, por ejemplo podemos definir un constructor para una nueva clase que extienda a Carrito de la siguiente forma:

<?php
class Auto_Carrito extends Carrito {
    function Auto_Carrito() {
        $this->agregar_item("10", 1);
    }
}
?>

El constructor debe llevar el mismo nombre de la clase a la que pertenece, como vemos en el ejemplo, el cual nos indica que al crearse una nueva instancia de la clase Auto_Carrito, se incluirá por defecto un primer item en el arreglo al emplear el método heredado agregar_item dentro del constructor.

Un constructor puede además incluir uno o más parámetros en su definición, de forma que podamos enviar valores a este método al instanciar un nuevo objeto de la clase:

<?php
class Constructor_Carrito extends Carrito {
    function Constructor_Carrito($item = "10", $num = 1) {
        $this->agregar_item ($item, $num);
    }
}

// Comprar lo mismo de antes.
$carrito_predeterminado = new Constructor_Carrito;

// Comprar esta vez en serio...
$carrito_diferente = new Constructor_Carrito("20", 17);
?>

En el ejemplo dentro de la definición se utilizaron parámetros con valores por defecto, por lo cual no es necesario que en la primera instancia($carrito_predeterminado) se incluyan nuevos valores, para obtener un resultado diferente vemos que en la segunda instancia($carrito_diferente) ya se incluyen los valores dentro de los paréntesis, de forma que ahora el constructor los incluirá dentro del arreglo asociativo.

Los constructores son muy útiles si deseamos asegurarnos que los campos nuestras clases tengan un valor inicial al crearse una nueva instancia de estas.

Operador de resolución de contexto (::)

El operador :: nos permite acceder a un campo o método de una clase sin la necesidad de tener que hacer una instanciación, como sucede en el siguiente ejemplo:

<?php
class A {
    function ejemplo() {
        echo "Soy la función original A::ejemplo().<br />\n";
    }
}

class B extends A {
    function ejemplo() {
        echo "Soy la función redefinida B::ejemplo().<br />\n";
        A::ejemplo();
    }
}

// no hay un objeto de la clase A.
// esto imprime
//   Soy la función original A::ejemplo().<br />
A::ejemplo();

// crear un objeto de clase B.
$b = new B;

// esto imprime
//   Soy la función redefinida B::ejemplo().<br />
//   Soy la función original A::ejemplo().<br />
$b->ejemplo();
?>

El ejemplo anterior llama al método ejemplo() en la clase A, pero no hay un objeto de la clase A, así que no podemos escribir $a->ejemplo() o algo semejante. En su lugar llamamos ejemplo() como un 'método de clase', es decir, un método de la clase misma, no de un objeto de tal clase.

Acceso a los campos y métodos del padre (parent)

Al utilizar herencia o extensión de clases con 'extends', ya nos es posible acceder a los métodos y campos de la clase dentro de los nuevos métodos que definimos en las clases hijo, sin embargo, al realizar una refinación o especialización de un método ya existente, a veces resulta necesario utilizar la funcionalidad del método original antes de incluir nuestros cambios.

Para acceder a un método del padre se utiliza la palabra reservada 'parent' seguida del operador de resolución de contexto (::), acompañado con la referencia al método deseado.

En el siguiente ejemplo se muestra la refinación del método ejemplo() en el cual además de incluirse una nueva funcionalidad se hace uso de la funcionalidad del método original:

<?php
class A {
    function ejemplo() {
        echo "Soy A::ejemplo() y ofrezco funcionalidad básica.<br />\n";
    }
}

class B extends A {
    function ejemplo() {
        echo "Soy B::ejemplo() y ofrezco funcionalidad adicional.<br />\n";
        parent::ejemplo();
    }
}

$b = new B;

// Esto hace la llamada a B::ejemplo(), la cual llama a su vez a A::ejemplo().
$b->ejemplo();
?>

A pesar de que los hijos heredan los métodos del padre, al volverlos a definir se hace necesaria una forma para diferenciar el método original del refinado, ya que si nos fijamos en el ejemplo, de haber utilizado la expresión $this->ejemplo() PHP interpretaría que se hace referencia al método del hijo, el cual ya cambió y no se obtendría el resultado deseado, además de que se crearía una problema recursivo.

Con este último ejemplo es que concluye el último artículo de esta semana, para el siguiente veremos las diferencias que tiene la versión 5 del lenguaje para el manejo de objetos y las nuevas funcionalidades que nos ofrece.

Hasta la próxima.

Notas para iniciarse en PHP, Parte 4: Operadores, estructuras de control y funciones

Un pequeño poema escrito en PHP

Operadores

Llamamos operador a cualquier símbolo o expresión que nos permite llevar a cabo una operación con uno o más valores para obtener un valor resultante. Por ejemplo, el siguiente código:

$a = 18;

Consta de un operador de asignación representado por "=", con el cual se asigna el valor de 18 a la variable $a.

Dependiendo del número de variables o valores involucrados, los operadores pueden ser unitarios, al operar sobre un único valor (por ejemplo el operador de incremento ++), binarios, que operan sobre dos valores (estos representan la mayoría de los operadores de PHP, que encontramos listados de forma completa en la sección Precedencia de operadores del manual) y el operador ternario ?:, del que se hablará más adelante.

Dentro del manual vemos que existe un gran grupo de operadores que se clasifican de la siguiente manera:

Operadores aritméticos
Operadores de asignación
Operadores Bit a Bit
Operadores de comparación
Operadores de manejo de errores
Operadores de ejecución
Operadores de incremento
Operadores de lógica
Operadores de cadenas
Operadores de matrices
Operadores de tipo


Estructuras de control

En el último post quedó pendiente seguir hablando sobre las estructuras de control en PHP, para buena fortuna de los programadores de C que lean esto, la gran mayoría de sus estructuras están presentes en este lenguaje:

Estructuras condicionales:
if
else
else if / elseif
switch

Estructuras para bucles
while
do-while
for
foreach

Instrucciones para saltos y rompimientos de ciclos
goto
break
continue

Entre otras novedades con respecto a C, encontramos que else if y elseif son equivalentes para la compilación del programa, también utilizar las palabras reservadas and y or en lugar de || y && respectivamente es totalmente válido.

Las sentencias del lenguaje pueden agruparse dentro de estas estructuras utilizando los clásicos corchetes, pero además el lenguaje nos ofrece la alternativa de utilizar un modo similar al de Python, con los dos puntos ":" y una palabra clave para indicar el inicio y el final de una estructura. Por ejemplo, si tenemos el siguiente código:

#Modo clásico con corchetes de C
if ($a > $b) {
   echo "a es más grande que b";
   $b = $a;
}

También se puede escribir de la siguiente manera:

#Modo similar al de Python, excepto por el uso necesario de paréntesis
if ($a > $b) :
   echo "a es más grande que b";
   $b = $a;
endif;

Como vemos en el enlace de sintaxis alternativas, también aplica para los bucles:

#Modo clásico con corchetes de C
while ($a < $b) {
   echo "a vale $a";
   $a ++;
}

Pudiendo escribir el código anterior como:

#Modo similar al de Python, excepto por el uso necesario de paréntesis
while ($a < $b) :
   echo "a vale $a";
   $a ++;
end while;

Dentro de nuestras estructuras encontramos también otro viejo conocido para muchos veteranos de C, la alternativa muy útil al uso de if - else:

condición ? ejecuta si es cierto : ejecuta si es falso

En casos como el siguiente:

#Modo común usando if - else
if ($a > 0) 
   $b = 1;
else
   $b = 2;

Se puede obtener una ejecución idéntica de esta forma:

#Modo alternativo usando "?"  y ":"
$b = ($a > 0)? 1 : 2;

Al asignarle a $b uno de dos valores dependiendo de si la condición $a > 0 es verdadera.


Funciones

Una función consiste un una estructura que contiene código, la cual que puede ser llamada para la ejecución de este código desde otra parte del programa, está puede además recibir uno o más valores llamados parámetros, y devolver un resultado que pueda ser utilizado desde el contexto en que son llamadas.

Las funciones pueden ser definidas por el usuario siguiendo una estructura como la siguiente:

<?php
function foo ($arg_1, $arg_2, ..., $arg_n) 
{
   echo "Función de ejemplo.\n";
   return $retval;
}
?>

En donde vemos que es necesario que la declaración de la función sea antecedida por la palabra clave function, seguida del nombre de la función, dentro del paréntesis se pueden declarar uno o más parámetros sin que esto sea obligatorio. La instrucción return sirve para indicar el final de la ejecución de una función, ya que regresa el apuntador de ejecución del programa al punto en el que se mando a llamar a la función ejecutada; al igual que los parámetros, esta instrucción no es indispensable para que una función esté declarada correctamente, de no incluirse un return, la función finalizará al acabar de ejecutar la última instrucción que contenga.

La instrucción return puede incluir un valor de retorno, que puede ser una variable o valor de cualquier tipo (incluyendo arreglos y objetos) que es devuelto al lugar donde se mando ejecutar la función.

En el siguiente ejemplo se muestra la declaración y llamado a una función, que recibe una serie de parámetros y devuelve un valor de retorno:

<?php
//Función que calcula la hipotenusa al cuadrado a partir del valor de dos catetos
function hipotenusa2($a, $b)
{
   $c2 = $a * $a + $b * $b;
   return $c2;
}

$catetoOp = 2;
$catetoAd = 4;
$h2 = hipotenusa2($catetoOp, $catetoAd); //Llamada a la función
echo "La hipotenusa al cuadrado es $h2";
?>

La declaración de la función no necesariamente tiene que aparecer antes de su llamada en el programa, puede declararse en cualquier punto dentro de éste, o incluso encontrarse dentro de otro archivo de código PHP que podemos incluir en nuestro programa, a través de las instrucciones require, require_once, include e include_once. Un ejemplo de un uso muy práctico para esto es tener en un archivo una serie de funciones que serán usados dentro de nuestros programas, y en lugar de volver a escribirlas en cada uno, las incluimos con alguno de estas instrucciones.

A través de las funciones PHP nos ofrece una amplia gama de utilidades para facilitar nuestro trabajo al momento de programar, estas son llamadas funciones internas, a las que podemos acceder de la misma forma a la que a las funciones declaradas por el usuario. Podemos encontrarlas dentro del manual en la sección de referencia de funciones. En los siguientes posts exploraremos algunas funcionalidades muy interesantes que encontramos en esta lista.

Además de las funciones, PHP también soporta la utilización de clases y objetos para estructurar la ejecución del código de nuestros programas, así como las funciones las clases también pueden ser declaradas por el usuario, y además existen clases internas que nos permiten acceder a funcionalidades adicionales a las que ya teníamos con las funciones internas. El tema de las clases y objetos, y la referencia de funciones internas lo encontrarán en nuestro siguiente post.

Hasta la próxima.

Notas para iniciarse en PHP, Parte 3: Sintaxis y conceptos básicos

¡Saludos nuevamente!

Este artículo tiene por propósito ayudar a los programadores que inicien en el lenguaje PHP a dar sus primeros pasos con una mayor confianza, ya que tome algunas anotaciones de varios detalles que encontré importantes para comenzar.

Hasta ahora el mejor manual que he encontrado sobre el contenido del lenguaje PHP es el que encontramos en su sitio oficial, que por cierto tengo incluido en la lista de enlaces de este blog, y es al que siempre recurro en caso de una duda sobre las funciones y clases nativas del lenguaje, o sobre cualquier contenido en general. Digo esto porque es de llamar la atención que en algunos foros de programación, se contestan a muchas de las dudas de los usuarios mandándolos a revisar este mismo manual, lo cual habla por un lado de lo útil que resulta esta herramienta y por otro, del gran desconocimiento que tienen los usuarios que inician en PHP sobre a donde acudir para solucionar sus problemas.

Los bloques de código

Dicho esto pasemos a ver un poco sobre las especificaciones del lenguaje, el primer punto es que el código deberá incluirse dentro de etiquetas que indicarán el inicio y finalización de los bloques de código, estas pueden ser las que vimos <?php. . .?> y <script language="php">. . .</script>, como se muestra en el contenido de la página oficial estas son las dos formas que siempre están disponibles en todas las configuraciones por defecto.

1.  <?php echo("si quieres servir documentos XHTML o XML, haz como aquí\n"); ?>


2.  <? echo ("esta es la más simple, una instrucción de procesado SGML \n"); ?>

<?= expression ?> Esto es una abreviatura de "<? echo expression ?>"


3.  <script language="php">

      echo ("muchos editores (como FrontPage) no

            aceptan instrucciones de procesado");

    </script>


4.  <% echo ("Opcionalmente, puedes usar las etiquetas ASP"); %>

    <%= $variable; # Esto es una abreviatura de "<% echo . . ." %>

En el caso de las etiquetas <?... ?> y <% ... %>, éstas solo estarán disponibles si así se especifica en el archivo de configuración php.ini.

Una de las ventajas que ofrece PHP a los programadores de lenguajes más antiguos como C o PERL es que su sintaxis general es muy parecida a la de estos lenguajes, realmente teniendo dominada la sintaxis de C es bastante sencillo comprender la de PHP, lo que quizas les puede resultar más complicado es la combinación que muchas veces se hace del contenido HTML con código PHP, cosa que iremos viendo en los siguientes ejemplos.

Un programa puede consistir en un archivo HTML con código PHP embebido en estas etiquetas o, en un archivo que incluya solamente una o más bloques de código PHP, y que cualquiera que sea la salida se genere desde las instrucciones de este lenguaje. Un ejemplo de un código embebido en HTML sería el siguiente:

<?php
if ($expression) {
    ?>
<strong>This is true.</strong>
<?php
} else {
    ?>
<strong>This is false.</strong>
    <?php
}
?>

De este código podemos aprender dos cosas, primero que las instrucciones de control condicionales if y else del lenguaje son similares a las de C, y segundo que es posible separar en diferentes script la ejecución de un solo bloque de código. Lo que ocurrirá en la ejecución de este código es que si la variable $expresion, contiene un valor verdadero, se mostrará el mensaje This is true, porque cuando PHP encuentra la etiqueta ?> de fin de bloque, empieza a escribir lo que encuentra tal cual hasta que se topa con otra etiqueta de inicio de bloque, en caso de que la condición sea falsa, ignorará todo lo que este contenido entre sus llaves de apertura y de cierre { ... }, sin importar que se encuentren dentro de bloques de código diferentes, siguendo la ejecución del programa se mostraría el mensaje This is false.

Este ejemplo, a pesar su simplicidad es importante, ya que resulta más eficiente mandar a desplegar contenido HTML en pantalla separandolo del código PHP de manera similar, en lugar de desplegarlo desde las funciones echo() o printf(), como es común que suceda en muchos ejemplos por la red.

Separación de instrucciones

Al igual que en lenguajes como C o PERL las instrucciones se separan unas de otras utilizando el caracter punto y coma ";". En caso de que una instrucción sea la última dentro de un bloque de código, este separador puede ser omitido.

Comentarios

PHP también soporta los tipos de comentarios de C y C++ indicados por los caracteres /* */ y //, agregando además los comentarios de una sola línea indicados por #:

<?php
echo "This is a test"; // Comentario estilo C++ de una sola línea
/* Comentario estilo C++ de múltiples líneas
       que permite realizar saltos de línea */
echo "This is yet another test";
 echo "One Final Test"; # Comentario estilo línea de comandos (shell) de una solo línea
?>

Tipos de datos en PHP

PHP soporta varios tipos de datos existentes en otros lenguajes, pero con la gran diferencia de que las variables en PHP no necesitan de una declaración del tipo de dato que poseerán, PHP asume el tipo de dato de que se trata a partir del valor que el programador asigne a esas variables, además, las variables son dinámicas ya que en tiempo de ejecución pueden adquirir valores de distintos tipos de datos. Basta con que una expresión sea precedida por el caracter de signo de pesos "$" para que esta represente una variable.

PHP soporta ocho tipos primitivos.

• Cuatro tipos escalares: boolean, integer, float y string.
• Dos tipos compuestos: array y object.
• Dos tipos especiales: resource y null.
  

*Nota: A diferencia de otros lenguajes no existe una diferencia entre el tipo double y float en PHP, cualquiera de los dos son equivalentes para representar números de punto flotante, solo que en los manuales más actuales se utiliza normalmente solo float.

El siguiente ejemplo de código muestra la forma de declarar variables con distintos tipos de datos en PHP:

<?php
$un_bool = TRUE;   // un valor booleano
$un_str  = "foo";  // una cadena
$un_str2 = 'foo';  // una cadena
$un_int  = 12;     // un entero

echo gettype($un_bool); // imprime: boolean
echo gettype($un_str);  // imprime: string

// Si este valor es un entero, incrementarlo en cuatro
if (is_int($un_int)) {
    $un_int += 4;
}

// Si $bool es una cadena, imprimirla
// (no imprime nada)
if (is_string($un_bool)) {
    echo "Cadena: $un_bool";
}
?>

Una anotación importante es que PHP realiza conversiones entre los tipos de datos de forma automática al ejecutar algunas de las instrucciones de nuestros programas, por ejemplo, al sumar un valor entero con una cadena que contiene un número, automáticamente convertirá la cadena en un valor numérico para realizar la suma. Dentro del manual encontramos un apartado dedicado a este tipo casos, llamado manipulación de tipos de datos. Algo similar sucede al someter el valor de una variable a un bloque condicional -como un if o un switch-, si el valor no es de tipo booleano PHP automáticamente realizará la conversión de este valor a un booleano equivalente, lo cual puede apreciarce en la tabla de comparación de tipos del manual.

Otros conceptos básicos

• Los nombres de las variables son sencibles a mayúsculas y minusculas.
• Los nombres de las variables siguen las mismas reglas que otras etiquetas en PHP. Un nombre de variable válido tiene que empezar con una letra o un carácter de subrayado (underscore), seguido de cualquier número de letras, números y caracteres de subrayado.
• De forma predeterminada las variables se asignan por valor, pero php ofrece la opción para asignar por referencia. Basta con que se agregue el caracter ampersan '&' antesediendo el nombre de la variable referenciada en la asignación, para obtener la referecia a esta variable, por ejemplo:
  

    <?php
    $foo = 'Bob';                // Asigna el valor 'Bob' a $foo
    $bar = &$foo;                // Referenciar $foo vía $bar.
    $bar = "Mi nombre es $bar";  // Modificat $bar...
    echo $foo;                   // $foo también se modifica.
    echo $bar;
    ?>

• Una variable no necesariamente tiene que ser inicializada para poder utiizarla, pero es una buena prácticar el hacerlo. Las variables no inicializadas toman un valor predeterminado dependiendo del contexto en el que se estén utilizando, así, una variable de tipo bool poseerá un valor por defecto de false, los enteros y flotantes tendrán cero, las cadenas se establecen como una cadena vacía y las matrices se convierten en una matriz vacía.
• Una forma infalible para detectar si una variable ha sido o no inicializada es utilizar la función del lenguaje isset().

Al internarse en la información sobre las variables en PHP nos encontramos además con las variables predefinidas del lenguaje, que se trata de un conjunto de variables que nos proporcina PHP para realizar gran cantidad de tareas. Éstas son de gran importancia ya que a través de ellas es que podemos acceder a la información del servidor Web, leer los datos de los formularios, leer el contenido de las cookies y las sesiones, entre otras cosas, por lo que su aplicación merece un post completo, por lo que lo veremos este temas en un siguiente artículo.

El ámbito de las variables es el contexto dentro del cual una variable está definida, este es importante porque nos indica las regiones del código desde las cuales una variable puede ser accedida. Por fortuna el ámbito de las variables en PHP es de tipo simple, ya que basta con declarar una variable en cualquier bloque de código, para accederla desde cualquier otro bloque del archivo o dentro de otros archivos de código incluidos o requeridos. Este ámbito puede verse limitado solamente por el uso de funciones o clases.

También es posible declarar constantes dentro de nuestro programas a través de las funciones define(). Esta función solo aceptan valores escalares. Las constantes tienen la caracteristica de que se declaran sin utilizar el signo de pesos "$" de las variables.

Las estructuras de control del lenguaje son bastante similares a las de C, como vemos se trata de un gran número, ya que el manual de PHP dedica un solo capítulo a su estudio. Una de las que encuentro más interesante es la sentencia foreach, ya que además de no tener un equivalente en C, nos permite acceder dentro de un ciclo a cada uno de los valores de un arreglo de forma más sencilla, ya sea de forma simple:

<?php
$arreglo = array("uno", "dos", "tres");
foreach ($arreglo as $valor) {
    echo "Valor: $valor";
}
?>

en la que se extraen solo los valores del arreglo, o de forma indexada:

<?php
$arreglo = array("uno", "dos", "tres");
foreach ($arreglo as $llave=>$valor) {
    echo "Llave: $llave, valor: $valor";
}
?>

en la que además de los valores obtenemos la llave de cada valor, que corresponde al valor en el indice del arreglo que ocupan cada uno de los valores.

Y es hasta aquí donde llega este post, en los siguientes artículos veremos la forma de implementar funciones dentro del lenguaje, otras estructuras de control, el uso de variables predefinidas para leer datos de los formularios, y el manejo de clases y objetos en las versiones 4 y 5 del lenguaje.

Hasta la próxima.

Notas para iniciarse en PHP, Parte 2: La herramienta

Un peluche de la mascota de PHP es muy importante pero por ahora puede esperar

¿Que necesitamos para dar nuestros primeros pasos en PHP?

Pues lo indispensable es contar con un servidor Web con el CGI de PHP instalado, independientemente del sistema operativo en el que vayamos a trabajar. Las opciones de servidores Web más conocidas son el IIS, el Apache y el Cherokee, siendo estos dos últimos sistemas libres y multiplataforma.

Una vez que hemos elegido el servidor y este está instalado lo que sigue es preguntarnos, ¿cómo escribiremos nuestros programas en PHP? En realidad un programa PHP se puede escribir con un simple editor de notas, pero por motivos de practicidad es conveniente conocer que existen diferentes herramientas que pueden facilitar nuestro desarrollo de aplicaciones con éste lenguaje, desde una herramienta que nos facilite el cuidado de la sintaxis de los programas mostrando en diferentes colores los componen del código, como lo hace el Notepand++. Hay otras herramientas cuyo soporte para PHP se orienta a combinar el diseño visual de páginas con la programación de scripts, como es el caso de Dreamwaver y Quanta, éste último es una herramienta libre pero solo disponible para NGU/Linux. Otra de las opciones de las cuales ya hablé un poco en este blog es el Eclipse PDT, pensado especialmente para la programación orientada a objetos. Si ya somos un poco más veteranos en PHP, podemos probar además utilizar un framework que nos ayude a crear arquitecturas complejas para nuestros sistemas, uno de los frameworks más populares para este propósito es Sympony, que nos lleva a trabajar de una manera completamente nueva, pero facilitando la creación y el mantenimiento de nuestros programas.


¿Dónde puedo conseguir estos componentes?

El servidor Web y el CGI de PHP se pueden conseguir de manera independiente, de cualquiera de las fuentes que ofrece Internet, instalando el servidor Web de nuestra preferencia y posteriormente este CGI, si queremos facilitar este trabajo, bastaría con conseguir una paquete o kit de instalación que ya cuente con ambos productos. Pondré solo un par de opciones de las muchas combinaciones que puede haber, siendo parcial hacia las opciones de software libre, porque después de todo, sobre eso trata este blog:

• AppServ. De nuevo menciono este paquete, y es que es una opción bastante fácil de instalar, que cuenta con el servidor Web Apache, PHP, el servidor MySQL y la aplicación Web para administración de bases de datos phpMyAdmin. Es una buena opción si trabajaremos sobre Windows. La guía de instalación se encuentra aquí.

• XAMPP. Este paquete también facilita enormemente la instalación de los componentes, cuenta con Apache, PHP, MySQL y el interprete de PERL, y podemos encontrar su instalación dentro de los cuatro principales sistemas operativos del mercado: GNU/Linux, Windows, Mac OS y Solaris.
  

Dentro del enlace de XAMPP podemos ver que encontramos guías para su instalación en los diferentes sistema operativos.

Las diferentes herramientas para desarrollo se pueden descargar desde los enlaces que aparecen en un principio, exceptuando el Dreamweaver que es un sistema propietario. En lo personal yo recomiendo ampliamente el Eclipse PDT, que podemos descargar desde su página oficial, ya que es un entorno multiplataforma que además nos ofrece gran ayuda en la programación, sobre todo si ésta es orientada a objetos.

Ejemplo del árbol de clases de Eclipse PDT

Encontramos una sencilla guía de instalación para este sistema dentro de la misma página. C0omo vemos, es necesario contar con la máquina virual de Java o Java Runtime al menos en su versión 5.0, una vez descargado y desempaquetado basta con que corramos archivo ejecutable de Eclipse, creemos un área de trabajo para nuestros proyectos y listo, podemos comenzar a crear proyectos de programación en PHP o en Java.


Ya elegí e instale las herramientas necesarias ¿Cuál es el siguiente paso ahora?

Ahora ya podemos comenzar a hacer nuestros primeros pasos en PHP, lo primero es indentificar el directorio donde se alamacenarán los archivos de nuestras aplicaciones Web, donde realizaremos las prácticas corresponedientes, el resto simplemente consistirá en ir conociendo los contenidos del lenguaje y crear los programas que servirán de ejemplo para los temas abordados. Y estes serán prescisamente los temas que abordaremos en los siguientes posts.

Hasta la próxima.

Notas para iniciarse en PHP, Parte 1: El concepto

Saludos blogueros, regreso después de unas semanas en las que me recuperé de la gripe y preparé una nueva serie de post, esta vez relacionadas con el lenguaje para aplicaciones Web PHP, debido principalmente a que necesito crear una introducción a este lenguaje para un curso que próximamente voy a dar, así que aprovecharé el blog para poner en orden mis ideas.

¿Qué es PHP?

Es la primera pregunta que salta al iniciarse en el lenguaje, bueno, pues la definición nos dice que PHP es el acrónimo recursivo de "PHP: Hypertext Preprocessor", en castellano "PHP: Hipertexto Preprocesado", ¿qué falta el significado de la primer P? es que por eso es recursivo. Este es un lenguaje que es utilizado para realizar aplicaciones Web, una modalidad de trabajo para nuestros usuarios que ha venido teniendo gran crecimiento en el sector de desarrollo. Dice la definición más exacta que: PHP es un "lenguaje de código abierto interpretado, de alto nivel, embebido en páginas HTML y ejecutado en el servidor", pero ¿qué significa exactamente esto,? bueno en primer lugar que es un lenguaje de código abierto es decir open source, o sea que este es mantenido por una comunidad de programadores y no tenemos que pagar por ningún tipo de licencia, para escribir programas en PHP y utilizar su CGI en nuestro servidor, ¿dije CGI? pues sí, ese es el otro tema importante que hay que conocer:

En las aplicaciones de escritorio que utilizamos normalmente, el usuario cuenta con los archivos binarios que se ejecutan o interpretan -según sea el caso- dentro de nuestros equipos de computo, en el entorno de las aplicaciones Web -que es donde nos estamos adentrando- el esquema es diferente, aquí los usuarios accederán a las aplicaciones utilizando un navegador que que se conectará a un servidor Web, dentro del servidor Web se llevará a cabo la ejecución de estas aplicaciones y se regresará el resultado al navegador, en un formato que pueda interpretar el navegador como una página HTML o un archivo PDF, entre otros. En el caso de PHP, las aplicaciones consisten en scripts de código que se encuentran incluidos -embebidos- dentro de páginas HTML, estas aplicaciones son accedidas por medio del navegador como si se tratara de cualquier página HTML, ya que la ejecución del código que contienen se realiza del lado del servidor, por medio de un CGI que se encuentra instalado en éste -creían que me había olvidado del CGI eh-. Para muestra el siguiente ejemplo:

<html>
  <head>
      <title>Ejemplo</title>
  </head>
  <body>
      <?php
      echo "Hola, ¡soy un script PHP!";
      ?>

  </body>
</html>

Para probarlo tenemos que almacenar el código anterior en un archivo con extensión .php en el directorio de nuestro servidor Web, y accesar a este archivo con nuestro navegador, obteniendo el siguiente resultado en la pantalla:

Hola, ¡soy un script PHP!

Y lo que sucedió fue que al momento de solicitar el archivo el servidor, este realizó una revisión de todo su contenido, al encontrarse con la etiqueta de apertura <?php, interpretó que se trataba de un script PHP y efectuó la ejecución del mismo, deteniéndose al encontrar la etiqueta de cierre ?>; en este caso el programa consistía en enviar el mensaje de salida "Hola, ¡soy un script PHP!" por medio de la función echo, lo que esta función hizo fue que incrustó la cadena dentro del contenido de la página HTML, lo cual se puede comprobar si revisamos el código HTML de ésta:

<html>
  <head>
      <title>Ejemplo</title>
  </head>
  <body>
      Hola, ¡soy un script PHP!
  </body>
</html>

Como vemos las etiquetas de apertura y cierre del programa desaparecieron dejando únicamente el texto enviado con la función echo, lo cual nos habla de una de las características importantes de este lenguaje: el código fuente de los programas nunca es visible para los usuarios, solo serán visibles aquellas cadenas de texto que se manden desplegar desde estos. Otra característica importante -que también se menciona en su definición- es que PHP es un lenguaje interpretado, esto quiere decir que no se genera un archivo de código máquina o intermedio antes de su ejecución, sino que durante la revisión del contenido de la página que el servidor hace, las instrucciones del script son compiladas directamente y e inmediatamente ejecutadas, en versiones inferiores a la 3.0 el código fuente era solo interpretado, como sucede con Javascript, pero esto no era del todo eficiente por lo que se cambio por el método actual.

Este esquema de trabajo permite que podamos crear páginas HTML con contenido dinámico, es decir que por medio de una variable que exista en el script PHP se puede cambiar la apariencia o contenido de una página Web. Podemos indagar ahora que aquello de Hipertexto Preprocesado se refiere precisamente a que el contenido del hipertexto del navegador recibe un tratamiento previo a su despliegue.

¿Por qué PHP es un lenguaje de tanta importancia?

Como mencioné antes este es un lenguaje que ha venido teniendo un gran crecimiento en los últimos años, de hecho actualmente es el lenguaje de aplicaciones Web más utilizado en Internet, con el 32.84%:

Otro dato interesante es que PHP también es la plataforma más popular para trabajar con Ajax:

Si no lo han hecho valdría la pena que revisarán los artículos sobre como combinar Ajax con PHP, que aparecen en este mismo blog.

¿Por qué se ha extendido tanto?

Primero que nada es un lenguaje fácil de aprender, al revisarlo nos encontramos con que tiene gran similitud con otros lenguajes de alto nivel como C, Perl y Python, además es un lenguaje multiplataforma, podemos encontrarlo en cualquier sistema operativo con diferentes servidores Web, la otra razón importante es que se pueden hacer muchísimas cosas con este lenguaje: leer contenidos de formularios, generar páginas con contenidos dinámicos, crear y leer cookies, crear y leer sesiones, acceder a gran cantidad de bases de datos, crear servicios Web, utilizar clases y objetos, entre otras muchas cosas más.

¿Qué es lo más importante que necesito saber sobre PHP?

Considero que hay una cosa que nunca debemos perder de vista al comenzar a aprender este lenguaje, ésta es que nuestros programas se ejecutarán del lado del servidor, lo cual es de gran importancia debido a las diferentes implicaciones que esto tendrá, al traernos beneficios y limitaciones, como se verá en el desarrollo de los siguientes temas. El segundo punto que nunca debemos olvidar es que la mascota oficial de PHP es un elefante:

El buen ElePHPant, mascota oficial de PHP

Y todos sabemos que los elefantes son geniales.

Bueno, hecha esta pequeña introducción creo que estamos listos para iniciarnos en cosas más serias, lo cual será el tema de los siguientes artículos.

Hasta la próxima.