Quinta y última parte de esta guía introductoria al desarrollo de aplicaciones web sobre la Facebook Platform. Ya conoces el ecosistema de tecnologías de Facebook, sabes cómo crear distintos tipos de aplicaciones, y conoces el SDK JavaScript por completo. Hoy vamos a ver el PHP SDK.

Antes de seguir leyendo, puedes echar un vistazo a la página GitHub donde está alojado el proyecto PHP SDK, y desde donde te lo podrás descargar. Nosotros vamos a hablar sobre la última versión estable, la 3.1.0.

1 Instalación

Ya has dado de alta tus aplicaciones, y ahora quieres saber cómo incorporar el PHP SDK a alguna de ellas. Lo primero, deberás descargarte el SDK de su página en GitHub y descomprimirlo. Verás tres carpetas:

Se incluye:

• changelog.md – Fichero que registra todos los cambios entre las distintas versiones del SDK.
• examples – Un ejemplo de uso.
• readme.md – Fichero ‘léame’ con documentación básica.
• src – Bibliotecas del SDK. Esta carpeta es la que usaremos en nuestro proyecto.
• tests -Batería de tests unitarios para comprobar el correcto funcionamiento del SDK.

<?php
    require_once("src/facebook.php");

    $config = array(
        'appId' => 'TU_APP_ID',
        'secret' => 'TU_APP_SECRET',
        'fileUpload' => false, // opcional
    );

    $facebook = new Facebook($config);

Es decir, cargamos el SDK, creamos un nuevo array con la configuración del objeto Facebook, y finalmente lo creamos. ¡Ya está! Ya puedes usar el PHP SDK.

2 Métodos básicos

Vamos a ver 6 métodos getter y setter básicos:

Facebook::getAccessToken

Mediante este método podremos obtener el accessToken en uso. Los access token son objetos que definen los permisos que tenemos para interactuar con un determinado usuario. Puedes ver más sobre el objeto access_token en la documentación de los permisos.

Facebook::setAccessToken

Del mismo modo, podremos establecer el accessToken con el que funcionará nuestra aplicación. Se sobreentiende que este AccessToken ha sido obtenido por algún medio ajeno al SDK de PHP (por ejemplo, mediante cURL).

Facebook::getApiSecret

Nos devuelve el APP_SECRET de la aplicación.

Facebook::setApiSecret

Permite establecer a mano el APP_SECRET para nuestra aplicación

Facebook::getAppId

Devuelve el APP_ID de nuestra aplicación

Facebook::setAppId

Nos permite establecer a mano el APP_ID de la aplicación

3 Métodos de autenticación

Lo primero es lo primero. Vamos a ver cómo podremos autenticar a un usuario, y cómo solicitarle permisos. Para ello, vamos a revisar antes cuatro métodos más:

Facebook::getLoginStatusUrl

Este método nos permite especificar URLs según el estado de login del usuario, de manera que en función de este estado, nos redirigirá a un URL u otra. Hay tres estados posibles:

1. ok_session – El usuario ha iniciado sesión en Facebook.
2. no_user – El usuario no ha iniciado sesión en Facebook.
3. no_session – El usuario no está conectado a nuestra aplicación.

El valor devuelto por esta URL es una dirección de Facebook que se encarga de llevar a cabo por nosotros la redirección. Puedes probar aquí para ver en funcionamiento este ejemplo:

    if (isset($_GET['status']) && !empty($_GET['status'])) {
        switch($_GET['status']) {
            case 1: echo 'Te conozco  '; break;
            case 2: echo 'No estás conectado a Facebook.'; break;
            case 3: echo 'Estás conectado, pero no te conozco.'; break;
        }
        echo "<br /><a href='http://www.chusete.es/facebook/phpdemo/getLoginStatusUrl.php'>Volver a intentar</a>";
    } else {
        $params = array(
            'ok_session' => 'http://www.chusete.es/facebook/phpdemo/getLoginStatusUrl.php?status=1',
            'no_user' => 'http://www.chusete.es/facebook/phpdemo/getLoginStatusUrl.php?status=2',
            'no_session' => 'http://www.chusete.es/facebook/phpdemo/getLoginStatusUrl.php?status=3',
        );

        header("Location: ".$facebook->getLoginStatusUrl($params));
    }

Facebook::getLoginUrl

Construye por nosotros la URL desde la que accedemos a la página que nos muestra el diálogo OAuth. Acepta dos parámetros:

1. scope – Como ya sabes, la lista de permisos que queremos solicitar al usuario.
2. redirect_uri – Dirección a la que se redirigirá tras el diálogo OAuth.

    $params = array(
        'scope' => 'read_stream, friends_interests',
        'redirect_uri' => 'http://chusete.es/post_login_page',
    );

    $loginUrl = $facebook->getLoginUrl($params);

Facebook::getLogoutUrl

Del mismo modo que podemos generar la URL de inicio de sesión en nuestra aplicación, podemos crear otra para salir. Sólo debemos indicar un parámetro (opcional):

• next – URL a la que se le redirigirá al usuario tras hacer logout.

Facebook::getUser

Este método tan sólo nos devuelve el ID del usuario activo en nuestra aplicación.

4 Autenticación

Ya tienes la aplicación creada, ya has descargado el SDK, ya has instanciado un objeto de la clase Facebook, y ya conoces los métodos necesarios. Es el momento de ver cómo hacer un inicio de sesión en nuestra aplicación

Esto es lo que va a realizar nuestro ejemplo: Cuando el usuario acceda a la aplicación, si ha conectado con ella previamente, se le mostrará un mensaje de bienvenida. En caso contrario, le reenviaremos al diálogo OAuth para solicitarle permisos. Si los acepta, volverá a la aplicación, donde le daremos la bienvenida y le daremos la opción de cerrar sesión. En caso contrario, le mostraremos un mensaje lamentando que no haya conectado con nuestra súper app. Puedes ver aquí la demo.

Éste es el código:

    $params = array(
        'scope' => 'read_stream, friends_interests',
        'redirect_uri' => 'http://chusete.es/facebook/phpdemo/',
    );
    $loginUrl = $facebook->getLoginUrl( $params );

    if ( $_GET['error'] ) {
        echo "Parece que no quieres usar la aplicaci&oacute;n  <br />";
        echo "Si cambias de opini&oacute;n, haz clic <a href='".$loginUrl."'>aqu&iacute;</a>";
    } elseif( $facebook->getUser() ) {
        $logoutUrl = $facebook->getLogoutUrl(array('next' => 'http://www.facebook.com/'));
        echo "Bienvenido!  <br />";
        echo "Puedes <a href='".$logoutUrl."'>cerrar sesi&oacute;n</a> si lo deseas.";
    } else {
        header( "Location: ".$loginUrl );
    }

Como de costumbre, vamos a revisarlo:

1. En primer lugar construímos la URL en la que se muestra el diálogo OAuth, generado a partir de unos determinados parámetros:
1. Solicitamos algunos permisos extra: read_stream y friends_interets.
2. Definimos la URL actual como la dirección a la que debe retornar el diálogo OAuth tras la autorización (o no) del usuario.
2. Ahora seguimos la ejecución. Recuerda que, como hemos definido esta misma URL como dirección de retorno, cuando el usuario autorice (o no) nuestra aplicación, volveremos aquí:
1. Si está presente el parámetro GET ‘error‘, significa que el usuario no autorizó la aplicación. En ese caso mostramos un mensaje con una carita triste, y le damos de nuevo la opción de conectar con la aplicación.
2. En caso contrario, comprobamos si hay algún usuario reconocido. Si así fuera, mostramos un mensaje de bienvenida y un link de logout.
3. Y si no hubiera ningún usuario reconocido, redirigiríamos automáticamente mediante la función header() a la URL del diálogo OAuth desde la que podrá conectar con la aplicación.

5 Resto de métodos

Lo creas o no, hemos visto prácticamente todos los métodos del PHP SDK. Vamos a revisar los cuatro que nos quedan:

Facebook::api

Método polimórfico que nos permite realizar llamadas al Graph API (incluso con FQL, el Facebook Query Language). Puede lanzar excepciones de tipo FacebookApiException. Para poder realizar consultas que no sean públicas, debemos asegurarnos previamente de que tenemos permisos suficientes de ese usuario. Puedes probar esta demo, de la que tienes a continuación el código:

<?php
    require_once("src/facebook.php");

    $config = array(
        'appId' => '256797284360192',
        'secret' => '1e4791731181402f02399fbe174cdb0d',
        'fileUpload' => false, // opcional
    );

    $facebook = new Facebook($config);

    $loginUrl = $facebook->getLoginUrl();

    $user = $facebook->getUser();
?>
<html>
    <head>
        <meta charset="UTF-8" />
    </head>
    <body>
    <?php
        if($user) {
            try {
                $_SESSION['user_id'] = $user;
                $user_profile = $facebook->api('/me','GET');
                echo "Nombre: " . $user_profile['name'];
            } catch(FacebookApiException $e) {
                echo "Error. Posiblemente ha expirado la sesión. ";
                echo "<a href='".$loginUrl."'>Volver a iniciar sesión</a><br />";
                $result = $e->getResult();
                var_dump($result);
            }
        } else {
            echo "Haz clic <a href='".$loginUrl."'>aqu&iacute;</a> para iniciar sesi&oacute;n";
        }

    ?>
    </body>
</html>

FacebookApiException

Cuando realizamos una consulta al API de Facebook mediante Facebook::api, podrán lanzarse excepciones, por lo que cada llamada a Facebook::api deberá ir dentro de su bloque try-catch correspondiente. Las excepciones tendrán estos dos métodos:

1. getResult – Devuelve un objeto array con el mensaje de error que devuelve el servidor.
2. getType – Devuelve el tipo de excepción, como por ejemplo OAuthExcepcion.

Facebook::getSignedRequest

En la cuarta parte de esta guía vimos qué es el objeto signedRequest. Como dijimos, se trata de un objeto que sirve para compartir información entre Facebook y nuestra aplicación. Desde JavaScript no era seguro su uso, ya que, al no deber hacer público el APP_SECRET de una aplicación, no podríamos tener la certeza de que el contenido del objeto signedRequest estuviera realmente firmado por Facebook.

Sin embargo, desde PHP sí podremos, y este método realiza todo el trabajo sucio por nosotros: decodifica, comprueba la firma, y devuelve el objeto en forma de array PHP. De esta forma, con el objeto devuelto por este método podríamos comprobar en una aplicación de tipo Page Tab si el usuario es o no fan (sin necesidad de solicitar ningún permiso).

Consulta la documentación de signedRequest para más información.

Facebook::setFileUploadSupport

Habilita o deshabilita el soporte para subida de ficheros. Éstas se realizarán mediante llamadas al Graph API con el método Facebook::api utilizando el método de envío POST. Podemos ver el ejemplo de la documentación de Facebook:

$facebook->setFileUploadSupport(true);

$img = '/tmp/mifoto.png';

$photo = $facebook->api(
    '/me/photos',
    'POST',
    array(
        'source' => '@' . $img,
        'message' => 'Foto subida mediante el SDK de PHP!'
    )
);

Facebook::useFileUploadSupport

Indica si está o no habilitado el soporte para subir ficheros.

6 Y ahora qué

Si te has quedado con ganas de más, estás de enhorabuena, porque han quedado muchos conceptos en el tintero.

Otros SDK. Si tienes pensado desarrollar para Android, puedes echar un vistazo al Android SDK. Puedes hacer también lo propio con el iOS SDK si tu intención es crear una aplicación para iPhone o iPad.

Consultas más eficaces. Otro asunto interesante por explorar es el lenguaje FQL para realizar consultas a-la-SQL a Facebook. Mediante este método puedes llevar a cabo comportamientos que con el Graph API no podrías, como ejecutar consultas por lotes.

¡Internacionalizate! Es otra de las opciones que proporciona Facebook: habilita tu aplicación para que sea traducida, preparándola según las directrices de internacionalización de Facebook.

Todavía más APIs… Tienes a tu alcance Ads API, que te permitirá crear y monitorizar mediante código ambiciosas campañas publicitarias. O Credits API, con la que podrás permitir a tus usuarios comprar créditos de Facebook con los que adquirir nuevas funcionalidades o ítems en tu aplicación. Y Chat API, con la que podrás incorporar a tu página web, o aplicación nativa, un chat compatible XMPP compatible con Facebook.

Más sobre Graph API. Si te interesa conocer más acerca de las consultas por lotes, tienes un apartado íntegro dedicado a ellas. Tienes también una API de actualizaciones en tiempo real.

Juegos. Lo mencionamos de pasada, pero existe toda una API para que los desarrolladores de videojuegos puedan añadir logros y puntuaciones.

Social Design, es como llaman en Facebook a la forma de pensar cómo crear productos sociales, utilizando tres conceptos clave, comunidad, conversación e identidad. Ver más sobre Social Design.

Opciones, muchas más opciones de configuración:

• Configuración avanzada:
• Deauthorize Callback – Definir una URL a la que se hará un ping cada vez que un usuario se desvincule de tu aplicación (con información en el signedRequest).
• Migraciones – Facebook está en constante cambio. Puedes elegir qué tecnologías usar: las que están en uso o las obsoletas.
• Seguridad – Autorizar determinadas IPs para realizar peticiones en nombre de tu aplicación o para cambiar su configuración. Alertas por email.
• Publicidad – Puedes indicar las direcciones de correo de las cuentas de usuario utilizadas para la publicidad de la página.
• Datos de contacto – Enlaces a las URLs de privacidad, condiciones de uso, de soporte, etc.
• Roles – Desde donde podrás añadir otros usuarios a diferentes perfiles: Desarrollador, tester, usuarios de pruebas (usuarios falsos creados al vuelo), etc.
• Credits – Donde personalizas los parámetros de configuración necesarios para poder operar con créditos Facebook.

Nueva versión de Open Graph: Hasta ahora podía establecerse un vínculo entre un usuario y otro objeto con el verbo “me gusta”. Por ejemplo, “A Pedro le gusta Coca-Cola“. Tenemos un sujeto (Pedro), una acción (gustar), y un objeto (Coca-Cola). Hasta ahora el verbo era siempre “gustar”. Sin embargo, con esta nueva versión, podrá ser cualquier cualquier cosa: “María ha tomado un Big Mac“. Puedes seguir este tutorial paso a paso.

7 Resumen

Con suerte, habrás llegado hasta aquí. Eso significa que ya ha finalizado tu toma de contacto con el desarrollo de aplicaciones en Facebook. Dominas tecnologías básicas como los social plugins, open graph, o los diálogos. Sabes crear distintos tipos de aplicaciones, ya sea en una web externa, en un Canvas, o en un Page Tab. Conoces a fondo el JavaScript SDK y el PHP SDK. Has tenido una toma de contacto con el Graph API. Sabes autenticar y solicitar permisos a tus usuarios en cualquier escenario. Eres consciente del resto de tecnologías de Facebook que tienes a tu alcance. Sabes qué son los Social Channels, y cómo aprovecharlos para dar mayor visibilidad a tus aplicaciones. No está nada mal, ¿no?

Espero que hayas disfrutado de estos artículos tanto como yo, y ojalá puedan serte de utilidad.

¡Muchas gracias por haber seguido esta guía!.

¿De modo que te han pedido que hagas una aplicación para Facebook y no sabes por dónde empezar? ¿Has llegado a la documentación oficial y te pierdes entre tanto Open Graph, SDK, plugins, dialogs y Graph API? Don’t panic! En este artículo vamos a ver paso a paso cómo empezar a programar en el nuevo sistema de Facebook. ¡Al lío!

Tipos de aplicaciones

En el apartado Getting Started de la documentación oficial vemos que nos dan tres opciones:

1. Páginas web. Para crear una aplicación que se ejecute en tu página web fuera de Facebook.
2. Aplicaciones móviles. Para crear apps para las principales infraestructuras móviles.
3. Aplicaciones en Facebook. Este decir, para crear una aplicación que se insertará dentro de la web de Facebook, en un canvas.

En cualquiera de los tres casos, las tecnologías que utilizaremos serían básicamente las mismas.

Más adelante revisaremos algunas de las tecnologías que nos ofrece Facebook para integrar nuestra aplicación con su infraestructura.

Además, en la página de inicio ofrecen un apartado de ejemplos donde podrás probar y descargar distintas demos, como el de una aplicación en página web, o una aplicación dentro de un canvas en Facebook. También puedes acceder a vídeos con charlas y guías.

Dando de alta una aplicación

Para entender mejor todos los apartados, y para poder realizar algunos ejemplos, vamos a crearnos una nueva aplicación. Para ello, vamos a seguir los siguientes pasos:

Accedemos a la página de desarrolladores de Facebook: https://developers.facebook.com/

Una vez ahí, seleccionamos “Aplicaciones” en el menú.

En tercer lugar, pulsamos sobre el botón .

Ahora indicamos un nombre y la local de la aplicación y pulsamos Continuar:

Completamos el captcha y pulsamos sobre Enviar:

Y con esto ya estaría dada de alta nuestra aplicación:

Fíjate en la caja superior. Verás dos campos: App ID y App Secret. Estos código los necesitarás para hacer funcionar tu aplicación. El primero es el código que identifica la app, y el segundo es un código de seguridad que utilizarás para la autenticación en el lado del servidor.

Por lo pronto, podemos cambiar los siguientes campos:

• Logo. Corresponde al logo de 75×75 px de la aplicación.
• Icono. Icono de 16×16 px de la aplicación
• App Secret. Este código no debemos compartirlo con nadie. Desde este apartado podremos reiniciarlo si lo deseáramos.
• App Display Name. Nombre con el que se mostrará la aplicación.
• App Namespace. Nombre del espacio de nombres de la aplicación, formado únicamente por caracteres en minúsculas, guiones medios y guiones bajos.
• Contact Email. Dirección de correo electrónico de contacto.
• App Domain. Dominio sobre el que se alojará la aplicación (por ejemplo www.example.com).
• Category y Sub-category. Categorías en las que catalogamos la aplicación.

Además, vemos que podemos definir 4 formas distintas de integrar la aplicación con Facebook:

1. Website. Para cuando queramos que en nuestra página puedan los usuarios hacer login con su cuenta de Facebook.
2. App on Facebook. Aplicación para incorporar en un canvas dentro de Facebook.
3. Mobile Native. Para crear una aplicación para móviles.
4. Page Tab. Permite crear una aplicación que se mostrará como una pestaña dentro de una Facebook Page.

Y estas son todas las opciones básicas que tenemos disponibles para configurar una aplicación de Facebook. Sin embargo, podemos acceder a la configuración avanzada desde el menú de la izquierda, pulsando sobre Configuration > Advanced:

En este apartado avanzado por ahora podremos establecer la descripción de nuestra aplicación, y el Sandbox Mode (habilitado indica que sólo los desarrolladores pueden acceder a la aplicación).

Rápido e indoloro, ya tenemos nuestra aplicación creada . Cada vez que queramos volver a la configuración de nuestra aplicación, tan solo tendremos que acceder a la página de desarrolladores de Facebook, apartado Aplicaciones, y seleccionamos la opción deseada.

Tecnologías disponibles

Bien, y ¿qué tecnologías nos ofrece Facebook para implementar una aplicación? Éstas son las principales:

1. Social plugins

Corresponde a pequeños plugins o widgets que se pueden incorporar muy fácilmente en cualquier página web ajena a Facebook. Accediendo a la página de cada uno de ellos verás un pequeño formulario que te genera el código necesario para que lo incorpores en tu página. Seguro que estás muy familiarizado con casi todos ellos:

Botón “Me gusta”.
Es el más famoso de todos los plugins. Permite a los usuarios compartir con un solo clic la página que están visitando

Botón “Enviar”.
Permite que los usuarios envíen a alguno/s de sus contactos la página que están visitando.

Comentarios.
Para añadir un sistema de comentarios a tu página web.

Feed de actividades.
Muestra una lista de las últimas actividades que han llevado a cabo tus contactos de Facebook.

Recomendaciones.
Muestra al usuario una lista personalizada de enlaces recomendados, en función de diferentes parámetros, como por ejemplo las preferencias de sus amigos.

Caja “me gusta”.
Similar al botón “Me gusta”, pero con más elementos. Por ejemplo, muestra las últimas actividades de la página, o una lista de personas a las que les gusta.

Botón “Login”.
Botón que permite iniciar sesión en la página utilizando la infraestructura de sesiones de Facebook.

Registro.
Formulario de registro a una página que se rellena automáticamente con tus datos de Facebook. De este modo, se ahorra tiempo a los usuarios.

Facepile.
Muestra una lista de imágenes de perfil de los usuarios a los que les ha gustado la página que se está visitando.

Live Stream.
Muestra un pequeño ‘chat’ vinculado a la página que se está visitando.

Como ves, a base de insertar este tipo de plugins, puedes crear una página web muy rica en funcionalidades en un tiempo récord. A modo de demostración, puedes consultar esta página, que forma parte del apartado de ejemplos de Facebook. Esta demo hace uso del botón “me gusta”, del feed de actividades, de las recomendaciones y de los comentarios.

2. Diálogos

Podemos definir los diálogos como ventanas emergentes que solicitan al usuario permiso para realizar alguna acción.

Podemos invocar los diálogos a mano, sin embargo en general suele ser mucho más cómo realizarlo mediante alguno de los SDK que Facebook nos ofrece. En concreto, para páginas web, utilizaremos el SDK JavaScript mediante el método FB.ui. En el apartado del SDK de JavaScript veremos cómo invocar estos diálogos.

Por lo pronto, vamos a ver cuáles son los distintos diálogos que nos ofrece Facebook:

Diálogo de Feed

Permite al usuario añadir a su muro, desde nuestra aplicación, una publicación.

Diálogo de amigos

Muestra un diálogo para añadir a un amigo.

Diálogo OAuth

Solicita al usuario unas determinadas autorizaciones, y concede permisos a la aplicación.

Diálogo de Pago

Permite al usuario adquirir nuevos créditos de Facebook.

Diálogo de petición

Diálogo que permite al usuario enviar una petición a uno o más amigos.

Diálogo de envío

Diálogo para que el usuario envíe un mensaje a algún amigo, a un grupo de amigos, o a una dirección de correo.

3. Autenticación y Permisos

A menudo necesitaremos que los usuarios nos autoricen a acceder a su información. Por ejemplo, cuando queramos que puedan iniciar sesión en nuestra web utilizando su cuenta de Facebook, o cuando desde nuestra aplicación queramos acceder a determinados campos de su perfil de usuario. Para solicitar esta autorización utilizaremos el Diálogo OAuth.

Cada vez que se utiliza el diálogo OAuth, podremos pasarle información al diálogo acerca de la los permisos de acceso que autorizará el usuario. Te recomiendo que revises la lista de todos los posibles permisos. Además, ten en cuenta que cuantos más permisos solicites a un usuario, menor será el número de personas que decidan autorizar a tu aplicación.

Existen dos métodos posibles de autenticación: Desde el servidor, o desde el cliente. Pero, para simplificar, podemos decir que son equivalentes el uno al otro.

4. Graph API

El nucleo de Facebook es un grafo social, donde cada persona, foto, evento o página tiene su ID único, y donde existen conexiones entre todos ellos (por ejemplo, amistades, etiquetas en fotos, contenidos compartidos, etc.).

Para acceder a las propiedades de cualquiera de estos objetos accederemos a la URL: https://graph.facebook.com/ID cambiando ID por el identificador del objeto que queramos consultar. Como resultado, nos devolverá un objeto JSON.

Por ejemplo, al comienzo de este artículo creamos una aplicación. Puedes coger el App ID de tu aplicación y acceder a su información. Te saldrá algo similar a esto:

{
   "id": "256797284360192",
   "name": "chusete demo",
   "description": "Aplicaci\u00f3n de pruebas de Chusete",
   "category": "Utilities",
   "subcategory": "News",
   "link": "http://www.facebook.com/apps/application.php?id=256797284360192"
}

En el caso de los usuarios y de las páginas, cuando tengan un alias, se podrá usar como alternativa al ID.

Por supuesto, todas estas peticiones devuelven por defecto tan solo la información pública de ese objeto/persona. Para acceder a información privada, debemos contar con su autorización. Esta autorización se proporciona mediante el parámetro GET access_token.

5. Open Graph Protocol

Esto no es una tecnología del core de Facebook propiamente dicha, pero sí es algo sobre lo que se apoya. ¿De qué se trata? Voy a explicarlo mediante un ejemplo. Supón que creas una página web de restaurantes, donde cada uno tiene su propia URL. Un día un usuario comparte esta URL en Facebook. ¿Qué ocurrirá? Que Facebook elegirá la información y las imágenes que él considere relevante. Pero, ¿y si quisiéramos nosotros decirle a Facebook (y otras redes sociales) la información que debe mostrar? Para dar respuesta a eso surge el protocolo Open Graph.

En otras palabras: Hace que nuestras páginas web se conviertan en objetos “del mundo real” con el que pueden interactuar las redes sociales. Películas, restaurantes, celebridades, etc.

En el caso concreto de Facebook, además, cuando un usuario haga clic en el plugin del botón “Me gusta” de una de tus páginas, será equivalente a que hiciera clic en “Me gusta” de alguna de las Facebook Pages, por lo que podrás enviarle actualizaciones a su Feed. Mola, ¿no?

Su funcionamiento no podría ser más sencillo. Open Graph Protocol está basado en RDFa, por lo que mediante etiquetas meta puedes añadir semántica a tus páginas. Además, para una correcta integración con Facebook, debes añadir el plugin del botón “Me gusta”.

Para más información, revisa la página oficial de Open Graph Protocol: http://ogp.me/

6. Otras tecnologías

Además de todas las tecnologías que hemos visto, existen otras de tipo avanzado que, por lo general, no será necesario usarlas. En concreto estaríamos hablando de:

• FQL. Facebook Query Language, o Lenguaje de consultas de Facebook. Similar a SQL, sirve para consultar los datos que ofrece Graph API.
• API de internacionalización. Mediante esta API puedes aprovechar la infraestructura de internacionalización de Facebook para tu aplicación.
• API de créditos. Para que los usuarios puedan realizar pagos de créditos de Facebook para utilizar en tu aplicación.
• API de publicidad. Permite crear y gestionar mediante código tus campañas publicitarias.
• API de Chat. Para aquellos desarrolladores que quieran integrar el chat de Facebook en sus aplicaciones, mediante el protocolo estándar Jabber/XMPP.

APIs obsoletas. Además, existen determinadas APIs que han quedado obsoletas y a las que pronto Facebook dejará de dar soporte, como la API REST, el lenguaje de marcado FBML, o la API JavaScript.

SDKs

Por último, vamos a repasar los distintos kits de desarrollo que nos regala Facebook. Cabe destacar que no es imprescindible utilizarlos, ya que podremos realizar la autenticación, invocación de diálogos, o las llamadas a la API a mano. Pero, como podrás imaginar, resulta mucho más sencillo utilizar una herramienta ya probada que lo haga por nosotros.

Existen cuatro SDKs:

1. JavaScript SDK.
2. PHP SDK.
3. iOS SDK (iPhone & iPad).
4. Android SDK.

Aquí vamos a hablar de los dos primeros.

1. JavaScript SDK

Permite realizar llamadas a la Graph API, crear diálogos, renderizar los Social Plugins, además de otras muchas cosas. Para usar el SDK, debemos  intrducir el siguiente código a nuestra aplicación:

<div id="fb-root"></div>
<script src="http://connect.facebook.net/en_US/all.js"></script>
<script>
  FB.init({
    appId  : 'ID DE TU APP',
    status : true, // comprobar estado de login
    cookie : true, // habilitar cookies para permitir al servidor acceder a la sesión
    xfbml  : true, // ejecutar código XFBML
    channelURL : 'http://WWW.MIDOMINIO.COM/channel.html', // fichero channel.html
    oauth  : true // habilita OAuth 2.0
  });
</script>

Y en el fichero channel.html añades el siguiente contenido:

<script src="http://connect.facebook.net/en_US/all.js"></script>

Y ya lo tienes. Tu página está preparada para ejecutar código del SDK JavaScript de Facebook.

2. PHP SDK

El SDK oficial para PHP de Facebook es un proyecto open source que se encuentra alojado en GitHub:  https://github.com/facebook/php-sdk/.

Si bien existe un ejemplo básico, pero completo, sobre su uso, vamos a resumir aquí las principales operaciones:

Código de inicialización:

require 'php-sdk/src/facebook.php';

$facebook = new Facebook(array(
  'appId'  => 'TU_APP_ID',
  'secret' => 'TU_APP_SECRET',
));

// Obtener ID de usuario
$user = $facebook->getUser();

Llamada a la API (Graph API):

if ($user) {
  try {
    // Procedemos sabiendo que tenemos un usuario que ha iniciado sesión y concedido permisos.
    $user_profile = $facebook->api('/me');
  } catch (FacebookApiException $e) {
    error_log($e);
    $user = null;
  }
}

Obtener URLs de inicio de sesión y de salida:

if ($user) {
  $logoutUrl = $facebook->getLogoutUrl();
} else {
  $loginUrl = $facebook->getLoginUrl();
}

Resumen

Este ha sido un post bastante extenso, al que le seguirán otros con distintos casos de uso. Por lo pronto, hemos visto que es posible implementar distintos tipos de aplicaciones para Facebook: para el móvil, para una página web, y empotradas en Facebook. Hemos revisado paso a paso el proceso de alta de una nueva aplicación, donde establecemos los parámetros básicos, el nombre, logo, descripción, etc. También hemos revisado todas las tecnologías que nos ofrece Facebook para desarrollar aplicaciones en su ecosistema: Social Plugins, Diálogos, Autenticación y permisos, Graph API y Open Graph. Por último, hemos repasado las distintas bibliotecas que nos da Facebook para facilitar el desarrollo de aplicaciones en JavaScript, PHP, iOS y Android, centrándonos en las dos primeras.

Ahora que conocemos bien todo marco de trabajo sobre el que se apoyan las aplicaciones en Facebook, estamos listos para comenzar. En el siguiente post realizaremos una pequeña aplicación que sirva como demo de todos estos conceptos.

En primer lugar, ¿qué diantres es un ORM? Viene de las siglas Object-relational mapping, que viene a traducirse como Mapeo objeto-relacional. En concreto es una técnica, o patrón arquitectónico, que permite comunicar dos sistemas distintos, típicamente una base de datos relacional con objetos de un lenguaje orientado a objetos, mediante un sistema que “mapea” (vincula) ambos sistemas. Mucha gente (yo mismo) ha creado a mano sus objetos mapeadores que, junto con objetos usando el patrón Active Record, daban un resultado muy similar a lo que un ORM nos ofrece. Pero oye, un ORM hace todo el trabajo sucio por nosotros

Existen ORMs para la mayoría de lenguajes de programación. Por ejemplo, en Java es muy popular Hibernate, en .NET se utiliza ADO.NET Entity Framework, y en PHP el más usado es Doctrine (hay más). Doctrine está inspirado en Hibernate.

Pero veamos algunas de las características que nos ofrece un ORM como Doctrine 2:

• Muy sencillo de configurar. De hecho, no es necesario mantener complejos ficheros de configuración XML.
• Tiene su propio dialecto de SQL, llamado DQL (Doctrine Query Language).
• Puede generar los modelos (las clases PHP que representan una fila de la BD) a partir de la base de datos. Sólo habría que definir las dependencias entre ellos
• Del mismo modo, también puede generar la base de datos a partir de los modelos.

¡Fantástico! Él puede crear las tablas, y las consultas por nosotros. Pero veamos ahora lo sencillo que es usarlo:

/* Código de inicialización ... */
$user = new User();
$user->name = "john";
$user->password = "doe";
$em->persist($user);
$em->flush();

Para que este código funcione sólo tenemos que hacer dos cosas:

1. Creamos el código de inicialización que cree el EntityManager $em. Es el objeto que en última instancia lleva a cabo las acciones.
2. Definimos las entidades (módulos) especificando en comentarios (o en XML o en YAML) cómo se relaciona con la base de dato

Vamos a ver cómo instalarlo y después haremos un ejemplo sencillo en SQLite.

Instalación

Si bien podemos instalarlo a mano descargándolo desde la página de Doctrine, para esta guía asumiré que se ha instalado con PEAR. Para ello tenemos primer que instalar el canal:

sudo pear channel-discover pear.doctrine-project.org

Y después instalamos el ORM:

sudo pear install pear.doctrine-project.org/DoctrineORM-2.0.1

Ahora lo tenemos instalado. Podemos probar a ejecutar su utilidad de línea de comandos, y nos mostrará esto:

$ doctrine
Doctrine Command Line Interface version 2.0.1
Usage:
[options] command [arguments]
Options:
--help           -h Display this help message.
--quiet          -q Do not output any message.
--verbose        -v Increase verbosity of messages.
--version        -V Display this program version.
--ansi           -a Force ANSI output.
--no-interaction -n Do not ask any interactive question.
Available commands:
help                         Displays help for a command (?)
list                         Lists commands
dbal
:import                      Import SQL file(s) directly to Database.
:run-sql                     Executes arbitrary SQL directly from the command line.
orm
:convert-d1-schema           Converts Doctrine 1.X schema into a Doctrine 2.X schema.
:convert-mapping             Convert mapping information between supported formats.
:ensure-production-settings  Verify that Doctrine is properly configured for a production environment.
:generate-entities           Generate entity classes and method stubs from your mapping information.
:generate-proxies            Generates proxy classes for entity classes.
:generate-repositories       Generate repository classes from your mapping information.
:run-dql                     Executes arbitrary DQL directly from the command line.
:validate-schema             Validate that the mapping files.
orm:clear-cache
:metadata                    Clear all metadata cache of the various cache drivers.
:query                       Clear all query cache of the various cache drivers.
:result                      Clear result cache of the various cache drivers.
orm:schema-tool
:create                      Processes the schema and either create it directly on EntityManager Storage Connection or generate the SQL output.
:drop                        Drop the complete database schema of EntityManager Storage Connection or generate the corresponding SQL output.
:update                      Processes the schema and either update the database schema of EntityManager Storage Connection or generate the SQL output.

Demo básica

Para este apartado, voy a utilizar una demo Sandbox (entorno de pruebas) prácticamente igual que la que usan en la documentación de Doctrine 2. En este artículo encontrarás el código de todos los ficheros necesarios. Además, al final del mismo encontrarás un enlace para poder descargarlo.

El proyecto consiste de sólo 4 ficheros:

• Entities/Users.php – Modelo de usuarios
• Entities/Address.php – Modelo de dirección
• cli-config.php – Fichero PHP que contiene el código de inicialización necesario para usar la utilidad en linea de comandos ‘doctrine’. Cada vez que usemos la utilidad ‘doctrine’, tendremos que tener este fichero.
• index.php – Código de inicialización típico de una aplicación web que utilice Doctrine 2.

Vamos a echar un vistazo a los ficheros. En primer lugar veamos cómo es el archivo cli-config.php:

<?php
// (1) Autocargamos clases
require_once 'Doctrine/Common/ClassLoader.php';
$classLoader = new \Doctrine\Common\ClassLoader('Doctrine');
$classLoader->register();
$classLoader = new \Doctrine\Common\ClassLoader('Entities', __DIR__);
$classLoader->register();
$classLoader = new \Doctrine\Common\ClassLoader('Proxies', __DIR__);
$classLoader->register();

// (2) Configuración
$config = new \Doctrine\ORM\Configuration();

// (3) Caché
$cache = new \Doctrine\Common\Cache\ArrayCache();
$config->setMetadataCacheImpl($cache);
$config->setQueryCacheImpl($cache);

// (4) Driver
$driverImpl = $config->newDefaultAnnotationDriver(array(__DIR__."/Entities"));
$config->setMetadataDriverImpl($driverImpl);

// (5) Proxies
$config->setProxyDir(__DIR__ . '/Proxies');
$config->setProxyNamespace('Proxies');

// (6) Conexión
$connectionOptions = array(
'driver' => 'pdo_sqlite',
'path' => 'database.sqlite'
);

// (7) EntityManager
$em = \Doctrine\ORM\EntityManager::create($connectionOptions, $config);

// (8) HelperSet
$helperSet = new \Symfony\Component\Console\Helper\HelperSet(array(
'db' => new \Doctrine\DBAL\Tools\Console\Helper\ConnectionHelper($em->getConnection()),
'em' => new \Doctrine\ORM\Tools\Console\Helper\EntityManagerHelper($em)
));

¡Que nadie se asuste! Realmente es un código muy sencillo, y prácticamente siempre se usará algo igual o muy parecido. Para superar el medio inicial, vamos a ver detalladamente qué es lo que ha pasado. El proceso de inicialización consta básicamente de dos pasos: Por una parte hay que asegurarse de que las clases de Doctrine pueden cargarse, y por otra hay que crear una instancia del Entity Manager. Siguiendo paso a paso:

1. En primer lugar autocargamos las clases necesarias (nota: para esto podríamos haber utilizado el autocargador de otro framework). En concreto autocargaremos 3 secciones:
   1. El propio Doctrine, que trae Common, DBAL, ORM y Symfony. Si lo hemos instalado con PEAR, podremos verlo en el directorio /usr/share/php/Doctrine.
   2. Entities, que es el directorio en el que almacenaremos nuestros modelos.
   3. Proxies, otro espacio que es necesario definir. Los proxies son subclases de nuestros modelos que el propio Doctrine crea automáticamente.
2. Una vez que nos hemos asegurado de que todas las clases pueden cargarse automáticamente, comenzamos a crear nuestro objeto EntityManager. Para ello, lo primero es crear un objeto de tipo Configuration.
3. El primer parámetro que vamos a configurar es la caché. Podríamos haber usado APC, el sistema de cachés de facto de PHP (aconsejable en un entorno en producción), pero para pruebas usaremos el método ArrayCache.
4. A continuación establecemos el driver con el que mapearemos nuestra base de datos. Esto es necesario para  hacer que nuestros modelos se correlacionen con nuestras bases de datos. Existen tres drivers disponibles:
   1. XML, desde donde se puede definir como encajar el modelo con la base de datos mediante sintaxis XML.
   2. YAML, al igual que con XML, también se puede definir utilizando YAML.
   3. Anotaciones, que en mi opinión son una maravilla. Mediante etiquetas en comentarios PHP defines cómo se mapean los datos. Más abajo, cuando lleguemos a los modelos, veremos un ejemplo de uso.
5. Ahora configuramos los proxies. Simplemente establecemos su directorio, y su espacio de nombres.
6. Conexión. Es aquí donde establecemos dónde se se encuentra nuestra base de datos. Si ésta no existiera, Doctrine la crearía por nosotros. En nuestro ejemplo usaremos SQLite.
7. Ya está todo listo: hemos configurado la Caché, el Driver para mapear, los proxies y la conexión. Ya podemos crear el objeto EntityManager.
8. Por último, creamos un objeto de tipo HelperSet, que es el que utilizará la utilidad de línea de comandos para saber cómo conectarse. El objeto HelperSet debe tener dos helpers: db, para identificar la conexión, y em, el EntityManager.

Ya tenemos listo el fichero cli-config.php, que como dijimos, es el que se utiliza para conectar la utilidad de consola ‘doctrine’ con nuestro proyecto.

Ahora vamos a ver los modelos.

Entities/Adress.php

<?php
namespace Entities;

/** @Entity @Table(name="addresses") */
class Address
{
   /**
    * @Id @Column(type="integer")
    * @GeneratedValue(strategy="AUTO")
    */
   private $id;

   /** @Column(type="string", length=255) */
   private $street;

   /** @OneToOne(targetEntity="User", mappedBy="address") */
   private $user;

   public function getId()
   {
      return $this->id;
   }

   public function getStreet()
   {
      return $this->street;
   }

   public function setStreet($street)
   {
      $this->street = $street;
   }

   public function getUser()
   {
      return $this->user;
   }

   public function setUser(User $user)
   {
      if ($this->user !== $user) {
         $this->user = $user;
         $user->setAddress($this);
      }
   }
}

Entities/User.php

<?php
namespace Entities;

/** @Entity @Table(name="users") */
class User
{
   /**
    * @Id @Column(type="integer")
    * @GeneratedValue(strategy="AUTO")
    */
   private $id;

   /** @Column(type="string", length=50) */
   private $name;

   /**
    * @OneToOne(targetEntity="Address", inversedBy="user")
    * @JoinColumn(name="address_id", referencedColumnName="id")
    */
   private $address;

   public function getId()
   {
      return $this->id;
   }

   public function getName()
   {
      return $this->name;
   }

   public function setName($name)
   {
      $this->name = $name;
   }

   public function getAddress()
   {
      return $this->address;
   }

   public function setAddress(Address $address)
   {
      if ($this->address !== $address) {
         $this->address = $address;
         $address->setUser($this);
      }
   }
}

No me detendré a explicar cómo se definen los modelos. En la propia documentación de Doctrine puedes ver una introducción al mapeo. Lo importante aquí es que, mediante etiquetas en los comentarios, hemos definido la relación entre la entidad User y la entidad Address, y también hemos definido cada una de sus columnas (¡hasta podemos indicar que una columna sea autoincremental!).

Llegados a este punto, tenemos 3 ficheros ya creados: cli-config.php, Entity/User.php y Entity/Address.php. Desde el raíz de nuestro proyecto vamos a ejecutar lo siguiente:

$ doctrine orm:schema-tool:create

Si todo ha ido bien, nos saldrá un mensaje indicándonos que el esquema de base de datos se ha creado correctamente. Y si comprobamos el directorio, veremos que se ha creado un nuevo fichero, database.sqlite, que contiene la definición de nuestras dos tablas.

Usándolo en una aplicación web

Bien, ya hemos definido las entidades, hemos creado la base de datos, y sabemos cómo funciona el código de inicialización de Doctrine 2. Ahora vamos a ver el fichero index.php:

<?php

// (1) Autocargamos clases
require_once 'Doctrine/Common/ClassLoader.php';
$classLoader = new \Doctrine\Common\ClassLoader('Doctrine');
$classLoader->register();
$classLoader = new \Doctrine\Common\ClassLoader('Entities', __DIR__);
$classLoader->register();
$classLoader = new \Doctrine\Common\ClassLoader('Proxies', __DIR__);
$classLoader->register();

// (2) Configuración
$config = new \Doctrine\ORM\Configuration();

// (3) Caché
$cache = new \Doctrine\Common\Cache\ArrayCache();
$config->setMetadataCacheImpl($cache);
$config->setQueryCacheImpl($cache);

// (4) Driver
$driverImpl = $config->newDefaultAnnotationDriver(array(__DIR__."/Entities"));
$config->setMetadataDriverImpl($driverImpl);

// (5) Proxies
$config->setProxyDir(__DIR__ . '/Proxies');
$config->setProxyNamespace('Proxies');

// (6) Conexión
$connectionOptions = array(
    'driver' => 'pdo_sqlite',
    'path' => 'database.sqlite'
);

// (7) EntityManager
$em = \Doctrine\ORM\EntityManager::create($connectionOptions, $config);

// (8) Código de prueba
$user = new \Entities\User();
$address = new \Entities\Address();

echo 'Hola mundo!' . PHP_EOL;

// Introduce aquí el código que maneje $user y $address

Si nos fijamos, los 7 primeros puntos son exactamente iguales que en cli-config.php. En el punto 8 creamos dos objetos de nuestro modelo, ya listos para usar. ¡Pero cuidado! Antes de poder hacer cambios en la base de datos SQLite, debes asegúrate de que el usuario de tu servidor web tiene permisos de escritura en el fichero database.sqlite. Ahora podríamos añadir el siguiente código de ejemplo:

$address->setStreet("Calle Río tinto, 12");
$em->persist($address);
$em->flush();

echo "Insertamos dirección<br />" . PHP_EOL;

$user->setName("Pedro");
$user->setAddress($address);
$em->persist($user);
$em->flush();

echo "Insertamos usuario<br />" . PHP_EOL;

Simplemente tenemos que acceder desde nuestro navegador a ese fichero (o también mediante “php index.php”) para que PHP ejecute el código. Una vez hecho, podemos consultar la base de datos mediante sqlite3:

$ sqlite3 database.sqlite
SQLite version 3.6.22
Enter ".help" for instructions
Enter SQL statements terminated with a ";"
sqlite> select * from addresses;
1|Calle Río tinto, 12
sqlite> select * from users;
1|1|Pedro

¡Lo ha hecho todo él sólo por nosotros! Así de sencillo resulta trabajar con bases de datos con un ORM A partir de aquí empieza lo bueno: ya puedes guardar tus objetos de forma persistente en base de datos, sin tener preocuparte ni por crear las tablas, ni por SQL, ni nada. Céntrate en PHP

¡Gracias por leer!

Descargar el código fuente

En este ejemplo vamos a suponer que queremos limitar la velocidad de descarga a 5kB/s. Para ello utilizaremos la extensión HTTP de pecl, en concreto la magia reside en la función http_throttle. Esta función recibe dos parámetros:

1. número de segundos entre cada envío de bloques de datos.
2. tamaño en bytes de cada bloque de datos.

De este modo, si le decimos que cada bloque de datos tenga un tamaño de 5000 bytes, y que entre cada petición debe transcurrir un segundo, conseguiremos que las descargas se realicen a 5kB/s. Realmente no es una velocidad estable, pero tiene muy pocas oscilaciones, la mayoría debidas a la conexión más que al servidor. Este es el código de ejemplo:

<?php
   http_throttle(1, 5000);
   http_send_content_type('application/pdf');
   http_send_content_disposition('test.pdf');
   http_send_file('test.pdf');
?>

Como veis, únicamente establecemos la velocidad, las cabeceras para que el navegador sepa cómo manejar la petición, y finalmente mandamos un fichero de prueba llamado test.pdf que se encuentra en el directorio de trabajo actual.

El único problema está en la disponibilidad de la extensión HTTP. No creo que muchos servicios de alojamiento la tengan activada, aunque siempre se les puede pedir que lo instalen. Si quieres saber cómo hacerlo, simplemente tienes que hacer lo siguiente (en sistemas debian):

$ sudo pecl install http_pecl

Si te devolviera un código de error, quizás sea porque no tienes instaladas las herramientas de desarrollo de PHP, o alguna de las bibliotecas necesarias para compilar esta extensión. Tendrás que hacer lo siguiente:

$ sudo aptitude install php5-dev
$ sudo aptitude install libcurl3-openssl-dev

Ahora ya podrás compilarla. Sólo queda activarla en tu fichero php.ini. Añade esta línea:

extension=http.so

Y reinicia Apache con

$ sudo /etc/init.d/apache2 restart

Nota: Toda esta información está disponible en el manual de documentación de PHP.

1. Ejecutar un script

Podemos crearnos nuestros propios programas simplemente creando un fichero .php y ejecutándolo con el binario CLI php. Por ejemplo:

<?php
   echo "hola mundo!\n";
?>

Y ahora para ejecutarlo sólo tendríamos que llamar al binario php (php.exe en Windows) seguido del nombre del script. Supongamos que el ejemplo de arriba lo guardamos en un fichero que se llama test.php. Sería así:

$ php test.php

Y en sistemas Windows:

> php.exe test.php

De esta forma, los dos mostrarían en pantalla el texto “hola mundo!”. Fácil, verdad?

2. Hacer que el script se sea ejecutable

En Windows tendremos que asociar la extensión .php al binario php.exe. De esa forma, al hacer doble clic sobre un fichero, este se ejecutará. Sin embargo, si quisiéramos que se pudiera ejecutar desde la consola, tendríamos que crear un fichero por lotes .bat que realice la llamada.

@echo OFF
"C:\php\php.exe" test.php

En sistemas Unix es más sencillo. Tenemos que añadir en la primera línea la ruta al binario que ejecuta el script, y posteriormente otorgamos permisos de ejecución al fichero. Y ya está, ya es ejecutable desde la consola y desde el entorno gráfico. El fichero quedaría así:

#!/usr/bin/php
<?php
   echo "hola mundo!\n";
?>

Y después damos permisos de ejecución, y ya podremos ejecutarlo:

$ chmod +x test.php
$ ./test.php

3. Pasar parámetros al programa

Supongamos un comando cualquier de la consola, por ejemplo “ls”. Este comando acepta numerosos parámetros para controlar su comportamiento. En PHP también podemos pasar parámetros. Sólo tenemos que tener en cuenta una cosa: Si el script no tiene permisos de ejecución, hay que pasar los parámetros tras los caracteres “–”. Es así para prevenir que el binario php los considere parámetros suyos. Veamos un ejemplo de cómo hacerlo:

$ php test.php — parametro1 parametro2
$ ./test.php parametro1 parametro2

En el primer ejemplo ejecutamos el binario php y le pasamos como parámetro el nombre del script, por lo que en este caso añadimos los caracteres “–”. En cambio, en el segundo no es necesario, ya que el script tiene permisos de ejecución.

En sistemas Windows, como vimos arriba, habría que crear un fichero por lotes .bat, que para que pasara los parámetros a nuestro script quedaría así:

@echo OFF
"C:\php\php.exe" test.php %*

Bien, ya sabemos cómo enviar parámetros al script. Sólo nos queda saber cómo manejarlos. Pues muy sencillo. Hay dos variables globales para manejarlos:

1. $argc – Contiene el número de parámetros que recibe el script
2. $argv – Es un array con los parámetros en sí

4. Usar PHP en como consola interactiva

Al igual que ocurre con Python, PHP también puede ejecutarse en modo interactivo. Esto es, introducimos a mano los comandos en una “consola PHP”, y ésta los ejecuta al vuelo. Sólo hay que poner el parámetro “-a”. Por ejemplo:

$ php -a
Interactive shell

php > echo 5+8;
13
php > function sumarDos($n)
php > {
php { return $n + 2;
php { }
php > var_dump(sumarDos(2));
int(4)
php >

Además, pulsando el botón tabulador, tendrás autocompletado de variables, funciones, clases, constantes, método estáticos y constantes de clases.

5. Ejecutar una línea de código PHP al momento

Podemos ejecutar el código que queramos usando el modificador “-r”. Imaginemos que queremos aplicar un hash md5 a un fichero de texto, y no tenemos en nuestro sistema el comando md5sum. Podríamos hacer lo siguiente:

php -r 'echo md5(file_get_contents("fichero.txt"));'

Lo que hacemos es ejecutar los comandos que hay entre las comillas simples:

1. Cargamos el contenido de ‘fichero.txt’.
2. Le aplicamos el hash md5.
3. Lo mostramos en pantalla.

¡Qué de cosas se pueden hacer con esto!

6. Pasar contenidos a PHP por tuberías

Muchas veces vemos comandos como:

echo "hola mundo" | wc -c

En este sencillo ejemplo lo que hemos hecho es en la salida estándar el texto “hola mundo”, que a su vez se envía a la entrada estándar del comando “wc -c”, que se encarga de contar el número de caracteres. ¿Cómo hacemos esto en PHP? Consultando la entrada estándar. En la versión CLI de PHP ponen a nuestra disposición 3 útiles constantes:

1. STDIN – Stream a la entrada estándar.
2. STDOUT – Stream a la salida estándar.
3. STDERR – Stream a la salida de errores.

Si quisiéramos contar el número de caracteres del texto recibido por la entrada estándar en PHP, podríamos hacer lo siguiente:

echo "hola mundo" | php -r 'echo strlen(fgets(STDIN));'

7. Mostrar un fichero PHP sin comentarios ni espacios

¿Nunca te has preguntado cuántos caracteres útiles tiene un gran proyecto? Con el modificador “-w” puedes verlo, pues eliminará todos los caracteres en blanco innecesarios (incluidos tabulares, retornos de carro, cambios de línea, etc), y todos los comentarios. Además, también podrás así minimizar el tamaño de los ficheros. Por ejemplo:

$ php -w fichero.php

8. Consultar documentación desde la consola

Supón que deseas conocer los parámetros de una función, o los métodos de una clase… Puedes consultarlo desde la consola, siempre y cuando tu versión de PHP esté compilada con la extensión Reflection. Esta familia de modificadores nos da 4 opciones:

1. “–rf” – Muestra información de una función o de un método de una clase.
2. “–rc” – Muestra información de una clase (sus métodos, atributos, constantes…).
3. “–re” – Muestra información de una extensión (directivas .ini, funciones, constantes, clases, etc).
4. “–ri” – Muestra información sobre la configuración de una extensión. Esto es, lo mismo que devuelve phpinfo() para cada extensión. Si queremos ver la información general, usaremos “main” como nombre de extensión.

Veamos un ejemplo en el que consultamos información de la función md5():

$ php --rf md5
Function [ <internal:standard> function md5 ] {
  - Parameters [2] {
    Parameter #0 [ <required> $str ]
    Parameter #1 [ <optional> $raw_output ]
  }
}

Una opción estupenda cuando no tenemos acceso a internet, ni nos hemos descargado la documentación de PHP a nuestro equipo.

9. Decorar la sintaxis de nuestro código

PHP nos ofrece una forma sencillísima de generar una versión HTML de nuestro código, coloreando y destacando cada parte. Sólo tendremos que ejecutarlo con el modificador “-w”. Una vez hecho esto, podremos exportarla al formato que queramos (PDF, Word, XHTML, etc). Muy útil cuando queremos imprimir un código fuente.

$ php -w fichero.php

Además, al estar disponible desde el propio binario de php, es muy fácil generar una versión HTML coloreada de cada fichero.

10. La joya de la corona: definir código inicial, final, y para cada línea

Si no tenías suficiente con sed o awk, ahora con PHP vas a poder hacer maravillas. Tenemos estos cuatro modificadores:

1. “-B” – Código PHP a ejecutar antes que todo lo demás.
2. “-F” – Código PHP a ejecutar cuando finalice todo lo demás.
3. “-R” – Código PHP a ejecutar por cada línea. Tendremos $argn con la línea que se está procesando, y $argi con el número de línea.
4. “-F” – Fichero con el código PHP a ejecutar por cada línea.

Veamos un ejemplo muy didáctico y muy poco útil de la documentación de PHP. Supongamos que queremos contar el número de líneas de un proyecto. Accedemos a su directorio y ejecutamos lo siguiente:

$ find . | php -B '$lineas=0;' -R '$lineas += count(@file($argn));' -E 'echo "Total de líneas: $lineas\n";'

Veámoslo paso a paso:

1. En primer lugar ejecutamos el comando “find” de la consola de Linux. Nos mostrará (recursivamente) todos los ficheros del directorio actual.
2. El resultado se lo pasamos por la entrada estándar al binario php, el cual realiza lo siguiente:
   1. En el modificador “-B” especificamos el código inicial. Simplemente inicializamos la variable $lineas a cero.
   2. En el modificador “-R” decimos lo que se hará por cada línea recibida por la entrada estándar. En este caso, cada línea se corresponde con la ruta a un fichero:
      1. Como vimos arriba, $argn contiene el texto que se está procesando. Contiene la ruta a un fichero
      2. Pasamos esa ruta a la función file(), que genera un array donde cada índice contiene una fila del fichero leído.
      3. Consultamos el tamaño del array, es decir, el número de líneas del fichero.
      4. Incrementamos la variable $lineas con el valor obtenido en el paso anterior.
   3. Finalmente, el modificador ‘-E’ se ejecuta al finalizar todo lo demás, y nos muestra como resultado el número total de líneas de texto que hay en todos los ficheros de la carpeta actual.

Sencillísimo y muy potente. Lo que más complicado puede resultar es recordar los 3 modificadores (B,F,R) y las dos variables ($argn y $argi).

Pensando en qué puedo y qué me apetece aportar, llegué a la conclusión de que el proyecto adecuado era PHP. No en vano es el proyecto de software libre que me da de comer Si Apache no existiera podría utilizar lighttpd. Si Linux no existiera me instalaría algún BSD. Si MySQL tampoco existiera, mi gestor de bases de datos probablemente sería postgresql. Sin Joomla! utilizaría Drupal. Sin Zend Framework usaría Codeigniter.

Y sin PHP… ¿¡qué haría yo sin PHP!? ¿Usar Python? Sí, pero noslomismo… A PHP le tengo un cariño especial. Mi primera página web la hice ya en PHP, en el año 2003, y desde entonces no he parado de aprender.

Bien, el proyecto ya está elegido. Ahora, ¿qué puedo hacer yo por PHP? Ya quisiera yo tener nivel para poder aportar algo al core de PHP. Hoy por hoy donde creo que puedo ser más útil es traduciendo la documentación a español. De modo que me puse en contacto con Yago (yago[arroba]php.net), quien amablemente me indicó los pasos a seguir para formar parte del equipo de traducción.

Tras un breve training, consistente en traducir un par de documentos y emplear la herramienta oficial de traducción, ya estoy dentro. ¡Y muy ilusionado!

Por ahora ya he detectado unas cuantas ventajas:

• Es agradecido ver que tu trabajo puede ayudar a otras personas.
• Devuelves parte del favor que otros te han hecho al usar software libre.
• Aprendes a trabajar en proyectos libres.
• Puedes fardar de tener una cuenta @php.net (chuso[arroba]php.net).
• En muchas empresas valoran que participes en proyectos libres.
• Y lo más importante en mi opinión: Es una forma sensacional de no parar de aprender nuevas cosas de PHP.

¿Alguien más se anima? Actualmente la documentación española es la tercera más traducida, lejos de la japonesa y la francesa. ¡Toda ayuda será bienvenida!

Tipos de datos en PHP

PHP en concreto soporta los siguientes tipos:

• Escalares
  • booleano
  • integer
  • float (o double).
  • string
• Compuestos
  • Array
  • Object
• Especiales
  • resource
  • NULL

Si en un momento dado quisiéramos mostrar el tipo de una variable, podemos utilizar la función gettype(). Por ejemplo:

<?php
   $a = 'hola';
   $b = 42;
   $c = true;

   echo gettype($a); // Devuelve: string
   echo gettype($b); // Devuelve: integer
   echo gettype($c); // Devuelve: boolean
?>

Para comprobar si una variable es de un tipo determinado usaríamos is_type(), por ejemplo, is_integer($a).

Por otra parte, si lo que quisiéramos es mostrar tanto el tipo como el valor de una variable, utilizaríamos la función var_dump().

Además, al ser PHP un lenguaje de tipado dinámico, podemos forzar en tiempo de ejecución la conversión de un tipo a otro, técnica conocida como casting. Para ello podemos utilizar dos métodos: (1) O bien utilizado un cast, (2) o bien mediante la función settype().

A todo esto, hay que sumarle que PHP también puede cambiar el tipo de una variable en tiempo de ejecución dependiendo de su contexto. Por ejemplo, si a un string le sumamos un entero, PHP convertirá al string en entero en tiempo de ejecución. Esto puede desencadenar en comportamientos inesperados.

Como nota curiosa… Hace poco, en una entrevista de trabajo, me hicieron una pregunta. Si mal no recuerdo era algo tal que así: Si tenemos una variable a la que le asignamos la cadena “abc123″, y la comparamos con el operador == con el entero 0, ¿qué devuelve? La respuesta, aunque sorprendente, es que el resultado es true. Esto se debe a que PHP detecta que en este contexto la cadena debe comportarse como un entero, por lo que convierte “abc123″ en un número: 0. ¿Es 0 igual a 0? Sí, por tanto el resultado el true.

zval

Pero volvamos a las variables. ¿Cómo se almacenan internamente? Cada una de ellas se almacena en un contenedor llamado ‘zval’. Un contenedor zval tiene:

1. Tipo de la variable. Como hemos visto, PHP tiene 8 tipos primitivos de datos.
2. Valor de la variable. Esto es, el valor que le hemos asignado.
3. refcount. Campo numérico que lleva la cuenta del número de variables que utilizan este contenedor.
4. is_ref. Se trata de un booleano que indica si la variable está accedida por referencia.

Los dos primeros campos están bastante claros, de modo que centrémonos en los dos últimos.

refcount

Hemos visto que el campo refcount lleva la cuenta de las variables que utilizan un determinado zval. Veámoslo con un ejemplo.

<?php
   $a = "test";
   xdebug_debug_zval($a);
   // a: (refcount=1, is_ref=0)='test'
?>

Nota: Para poder consultar el zval de una variable, tan sólo debemos llamar a la función xdebug_debug_zval() de la extensión Xdebug para PHP.

Vemos que el campo refcount está a 1, es decir, sólo hay una variable que utilice este contenedor.

Veamos un ejemplo más avanzado:

<?php
   $a = 'test';
   $b = $a;
   xdebug_debug_zval( 'a' );
   // a: (refcount=2, is_ref=0)='test'

   $b += 'ing';
   xdebug_debug_zval( 'a' );
   // a: (refcount=1, is_ref=0)='test'
?>

¿Qué ha pasado ahora? Vayamos paso a paso. En un primer lugar, creamos la variable $a a la que asignamos el valor ‘test’. Posteriormente creamos otra variable, $b, a la que le copiamos el mismo contenido que tiene $a. Al mostrar el zval de $a vemos que el valor refcount tiene ahora un 2. Esto es porque este contenedor zval está siendo utilizado por dos variables: $a y $b. Nótese que anteriormente he resaltado el verbo copiar, pues $b es una variable distinta a $a. Pero si son dos variables distintas, ¿por qué utilizan el mismo contenedor? Porque PHP es muy inteligente Al tener las dos variables el mismo valor, hace que utilicen el mismo contenedor para ahorrar espacio en memoria. ¿Pero qué ocurre si modificamos ahora una de ellas? En el siguiente paso vemos cómo modificamos $b, añadiéndole el sufijo ‘ing’. PHP, que como digo es muy inteligente, ve que ya no tienen el mismo valor $a y $b, por lo que, ahora sí, crea un nuevo espacio en memoria para $b. Por esa razón si ahora vemos el zval de $a comprobaremos que su refcount está a 1.

Este valor es muy útil para la gestión de memoria de PHP. Este lenguaje, a diferencia de otros, contiene un recolector de basura, un proceso que se encarga de liberar la memoria de las variables y objetos que no se van a volver a usar. De este modo, el propio lenguaje se encarga por nosotros de limpiar la memoria. Por supuesto, el recolector de basura liberará todos los contenedores zval cuyo refcount esté a 0, pues significa que no están siendo utilizados por ninguna variable.

En cualquier momento podemos, además, forzar la eliminación de una variable, llamando a la función unset(). Ésta lo que hace es decrementar el valo refcount. Y como hemos visto, si llega a 0, se eliminará por completo el zval correspondiente.

is_ref

Si alguna vez has programado en C, sabrás bien lo que son los punteros: Se trata de variables cuyo valor es una dirección de memoria física, de modo que únicamente apuntan al lugar donde se encuentra su valor. Esto es muy útil para, por ejemplo, hacer que varias variables sean en realidad la misma. O para pasar a una función una variable, y que la función pueda modificar el valor de ésta. Esto es posible en PHP utilizando referencias.

Nota: A partir de PHP5 cada vez que pasas un objeto a una función o método, éste se pasa siempre por referencia. Es decir, las modificaciones que se hagan de un objeto dentro de una función persistirán fuera de ésta.

Veamos dos ejemplos para comprender que son las variables por referencia:

<?php
   $a = 'hello';
   $b = $a;
   echo $b; // Muestra 'test';
   $b = 'ciao';
   echo $a; // Muestra 'test';
   echo $b; // Muestra 'ciao';
?>

Simplemente copiamos a $b el valor de $a. Posteriormente modificamos $b, y comprobamos cómo sólo ha cambiado éste, pero no $a. El siguiente ejemplo es prácticamente igual, salvo que en lugar de copiar $a a $b, copiamos por referencia:

<?php
   $a = 'hello';
   $b =& $a;
   echo $b; // Muestra 'test';
   $b = 'ciao';
   echo $a; // Muestra 'ciao';
   echo $b; // Muestra 'ciao';
?>

En este caso, al haber usado el operador =&, hemos hecho que $b sea en realidad la misma variable que $a. Y aquí es donde volvemos con zval. ¿Qué contiene ahora? Comprobémoslo:

a: (refcount=2, is_ref=1)='ciao'

¡Y ahí lo tenemos! Ahora el campo is_ref tiene valor true (1). Esto es porque, como hemos visto, este zval está siendo también apuntado por una variable por referencia. Además podemos comprobar cómo el refcount se ha incrementado a 2.

zval en tipos compuestos

Hasta ahora hemos visto ejemplos de zval en variables escalares. Vamos a ver un ejemplo de qué se almacena cuando es un tipo compuesto, como por ejemplo un array:

<?php
   $a = array('foo' => 'bar', 'gen' => 'oma');
   xdebug_debug_zval('a');
?>

Y esto es lo que obtenemos:

a: (refcount=1, is_ref=0)=array (
‘foo’ => (refcount=1, is_ref=0)=’bar’,
‘gen’ => (refcount=1, is_ref=0)=’oma’
)

¡Curioso! Un array lo que hace es crear una nueva tabla, distinta de la global, de valores zval. Pero la cosa se puede complicar bastante. Para terminar, vamos a ver el siguiente ejemplo extraído de la documentación de PHP:

<?php
   $a = array( 'one' );
   $a[] =& $a;
   xdebug_debug_zval( 'a' );
?>

Creamos un array con un solo elemento. Posteriormente creamos un segundo campo en el que asignamos una referencia circular al propio array. Obtenemos el siguiente resultado:

a: (refcount=2, is_ref=1)=array (
   0 => (refcount=1, is_ref=0)='one',
   1 => (refcount=2, is_ref=1)=...
)

Supongamos que ahora hacemos una llamada a unset($a). El resultado esperado sería que se eliminara por completo de memoria el zval anterior. ¿Pero es esto lo que realmente ocurre? Como explicamos anteriormente, mediante unset() lo que hacemos es decrementar el refcount. Pero en este caso, tras llamar a unset() quedaría el siguiente zval huérfano sin ser eliminado de memoria pues su refcount vale 1:

(refcount=1, is_ref=1)=array (
   0 => (refcount=1, is_ref=0)='one',
   1 => (refcount=1, is_ref=1)=...
)

No se elimina puesto que el item 1 del array sigue apuntando al propio array. Y al no haber ningún símbolo externo apuntando a este zval, no existe ningún mecanismo que nos permita liberar esta memoria, obteniendo un memory leak. Afortunadamente, desde PHP 5.3, esta memoria se libera automáticamente al finalizar la petición. Pero hasta entonces, sigue ocupando memoria, lo cual puede ser un problema en procesos de larga duración como por ejemplo un demonio.

Resumen

En este artículo hemos pasado de lo más elemental, hasta conocer cómo se almacenan las variables internamente en PHP, y sus mecanismos de control. Conocemos los 8 típos primitivos de PHP, y cómo trabajar entre ellos. Sabemos qué es el campo refcount, lo que son los valores por referencia, el campo is_ref, y cómo afectan éstos al recolector de basuras. Del mismo modo, hemos visto cómo hay situaciones que pueden escapar a nuestro control, donde la memoria no queda libre a pesar de haber finalizado una variable.

Para más información podéis consultar:

• Guía de PHP sobre el funcionamiento de refcount y cómo afecta al recolector de basuras en php.net
• Información sobre el algoritmo de recolección de basuras de PHP en php.net
• Guía de los tipos soportados por PHP en php.net
• Otra guía introductoria a variables, referencias, y zval en porteighveight.com
• Valores por referencia en php.net
• Un curioso comportamiento inesperado en bucles foreach y referencias en schlueters.de
• Interesante artículo sobre por qué no usar referencias en PHP en schlueters.de

• Arquitectura basada en Modelo-Vista-Controlador.
• Seguridad, con un completo sistema de perfiles de acceso.
• Acceso a base de datos.
• Sistema de cachés.
• Gestión de errores.
• Administración de formularios.
• Sesiones.
• Plantillas.
• Utilidades para fechas, criptografía, XML, ficheros…

Con todo esto, podemos crear diferentes extensiones de Joomla!:

• Component. Son las extensiones más complejas. Se trata de aplicaciones completas que se ejecutan dentro del espacio de Joomla!. Tenemos muchas de serie, como por ejemplo el componente Content (/components/com_content/), que es el encargado de manejar los artículos, categorías y secciones.
• Module. Se trata de pequeñas piezas de contenido que se muestran en la página. A menudo, dependen de un componente, como es el caso del módulo “latest news” (/modules/mod_latestnews/). Otro ejemplo de módulos, son los menús. En los módulos, además, se debe especificar su posición dentro de la página.
• Plugins. Son bloques de código que se disparan ante determinados eventos. Antes de Joomla! 1.5 se los llamaba Mambots.
• Templates. Plantillas que modifican el aspecto visual de la aplicación web.
• Languages. Las extensiones de este tipo contienen ficheros que definen cadenas de texto traducidas para distintas partes de Joomla!.

A partir de Joomla 1.6, además, tendremos dos nuevos tipos de extensiones. Library, que se tratará de un bloque de código que contenta un conjunto de funciones relacionadas entre sí. Por ejemplo, para acceder a la API de Twitter. Y también se incluirá la extensión Packages.

Como vemos, la extensión más compleja y flexible son los components. Con ellos podremos crear, por ejemplo, una completa agenda de eventos o un sistema de ecommerce. Veamos cómo podemos crear un componente básico “Hola Mundo”. Vamos a utilizar la primera parte del ejemplo que viene en la documentación de Joomla!.

Modelo Vista Controlador

Lo primero es conocer el patrón Modelo-Vista-Controlador. Queda fuera del alcance de este artículo explicar en qué consiste, de modo que en resumen diremos que se trata de una arquitectura que permite dividir una aplicaciones en tres apartados:

1. Controlador, que es el que gobierna el comportamiento principal, y el que responde las peticiones del usuario. En Joomla: JController.
2. Vista. Se trata del código que se encarga de generar el contenido que se le devolverá al usuario. Generalmente en HTML. En Joomla: JView.
3. Modelo. Es una abstracción de los datos que usa la aplicación. Si bien normalmente encapsulan bases de datos, también pueden utilizar otros origines de datos como un feed RSS. En Joomla: JModel.

Crear árbol de directorios

El primer paso consiste en crear el siguiente árbol de directorio y ficheros:

Además de los ficheros en blanco index.html (Para prevenir accesos a los directorios), vemos que tenemos 5 ficheros:

1. /site/hello.php – Punto de entrara a nuestro componente
2. /site/controller.php – Fichero que contiene nuestro controlador.
3. /site/views/hello/view.html.php – Clase que extiende JView que se encarga de construir la vista
4. /site/views/hello/tmpl/default.php – Plantilla
5. /hello.xml – Fichero XML que indica a Joomla! cómo instalar el componente.

Crear el punto de entrada

Vamos a editar el fichero /site/hello.php y vamos a guardar en el lo siguiente:

/**
 * @package    Joomla.Tutorials
 * @subpackage Components
 * components/com_hello/hello.php
 * @link http://docs.joomla.org/Developing_a_Model-View-Controller_Component_-_Part_2
 * @license    GNU/GPL
 */

// No direct access
defined( '_JEXEC' ) or die( 'Restricted access' );

// Require the base controller

require_once( JPATH_COMPONENT.DS.'controller.php' );

// Require specific controller if requested
if ($controller = JRequest::getWord('controller')) {
	$path = JPATH_COMPONENT.DS.'controllers'.DS.$controller.'.php';
	if (file_exists($path)) {
		require_once $path;
	} else {
		$controller = '';
	}
}

// Create the controller
$classname	= 'HelloController'.$controller;
$controller	= new $classname();

// Perform the Request task
$controller->execute( JRequest::getVar( 'task' ) );

// Redirect if set by the controller
$controller->redirect();

¿Qué es lo que hemos hecho? Veámoslo paso a paso:

1. En primer lugar comprobamos que estamos ejecutando éste código dentro de Joomla mirando si está definido _JEXEC. En caso contrario, finalizamos la aplicación.
2. Cargamos con require_once nuestro controlador.
3. El siguiente bloque de código comprueba si se necesitan más controladores. Por ahora no es necesario, pero lo mantenemos ahí para un futuro.
4. Después, creamos el controlador. En este caso, siempre se creará un controlador de la clase HelloController(), dado que en este ejemplo, como vimos en el paso anterior, no hay más.
5. Posteriormente indicamos al controlador que lleve a cabo la tarea solicitada. Por defecto, si no hay ninguna, la tarea es ‘display’.
6. Finalmente, pasamos el control al controlador, para que, si fuera necesario, lleve a cabo una redirección.

Creamos el controlador

Nuestro controlador sólo hace una cosa: Mostrar el mensaje Hello World, de modo que no se hace necesaria ninguna manipulación de datos. Guardamos el siguiente código en /site/controller.php

 /**
 * @package    Joomla.Tutorials
 * @subpackage Components
 * @link http://docs.joomla.org/Developing_a_Model-View-Controller_Component_-_Part_1
 * @license    GNU/GPL
 */

// No direct access

defined( '_JEXEC' ) or die( 'Restricted access' );

jimport('joomla.application.component.controller');

/**
 * Hello World Component Controller
 *
 * @package    Joomla.Tutorials
 * @subpackage Components
 */
class HelloController extends JController
{
    /**
     * Method to display the view
     *
     * @access    public
     */
    function display()
    {
        parent::display();
    }

}

Como vemos, creamos una clase llamada HelloController que hereda a JController. Tan sólo define el método display(), pues es la tarea por defecto (Salvo que no se especifique otra). Este método tan sólo invoca al método JController::display(), que determina y carga la vista y plantilla a utilizar. En nuestro ejemplo, sólo tenemos una vista y una plantilla.

Crear la vista

La vista tan sólo carga datos y los guarda para usar en la plantilla. Para ello se usa el método assignRef(), donde el primer parámetro es el nombre de la variable en la plantilla, y el segundo la variable que se comparte.

Código de /site/views/hello/view.html.php:

/**
 * @package    Joomla.Tutorials
 * @subpackage Components
 * @link http://docs.joomla.org/Developing_a_Model-View-Controller_Component_-_Part_1
 * @license    GNU/GPL
*/

// no direct access

defined( '_JEXEC' ) or die( 'Restricted access' );

jimport( 'joomla.application.component.view');

/**
 * HTML View class for the HelloWorld Component
 *
 * @package    HelloWorld
 */

class HelloViewHello extends JView
{
    function display($tpl = null)
    {
        $greeting = "Hello World!";
        $this->assignRef( 'greeting', $greeting );

        parent::display($tpl);
    }
}

Y ahora definimos el código de la plantilla en /site/views/hello/tmpl/default.php:

<?php

// No direct access

defined('_JEXEC') or die('Restricted access'); ?>
<?php echo $this->greeting; ?>

Se trata de un fichero PHP convencional en el que tenemos accesibles todas las variables que hemos compartido desde la vista.

Juntándolo todo

Nos queda definir el fichero Manifiest que define el componente para poder instalarlo fácilmente (Sin tener que copiar los ficheros a mano y actualizar la base de datos nosotros). Contiene distinta información, como por ejemplo:

• Descripción del componente.
• Lista de ficheros que incluye.
• Un fichero opcional PHP que realizar tareas de instalación.
• Un fichero opcional SQL que se ejecuta al instalar o desinstalar

 Hello
 
 2007-02-22
 John Doe
 john.doe@example.org
 http://www.example.org
 Copyright Info
License Info
 
 1.01
 
 Description of the component ...

 
 
 
  controller.php
  hello.php
  index.html
  views/index.html
  views/hello/index.html
  views/hello/view.html.php
  views/hello/tmpl/default.php
  views/hello/tmpl/index.html
 

 
  
Hello World!

  
  
   hello.php
   index.html
  

 

Finalmente, guardamos en los ficheros index.html un contenido trivial, como por ejemplo:

<html><body bgcolor="#FFFFFF"></body></html>

Por último, comprimimos en un fichero ZIP el contenido de la carpeta com_hello, y ya podemos instalar nuestro componente desde el instalador de extensiones de Joomla.

Mostrando el componente

Ahora, para poder ver el resultado, debemos consultar el componente. Para ello, debemos acceder a la siguiente URL:

/index.php?option=com_hello&view=hello

Vemos que no se define ninguna tarea (Recordemos que por defecto se usa Display). En caso de querer ejecutar otra tarea, tendríamos que definir el parámetro GET task, por ejemplo para la tarea ‘save’:

/index.php?option=com_hello&view=hello&task=save

Entre las novedades, se destacan:

• Actualizada la versión de sqlite a 3.6.23.1
• Actualizada la versión de PCRE (Expresiones Regulares Compatibles con Perl) a la versión 8.02
• Añadido FPM (Gestor de Procesos de FastCGI) SAPI. SAPI hace referencia a los módulos de PHP que hacen de interfaz al servidor web (Server Application Programming Interface)
• Añadido soporte para stream filter de la extensión mcrypt.

¡A disfrutarlo!