Cómo ejecutar JavaScript desde Python: Guía práctica con js2py

Aunque Python y JavaScript son lenguajes muy distintos en su propósito y ecosistema, no es raro encontrarnos en situaciones en las que necesitamos integrar ambos. Tal vez queremos reutilizar una función compleja escrita en JavaScript, o simplemente acceder a una librería que no existe (o no está tan madura) en el ecosistema Python. En esos casos, poder ejecutar código JavaScript desde Python se vuelve una opción más que interesante.

Por ejemplo, algunas situaciones comunes en las que esto puede ser útil son:

• Aplicaciones que combinan frontend en JS con backend en Python.
• Reutilización de lógica de negocio o validación ya implementada en JS.
• Acceso a funciones de bibliotecas JS que no tienen equivalente en Python.
• Automatización de pruebas que requieren analizar scripts JS.

A lo largo de esta guía veremos cómo ejecutar código JavaScript (y también TypeScript) desde Python, usando principalmente la herramienta js2py, aunque también mencionaremos otras opciones. Veremos casos básicos y avanzados, así como buenas prácticas para que tu integración sea mantenible y eficiente.

Opciones disponibles para ejecutar JavaScript desde Python

Actualmente existen varias opciones para ejecutar JavaScript desde Python. Algunas se apoyan en motores JavaScript integrados como el de Node.js o V8, y otras implementan su propio intérprete. En esta sección, te presentamos las principales alternativas, con sus ventajas y limitaciones.

js2py – Intérprete puro en Python

js2py es una biblioteca que traduce código JavaScript a Python (en tiempo de ejecución), permitiendo su ejecución directa sin depender de un motor externo como Node.js.

En Analytics Lane

Nuevo test de normalidad interactivo en el laboratorio de Analytics Lane

Ventajas:

• Se instala con pip, sin dependencias externas.
• No requiere tener Node.js instalado.
• Puedes ejecutar código JavaScript desde cadenas de texto o archivos .js.
• Permite acceder y modificar variables JavaScript desde Python.

Limitaciones:

• Soporte parcial de ECMAScript (hasta ES5.1; no soporta ES6+).
• No es adecuado para librerías modernas basadas en módulos o DOM.
• No soporta librerías que dependen de window, document, fetch, etc.
• No compatible con Python 3.12 (ni completamente con 3.11)

js2py es la solución ideal para la integración de funciones puramente lógicas o matemáticas.

PyMiniRacer – Motor V8

PyMiniRacer incluye el motor V8 de Google, permitiendo ejecutar código JavaScript moderno con alto rendimiento.

Ventajas:

• Soporte para ECMAScript moderno.
• Muy rápido gracias a V8.
• No necesita Node.js.

Limitaciones:

• No se puede acceder fácilmente a variables entre contextos.
• Menos flexible que js2py en cuanto a integración con objetos Python.
• Instalación más compleja (requiere compilación o binarios compatibles).

**PyMiniRacer ** es la opción más adecuada si necesitas ejecutar JavaScript moderno pero sin depender del entorno web.

subprocess + node – Ejecutar JS usando Node.js

Si ya tienes Node.js instalado, puedes ejecutar cualquier archivo JS usando subprocess desde Python.

import subprocess

result = subprocess.run(['node', 'script.js'], capture_output=True, text=True)

print(result.stdout)

Ventajas:

• Soporte completo para JavaScript moderno (ES6+).
• Permite usar cualquier librería disponible en npm.
• Puedes trabajar con TypeScript transpilado previamente.

Limitaciones:

• Comunicación limitada (entrada/salida estándar).
• Necesita Node.js instalado.
• El intercambio de datos es más manual (JSON, stdin/stdout).

El uso de subprocess y node es la opción más flexible, pero también la más “manual” de todas.

PyExecJS – Ejecutar código JS con múltiples motores

PyExecJS permite ejecutar código JS usando distintos motores de JavaScript: Node.js, JScript, PhantomJS, etc.

Ventajas:

• Interfaz unificada para distintos motores.
• Simple de usar si ya tienes Node.js instalado.

Limitaciones:

• Requiere motor externo (por ejemplo, Node.js).
• Limitado en cuanto a integración de datos complejos entre Python y JS.

PyExecJS es similar a subprocess y node, pero con menos requiere de menos configuraciones “manuales”.

¿Cuál elegir?

En la siguiente tabla se muestra una comparativa entes estas cuatro opciones que se han visto para ejecutar JavaScript desde Python.

En esta entrada, nos centraremos en js2py porque es la opción más accesible para comenzar, ideal para scripts pequeños, funciones simples y prototipos.

Instalación de js2py y primer ejemplo básico

La mayor ventaja de js2py es que no necesita tener Node.js ni ningún motor JavaScript instalado. Solo necesitas tener Python 3.6 o superior.

Puedes instalar js2py directamente desde PyPI con:

pip install js2py

Tu primer script JavaScript en Python

Vamos a comenzar con algo sencillo: ejecutar una función JavaScript que suma dos números. Por ejemplo, la siguiente función:

function suma(a, b) {
    return a + b;
}

Para ejecutar esta función de suma, solamente se tiene que importar js2py, crear una variable de Python con la función, crear un contexto de js2py, inyectar la función en este contexto y llamar a la función desde Python con los parámetros para que se ejecute. Lo que se puede ver en el siguiente código:

import js2py

# Código JavaScript como string
codigo_js = """
function suma(a, b) {
    return a + b;
}
"""

# Ejecutamos el código JS y creamos un contexto
contexto = js2py.EvalJs()
contexto.execute(codigo_js)

# Ahora podemos usar la función suma como si fuera una función Python
resultado = contexto.suma(5, 7)
print(f"Resultado: {resultado}")  

Notas importantes

Respecto al uso de js2py para ejecutar código JavaScript es importante notar los siguientes puntos:

• El contexto es como una “caja de arena” (sandboxing) de JavaScript embebida en Python. Todo el código JavaScript vive ahí dentro.
• Los valores simples (int, float, str) se convierten automáticamente entre Python y JS. Los objetos complejos pueden necesitar conversión manual.
• Si hay errores de sintaxis en el JS, js2py lanzará una excepción de tipo JsException.

Ejecutar código JavaScript desde un archivo .js

En vez de escribir el código JavaScript como un string dentro de Python, también puedes cargarlo desde un archivo externo. Facilitando la reutlización del código ya existente. Ademas esto mantiene tu código más limpio y organizado.

Crear el archivo

A modo de ejemplo, vamos a generar un llamado utilidades.js con el código JavaScript que se dese ejecutar:

function cuadrado(x) {
    return x * x;
}

function saludar(nombre) {
    return "Hola, " + nombre + "!";
}

Cargar y ejecutar desde Python

Una vez creado al archivo, solo hay que importar el archivo en una variable y repetir el procesos visto anteriormente: crear el contexto, inyectar el código y llamar a las funciones desde Python. Una forma de hacer esto seria como se muestra en el siguiente ejemplo:

import js2py

# Leer el contenido del archivo .js
with open('utilidades.js', 'r', encoding='utf-8') as f:
    codigo_js = f.read()

# Crear un contexto JS y ejecutar el código
contexto = js2py.EvalJs()
contexto.execute(codigo_js)

# Llamar funciones definidas en el JS
print(contexto.cuadrado(9))
print(contexto.saludar("Lucía"))

Consideraciones al usar archivos .js

El código JavaScript no tiene porque estar en un único archivo, lo que mejora la mantenibilidad y escalabidliad de esta solución. En estos casos es importante tener en cuenta los siguiente puntos:

• Puedes dividir tu lógica JS en varios archivos y combinarlos en Python.
• Ten cuidado con funciones duplicadas o conflictos de nombres si cargas varios archivos.
• Si tu código JS depende de módulos (con import o require), js2py no los soporta, porque no tiene un sistema de módulos como Node.js.

¿Y qué hay del TypeScript?

Debido a que js2py no entiende TypeScript directamente, pero sí puedes usar TypeScript si lo transpilas primero a JavaScript. A continuación, te mostramos cómo hacerlo.

Instalar TypeScript (si no lo tienes)

Para esto es necesario tener tener Node.js y TypeScript instalado como dependencia global. Si no lo tienens puedes usar la siguiente linea para instarlo:

npm install -g typescript

Crear un archivo logica.ts

Ahora, solamente hay que disponer de un archivo con una o varias funciones escritas en TypeScript. Por ejemplo, el siguiente archivo con la función doble:

export function doble(x: number): number {
    return x * 2;
}

Transpilar a JavaScript

Es importante recordar que js2py no soporta export ni el sistema de módulos de ES6, así que deberás transpilar y adaptar el resultado. Esto es, compilar para ES5 como se muestra a continuación:

tsc logica.ts --target ES5 --module none

Esto generará un archivo logica.js con código JavaScript similar al que se muestra a continuacion:

function doble(x) {
    return x * 2;
}

Ejecutar desde Python

Ahora, que se tiene un archivo JavaScript con el código traspalado, simplemente se debe ejecutar como se ha hecho en las secciones anteriores.

import js2py

with open('logica.js', 'r', encoding='utf-8') as f:
    codigo_js = f.read()

contexto = js2py.EvalJs()
contexto.execute(codigo_js)

print(contexto.doble(21))  # 42

Buenas prácticas al ejecutar JavaScript desde Python

Aunque js2py permite una integración muy directa, es importante mantener cierto orden y estructura para evitar errores difíciles de depurar, especialmente si el proyecto crece. Aquí te comparto una serie de buenas prácticas a la hora de usar esta libreria:

Separa el código JavaScript del código Python

Evita incrustar cadenas JS largas dentro de tu código Python. En su lugar:

• Coloca el JavaScript en archivos .js separados.
• Usa with open() para cargarlos.
• Esto mejora la legibilidad y facilita el mantenimiento.

with open("mi_script.js") as f:
    js_code = f.read()

Evita depender de características modernas de JS

js2py solo es compatible con ECMAScript 5.1. Por tanto, evita:

• import / export
• class, let, const
• Promise, async/await
• Arrow functions (() => {})

No es necesario hacer esto de manera manual, puedes convertir tu código a ES5 con herramientas como Babel o el compilador de TypeScript (tsc).

Controla los errores con bloques try/except

Si el código JavaScript falla, js2py lanza una excepción JsException:

import js2py

try:
    ctx = js2py.EvalJs()
    ctx.execute("function error() { throw '¡error!'; } error();")
except js2py.internals.simplex.JsException as e:
    print("Se produjo un error en JavaScript:", e)

Conviértelo a estructuras nativas cuando sea posible

Esto facilita trabajar con los datos y evita errores sutiles:

resultado = ctx.getDatos()         # Objeto JavaScript
datos = resultado.to_dict()        # Diccionario Python

Documenta bien la interfaz entre JS y Python

Cuando tu código JavaScript implemente funciones que serán usadas desde Python, asegúrate de:

• Documentar claramente sus nombres, parámetros y tipos esperados.
• Evitar nombres genéricos como run, calc, doStuff.

Esto previene errores si otro desarrollador (o tú mismo en el futuro) retoma el código.

Automatiza la conversión desde TypeScript o Babel

Si usas TypeScript o ES6, puedes usar tsc o babel para convertir automáticamente el código a ES5 compatible. Ejemplo con TypeScript:

tsc archivo.ts --target ES5 --module none --outDir js_build

Luego desde Python:

with open("js_build/archivo.js") as f:
    js_code = f.read()

Conclusiones

Ejecutar código JavaScript desde Python es una recuso que ofrece múltiples posibilidades, pero debe usarse con cabeza. No es una solución mágica, sino una herramienta extremadamente útil para casos concretos.

Cuándo sí puede tener sentido:

• Ya tienes lógica implementada en JavaScript o TypeScript y quieres aprovecharla desde un entorno Python sin reescribirla.
• El código JavaScript es simple, sin dependencias modernas (ES5 puro), como funciones utilitarias o algoritmos específicos.
• Necesitas compartir lógica entre backend y frontend, por ejemplo, validaciones de formularios o cálculos comunes.
• Quieres usar pequeñas librerías sin dependencias externas, como funciones matemáticas, generadores, transformadores, etc.
• Usas TypeScript y puedes compilarlo a ES5, reutilizándolo también desde Python.

Cuándo no es una buena idea:

• Si necesitas usar librerías modernas (como React, Lodash, D3, etc.) que requieren módulos, DOM o Web APIs.
• Si el código es complejo y depende de características modernas como Promise, fetch, async/await.
• Si la solución es más simple reimplementando la lógica directamente en Python.
• Si no tienes control del código JavaScript (por ejemplo, lo mantiene otro equipo y cambia constantemente).

Recomendación general

Para casos sencillos y controlados, js2py es una opción liviana y efectiva que te permite aprovechar código JavaScript desde Python de forma integrada. Para casos más complejos, será necesario usar Node.js como servicio auxiliar (ejecutado desde subprocess) lo que te dará mayor flexibilidad y escalabilidad.

Nota: La imagen de este artículo fue generada utilizando un modelo de inteligencia artificial.

Apéndice: Crear un entorno virtual para usar js2py con Python 3.10

Dado que js2py no es compatible con Python 3.11 o 3.12, la solución más segura es crear un entorno virtual con una versión de Python soportada (por ejemplo, Python 3.10). Esto te permite instalar y usar js2py sin afectar el resto de tus proyectos o tu sistema.

¿Por qué usar un entorno virtual?

• Aísla dependencias para evitar conflictos con otros proyectos.
• Permite usar una versión de Python específica (por ejemplo, 3.10) solo dentro del entorno.
• Facilita la portabilidad y reproducibilidad del entorno de desarrollo.
• Es buena práctica en proyectos Python, especialmente si usas herramientas como pip, conda o poetry.

Opción 1: Usar venv con Python 3.10

1. Instala Python 3.10 (si no lo tienes). Puedes usar pyenv o descargarlo desde python.org.
2. Crea un entorno virtual:

python3.10 -m venv js2py-env

3. Activa el entorno:

• En Linux/macOS:

source js2py-env/bin/activate

• En Windows (CMD):

js2py-env\Scripts\activate

4. Instala js2py:

pip install js2py

5. ¡Listo! Ya puedes importar y usar js2py sin errores.

Opción 2: Usar conda (más fácil si usas Anaconda/Miniconda)

Si trabajas con Anaconda o Miniconda, puedes crear un entorno con Python 3.10 fácilmente:

conda create -n js2py-env python=3.10
conda activate js2py-env
pip install js2py