Si alguna vez has realizado secuencias de comandos en Mac, lo más probable es que hayas visto AppleScript. AppleScript ha sido el estándar de facto para mallar aplicaciones juntas y para crear secuencias de comandos de interfaz de usuario.

Desde OS X 10.10 Yosemite, existe un segundo lenguaje de programación para la interfaz de usuario: JavaScript para Automatización (JXA).

En este tutorial, te ayudaré a aprender esta alternativa a AppleScript con algunos ejemplos del mundo real.

Ejecutando JXA

Hay muchas formas de ejecutar un script JXA. La forma estándar de ejecutar el script JXA es con el Editor de Script que forma parte del sistema operativo.

Con el cuadro de lista en la esquina superior izquierda, debajo del botón de detención, configurado en JavaScript en lugar de AppleScript, tienes un intérprete de JavaScript completo. Para acceder a la aplicación actual para secuencias de comandos, agrega estas líneas:

//
// Get the current application and set it up
// for scripting.
//
var app = Application.currentApplication();
app.includeStandardAdditions = true;

La primera línea obtendrá el objeto JXA para la aplicación que ejecuta el código. La segunda línea te permite agregar cuadros de diálogo y otras ventajas a ese objeto de aplicación.

Ahora añade esto al guión.

//
// Send a message to the user.
//
app.displayAlert("This is a message");

Cuando ejecutas esto, desplegará un diálogo de mensaje con el texto "Este es un mensaje".

Si quieres escoger de una lista de ítems, añade lo siguiente:

//
// Let the user pick from a list.
//
var lang = app.chooseFromList(['JavaScript', 'AppleScript', 'JXA'], { withPrompt: 'What is your favorite language?' });
app.displayNotification(lang, { withTitle: 'Language Chooser', subtitle: 'Your Choice is...' });

La función chooseFromList() toma una matriz de cadenas y un objeto opcional con opciones de configuración. La opción de configuración withPrompt te permite configurar el texto que se muestra arriba de la lista de cadenas. La cadena seleccionada será devuelta.

La función displayNotification () se usa para mostrar una notificación con la información suministrada al usuario. Puedes establecer el título y los subtítulos de la notificación con el objeto de configuración.

Cuando presiones el botón Ejecutar (el triángulo que apunta a la derecha en la barra de herramientas), elige tu lenguaje de programación favorito en el cuadro de diálogo.

Cuando seleccionas uno, como JXA, tu selección se muestra en una ventana emergente de notificación. Si el usuario selecciona cancelar en el cuadro de diálogo, el resultado devuelto será el falso booleano.

Si necesitas obtener información del usuario, usa la función de displayDialog() Con esta función necesitarás llamarlo adentro de la estructura try...catch porque si el usuario presiona el botón de cancelar, arrojará un error. Tipea el siguiente código:

//
// Get user typed information.
//
try {
        var age = app.displayDialog('How old are you?', { defaultAnswer: "" });
        app.displayNotification(age.textReturned + ' years old!', { withTitle: 'You are How old?' });
} catch(e) {
        app.displayNotification('User Canceled', { withTitle: 'Error' });
}

Al ejecutar ese código, se le solicitará su edad en un aviso. Cuando escriba una edad y haga clic en Aceptar, se mostrará una notificación que le preguntará su nombre. Si presiona Cancelar, se muestra una notificación con el texto Error Usuario cancelado.

Un Clásico Ejemplo

El ejemplo clásico de la automatización del programa es abrir iTunes y reproducir una canción. En un nuevo archivo llamado iTunesScript.scpt, agrega el siguiente código:

//
// Get a application object for iTunes.
//
var itune = Application('iTunes');
itune.activate();

//
// Play a song.
//
itune.play();

//
// To pause:
// itune.pause()
//
// To stop:
// itune.stop()
//

//
// Get the current track information.
//
var track = itune.currentTrack()

var info = track.name() + " - " + track.artist() + " - " + track.album() + " - " + track.duration();

//
// Display the information to the user.
//
var app = Application.currentApplication();
app.includeStandardAdditions = true;

app.displayNotification(info, { withTitle: 'iTunes Song' });

Este script reproducirá la canción actual en iTunes y mostrará el nombre, el artista, el álbum y la duración de las canciones en una notificación.

Lo básico para controlar una aplicación es obtener un objeto de la aplicación, ejecutar métodos del objeto para obtener la información necesaria o el efecto deseado. Puedes obtener información sobre los métodos válidos de cada objeto de aplicación desde el menú Archivo> Abrir diccionario en el Editor de secuencias de comandos.

Si deseas ejecutar el script en una línea de comando, escribe este comando en una ventana de terminal:

osascript -l JavaScript iTuneScript.scpt

El -l JavaScript le dice al osascript que el script está usando JXA

JXA en Alfred

En el archivo zip de descarga, encontrarás el flujo de trabajo Alfred 3 de QuickEditJXA.alfredworkflow.

Este flujo de trabajo te permite copiar una selección en un programa, pegarla en otro programa que configuraste de antemano y luego copiar las ediciones nuevamente al programa original.

Este es un flujo de trabajo muy útil que ahorra mucho tiempo. Mi editor preferido para hacer estos cambios rápidos es TextWell.

El conjunto verde de bloques copia el texto ya seleccionado y lo coloca en el editor. En Alfred, una acción puede dividirse en cualquier número de otras cadenas de acción. En este, se divide de dos maneras.

La línea de acción superior se realiza primero y luego retrocede a la segunda línea de acción. La primera acción de la línea superior es un script JXA:

function run(argv) {
        var query = argv[0];

        //
        // Get the name of the current application.
        //
        var system = Application("System Events");

        var proc = system.processes.whose({ frontmost: {'=': true } }).name();

        return proc;
}

Este script JXA obtendrá el nombre de la aplicación superior del subproceso de Eventos del sistema. La línea 7 obtiene un objeto de aplicación en Eventos del sistema. La línea 9 busca en la matriz de procesos activos con un comando .whose ({frontmost: {'=': true}}) que encuentra el proceso con la propiedad frontmost establecida en true. Luego devuelve el nombre de ese proceso.

Un script JXA en Alfred debe tener la función run () que acepte una matriz de entradas. Lo que devuelve esta función se pasa al siguiente bloque del flujo de trabajo: un comando de escritura en archivo. Esto guarda el nombre de la aplicación actual en el archivo para volver a esta aplicación después de la edición.

La segunda línea de acción llama al siguiente script JXA:

function run(argv) {
        var editorName = argv[0];

        var ed = Application(editorName);
        ed.activate();
}

El nombre del editor se le pasa desde el bloque Arg y Vars anterior. La aplicación de editor establecida por el usuario en la sección de variables de entorno del flujo de trabajo de Alfred. La línea 4 obtiene el objeto de aplicación para el editor y la línea 5 activa el editor.

En la acción de pegar (los bloques morados), hay una rutina JXA:

ObjC.import('stdlib')

function run(argv) {
        var app = Application.currentApplication();
        app.includeStandardAdditions = true;

        var dataDir = $.getenv('alfred_workflow_data');

        var handle = app.openForAccess(dataDir + "/process.txt");
        var prog = app.read(handle);

        var dest = Application(prog.trim());
        dest.activate();

        return ";
}

La línea 1 incluye stdlib, que es la biblioteca de Objective C para el acceso estándar al sistema. JXA le permite usar cualquier biblioteca que esté en el sistema para usar en sus scripts. ¡Literalmente puedes escribir una aplicación completa en solo JXA!

Las líneas 4–5 obtienen el objeto de las aplicaciones actuales y lo configuran para las secuencias de comandos. La línea 7 usa stdlib para obtener la configuración de la variable de entorno por Alfred: alfred_workflow_data. Esta variable de entorno proporciona la ruta al directorio de datos para el flujo de trabajo actual.

La línea 9 abre el archivo process.txt en el directorio de datos del flujo de trabajo, y la línea 10 lee su contenido. Las líneas 12 a 13 llevan la aplicación al frente.

Una vez que la aplicación original está al frente, un retraso espera a que el sistema operativo se ponga al día, y luego el flujo de trabajo emite un cmd-v para pegarlo en la aplicación.

La versión original de este flujo de trabajo utilizaba PHP y Applescript. Al usar JXA, esta versión del flujo de trabajo se ejecuta mucho más rápido y de manera más confiable. De la misma manera, puedes usar JXA en otros programas también. Keyboard Maestro, Hazel y TextSoap, mediante el uso de un script de Automator, solo por nombrar algunos.

Otras Lecturas

También puedes encontrar más información sobre JXA en estos sitios web:

• Notas para desarrolladores de Apple sobre JavaScript para automatización
• JXA Cookbook
• Ejemplos y Rutinas Útiles de JXA de Dan Thomas
• Keyboard Maestro Wiki en JXA

Conclusión

En este tutorial, le mostré cómo utilizar JXA en el Editor de secuencias de comandos, en la línea de comandos y en un flujo de trabajo de Alfred. Ahora que sabes cómo usar JXA en tu Mac, puedes crear algunos scripts útiles para automatizar tareas.

Déjame saber, en los comentarios a continuación, lo que creas.