Técnicas avanzadas de AppleScript

Anteriormente presentamos una introducción básica a AppleScript, y este artículo cubrirá una serie de consejos y trucos útiles para AppleScript que te ayudarán a crear algunos sorprendentes scripts avanzados.

Este artículo forma parte de una serie de publicaciones que "reviven" algunos de los viejos tutoriales preferidos de nuestros lectores, cuyo contenido aún puede resultar muy útil. Este post fue publicado originalmente el 24 de septiembre de 2009.

Primero, haz tu tarea

Este es el tercer artículo de mi serie sobre automatización. Asegúrate de revisar mis Guías para principiantes tanto de AppleScript como de Automator para familiarizarte con el scripting y la automatización en general.

En esos artículos cubro funciones básicas como las variables que no explicaré aquí para reducir la redundancia. Una vez que te hayas familiarizado con el AppleScript básico, estarás listo para pasar a lo bueno. ¡Empecemos!

If e If, Else

Las sentencias "If" e "if, else" se utilizan cuando se tiene un determinado comando o conjunto de comandos que se desea que el script realice sólo si se cumplen los requisitos establecidos.

Por ejemplo, digamos que quieres que el script te diga si el valor de dos variables, x e y, es igual o diferente. Utilizarías una sentencia "if" para decirle al script cómo reaccionar ante cada situación.

Sólo hay tres posibilidades: x es mayor que y, y es mayor que x, o x = y. Empecemos con una sentencia "if" básica y vayamos haciéndola más compleja.

[applescript] --Declare Variables set x to 5 set y to 78

--Run if Statement if x < y then return "yes" end if [/applescript]

Aquí declaré primero dos variables y asigné valores a cada una. Luego le dije al Editor de Script que devolviera "yes" si x es mayor que y. Observa que la estructura de la sentencia "if" es muy parecida a la de un bloque tell. Debes terminar cada sentencia "if" con "end if" o tu código no compilará.

Debes terminar cada sentencia "if" con "end if" o tu código no compilará.

La estructura básica de la sentencia es la siguiente: Si (una declaración dada) es verdadera, entonces haz lo siguiente. Asegúrate de incluir la declaración que se va a probar y "then" en la misma línea que "if".

A continuación, coloca las instrucciones en la(s) siguiente(s) línea(s) antes de finalizar el bloque. Si compilas y ejecutas la sentencia anterior, el Editor de Script debería devolver un "yes", indicando que x es de hecho menor que y. Si x fuera mayor que y, no pasaría nada porque no hemos programado para esa contingencia. Intentemos algo un poco más complejo.

[applescript] --Declare Variables set x to 78 set y to 5

--Run if Statement if x < y then return "yes" else return "no" end if [/applescript]

Aquí hemos incluido una sentencia "else" que indica al Editor de Script qué hacer si la sentencia condicional inicial es falsa. La estructura es la siguiente: Si (una sentencia dada) es verdadera, realiza la acción a, en caso contrario, realiza la acción b.

Esto es suficiente para muchas situaciones, pero aún no hemos creado una contingencia para nuestra tercera situación: x = y. Para lograrlo utilizaremos "else if".

[applescript] --Declare Variables set x to 5 set y to 5

--Run if Statement if x < y then return "x is less than y" else if x > y then return "x is greater than y" else return "x is equal to y" end if [/applescript]

Aquí hemos tenido en cuenta los tres distintos escenarios. La ejecución de este script debería devolver "x is equal to y". Fíjate que el último escenario sólo requiere un "else" en lugar de un "else if". Esto se debe a que si las dos primeras sentencias son falsas, debe darse el caso de que x = y (salvo errores de entrada).

Booleanos

Asignar un valor verdadero a una variable es fácil. Basta con establecer la variable como verdadera o falsa.

[applescript] set theBoolean to false

if theBoolean = true then return "It's true!" else return "That's just not true" end if [/applescript]

Por ahora sólo hay que saber que es así de fácil. Veremos un uso más práctico en el último ejemplo.

Mostrar un cuadro de diálogo

AppleScript hace que sea súper sencillo mostrar información a un usuario. Sólo tienes que escribir lo siguiente:

[applescript] display dialog "Greetings!" [/applescript]

Esto debería producir una simple ventana que muestre un saludo y dos botones: "Cancelar" y "Aceptar". También es posible personalizar esos botones con el siguiente código:

[applescript] display dialog "How are you?" buttons {"Great", "Horrible", "None of your business!"} default button 3 [/applescript]

Este código tiene tres secciones. La primera sección muestra un cuadro de diálogo con el texto "How are you?" La segunda sección determina cuántos botones tendrá el cuadro de diálogo y qué dirán. En este caso tenemos tres botones. Fíjate que el conjunto de botones debe ir entre paréntesis y cada botón entre comillas.

Fíjate que el conjunto de botones debe ir entre paréntesis y cada botón entre comillas.

El cuadro de diálogo resultante

Por último, la tercera sección indica al cuadro de diálogo cuál debe ser el botón por defecto. Si se ajusta el botón por defecto a 3, se destacará el tercer botón cuando se muestre el cuadro de diálogo.

Tener un cuadro de diálogo con múltiples botones es genial, pero no sirve de nada si no sabes cómo utilizar la entrada recibida del usuario como resultado. Tomemos lo que acabamos de aprender sobre los diálogos y combinémoslo con una sentencia "if, else" para ver cómo podemos utilizar los cuadros de diálogo para llevar a cabo un... bueno... diálogo.

[applescript] --Create a dialog with 3 buttons display dialog "How are you?" buttons {"Great", "Horrible", "None of your business!"} default button 1

--If user is great if result = {button returned:"Great"} then display dialog "Excellent, carry on good sir"

--If user is Horrible else if result = {button returned:"Horrible"} then display dialog "You need to cheer up!"

--If user is a jerk else display dialog "Excuse me pal!" end if [/applescript]

Como puedes ver, la línea de código inicial está tomada directamente del ejemplo anterior. La siguiente parte utiliza una sentencia "if, else" para responder a cada pulsación de botón. La sintaxis es esencialmente: Si el usuario pulsa el botón x, entonces haz la acción a, si el usuario pulsa el botón y, entonces haz la acción b, si no haz la acción c.

Si el usuario pulsa el botón x, entonces realiza la acción a, si el usuario pulsa el botón y, entonces realiza la acción b, si no realiza la acción c.

Recibir entradas de texto de un usuario

A veces un simple botón no es suficiente. Con frecuencia escribo scripts que requieren que el usuario introduzca texto. Para ello, utilizamos un cuadro de diálogo como el anterior, con una sintaxis ligeramente diferente.

[applescript] --Display Dialog and Get Input display dialog "How are you?" default answer "Tell me how you feel"

--Get Answer & Return Comment set theAnswer to (text returned of result) display dialog "I'm glad you feel so " & theAnswer [/applescript]

Al poner "default answer" en nuestro código, le decimos a AppeScript que queremos que el usuario introduzca un texto en respuesta. Entonces establecemos una variable con el texto devuelto por el usuario. Luego podemos usar esa variable en cualquier lugar que queramos usar la entrada.

Recepción de entrada de texto de un usuario

Manejo de errores: El bloque Try

Dejar que los usuarios introduzcan datos es peligroso. Si buscas una respuesta o un tipo de dato muy específico, puedes estar seguro de que tus usuarios meterán la pata y provocarán un error.

Si buscas una respuesta o un tipo de dato muy específico, puedes estar seguro de que tus usuarios meterán la pata y provocarán un error.

Por esta razón, necesitas filtrar lo que viene del usuario para asegurarte de que es exactamente el tipo de entrada que quieres. Para ello, utilizaremos un bloque try y un par de sentencias "if".

[applescript] --Display Dialog and Get Input display dialog "Pick a number 1-10" default answer "Only Enter Numbers Less than 11!"

--Test For Invalid Characters try set theAnswer to (text returned of result) as number on error display dialog "Invalid Input" return end try

--Test for Correct Numbers if theAnswer < 1 then set theTest to 0 else if theAnswer < 11 then set theTest to 1 else set theTest to 0 end if

--Return Comments to user if theTest = 0 then display dialog "Invalid Input" else display dialog "You chose the number " & theAnswer end if [/applescript]

El código anterior es complicado, así que vamos a desglosarlo. La primera sección simplemente muestra un diálogo y pide al usuario que elija un número. Sin embargo, sólo queremos aceptar números del uno al diez. Si se introduce algo más, queremos decirle al usuario que la entrada no es válida.

En la segunda sección se comprueba si se ha introducido algún dato no numérico, como letras o símbolos. Un bloque try nos permite decirle a AppleScript que intente ejecutar el código y ver qué sucede.

Un bloque try nos permite decirle a AppleScript que intente ejecutar el código y ver qué sucede.

Aquí le hemos dicho a AppleScript que intente tomar el texto devuelto por el usuario y convertirlo en un número. Si no hubiera un bloque try y ejecutáramos este comando, arrojaría un error y cerraría el programa si el usuario introdujera una letra o un símbolo.

Sin embargo, el bloque try nos permite dar a AppleScript un comando especial si se produce un error. En este caso mostramos un cuadro de diálogo "Invalid Input" si se produce un error. Luego ordenamos que el script termine escribiendo "return". Fíjate que un bloque try debe terminar con el comando "end try".

A la hora de programar, siempre hay que tener en cuenta todos los posibles errores que puedan cometer los usuarios y crear una contingencia para ello. Intenta ejecutar el código anterior e introducir algunos caracteres no válidos. Puedes ver que no importa lo que introduzcas, el script sólo acepta los números del 1 al 10.

A la hora de programar, siempre hay que tener en cuenta todos los posibles errores que puedan cometer los usuarios y crear una contingencia para ello.

Manejadores

De la misma manera que las variables almacenan mucha información en un pequeño fragmento de código, los manejadores (a menudo llamados funciones en otros lenguajes de programación) son una excelente manera de ejecutar repetidamente un gran número de comandos con muy poco código.

Al almacenar varios comandos en un solo fragmento, te ahorras mucha programación y simplificas enormemente tu código. He aquí un ejemplo:

[applescript] --Define Handler on additionHandler(theVariable) set x to 5 set y to 5 set z to x + y + theVariable display dialog "10 + " & theVariable & " = " & z end additionHandler

--Run Handler additionHandler(8)

--Run Handler Again set theNumber to 145 additionHandler(theNumber) [/applescript]

La sintaxis para definir un manejador es: on HandlerName(variable), seguido de los comandos a ejecutar, seguido de "end handlerName".

La variable entre los paréntesis (theVariable) es la parte que debemos definir cada vez que ejecutemos el manejador. La primera sección de código por sí misma no hará nada porque aún no hemos ejecutado el manejador, sólo lo hemos definido.

Fíjate que cuando ejecutamos el manejador escribimos el nombre del manejador seguido de un número entre paréntesis. El manejador ahora tomará este número y lo insertará en cualquier lugar donde hayamos escrito "theVariable" en nuestra definición del manejador.

En este caso, establecerá la variable elegida en z y la sumará a x(5) e y(5) y mostrará un diálogo con la respuesta. Así, additionHandler(8) establece z en 8 y luego suma 10 (5+5) y nos da el resultado de 18. Cuando volvemos a ejecutar el manejador, se ejecuta el mismo código en un número diferente.

Hice esto para mostrarte que puedes definir una variable en cualquier lugar e insertarla en tu manejador. Aquí hemos establecido theNumber en 145 y luego ejecutamos el manejador en theNumber.

Ten en cuenta que cualquier variable definida dentro de un manejador no existe fuera del manejador. Por lo tanto, si terminas este script con "return z" obtendrás un error que te dirá que "z" no está definida.

Asegúrate de darle a todas tus variables nombres descriptivos y únicos.

Esto significa que técnicamente puedes utilizar nombres de variables idénticos para las variables definidas dentro y fuera de un manejador. Sin embargo, esto hace que el código sea desordenado y confuso, lo que debería evitarse. Asegúrate de dar a todas tus variables nombres descriptivos y únicos.

Bloques de repetición

Es frecuente que te encuentres con la necesidad de crear un paso en tu script que se repita un número determinado de veces.

En AppleScript realizamos bucles con bloques de repetición.

Muchos lenguajes de programación llaman a esto un bucle. En AppleScript realizamos bucles con bloques de repetición. Los bloques de repetición son bastante simples y versátiles, aquí hay un ejemplo sencillo:

[applescript] set theNumber to 5

repeat theNumber times display dialog "Isn't this annoying?" end repeat [/applescript]

Aquí hemos creado un cuadro de diálogo y lo hemos configurado para que se repita cinco veces seguidas. Este ejemplo, aunque inútil, te muestra lo fácil que es crear pasos que se repiten.

Sin embargo, no siempre se sabe cuántas veces se quiere repetir un determinado paso. A menudo es necesario repetir un paso o una serie de pasos mientras se cumpla una determinada condición. Para estos casos utilizamos un bloque "repeat while".

[applescript] set theNumber to 1

repeat while (theNumber < 2) display dialog "Play Again?" buttons {"Yes", "No"} default button 1 if result = {button returned:"Yes"} then display dialog "Please insert more quarters!" buttons {"OK"} default button 1

else display dialog "Goodbye!" default button 2 set theNumber to (theNumber + 1) end if

end repeat [/applescript]

Aquí hemos configurado el diálogo que se repite mientras theNumber es menor que 2. Si el usuario dice que quiere jugar de nuevo, se le da un mensaje para insertar más monedas y el diálogo se repite.

Mientras el usuario siga pulsando "yes", el diálogo se repite. Cuando el usuario selecciona "No", añadimos uno a theNumber, estableciendo el valor en dos. El script ve que el requisito de verdad se ha convertido en falso y deja de repetir la acción.

Engranar todo

En lugar de dejarte con varios fragmentos de código inconexos, pensé que sería mejor dar un último ejemplo que integre todo lo que hemos aprendido anteriormente. Vamos a tomar el ejemplo de "elegir un número" de arriba y convertirlo en una secuencia de comandos completamente funcional.

[applescript] --Set Random Number set randomNumber to random number from 1 to 10

--Boolean to Test if Script Should be Repeated set repeatTest to true

--If Result Is a Number, Change to True and See if the Number is Between 1 and 10 set testNumbers to false

--If Result Passes All Previous Tests, is it Correct? set winningTest to false

--Count Number of Guesses set tryCount to 0

--Generic Dialog Handler on dialogBox(theMessage) display dialog theMessage end dialogBox

--Repeat if Any Tests Are Failed repeat while (repeatTest = true) --Display Dialog & Get Result display dialog "Choose a number 1-10" default answer "Enter Only Numbers 1-10" default button 2

set theAnswer to (text returned of result)

--Is Result a Number? try set theAnswer to theAnswer as number set testNumbers to true on error dialogBox("Invalid Input") end try

--Is Result Between 1 and 10? if (testNumbers = true) then --Test for Correct Numbers if theAnswer < 1 then dialogBox("Invalid Input") else if theAnswer < 11 then set repeatTest to false set winningTest to true else dialogBox("Invalid Input") end if end if

--Is Result the Correct Answer? if winningTest = true then if theAnswer = randomNumber then dialogBox("You Guessed it in " & tryCount & " tries!") else dialogBox("Try Again!") set repeatTest to true set tryCount to tryCount + 1 end if end if

end repeat [/applescript]

A primera vista, este script puede parecer intimidante. Sin embargo, si has analizado todos los ejemplos anteriores, todo debería tener mucho sentido.

Paso 1: Declara tus variables

Primero, declaramos nuestras variables, en su mayoría booleanas en este punto. Luego creamos un manejador (dialogBox) para mostrar nuestros diversos diálogos a lo largo del script. A continuación, se pide al usuario que elija un número entre 1 y 10. La respuesta se somete a tres pruebas distintas.

Paso 2: Comprobación de la entrada

A continuación, comprobamos si la entrada contiene letras o símbolos. Luego comprobamos si el número devuelto por el usuario está en el rango aceptable (1-10).

Paso 3: ¿Coincide la entrada con el número aleatorio?

Por último, comprobamos si la suposición del usuario coincide con el número aleatorio generado por el script.

Utilizando booleanos y sentencias "if", el script está estructurado de manera que cada prueba consecutiva sólo se ejecuta si la entrada pasa la prueba anterior. Si alguna prueba devuelve falso, el bloque de repetición comienza de nuevo y las siguientes acciones no se ejecutan.

Anidamiento

Fíjate en que es posible anidar sentencias if dentro de sentencias if. Esto también es válido para los bloques de repetición y los bloques tell. Sin embargo, hay que tener cuidado con el uso excesivo de sentencias anidadas. Una o dos capas de profundidad no son malas, pero todo lo que vaya más allá se vuelve complicado y difícil de seguir.

La ejecución de este script debería permitirte elegir un número y seguir adivinando hasta que lo aciertes. Juega con él unas cuantas veces y comprueba cuántas veces tardas en acertar.

Conclusión

Este artículo te ha guiado a través del uso de sentencias if, booleanas, cuadros de diálogo, entradas de usuario, manejadores, manejadores de error y bloques de repetición.

En este momento deberías estar preparado para crear algunos scripts muy sofisticados que automatizarán los flujos de trabajo más difíciles. Simplemente guarda esta página en tus favoritos y úsala como una hoja de referencia para todos tus futuros scripts.

Como mencioné anteriormente, esta es la tercera entrega de mi serie sobre automatización. Tus comentarios son muy importantes para decidir sobre qué escribo, así que avísame si quieres que siga haciéndolo. Si la demanda es lo suficientemente grande, ¡con gusto escribiré más!