Archives: script

Aunque en muchos ejemplos he mostrado las clases dentro del mismo script donde ejecutaba sus métodos, esto no es lo adecuado (ya lo comenté en su momento), lo ideal realmente es tener un fichero por separado donde su nombre sea exactamente el nombre de la clase que contiene para así localizarlo de una forma rápida y ordenada.

Esto nos lleva a tener que incluir o mas bien “requerir” cada uno de los ficheros donde se alojen las clases que vamos a necesitar para realizar nuestros scripts. Esta, sin duda es la forma correcta de hacerlo, por cada tipo de clase que usemos hemos de añadir un require_once al comienzo del script, no es solo por el buen funcionamiento del script, si no también porque de un solo vistazo a la cabecera del script seremos capaces de ver que objetos usa e intuir su cometido.

Pero como siempre, en casi todo lo que se puede hacer en el mundo del desarrollo disponemos de otra forma de realizarlo. En PHP contamos con la función __autoload, si, he dicho función y no método, porque esta función no se sitúa en el cuerpo de ninguna clase, va fuera de ellas.

Su misión principal es la de cargar de forma dinámica las clases que usemos en el script pero que no tenemos incluidas de primera mano. Hay que pasarle un parámetro con el nombre de la clase, pero lo bueno es que además de permitirnos incluir las clases, también nos deja ejecutar otras rutinas, por ejemplo para escribir en nuestro sistema de logs que hemos cargado la clase ‘MiClase‘. Veamos un ejemplo, por un lado tenemos la clase ‘MiClase‘ almacenada en el script ‘MiClase.php‘ en el mismo directorio:

<?php

class MiClase
{

    public function __construct(){
        echo ' <-- He sido instanciada';
    }

}

?>

Por otro lado tenemos un script que incluye la función __autoload indicándole que compruebe si existe el script de la clase que intentamos instanciar:

<?php

function __autoload( $nombreClase ){

    if(file_exists( $nombreClase . '.php' )){
        include( $nombreClase . '.php' );
        echo 'Incluida clase: ' . $nombreClase;
    }else{
        echo 'No encontrada clase: ' . $nombreClase;
    }
}

$clase = new MiClase(); //Imprime: Incluida clase: MiClase <-- He sido instanciada
$clase2 = new NoExisto(); //Imprime: No encontrada clase: NoExisto y un error fatal.

?>

Como se aprecia en el ejemplo, se consigue instanciar ‘MiClase‘ sin ningún problema sin tener que incluir el script al principio, pero en el caso de la clase ‘NoExisto‘ recibimos un ‘FATAL ERROR‘ debido a que el script que hemos pedido no existe.

Podemos alterar al ruta como queramos para buscar los scripts en el directorio que necesitemos, o hacer la comprobaciones pertinentes, en este caso he comprobado mediante file_exists si realmente existe la clase.

Algo que quizás sea llamativo es el hecho de usar include en vez de include_once en el interior de __autoload. Esto tiene una explicación, no es necesario include_once porque al llamar dinamicamente el script este solo se llamara una vez por clase, por lo tanto la siguiente vez el script ya estará incluido y __autoload no volverá a dispararse. Una buena practica podría ser sustituir el include por un require de forma que no dejemos que se ejecute el script si no se encuentra el fichero en cuestión.

Todos los lenguajes incorporan herramientas para hacer frente a diversos tipos de situaciones, algunas comunes, otras absurdas y otras poco usadas, como el método mágico __invoke().

Si recordamos hace menos de un mes hablamos sobre las funciones anónimas en el blog, en ese artículo se explicaba como poder usar una variable como una función, que aunque no es muy usado se puede dar el caso. Pues el método invoke sirve precisamente para controlar el comportamiento cuando llaman a nuestro objeto como si fuera una función.

Si no incluimos __invoke() en el objeto y lo llamamos como si fuera una función PHP mostrara un error, pero al definirlo podremos manipular tanto el objeto en si, como darle un comportamiento especifico, veamos un ejemplo:

<?php
class MiClase
{

    public function __invoke(){
        return "Me han llamado como a una función.";
    }

}

$clase = new MiClase();
echo $clase(); //Imprime: Me han llamado como a una función.
?>

En este ejemplo podemos ver que hay que instanciar el objeto para poder invocarlo como función, luego hemos definido que nuestro objeto devuelva un string al invocarlo, pero vamos a manipular también el contenido del objeto:

<?php

class MiClase
{

    public $mensaje = "Mi Mensaje";

    public function __invoke( $str ){
        $this->mensaje = $str;
    }

}

$clase = new MiClase();
echo $clase->mensaje; //Imprime: Mi Mensaje

//Cambiamos el mensaje
$clase('El nuevo mensaje');
echo $clase->mensaje; //Imprime: El nuevo mensaje

?>

En esta ocasión hemos alterado el contenido de un atributo del objeto al invocarlo como función.

Esto parece útil pero personalmente no sabría en que caso real aplicar esto, además no termina de convencerme porque da la sensación de romper la legibilidad del código orientado a objetos, pero bueno es una herramienta más que nos proporciona el lenguaje y que en algún momento podríamos usar.

El método mágico call si me parece útil en comparación con invoke. Y es que PHP nos permite controlar el comportamiento cuando llamamos a un método no accesible en el objeto, ¿esto que quiere decir? Pues que __call() entre en juego cuando tratamos de llamar a un método que no existe o a un método privado. Este método recibe dos parámetros, uno es el nombre del método al que se intenta invocar, y el otro los parámetros que le hemos pasado. Veamos un ejemplo intentando acceder a un método inexistente:

<?php

class MiClase
{

    public function __call($metodo, $argumentos){

        //Al llamar a un metodo inaccesible.
        $msg = "Se ha invocado un método inaccesible: Método -> '" . $metodo . "', Parámetros -> '";

        //Los parámetros se reciben en un array, para mostrarlos extraigo
        foreach($argumentos as $var){
            $msg .= $var . "' ";
        }

        echo $msg;

    }

}

$clase = new MiClase();
$clase->miMetodo('hola',123); //Imprime: Se ha invocado un método inaccesible: Método -> 'miMetodo', Parámetros -> 'hola' 123'

?>

Bastante simple, también funciona cuando el método al que invocamos es privado:

<?php

class MiClase
{

    private function miMetodo(){
        echo "Método privado.";
    }

    public function __call($metodo, $argumentos){

        //Al llamar a un método inaccesible.
        $msg = "Se ha invocado un método inaccesible: Método -> '" . $metodo . "', Parámetros -> '";

        //Los parámetros se reciben en un array, para mostrarlos extraigo
        foreach($argumentos as $var){
            $msg .= $var . "' ";
        }

    echo $msg;

    }

}

$clase = new MiClase();
$clase->miMetodo('hola',123); //Imprime: Se ha invocado un método inaccesible: Método -> 'miMetodo', Parámetros -> 'hola' 123'

?>

¿Para qué nos sirve todo esto? Por ejemplo para gestionar errores de una clase concreta (aunque para eso deberíamos usar las excepciones), para permitir en situaciones excepcionales acceso a métodos privados (va en contra de la encapsulación), etcétera. Parece que a todas las situaciones que se me ocurren ahora mismo les encuentro una pega, pero estoy seguro de que hay situaciones en las que si es realmente útil usar __call(), es cuestión de darle a la cabeza.

También contamos con una variante de call para métodos estáticos: __callStatic(). Como te imaginaras debe ser definida como ‘static’ y su funcionamiento es exactamente igual que __call():

<?php
class MiClase
{

    public function __call($metodo, $argumentos){

        //Al llamar a un método inaccesible.
        $msg = "Se ha invocado un método inaccesible: Método -> '" . $metodo . "', Parámetros -> '";

        //Los parámetros se reciben en un array, para mostrarlos extraigo
        foreach($argumentos as $var){
            $msg .= $var . "' ";
        }

        echo $msg;

    }

    static function __callStatic($metodo, $argumentos){

        //Al llamar a un método inaccesible.
        $msg = "Se ha invocado un método estático inaccesible: Método -> '" . $metodo . "', Parámetros -> '";

        //Los parámetros se reciben en un array, para mostrarlos extraigo
        foreach($argumentos as $var){
            $msg .= $var . "' ";
        }

        echo $msg;

    }

}

MiClase::miMetodo('hola',123); //Imprime: Se ha invocado un método estático inaccesible: Método -> 'miMetodo', Parámetros -> 'hola' 123'

?>

En el ultimo artículo de la serie empecé a hablar sobre los métodos mágicos construct y destruct, y para seguir con el tema de los métodos mágicos quiero hablar hoy de los métodos sleep y wakeup.

¿Os acordáis de Super Mario? Usaré su clase a modo de ejemplo pero quitando métodos y atributos para no contribuir a crear confusión. Pensad por un momento que tenéis que guardar el Objeto Mario en la base de datos de vuestra aplicación, para ello tenemos que convertirlo en un string, por suerte php provee de dos funciones para esto: serialize y unserialize.

Voy a explicar brevemente estas dos simples funciones apoyándome con var_dump:

<?php

class MiClase
{

    public $mensaje = 'Esto es un atributo';

    public function miFuncion(){
        echo 'Soy una función';
    }

}

//instanciamos la clase
$clase = new MiClase();

var_dump($clase); //Imprime: object(MiClase)#1 (1) { ["mensaje"]=> string(19) "Esto es un atributo" }

//Serializamos la clase
$claseSerializada = serialize($clase);

var_dump($claseSerializada); //Imprime: string(59) "O:7:"MiClase":1:{s:7:"mensaje";s:19:"Esto es un atributo";}"

//Deserializamos la clase
$claseRecuperada = unserialize($claseSerializada);

var_dump($claseRecuperada); //Imprime: object(MiClase)#2 (1) { ["mensaje"]=> string(19) "Esto es un atributo" }

?>

Como podemos ver al crear el objeto var_dump nos dice que el parámetro pasado es del tipo “object(MiClase)”, pero una vez serializado lo que nos devuelve es muy diferente, un string, “string(59)”, en este estado puedes entre otras cosas manipularlo como a cualquier string o almacenarlo en una base de datos para recuperarlo en otro momento. En el tercer var_dump ya lo hemos deserializado y nos devuelve nuevamente un objeto tipo “object(MiClase)”.

Es aquí donde entra en juego __sleep() y __wakeup(). El método sleep sera invocado cuando pasemos el objeto por la función serialize, de esta forma podremos prepararlo para ser almacenado o para lo que queramos, como siempre el limite es la imaginación de cada cual y los posibles usos que se le pueden dar a esto son muchísimos. Hay que tener en cuenta que siempre ha de devolver un array, es preferible no usar sleep a hacer un return que no sea un array porque php dará un error. Veamos un ejemplo:

<?php
class Mario
{

    public $mensaje = 'Hola, ¿que haces?';

    public function diHola(){
        echo $this->mensaje;
    }

    public function __sleep(){
        $this->mensaje = 'He sido serializado';
        return array('mensaje');
    }

}

$mario = new Mario();
var_dump($mario); //Imprime: object(Mario)#1 (1) { ["mensaje"]=> string(18) "Hola, ¿que haces?" }

$mario = serialize($mario);
var_dump($mario); //Imprime: string(57) "O:5:"Mario":1:{s:7:"mensaje";s:19:"He sido serializado";}"

$mario = unserialize($mario);
var_dump($mario); //Imprime: object(Mario)#1 (1) { ["mensaje"]=> string(19) "He sido serializado" }

$mario->diHola(); //Imprime: He sido serializado

?>

En el primer caso var_dump nos dice que le hemos pasado un objeto, en el segundo ya es un string, pero si nos fijamos ha desaparecido “Hola, ¿que haces?”, en el tercero ya hemos recuperado el objeto pero al llamar al método diHola() vemos que imprime “He sido serializado”. Realmente sencillo de usar, y si trabajas a menudo con bases de datos puede llegar a ser de los mas útil.

El método wakeup se encarga de realizar exactamente lo contrario que sleep, en el momento que deserializamos un objeto con unserialize se invoca a este método, para por ejemplo, restablecer la conexión con la base de datos, o alterar algún atributo. Probemos añadiendo wakeup a nuestro Mario para verlo mejor:

<?php
class Mario
{

    public $mensaje = 'Hola, ¿que haces?';

    public function diHola(){
        echo $this->mensaje;
    }

    public function __sleep(){
        $this->mensaje = 'He sido serializado';
        return array('mensaje');
    }

    public function __wakeup(){
        $this->mensaje = 'ola k ase';
    }

}

$mario = new Mario();
var_dump($mario); //Imprime: object(Mario)#1 (1) { ["mensaje"]=> string(18) "Hola, ¿que haces?" }

$mario = serialize($mario);
var_dump($mario); //Imprime: string(57) "O:5:"Mario":1:{s:7:"mensaje";s:19:"He sido serializado";}"

$mario = unserialize($mario);
var_dump($mario); //Imprime: object(Mario)#1 (1) { ["mensaje"]=> string(9) "ola k ase" }

$mario->diHola(); //Imprime: ola k ase

?>

Se puede apreciar que los dos primeros var_dump devuelven resultados idénticos al ejemplo anterior, pero en el momento de usar unserialize el siguiente cambia, se ha llamado al método wakeup donde hemos añadido una linea para alterar el mensaje, de forma que se ha modificado lo que dice Mario, y al llamar al método diHola() el mensaje que nos devuelve es un “ola k ase”.

Ahora que ya conoces el uso de bucles (hay dos artículos dedicados a estos “while“, “for“) y entiendes el concepto de “función“, vamos a ver otra técnica de generar bucles llamada recursión.

Por lo general es mas complicado realizar tareas con funciones recursivas que hacerlas con bucles for o while, pero puede darse el caso en el que sea necesario usar recursión.

Una función recursiva no es mas que una función que se llama a si misma generando un bucle, claro que esto provoca que la función se llame infinitas veces si no ponemos algún condicional que permita salir del bucle. Como siempre es mas fácil verlo con un ejemplo:

<?php

function miRecursion($contador, $limite){

    //Definimos nuestro condicional
    if($contador != $limite){

        echo “Esta es la repetición numero “ . $contador . “<br />”;

        $contador++;

        //Como aun no ha llegado al limite llamamos nuevamente a la función
        miRecursion($contador, $limite);

    }else{

        echo “Se ha terminado la recursión”;

    }

}

//Invocamos la función pasándole 1 como $contador y 10 como $limite.

miRecursion(1, 10);

?>

No es complicado generar Funciones Recursivas y sirven para resolver cualquier tipo de problemas que requiera de un bucle, teóricamente cualquier función recursiva puede traducirse a un bucle iterativo y viceversa.

Por ejemplo el ejemplo anterior lo podríamos representar con un bucle for de esta forma:

<?php

$contador = 1;
$limite = 10;

for( $i = $contador; $i < $limite; $i++){
    echo “Esta es la repetición numero “ . $contador . “<br />”;
}
echo “Se ha terminado la recursión”;

?>

Si una misma solución se puede representar de las dos formas, ¿Cuando debemos usar iteración y cuando la recursión?: No tengo ni idea.

La decisión, al menos en PHP creo que depende de cada programador, de que le resulta mas cómodo, personalmente prefiero la iteración, ya que al estar fuera del contexto de la función me parece que debe ser mas rápido.

De momento lo dejo aquí para que no resulte muy pesado, y en el próximo articulo trataré el tema de los Closures en PHP.

Hoy 6 de Enero es día de reyes, doy por hecho que nadie va a leer esta entrada, al menos hoy, pero por si hay alguien por aquí, me gustaría desearos a todos/as que paséis un agradable día en familia, y que los que tengáis niños pequeños disfrutéis de sus caras y su ilusión :D.

Bueno, al tema, estoy decidido a retomar la serie de artículos que servían de guía para principiantes en PHP, aun me queda bastante pero lo mas básico ya estaba cubierto, he tenido que revisar todos los artículos de la guía porque al cambiar el theme del blog se veían errores y cosas que por lo general no deberían de verse, pero ya están arreglados y bien maquetados, aun así si ves algún fallo te agradecería que me lo comentaras, es muy posible que se me escapara algo.

Hoy no entraré en materia porque no es día para leerse un ladrillo de letras, números y algoritmos, pero mañana hablaré sobre Funciones Recursivas que es por donde tenia pensado continuar cuando decayó mi animo por publicar en el blog…

Me queda tan solo pediros paciencia, soy un novato en esto de los Blogs y de escribir para los demás, por lo general en un post sencillo tardo mas de una hora en redactarlo, para uno técnico tardo 2 o tres veces mas, y claro, no dispongo todos los días de 3 horas para escribir, probar, etc. Por lo tanto iré intercalando los tutoriales con artículos mas sencillos, o de otro tipo.

Para terminar os dejo el recopilatorio de los artículos de la guía que hay hasta el momento:

1. Presentación y que necesitamos para empezar con PHP.
2. Realizando nuestro primer script.
3. Las variables y los operadores de asignación y aritméticos.
4. Explicando los Arrays simples y multidimensionales.
5. Usando condicionales y operadores lógicos y de comparación.
6. Usando bucles, aprendiendo sobre “while” y “do while”
7. Usando bucles 2ª parte, en este caso aprendindo sobre “for” y “foreach”
8. Como crear y usar funciones en nuestro código.
9. ¿Bucles o funciones recursivas? Explicando la recursividad.
10. …

Actualización 10/01/2013: He añadido el capitulo 9 que trata sobre las funciones recursivas.

Al programar nos encontramos con multitud de ocasiones en las que hemos de repetir código para poder realizar acciones especificas, como por ejemplo limpiar una cadena de texto, pero tener que copiar y pegar el mismo código cada ves que debamos limpiar una cadena de texto es simplemente una chapuza, además de poco eficiente de cara al futuro, ya que si queremos modificar su funcionamiento deberemos de hacerlo una a una en todas las partes que copiamos el código. Las funciones entre sus muchas ventajas permiten resolver este problema de manera elegante.

Las funciones se pueden considerar bloques de código separados del flujo original del programa que nos permite resolver problemas específicos, además, para poder interactuar correctamente se le pueden pasar parámetros para que trabajen con ellos, y estas a su ves pueden devolver valores.

Por ejemplo podemos usar la función trim() ya definida en PHP para quitar los espacios al principio y final de una cadena de texto, para hacerlo le pasamos como parámetro la cadena de texto y ella nos devuelve la cadena limpia:

<?php 

//En $textoSinEspacios se guarda el resultado de la función trim()

$textoSinEspacios = trim(“ Mi cadena de texto “);

?>

No solo podemos asignar el valor devuelto a una variable, sino que podemos trabajar con el en vivo, por ejemplo imprimirlo en pantalla:

<?php

echo trim(“ Mi cadena de texto “);

?>

Por supuesto puedes definir tus propias funciones y es muy sencillo, se hace mediante la palabra reservada function y el nombre de la función añadiéndole paréntesis y abriendo llaves, suena complicado pero nada mas lejos de la realidad, veamos un ejemplo:

<?php

function miFuncion() {

    //Aquí dentro el contenido de tu función.

    echo “Soy una función”;

}

//Invocamos la función

miFuncion();

?>

Como puedes ver la función se limita a imprimir en pantalla un texto que hemos definido dentro de esta, pero para hacerlo mas interesante vamos a hacer que imprima un texto que le pasamos a la función como parámetro:

<?php

function miFuncion($texto) {

    echo $texto . '<br />';

}

//Invocamos la función

miFuncion(“Soy un texto pasado como parámetro”);

 //Otra función a la que le pasamos mas parámetros

function otraFuncion($texto, $nombre) {

    echo $nombre . “: “ . $texto . '<br />';

}

otraFuncion(“¿Hola como estas?”, “Juan”); //Imprime “Juan: ¿Hola como estas?”

 //Ahora le pasamos como parámetros variables definidas fuera de la función

$unTexto = “Yo muy bien, ¿Y tu?”;

$unNombre = “Pedro”;

otraFunction( $unTexto , $unNombre ); //Imprime “Pedro: Yo muy bien ¿Y tu?”

?>

Los parámetros cuando hay mas de uno han de pasarse en el mismo orden que fueron definidos, esto es muy importante puesto que a cada parámetro que le pasas le corresponde la variable definida en ese lugar en la función.

PHP nos permite hacer algo muy interesante al declarar los parámetros que usara la función, y es declarar si el parámetro que has de pasar es opcional, ¿Como se hace esto? Muy fácil dándole al parámetro un valor por defecto. Ejemplo:

<?php

function miFuncion( $texto = 'Soy un texto por defecto' ) {

    echo $texto . '<br />';

}

//Invocamos la función sin pasarle parámetro

miFuncion(); //Imprime “Soy un texto por defecto”.

//Invocamos la función pasándole un texto

miFuncion('He sido pasado como parámetro'); //Imprime “He sido pasado como parámetro”.

?>

Para definir el parámetro como opcional le hemos dado un valor por defecto con el operador “=”, exactamente igual que si asignáramos un valor a una variable durante el flujo normal del script. ¿Fácil cierto?.

Para entender porque las funciones permiten pasar parámetros habría que hablar del ámbito de las variables. Hasta ahora has declarado variables y las has usado desde cualquier sitio de los scripts sin ningún impedimento, pero con las funciones esto cambia.

Toda variable declarada durante el flujo natural del script es considerada como una variable Global, mientras que las declaras dentro del bloque de la función se llaman Locales, esto quiere indicar que las variables locales solo se pueden usar dentro de la función que las declaró, veamos un ejemplo:

<?php

function miFuncion() {

    $variable = 'Hola mundo';

    echo 'Dentro de la función: ' . $variable;

}

miFuncion(); //Imprime “Dentro de la función: Hola mundo”.

//Al tratar de imprimir la variable desde fuera de la función no la reconocerá.

echo 'Fuera de la función: '. $variable;

?>

Este ejemplo muestra fácilmente como funcionan las variables locales, en caso de que queramos usar una variable declarada fuera de la función debemos de pasarla como parámetro, o indicarle a la función que esa variable es una global:

<?php

function miFuncion() {

    //Indicamos que $variable es una global
    global $variable;

    echo 'Dentro de la función: ' . $variable;

}

//Declaramos $variable
$variable = 'Hola mundo';

miFuncion(); //Imprime “Dentro de la función: Hola mundo”.

echo 'Fuera de la función: '. $variable; //Imprime “Fuera de la función: Hola mundo”.

?>

Esta forma de trabajar, usando globales dentro de las funciones no la recomiendo para nada, hace el código mas confuso y permite que se acceda y se alteren datos del script de una forma poco organizada. Las funciones hay que verlas como habitaciones de dos puertas, una para entrar (parámetros) y otra para salir (return), usar globales es como colarnos por la ventana, poco seguro.

Al igual que no es una buena practica usar globales, tampoco lo es imprimir datos directamente desde una función, (digo imprimir por citar un ejemplo, por supuesto hay excepciones).

Lo normal es que si le pasamos datos mediante los parámetros, tengamos una forma para devolver un resultado, para eso existe la sentencia return:

<?

//Esta función estaría mal planteada
function sumar($num, $numero){

    echo $num + $numero;

}

function multiplicar($num, $numero){

    return $num * $numero;

}

sumar(10, 4); //Imprimiría 14

$n = multiplicar(10, 4); //Esto asignaría a $n el valor 40

echo $n; //Usamos $n para lo que queramos.

?>

Al usar return $num * $numero; permitimos que el resultado se almacene en una variable para luego manipularla, también podríamos imprimirla directamente en pantalla mediante echo multiplicar(10, 4); o cualquier otra acción.

Es importante entender la importancia de encapsular el código, controlando lo que entra y sale de las funciones, porque mas adelante cuando hablemos de Programación Orientada a Objetos sera fundamental evitar que nada entre y salga de las clases sin control.

Quería tratar todo lo relacionado con las funciones en este articulo, pero es demasiado extenso, por lo tanto en el siguiente hablaré sobre Funciones Recursivas y Closures.

Las variables son contenedores de información usadas en todos los lenguajes de programación, se podría decir que son fundamentales, nos sirven para almacenar datos de forma que podamos usarlos mas adelante, su uso es extremadamente fácil, pero su utilidad alberga un sinfín de posibilidades. Además podemos variar su contenido en cualquier momento reasignando su valor, en PHP las variables se reconocen rápidamente porque están precedidas del símbolo del dólar ($), por ejemplo:

<?php

//Declaramos la variable
$texto = "Hola Mundo";

//Mostramos su valor
echo $texto;

?>

Como se ve en el ejemplo anterior, la variable seria $texto, la cual almacena la cadena de texto “Hola Mundo”, para asignarle el valor hemos usado el operador =, y hemos mostrado su valor con la sentencia echo. Para ‘jugar’ con el valor de las variables contamos con los operadores de asignación y aritméticos, los cuales te resultaran fácil ya que son muy parecidos a las típicas operaciones matemáticas.

Además el operador = se puede combinar con otros para facilitar algunas operaciones y no tener que escribir las variables varias veces, por ejemplo:

<?php

$a = 1;
$a = $a + 3;

?>

Es lo mismo qué:

<?php

$a = 1;
$a += 3;

?>

De esta forma nos hemos ahorrado el escribir la variable de nuevo.
La combinación de operadores no solo es valida con el operador de la suma, sino con otras muchas como: += , -= , *= , .= , /= , %= , por lo tanto podemos usarlo donde mas cómodo nos sea y mejor nos convenga.

Las variables pueden tener diferentes tipos de datos almacenados:

Cadenas de Texto:

<?php

$texto = "Es mi frase";

$texto = 'Es mi Frase';

?>

Numeros enteros o flotantes:

<?php

$n = 100; //Numero entero
$n = 100.56 //Numero flotante

?>

Objetos (Entraremos en este campo más adelante):

<?php

$coche = new coche();

?>

Booleanos:

<?php

//Puedes escribir true o false en mayúsculas o minúsculas

$verdadero = TRUE;

$falso = FALSE;

?>

y Matrices o Arrays que explico a continuación.

Un Array es una variable que guarda múltiples datos de una forma ordenada, imaginemos que hacemos un programa para una tienda en el que tenemos los productos almacenados en variables, tendríamos que tener una variable para cada producto, $producto1, $producto2, y asi con todos, el array nos permite almacenar todos los productos en una sola variable $producto, sin limite de capacidad, puede contener un solo producto, o millones, veamos un ejemplo de como se realizaría el programa con múltiples variables:

<?php

$producto1 = 'Leche';
$producto2 = 'Sal';
$producto3 = 'Aceite';
$producto4 = 'Azúcar';

//Etc....
?>

Veamos este mismo ejemplo usando una variable array:

<?php

$producto = array('Leche' , 'Sal' , 'Aceite' , 'Azúcar');

?>

Como se puede observar para declarar la variable como un array usamos la función array(), y dentro de los paréntesis situamos los valores, podemos usar cadenas, números, otras variables, y así con todos los tipos de datos, incluso podemos usar un array dentro de otro array.

Ya que los arrays son tremendamente importantes, imprescindibles y útiles es mejor dedicarles el próximo articulo a ellos.

Siguiendo el Hilo del anterior capitulo del Tutorial de PHP vamos a empezar con un script de ejemplo.

Para hacer tu primer script en PHP te puedes valer de cualquier editor de texto, hay muchas opciones, tanto de pago como gratuitas, pero no tienes por que complicarte, puedes usar el ‘bloc de notas‘ de windows, gedit de Gnome, Kate de KDE o cualquier otra opción que te resulte cómoda.
Aunque puedes usar los editores de texto mas básicos para crear y editar scripts PHP existen multitud de IDEs (Entornos de Desarrollo Integrado) que pueden hacerte mas fácil la programación, el mero hecho de colorear la sintaxis se nota bastante.
Un IDE muy ligero y multiplataforma que recomiendo es Geany, tiene todo lo necesario para sentirte cómodo, y si buscamos opciones mas completas yo optaría por NetBeans o Eclipse con los correspondientes Plugins de PHP. Por supuesto que hay IDEs enfocados solamente a PHP, ofreciendo opciones que otros no tienen, pero no puedo hablar sobre lo que no conozco, realmente dudo que los IDEs de pago traigan alguna herramienta ‘Imprescindible’ para desarrollar PHP.

Una vez que has elegido tu IDE lo siguiente sera crear un script, lo llamaremos, hola.php y debe estar en la carpeta /www de la instalación de tu Apache, de esta forma podemos acceder al fichero desde cualquier navegador entrando en la dirección http://localhost/hola.php.

De momento el script hola.php lo usaremos con el clásico ejemplo del Hola Mundo que se hace en todos los lenguajes. En PHP seria así:

<?php

echo "Hola Mundo";

?>

Fácil, ¿cierto?. Al entrar en http://localhost/hola.php se nos mostrara la frase hola mundo.

PHP fue diseñado para ser embebido en código HTML y viceversa, la forma de entrar y salir del ‘Modo PHP‘ es mediante las etiquetas <?php y ?>, de esta forma indicamos que lo que se encuentra dentro de estas etiquetas es código php, y lo que se encuentra fuera es código HTML, si dentro de un script no colocamos las etiquetas de apertura de código php, el script se envía completo como código HTML.

En la segunda linea vemos echo “Hola Mundo”; la sentencia echo se usa para enviar al navegador una cadena como parte de la web, las comillas dobles encierran una cadena de texto, también podemos usar comillas simples (‘), pero, no tenemos porque enviar cadenas de texto, también podemos enviar operaciones o variables, por ejemplo echo 2+5; mostrara en el navegador 7.
Si lo preferimos podemos usar la función print, la cual es muy parecida a echo, guardan algunas diferencias pero de momento no es necesario saberlo. Si no fijamos al final de la sentencia se coloca un punto y coma (;), este es el indicador de que la sentencia ha terminado, y se debe de poner siempre, si no dará un error.

Por ultimo cerramos con ?> para indicar que no hay mas código php.

Todo lenguaje de programación debe de permitir la inclusión de comentarios dentro del código, de esta forma podemos especificar para que sirve ciertas sentencias o bloques de código, es de mucha ayuda para nosotros mismos o para otros programadores que lean nuestro código. En php los comentarios de una linea se ponen tras el símbolo de la almohadilla (#) o dos barras (//); por ejemplo:

<?php

#Comentario de una linea
//Sentencia para mostrar hola mundo en pantalla
echo "Hola Mundo";

?>

Si lo que queremos o necesitamos es escribir un comentario de varias linea lo podemos hacer usando barra – asterisco (/*) para abrir y asterisco – barra (*/) para cerrar, por ejemplo:

<?php

/*
Estas lineas son un comentario del script
que no se ejecutan, pero sirven como información
adicional para el programadores
*/
echo "Hola Mundo";

?>

En el siguiente articulo empezaremos con Variables.