Incluso lo emplee como elemento principal en el desarrollo de PHAS-JS, realizando un servidor de aplicaciones en PHP, con la potencia que brindan muchas de sus librerías, pero escribiendo código de forma segura en JavaScript (o ECMAScript).

Hoy voy a tratar otra máquina que permite ejecutar código JavaScript dentro de PHP, de la misma forma que cuando vimos Spidermonkey, pero variando la forma en la que interactúa con PHP. En esta ocasión tenemos entre nosotros la máquina: el V8 de Google. Va a estar un poco inspirado en lo que he ido comentando con Sergio, que he visto que ha escrito también al respecto en su blog: PHP y JavaScript se entienden.

Instalando

Lo primero, es que si tenemos como paquete el libv8-dev, todo será más fácil ya que se resume en estos sencillos pasos (esto es válido para Debian y Ubuntu):

apt-get install libv8-dev
pecl install v8js

Esta es una de las implementaciones de V8 que hay para PHP, también está disponible V8 (a secas) que es un módulo que intenta imitar la implementación de Spidermonkey, con lo que, si tienes un código que emplee el sistema de spidermonkey, pasar a v8 debe de ser cambiar muy poquitas cosas. No obstante este código está marcado como experimental y hay cosas que no funcionan del todo. La instanación sería:

apt-get install libv8-dev
git clone https://github.com/metagoto/v8.git
cd v8 && phpize && ./configure && make && make install

La configuración es compatible si instalamos los dos, ya que es:

extension=v8js.so
extension=v8.so

Actualización: escribí un email a metagoto sobre el mantenimiento y mejora del módulo v8 para PHP. La respuesta fue que esa implementación la realizó para poder jugar y ver cómo se comportaba el sistema v8, y que no le pudo dedicar mucho tiempo, es más, abandonó el desarrollo y no tiene pensado retomarlo. Sobre el problema que observé del paso de objetos y que no pasaba sus métodos, parece que el problema no es trivial, por lo que, desecho la idea de tomarlo como una solución práctica y la dejo únicamente para pruebas y ensayos.

Probando…

En principio, podemos repetir la misma prueba que hicimos en el artículo de spidermonkey, a modo de poder enseñarlo de ambas formas. El código, por tanto sería así:

<?php
 
// crea la máquina para JavaScript
$js = new V8Js();
 
// define valores para el entorno JS
$js->a = 10;
$js->b = 2;
 
// define el código a ejecutar
$script = <<<END
  c = PHP.a + PHP.b;
END;
 
// evalua el script y muestra el resultado
echo "La suma de $a y $b es: " . $js->executeScript($script);

La pega que tiene este, en comparación con spidermonkey, es que las funciones solo se pueden pasar si son anónimas (como variables) y que la ejecución restringe o separa lo que se pasa desde PHP en un objeto específico, por lo que queda un poco engorroso (desde mi punto de vista).

Con el tema de los objetos pasa igual, se pueden pasar objetos, pero no clases, con lo que no se pueden realizar instancias nuevas, a menos que se emplee una función anónima que haga las veces de factory o singleton.

El código de v8, que intenta emular a spidermonkey facilita esto agregando registro de funciones, clases y variables en la parte global. No obstante, este código no es completamente funcional, ya que, en las pruebas realizadas, por ejemplo, no se tiene acceso a los métodos de las clases registradas cuando se crea un nuevo objeto dentro de V8.

Conclusiones

La máquina V8 ha demostrado ser un gran intérprete de JavaScript, ya que es la que emplea Google en el navegador Chorme, no obstante, su integración con PHP falta que madure un poco y se ajuste en usabilidad a algo similar a lo que se puede conseguir con Spidermonkey.

La pista ya la puso sobre la mesa Delayed::Job, una gema de Ruby on Rails, que crea una tabla en la base de datos, y se encarga de ir actualizando dicha tabla de modo que, en el momento que se lanza el proceso (a través de un cron, por ejemplo), ejecuta todas las tareas que estén esperando en la cola. Realmente es una tabla en la que se inserta cada tarea, y después una ejecución aparte que se encarga de lanzarla.

En PHP, con DJJob, se consigue el mismo resultado. Se crea la tabla para la gestión de los trabajos, y el sistema tiene mecanismos que permiten encolar trabajos y sacarlos para su ejecución, así como preguntar si está en ejecución o terminado. Si adaptamos un poco la tabla, podríamos incluso agregar un campo que nos diese el porcentaje de compleción de la tarea.

Probamos la teoría

Vamos a hacer un simple ejemplo, descargamos el fichero DJJob.php y creamos otros dos ficheros, el example.php:

 
<?php
 
include(__DIR__ . "/DJJob.php");
 
DJJob::configure("mysql:host=localhost;dbname=jobs", array ( 'mysql_user' => 'root', 'mysql_pass' => 'root'));
 
class HelloWorldJob {
        public function perform() {
                echo "Hello world!\n";
        }
}
 
DJJob::enqueue(new HelloWorldJob());

Y el worker.php, que será el que se encargue de sacar el trabajo y ejecutarlo:

 
<?php
 
include(__DIR__ . "/DJJob.php");
 
DJJob::configure("mysql:host=localhost;dbname=jobs", array ( 'mysql_user' => 'root', 'mysql_pass' => 'root'));
 
class HelloWorldJob {
        public function perform() {
                echo "Hello world!\n";
        }
}
 
$worker = new DJWorker(array ( "count" => 1, "sleep" => 0 ));
$worker->start();

Antes de ejecutarlo, necesitaremos tener en la máquina local una base de datos MySQL con este script cargado: jobs.sql; y con acceso root y clave root (se puede cambiar, modificando el código de ambos códigos PHP).

Una vez lo tengamos, solo nos quedará ejecutarlo:

$ php example.php
$ php worker.php
* [JOB] Starting worker host::bosqueviejo pid::18835 on queue::default
* [JOB] attempting to acquire lock for job::1 on host::bosqueviejo pid::18835
Hello world!
* [JOB] completed job::1
* [JOB] worker shutting down after running 1 jobs, over 1 polling iterations

Las opciones del worker, hacen que la ejecución sea solo una, por lo que se puede agregar la ejecución a un cron. No obstante, si no se pasan opciones, la ejecución se hace recurrentemente cada 5 segundos, lo cual es más óptimo si se emplea desde la web. Además, el sistema lanza varios hijos (en caso de tener pcntl_fork) con lo que, trabajará de forma paralela en caso de que haya varias tareas en la cola.

Una buena idea a tener en cuenta si queremos desarrollar cargas de ficheros que tengan un procesamiento bastante extenso, o trabajos de conexión y comunicación con otros servidores (como por ejemplo pagos) que requieran de mucho tiempo y puedan terminar en una desconexión por tiempo de espera agotado, o paciencia del usuario agotada.

¿Por qué tanta variedad?, en principio, he empleado PHP porque tiene todos los elementos básicos y necesarios para construir en poco tiempo la infraestructura que quería montar… pero igualmente, no quería que se mezclase el núcleo del programa con la interfaz de usuario, ya que sino, se tiende a confundir y enrarecer. En este caso, el único nexo de unión entre sistema e interfaz sería la base de datos.

Spidermonkey es un sistema probado desde hace mucho tiempo en navegadores como Firefox, donde se emplea JavaScript de forma segura, sin que interfiera ni dañe al resto de ejecuciones ni al propio núcleo del sistema, y por ende, tampoco al servidor ni elementos asociados a él. Por ello, el despliegue de aplicaciones es completamente seguro.

La interfaz, igualmente, se encarga de la gestión de la base de datos, tanto para la creación de la misma a través de las herramientas que incorpora Django.

Características

PHAS-JS se compone de cinco partes: entrada de datos, proceso, sesión, acceso a datos y salida de datos. Con respecto a estos elementos, se aportan las siguientes características:

• Entrada de Datos: la entrada de datos, normalmente, se realizará mediante la parte de query de la URL, pero también puede incluirse en el cuerpo de la petición a modo POST. Igualmente, se puede realizar una entrada de datos de tipo SOAP.
• Proceso: el proceso se realiza a través de la ejecución de un código JavaScript almacenado en la base de datos interna del sistema.
• Sesión: la sesión es un espacio de información que se mantiene activo entre llamadas. Este espacio se puede almacenar en sesiones normales y corrientes de PHP, con lo que se pueden configurar con los mecanismos que soporta PHP para distribuir las sesiones en varias máquinas en caso de que se quiera, o el uso de la implementación específica de Memcache o MongoDB que se ha realizado y probado para ello.
• Acceso a Datos: a través de la interfaz, se puede habilitar, para los procesos, el uso de conexiones a base de datos específicas. Estos procesos accederán referenciando el nombre, nunca la forma de conexión completa.
• Salida de Datos: una vez se ha realizado el procesado, la ejecución del código, se retornan los datos ya sea mediante respuesta SOAP (únicamente si la entrada ha sido SOAP) o algún tipo de serialización que puede indicarse explícitamente, como: YAML, JSON, serialización de PHP, XML o en texto plano (salida print_r de PHP).

Además, el sistema tiene caché a varios niveles:

• Caché explícita a nivel de petición: en caso de indicar entre los parámetros de entrada cache, el sistema activa la caché con el tiempo que se haya configurado. Con lo que las siguientes peticiones ya no saturarían al sistema o serían mucho más rápidas, en caso de que la petición en sí fuese costosa.
• Caché a nivel de consulta: a través de una consulta en la función dql de DataAccess, se puede activar la caché por consulta, que hace que el propio proceso pueda emplear caché para las consultas individuales que realiza a la base de datos.

Futuro…

Mientras desarrollaba esta versión iban surgiendo las ideas y las fui anotando en tickets que fueron a parar en lo que se ha convertido en el roadmap como la versión 1.1. Por lo que, en el futuro, el sistema tendrá una mejor integración con MongoDB, prubas unitarias en interfaz de administración y marcado de cuales son buenas para producción y cuales no, entornos de desarrollo, producción y test, además de otros que se quieran crear…

Espero que sea útil… aquí la web: http://phas-js.org

El lenguaje haXe, se presenta como un meta-lenguaje, un lenguaje que se compila resultando en otro diferente, como pueda ser JavaScript, PHP, Java o Neko, por lo que puede emplear cualquier entorno de ejecución conocido por el programador. Dicho de otra forma, este es un lenguaje para dominarlos a todos…

El lenguaje

Echándole un vistazo a la sintaxis del lenguaje, podríamos decir que el lenguaje es muy parecido a JavaScript, pero con definición de tipos. La declaración es parecida a Pascal o Modula-2, usando dos puntos, pero sin embargo, la forma de los arrays es más como las plantillas de Java.

Las estructuras condicionales son las que están disponibles en lenguajes como PHP, C, Java y demás, con algunos matices, por ejemplo, con el uso de iteradores, con lo que el for es más parecido a Python o Java, por ejemplo. Tiene una forma tal que así:

import php.Lib;
 
class Index {
    static function main() {
        var p = new Point(-1,65);
        trace(p);
    }
}
 
class Point {
    var x : Int;
    var y : Int;
    public function new(x,y) {
        this.x = x;
        this.y = y;
    }
    public function toString() {
        return "Point("+x+","+y+")";
    }
}

Este código (tomado de su web, sección de tipos) se encarga de definir una clase Point, con un constructor que inicializa los atributos internos (x e y) y una función especial para representar el dato en modo texto (como en Java).

Lo suyo sería que se particionase como clases independientes, e incluso se creasen paquetes, una vez se programe en serio con el lenguaje.

La compilación

En Debian, el compilador viene en el repositorio. Llama la atención el hecho de que se instala de la mano de Neko (que es otro lenguaje similar, que se puede compilar en otros, pero que además tiene una VM propio e integración con Apache).

Generar el código visto anteriormente en PHP, es tan simple como ejecutar esto:

haxe -main Index -php www

Nos creará un directorio www en la ruta en la que estemos que tendrá un directorio lib y un index.php en la base con los comandos básicos para ejecutar el código programado. Lo podemos ejecutar desde consola (si tenemos el php-cli), así:

$ php www/index.php
Index.hx:6: Point(-1,65)

Conclusiones

Últimamente se van escuchando cada vez más lenguajes nuevos que salen, buenos lenguajes con muchas nuevas características que facilitan mucho la vida a los programadores, pero que, por el simple hecho de ser más completos, tienen una curva de aprendizaje más alta.

Lo que propone HaXe, en sí, es un solo lenguaje, un lenguaje muy completo, con todas las características de alto nivel que tienen todos los lenguajes, fácil y muy parecido a los lenguajes más usados de hoy en día, por lo que su entrada a él sea rápida, pero además, muy versátil, como los lenguajes scriptting, y ajustable a las necesidades de producción, gracias a que se puede compilar en C++, Java, C#, PHP, JavaScript, Flash y Neko.

En mi opinión, es una muy buena propuesta, ya que se podría emplear para generar el código necesario para realizar la web a nivel de servidor, cliente, e incluso algunos códigos a nivel de aplicación de escritorio, todo en un solo lenguaje.

Versión PHP

Empezaremos con la complicada. Este código se encarga de descargar el código del RSS y deserializar el XML en un array, para poder tratarlo a posteriori. El tratamiento lo haré en plan cutre, ya que me intentaré, sobretodo, basar en el proceso de descarga y deserialización.

Para esto, se requiere de una librería que no suele venir con PHP, pero sí está en PEAR, con lo que, se puede instalar fácilmente ejecutando la siguiente línea de comandos:

pear install XML_Serializer

Con esto, el código, en plan simple, sería el siguiente:

<?php
 
 
include 'XML/Unserializer.php';
 
function xml_to_array( $data ) {
    $options = array(
        "addDecl"            => true,
        "encoding"           => "utf-8",
        "mode"               => XML_SERIALIZER_MODE_SIMPLEXML,
        "indent"             => "    ",
        "linebreak"          => "\n",
        "scalarAsAttributes" => true,
        "attributesArray"    => '_a',
        "contentName"        => '_c',
        "rootName"           => 'rss'
    );
 
    $unserializer = new XML_Unserializer($options);
    $unserializer->unserialize($data);
    $doc = $unserializer->getUnserializedData();
 
    return $doc;
}
 
$data = xml_to_array(file_get_contents('http://www.debian.org/News/news'));
?>
<html>
<body>
    <? foreach ($data["item"] as $noticia) { ?>
    <h1><a href="<?=$noticia["link"]?>"><?=$noticia["title"]?></a></h1>
    <p class="date"><?=date("d/m/Y H:i", strtotime($noticia["dc:date"]))?></p>
    <p class="desc"><?=$noticia['description']?></p>
    <? } ?>
</body>
</html>

No pinta mal, conseguimos lo que nos proponemos sin tener muchas complicaciones.

Ahora la versión bonita

En Rails las cosas siempre tienden a ser más simples, o al menos mucho más cortas, muestra de ello, es la versión del código anterior en versión Rails. Este sería:

  def noticias
    require 'rss/1.0'
    require 'rss/2.0'
    require 'open-uri'
 
    source = "http://www.debian.org/News/news"
    content = ""
    open(source) do |s| content = s.read end
    @rss = RSS::Parser.parse(content, false)
  end

Aunque he puesto los require dentro de la función, realmente podrían ponerse en otro sitio (como en environment.rb) y no requieren de la instalación de ninguna gema extra. En la vista sería tan solo usar el código de la siguiente forma:

<% @rss.items.each do |i| %>
    <h1><%= link_to i.title, i.link %></h1>
    <p class="date"><%=i.date.strftime("%d/%m/%Y %H:%M")%></p>
    <p class="desc"><%=simple_format(i.description)%></p>
<% end %>

Los helpers ayudan bastante en la creación del código, haciendo que los enlaces se hagan de forma simple, así como el formateado de la fecha, y el parseo del texto para HTML.

Conclusiones

He estado revisando el repositorio PEAR, donde he podido ver que había un par de paquetes de RSS, uno de ellos sin mantenimiento ya (XML_RSS), y el resto de blogs que he visitado lo hacen como he mencionado, por lo que, obliga a conocer los distintos formatos de los que se van a rescatar noticias, ya sean Atom, RSS (la versión que corresponda), etc. Me parece que en este sentido Rails ha demostrado ser más serio o aplicado.

Después de realizar una pequeña búsqueda por Internet, he visto que, en la propia página de PHP, ya tienen medio resuelto el problema y, funciona bastante bien… según leo en un ejemplo de :

<?php
function exception_error_handler($errno, $errstr, $errfile, $errline ) {
    throw new ErrorException($errstr, 0, $errno, $errfile, $errline);
}
set_error_handler("exception_error_handler", E_USER_ERROR);
 
/* Trigger exception */
strpos();
?>

Si lanzamos la ejecución del código, veremos que ya no se sucede el típico Fatal Error, sino una excepción no capturada, con lo que, si envolviésemos el código strpos con try ... catch, obtendríamos que el programa ya no deja de funcionar.

Hay que tener en cuenta de que PHP no tiene solo errores, sino también noticas (NOTICE), avisos de elementos en desuso (DEPRECATED) y avisos (WARNING), que podría capturarse si no indicamos el parámetro E_USER_ERROR como segundo parámetro de set_error_handler.

¿Para cuándo lo incluirán este cómo como por defecto en la distribución estándar de PHP?

Como cuando hablé sobre la liberación de PHP 5.3, esta nueva versión de PHP se va acercando un poco más al ideal de Programación Orientada a Objetos que ya se tiene en otros lenguajes como Python, Ruby, Java, C#, etc.

En esta nueva entrega, como en otras, hay cambios o mejoras sobre algunos elementos, cosas que se agregan al lenguaje y a la biblioteca de funciones (y objetos) y cosas que definitivamente se eliminan.

Deprecated…

Las cosas que se eliminan en esta versión son cosas tan poco usadas como los parámetros de break y continue, que supongo que tendrían su sentido… pero a mi nunca me hicieron falta, realmente.

Las funciones para almacenar datos en la sesión también han sido eliminadas, ya que con el array $_SESSION, se hacían poco útiles. Por lo que los códigos con funciones: session_register, session_unregister y session_is_registered… dejaran de funcionar en esta versión.

También se eliminan definitivamente cosas como y2k_compliance, register_globals, y otras cosas que en la versión antigua ya se marcaron como que se eliminarían a futuro.

Traits

Una de las grandes agregaciones en esta versión son los traits. Esta es una herramienta muy potente en entornos donde la herencia es simple, posibilitando la reutilización de código… más específicamente de los métodos que se desean portar entre clases de distinta índole.

Por ejemplo:

<?php
 trait ezcReflectionReturnInfo {
   function getReturnType() { /*1*/ }
   function getReturnDescription() { /*2*/ }
 }
 
 class ezcReflectionMethod extends ReflectionMethod {
   use ezcReflectionReturnInfo;
   /* ... */
 }
 
 class ezcReflectionFunction extends ReflectionFunction {
   use ezcReflectionReturnInfo;
   /* ... */
 }
 ?>

Esto hace que las clases ezcReflectionMethod y ezcReflectionFunction se puedan beneficiar de las funciones definidas en el trait ezcReflectionReturnInfo, heredando cada una de su respectiva clase padre.

Más información aquí.

Filtrando cabeceras

Se ha agregado un nuevo callback, para cuando se envíen las cabeceras, justo antes de este instante, se ejecute un código personalizado que permita, junto con las funciones headers_list, header_remove y header, enviar solo las cabeceras que se quieran enviar:

<?php
 
header('Content-Type: text/plain');
header('X-Test: foo');
 
function foo() {
    foreach (headers_list() as $header) {
        if (strpos($header, 'X-Powered') !== false) {
            header_remove('X-Powered-By');
        }
    }
    header_remove('X-Test');
}
 
$result = header_register_callback('foo');
echo "a";

Ejemplo del blog de Carlos Ballesteros, header_register_callback en PHP 5.4.

Por defecto… UTF-8

Así es, hasta ahora, el uso interno de cadenas y textos se hacía en ISO-8859-1 o Latin-1. Al igual que en distribuciones como Debian o Red-Hat este valor se modificó a UTF-8, ahora PHP, en esta versión ha modificado su conjunto de caracteres para que por defecto esté a UTF-8. No obstante, esto puede modificarse desde php.ini.

Rendimiento

Parece que se han modificado muchos de los aspectos internos que tienen que ver con la gestión de memoria, arrays y serializaciones. En principio, según se puede ver en esta presentación, PHP en esta versión ha duplicado su velocidad, mientras que ha dividido por la mitad su consumo de memoria. ¡Eso es optimización!

Conclusiones

Hace bastante tiempo, escribí un artículo acerca de las Nuevas Versiones de los Lenguajes de programación. En este artículo, reseñaba cosas de las que a PHP 5.4 ya no le falta nada… o muy poco, pero apenas perceptible.

Realmente, PHP es un lenguaje al que odias o amas… o ambas cosas, ya que tiene cosas que lo hacen un poco insufrible, y sin embargo, son esas cosas las que le dan flexibilidad y gracias a las que se pueden hacer las cosas que se hacen. Con PHP 5.4, las diferencias que mostraban otros lenguajes con respecto a integración de POO se van acortando. Ahora solo falta que todos se actualicen a estas últimas versiones.

¿Qué es y qué hace Xdebug?

Xdebug es un módulo de PHP que se carga únicamente cuando se quiere trazar una ejecución de un código PHP (por ello no conviene, en ningún caso, cargarlo en producción, ya que puede cargar de por sí el sistema).

El módulo se encarga de almacenar información de cada llamada a función de PHP, junto con la marca horaria en la que se sucede para tener la traza exacta del curso de la ejecución del programa.

¿Cómo y dónde se obtiene esta información?

Cada traza es soltada dentro de un fichero llamado cachegrind.out. finalizado con el número del proceso en el que se ejecuta el intérprete de PHP.

Este archivo puede ser abierto desde algún programa como KCacheGrind (de KDE para GNU/Linux y Windows), así como WinCacheGrind, xdebugtoolkit y WebGrind. Así se muestra con KCacheGrind:

Como puede verse, los procesos se muestran de forma jerárquica en las llamadas a través de un árbol de llamadas, pudiendo poner la base en cualquier función inicial.

Además, permite ver el listado de las llamadas que han sido más usadas, y las que más demoran su ejecución. Lo cual viene muy bien para poder optimizar, no solo las funciones en sí, sino también la forma en la que se llaman.

Conclusión

Es una gran herramienta que no debería de faltar en todo programador PHP, ya que nos da información muy valiosa sobre la optimización con la que escribimos nuestro código y nos puede señalar faltas en el rendimiento que solo se verían demasiado tarde, en producción.

Para ello, desde hace mucho tiempo, se integran soluciones de lenguajes embebidos (como Lua, que ya vimos hace tiempo), que permiten ejecutarse en un entorno o contexto controlado, donde cualquier fallo no afecta directamente al núcleo del programa principal, solo al propio módulo en sí.

Leyendo un artículo bastante extenso de Zend Developer Zone, encontramos el cómo instalar la solución spidermonkey dentro de PHP para poder realizar código en JavaScript que pueda servir para extender el núcleo de la aplicación que hayamos realizado en PHP.

Instalación

La instalación es algo manual, ya que, al menos en Debian Lenny, no están disponibles las librerías necesarias para hacer que funcione. Los requisitos para poder echar a correr son:

• PHP 5.3 o superior
• Spider Monkey Libraries 1.7 o superior

La instalación de las librerías de Spider Monkey terminan siendo bastante manuales, por lo que las describiré a continuación paso a paso, tal y como viene en el artículo original:

tar -xzvf js-1.70.tar-gz
cd js/src
make -f Makefile.ref
 
mkdir -p /usr/local/include/js/ 
cp *.{h,tbl} /usr/local/include/js/ 
cd Linux_All_DBG.OBJ
cp *.h /usr/local/include/js/ 
cp js /usr/local/bin/ 
cp libjs.so /usr/local/lib/
ldconfig

IMPORTANTE: se debe de tener en ld.so.conf agregada la ruta de las librerías locales /usr/local/lib antes de hacer el último comando o no tendrá efecto (aunque no dé error).

Por último, instalamos desde PECL la librería:

pecl install spidermonkey-0.1.4

Con esto ya tendremos compilado e instalado el código, ya solo nos quedaría configurar la extensión spidermonkey.so dentro del php.ini para PHP pueda encontrar las funciones y objetos que le acabamos de instalar.

Probando, Probando… uno, dos, tres…

Pues nada, una vez tenemos la extensión configurada y funcionando, ya solo nos queda escribir un código para probar que todo funcione como tiene que funcionar. El código más simple que podemos probar es:

<?php
 
// crea un contexto JavaScript
$js = new JSContext();
 
// define variables PHP
$a = 10;
$b = 2;
 
// asigna las variables al contexto JavaScript
$js->assign('a', $a);
$js->assign('b', $b);
 
// define el código a ejecutar
$script = <<<END
  c = a + b;
END;
 
// evalua el script y muestra el resultado
echo "La suma de $a y $b es: " . $js->evaluateScript($script);

Lo cual nos resulta:

La suma de 10 y 2 es: 12

Complicándolo un poco más

Como todo en la vida, se puede hacer más aún. En principio, tenemos una forma de hacerle llegar al contexto de JavaScript las variables definidas en PHP, pero además, podemos:

Uso de funciones

Pasar una función de PHP para poder ejecutarla desde JavaScript:

<?php
// define la función en PHP
function getCircleArea($radius) {
  return pi() * $radius * $radius;
}
 
// crea el contexto JavaScript
$js = new JSContext();
 
// registra la función en el contexto JavaScript (como gca)
$js->registerFunction('getCircleArea', 'gca');
 
// define el código
$script = <<<END
  ret = 'El área del círculo con radio 5 es: ' + gca(5);
END;
 
// evalua el código y muestra el resultado
echo $js->evaluateScript($script);

Esto muestra:

El área del círculo con radio 5 es: 78.53981633974483

Uso de Clases

Supongamos que tenemos definida la clase Cow en PHP y queremos poder emplearla desde JavaScript. Lo que supone crear un nuevo objeto y poder emplearlo. La clase Cow la definimos como a continuación:

<?php
// definición de la clase
class Cow {
 
  private $_name;
  private $_milked;
 
  public function __construct() {
    $this->_milked = 0;
  }
 
  // name setter/getter
  public function setName($name) {
    $this->_name = $name;
  }
 
  public function getName() {
    return $this->_name;
  }
 
  // milking status setter/getter
  public function milk() {
    $this->_milked = 1;
  }
 
  public function getMilked() {
    return $this->_milked;
  }
 
  public function output() {
    if ($this->getMilked() == 1) {
      return $this->getName() . ' ha sido ordeñada hoy.';
    } else {
      return 'Hora de ordeñar a ' . $this->getName();
    }
 
  }
}

Con la definición de la clase, podríamos ejecutar el siguiente código:

<?php
// cargamos el fichero de la clase
include_once 'Cow.class.php';
 
// crea el contexto JavaScript
$js = new JSContext();
 
// registra la clase PHP en JavaScript
$js->registerClass('Cow');
 
// define el código
$script = <<<END
  var c = new Cow;
  c.setName('Molly');
  var d = new Date();
  var ch = d.getHours();
  if (ch > 8) {
    c.milk();
  }
  c.output();
END;
 
// evalua el código y muestra el resultado
echo $js->evaluateScript($script);

En este caso, el resultado sería, dependiendo de la hora del servidor:

Molly ha sido ordeñada hoy.

O bien:

Hora de ordeñar a Molly

Conclusiones

Considero que, cuando se realizan aplicaciones de servidor que requieran de un nivel de personalización alto, es muy útil poder darle la posibilidad al usuario, o programador en caso de que sea un framework, de extender la funcionalidad propia del entorno, sin afectar con ello al núcleo de la aplicación o servidor.

Spidermonkey, en este aspecto, tiene la ventaja de que cumple con creces las necesidades que puedan surgir en este aspecto, además de ser bastante simple de manejar y, en sí, el lenguaje JavaScript no resulta desconocido para los programadores de PHP, ya que la mayoría son en sí programadores web que, por una causa u otra, han necesitado en algún momento del uso del mismo.

Hola 1
Hola 4
Hola 9
Hola 16
...

He realizado las pruebas en los lenguajes: C, Perl, Ruby, Python, PHP, Lua, Shell script, Erlang script y Java.

C

En lenguaje C se ha realizado el siguiente código:

#include <stdio.h>
 
main() {
        int i;
 
        for (i=0; i<100000; i++) {
                printf("Hola %d\n", i*i);
        }
}

Perl

En el lenguaje Perl, se ha implementado el código siguiente:

#!/usr/bin/perl
 
for ($i=0; $i<100000; $i++) {
        print "Hola " . ($i*$i) . "\n";
}

Ruby

En Ruby, el código escrito ha sido:

#!/usr/bin/ruby
 
(1..100000).each do |i|
        puts "hola " + (i*i).to_s
end

Python

En Python, el código ha sido:

#!/usr/bin/python
 
for i in range(1,1000000):
        print "Hola " + str(i*i)

PHP

En PHP el código escrito ha sido:

#!/usr/bin/php -q
<?php
 
for ($i=0; $i<100000; $i++) {
        print "Hola " . ($i*$i) . "\n";
}

Lua

El código de Lua escrito ha sido:

#!/usr/bin/lua
 
for i=1,100000 do
        print("Hola " .. (i*i))
end

Shell script

En shell script (en bash) se ha implementado lo siguiente:

#!/bin/bash
 
for i in $(seq 1 100000); do
        let RESULT=$i*$i
        echo "Hola $RESULT"
done

Erlang (Script)

Erlang también puede emplearse como lenguaje de scripting usando el intérprete escript. El código escrito para este intérprete ha sido:

#!/usr/bin/escript
 
main(_Args) ->
        loop(100000).
 
loop(0) -> 0;
loop(I) ->
        io:format("Hola ~p~n", [I*I]),
        loop(I-1).

Java

El código que se ha usado para la prueba de Java ha sido:

public class loop {
        public static void main( final String[] args ) {
                for (int i=0; i<100000; i++) {
                        System.out.println("Hola " + (i*i));
                }
        }
}

Resultado de las pruebas

Tras ejecutar 5 veces cada script, controlando el tiempo que toma cada uno hemos obtenido, según el equipo en el que se ha ejecutado. El equipo 1 es un Intel vPro con Debian GNU/Linux Lenny:

En el equipo 2, un Apple iBook G4 (PowerPC):

Ordenados por velocidad, se ve que el lenguaje C, como cabía esperar, es el más rápido, seguido de Perl, como el lenguaje de scripting más rápido.