Ejecutar JavaScript en el terminal en Ubuntu

¿Quieres ejecutar JavaScript en el terminal? Es indudable que JavaScript está viviendo momentos de gloria. Y creo que esto solo es el comienzo de lo que tiene que venir. Actualmente y de acuerdo a las estadísticas recogidas por StackOverflow en 2.018, JavaScript se sitúa como el lenguaje mas popular.

Si estás un poco al tanto de JavaScript, eeguro que has oído hablar de Angular, React de Facebook o Vue.js. Y si no, es probable que también.

GNOME adoptó, ya en 2.013, JavaScript como el lenguaje preferente para el desarrollo de aplicaciones para GNOME. Esto no quiere decir que se abandonan otros lenguajes, sino que se prioriza este sobre los demás. Pero, no solo esto, por parte de GNOME se anima a los desarrolladores al uso de JavaScript a la hora de implementar nuevas aplicaciones. Y además, aseguran que están trabajando para mejorar el flujo de trabajo de los desarrolladores que utilizan JavaScript.

Ejecutar JavaScript en el terminal en Ubuntu

JavaScript en el terminal

Mis batallitas

Hace algún tiempo leí un artículo en PC Suggest, en el que hacía mención precisamente, de lo que he comentado en la introducción, sobre de JavaScript se estaba convirtiendo cada vez mas en el lenguaje mas popular. Además, añadía que, estaba traspasando el mundo de los navegadores web, llegando al punto de que los microcontroladores comienzan a ejecutar JavaScript.

En este artículo, explicaba como poder ejecutar JavaScript en el terminal utilizando Node.js.

Esto me hizo dar una vuelta al asunto, y recordé el artículo, sobre la adopción de JavaScript como lenguaje para el desarrollo de aplicaciones… con lo que… Si tu entorno de escritorio es Ubuntu no necesitas instalar nada para poder comenzar a ejecutar JavaScript en el terminal.

¡Hola, Mundo!, en dos líneas de código…

Hacer tu propio ¡Hola, Mundo!, solo te llevará dos líneas de código. Tan solo necesitas crear un archivo test.js, con el siguiente contenido,

1
2
#!/usr/bin/gjs
print("¡Hola, Mundo!");

Para ejecutarlo, o bien escribes la orden gjs test.js o bien, le das permisos de ejecución, y como si se tratara de cualquier otro script o aplicación, ejecutas ./test.js.

También puedes ejecutar directamente gjs y escribir print("¡Hola, Mundo!");

Espectacular, ¿No te parece?

Pasando argumentos…

Ahora bien, la mayoría de los scripts que haces o utilizas, necesita recibir argumentos para procesarlos… ¿Cómo se hace esto con JavaScript?… De lo mas sencillo, solo tenemos que utilizar la variable ARGV.

Vamos a verlo en un sencillo ejemplo, que nos permite calcular el IMC (índice de masa corporal),

1
2
3
4
5
#!/usr/bin/env gjs
var peso = ARGV[0];
var altura = ARGV[1];
var IMC = peso / Math.pow(altura, 2);
print(IMC);

Es tan sencillo como que todos los argumentos se recogen en un array.

Pero no solo esto, sino que además JavaScript en GNOME se está modernizando y actualizando a pasos agigantados, siguiendo muy de cerca los pasos marcados por SpiderMonkey. Así por ejemplo, fíjate en el siguiente script para calcular el factorial de un número,

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
#!/usr/bin/env gjs

function factorial(n){
    if (n == 0)
        return 1;
    else
        return n * factorial(n-1);
}
var hasta = ARGV[0];
print(`factorial de ${hasta}`);
for (let i = 0; i <= hasta; i++){
    print(i + "! = " + factorial(i));
}

Recibiendo argumentos

Por supuesto que la salida print de cualquier script realizado en JavaScript, se corresponde con una entrada para otros scripts. Con lo que ya tenemos nuestra solución para realizar sencillos o complejos scripts con JavaScript en el terminal.

Eso no es todo amigos…, aún hay mas… Gtk

Por supuesto, si los desarrolladores de GNOME han pensado en JavaScript para implementar aplicaciones, es necesario que exista una forma de interactuar con Gtk, y por supuesto que existe.

Por ejemplo, podemos hacer una sencilla aplicación que nos muestre un cuadro de diálogo en el que nos solicite el nombre. Al pulsar el botón de aceptar, nos devolverá el nombre…

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
#!/usr/bin/env gjs

imports.gi.versions.Gtk = '3.0';
imports.gi.versions.GLib = '2.0';
imports.gi.versions.Gio = '2.0';

const Gio = imports.gi.Gio;
const GLib = imports.gi.GLib;
const Gtk = imports.gi.Gtk;


Gtk.init(null);

const win = new Gtk.Window({
    type : Gtk.WindowType.TOPLEVEL,
    title: '¡Hola, Mundo!',
    window_position: Gtk.WindowPosition.CENTER
});

win.set_default_size(200, 80);

var grid = new Gtk.Grid({'column-spacing': 5,
             'row-spacing': 5,
             margin: 5});
win.add(grid);
var label = new Gtk.Label({label: 'Dime tu nombre:',
               xalign: 0});
grid.attach(label, 0, 0, 1, 1);
var entry = new Gtk.Entry();
grid.attach(entry, 1, 0, 1, 1);
var box = Gtk.Box.new(Gtk.Orientation.HORIZONTAL, 5);
grid.attach(box, 0, 1, 2, 1);

var b_cancelar = new Gtk.Button({label: 'Cancelar'});
box.pack_start(b_cancelar, true, false, 0);
b_cancelar.connect('clicked', ()=>{Gtk.main_quit();});
var b_aceptar = new Gtk.Button({label: 'Aceptar'});
b_aceptar.connect('clicked', ()=>{
    print(entry.get_buffer().get_text());
    Gtk.main_quit();});
box.pack_start(b_aceptar, true, false, 0);

win.connect('show', () => {
    win.set_keep_above(true);
    Gtk.main();
});

win.connect('destroy', () => Gtk.main_quit());
win.show_all();

Y el resultado, es el esperado, por supuesto…

Por supuesto, en este caso, el asunto se complica un poco. Sin embargo, este script, es tan sencillo o mas que cualquier otro de los que se utilizan para solicitar datos y realizar acciones.

Algunos comentarios

  • En las primeras líneas utilizamos imports.gi.versions.Gtk = '3.0'; para asegurarnos que estamos utilizando la versión de la librería correcta.
  • Gtk.init(null); esto es necesario… sin mas.
  • b_cancelar.connect('clicked', ()=>{Gtk.main_quit();}); esto es magia para los sentidos. Mas simple creo que no se puede hacer…

Conclusión

Desde mi modesto e insignificante punto de vista, la elección de JavaScript como punto de lenguaje prioritario para el desarrollo de aplicaciones para GNOME, es todo un acierto. Sobre todo, tal y como he comentado en la introducción, teniendo en cuenta la tendencia actual de este lenguaje.


Más información,