Академический Документы
Профессиональный Документы
Культура Документы
CONTENIDO
AUTOPLAY MEDIA STUDIO 7.X.X ---------------------------------------------------------------------- 4
INTRODUCCIÓN ------------------------------------------------------------------------------------------------- 4
IF (SI) ---------------------------------------------------------------------------------21
WHILE (MIENTRAS) ---------------------------------------------------------------------22
REPEAT (REPITA) -----------------------------------------------------------------------23
FOR (PARA) ----------------------------------------------------------------------------23
TABLES (ARRAYS) | TABLAS (MATRICES) ----------------------------------------------------- 24
FUNCIONES ------------------------------------------------------------------------------------------------------ 31
CONSIDERACIONES FINALES-------------------------------------------------------------------------- 51
a = 5;
if a <10 then
Dialog.Message ("¿Adivina qué?", "a es menor que 10");
end
8. Una vez que se ejecuta la aplicación, haga clic en el botón que has
creado.
Esto hará que se ejecute el evento Clic del objeto botón, de modo que el
codigo (Script) que ha introducido se llevará a cabo. Deberías ver el
siguiente cuadro de diálogo al dar clic en el botón:
6
Script es Global
El motor de scripting es global para el entorno en tiempo de ejecución. Esto
significa que todos los eventos de su voluntad "saber" acerca de otras
variables y funciones declarados en el resto del producto. Por ejemplo, si
asigna "mivar = 10;" en el proyecto en el evento “On Startup”, “mivar”
será igual a 10, cuando el próximo evento es activado. Hay formas en torno
a esta naturaleza mundial, pero es generalmente cierto en el caso del motor
de scripting.
Por ejemplo:
ABC = 10;
aBC = 7;
Comentarios
Puede insertar comentarios no ejecutables en sus escrituras para explicar y
documentar el código. En un script, cualquier texto después de dos guiones
(--) en una línea será ignorado. Por ejemplo:
... o:
-- [[Esto es
un comentario
multi-línea]] --
a = 10;
Usted debe usar los comentarios para explicar sus escrituras en la medida
de lo posible, a fin de que sean más fáciles de entender por usted mismo y
otros.
Script 1:
a = 10
Mivar = a
Script 2:
a = 10; mivar = a;
8
Script 3:
a = 10;
Mivar = a;
Variables
¿Cuáles son las variables?
Las variables son muy importantes para los script en AutoPlay. Las variables
son, simplemente, "apodos" o "marcadores" de los valores que deben ser
modificados o reutilizados en el futuro. Por ejemplo, la siguiente secuencia
de comandos asigna el valor 10 a una variable llamada "cantidad".
cantidad = 10;
Aquí hay un par de ejemplos que demuestran cómo se puede operar sobre
la variable "cantidad":
cantidad = 10;
cantidad = cantidad + 20;
Dialog.Message ("Valor", cantidad);
a = 10;
b = a;
Dialog.Message ("Valor", b);
foo = 10;
Variables locales
Por naturaleza global del motor de script, significa que una variable
conservará su valor en todo el proyecto. Sin embargo, puede hacer que las
variables no sean globales, utilizando las palabras clave "local." Poner la
palabra "local" en frente de una asignación a variable crea una variable
que es local a la actual función o script.
Por ejemplo, digamos que usted tiene los siguientes tres script en el mismo
proyecto:
Script 1:
-- Asignamos el valor 10 a x
x = 10;
Script 2:
local x = 500;
Dialog.Message ("El valor local de x es:", x);
x = 250; -- esto cambia a local a x, no es Global
Dialog.Message ("El valor local de x es:", x);
Script 3:
10
Supongamos que estos tres script se realizan una tras otro. El primer script
da el valor 10 a x. Dado que todas las variables son globales por defecto, x
tendrá este valor dentro de todos los demás script también. El segundo
script hace una sesión local de x, dándole el valor de 500, pero sólo dentro
de ese script. Si cualquier otra cosa dentro de ese script quiere tener acceso
al valor de x, se vera el valor local en lugar del valor global. Esto sucede
porque la variable "x" ha sido sustituida temporalmente por otra variable
que se ve igual, pero tiene un valor diferente.
Por último, el tercer script muestra el valor global de x, que sigue siendo
10.
Nombres de Variables
Los nombres de variables pueden estar compuestos de cualquier
combinación de letras, dígitos y guión bajo (underscores), siempre que no
comiencen con un número y no entren en conflicto con palabras clave
(reservadas).
un
strNombre
_Mi_Variable
dato1
dato_1_23
Índice
bReset
nContar
1
1dato
%% MiValor
$ strDato
11
para
local
_PrimNombre + Apellidos_
Nombre de usuario
Tipos y Valores
El lenguaje de scripting de AutoPlay es dinámicamente tipado. No hay
ningún tipo de definiciones - en lugar de ello, cada valor tiene su propio
tipo.
Lo que esto significa es que usted no tiene que declarar una variable a ser
de un determinado tipo antes de usarlo. Por ejemplo, en C++, si desea
utilizar un número, usted tiene que declarar primero el tipo de la variable y,
a continuación, asignar un valor a la misma:
int j;
j = 10;
j = 10;
j = "Hola";
Número (Number)
Un número es exactamente eso: un valor numérico. El número representa
el tipo de números reales, concretamente, valores de doble precisión de
punto flotante. No hay distinción entre enteros y números de punto flotante
(también conocidos como "fracciones ")... todos ellos son sólo" números”.
He aquí algunos ejemplos de números válidos:
Normalmente se utilizan comillas dobles para las cadenas, pero puede ser
útil usar comillas simples („), si usted tiene una cadena que contiene
comillas dobles dentro de dicho string. Cualquiera que sea el tipo de cita
que utilice, puede incluir el otro tipo de comillas dentro de la cadena, sin
escapar de ella. Por ejemplo:
escapado = "Ella dijo \" Hable con la mano, \"y yo estaba con
todos los \" ¡Amigos! \"";
13
La barra invertida y la comilla doble (\") son conocidas como una secuencia
de escape. Una secuencia de escape es una secuencia especial de
caracteres que se convierten o "traducen" en otra cosa por el motor de
script. Las secuencias de escape le permiten incluir cosas que no pueden ser
escritas directamente en una cadena.
\a - campana
\b - de retroceso
\f - salto de pagina
\n - nueva línea
\r - retorno de carro
\t - tabulación horizontal
\v - tabulación vertical
\\ - barra invertida
\" - comillas
\' - apóstrofe
\[ - corchete izquierdo
\] - corchete derecho
Así, por ejemplo, si desea mostrar tres líneas de texto en una única cadena,
haga lo siguiente:
Cada doble barra representa una única barra cuando se utiliza dentro de
una cadena.
Sin embargo, usted no tendrá que utilizar este formato muy a menudo, o
nunca.
…es equivalente a:
Esto puede ser útil si usted tiene pre-texto que desea utilizar como una
cadena, y no desea tener que convertir todos los caracteres especiales en
secuencias de escape.
a = "10" + 1; -- es de 11 Resultados
b = "33" * 2; -- es de 66 Resultados
Ninguna (Nil)
Ninguna es un tipo dato de valor ausente. Básicamente representa la
ausencia de cualquier otro tipo de valor.
Puede asignar cero a una variable, al igual que cualquier otro valor. Tenga
en cuenta que esto no es lo mismo que la asignación de las letras "cero" a
una variable, como en una cadena. Al igual que otras palabras clave, Nil
debe ser escrita al lado derecho de la variable con el fin de ser reconocidos
como un tipo de valor. También debe ser escrita en letras minúsculas.
a = nil;
if a then
-- Ingrese acá todas las líneas
-- Esta expresión no se ejecutará
end
y = "Henry Diaz";
y = nil;
boolybooly = true;
if boolybooly then
-- Cualquier script de aquí será ejecutado.
end
a = true;
b = false;
if (A y B) then
-- Cualquier script de aquí no se ejecutará porque
-- verdadero y falso es falso.
end
Esta vez, si la declaración de necesidades, tanto "a" y "b" para ser verdad
para las líneas dentro de él a ser ejecutado. En este caso, que no va a
ocurrir porque "b" se ha establecido en falso.
Función (Function)
16
Arreglos (Table)
Las tablas o arreglos son una forma muy poderosa para almacenar listas de
valores indexados bajo un nombre. Las tablas son en realidad arrays
asociativos, es decir, que son arreglos que pueden ser indexados, no sólo
con números, sino con cualquier tipo de valor (incluyendo cadenas).
Ejemplo 1:
nombres = {"Henry", "Evert", "Paguada"};
Dialog.Message ("Segundo nombre en la lista", nombres[2]);
Ejemplo 2:
t = {};
t.Nombre = "Henry";
t.Apellido = "Díaz";
t.Ocupacion = "Programador";
Dialog.Message(t.Nombre, t.Ocupacion);
Se pueden asignar tablas con otras variables como así. Por ejemplo:
arreglo_uno = {};
arreglo_uno.Nombre = "Henry";
arreglo_uno.Apellido = "Díaz";
arreglo_uno.Ocupacion = "Programador";
arreglo_dos = arreglo_uno;
ocupacion = arreglo_dos.Ocupacion;
Dialog.Message(b.Nombre, ocupacion);
arreglo_dos = arreglo_uno;
Asignación a variable
Las variables pueden tener los nuevos valores asignados a ellos mediante el
operador de asignación (=). Esto incluye copiar el valor de una variable en
otra. Por ejemplo:
a = 10;
b = "Soy feliz";
c = b;
a, b = 1, 2;
Los arreglos y las funciones son parte de un caso especial: cuando se utiliza
el operador de asignación sobre una arreglo o función, se crea un alias que
apunta al mismo arreglo o función, es cuando la variable comienza a
"copiarse". Muchos programadores llaman a este modo “Por Referencia”
que es distinto al otro método de copiado llamado “Por Valor”.
18
Expresiones y operadores
Una expresión es todo lo que se evalúa como un valor. Esto puede incluir un
único valor, como "6" o un valor complejo construido con los operadores
tales como "1 + 3". Puede utilizar paréntesis para "agrupar" las expresiones
y control del orden en el que se evalúan las expresiones con sus
operadores. Por ejemplo, las siguientes líneas al ser evaluadas, todas
devuelven el mismo valor:
a = 10;
a = (5 * 1) * 2;
a = 100 / 10;
a = 100 / (2 * 5);
Operadores aritméticos
Operadores aritméticos se utilizan para realizar operaciones matemáticas
sobre los números. Los siguientes son los operadores matemáticos
soportados:
+ (Adición)
- (Resta)
* (Multiplicación)
/ (División)
unario - (negación)
a = 5 + 2;
b = a * 100;
veintitresPorciento = 23 / 100;
nega = -29;
posi = -nega;
Operadores relacionales
Operadores relacionales le permiten comparar cómo se relaciona un valor a
otro. Los siguientes operadores relacionales son compatibles:
a = 10;
a > 300; -- falso
Operadores lógicos
Operadores lógicos se utilizan para realizar operaciones booleanas sobre los
valores booleanos. Los siguientes operadores lógicos son compatibles:
Por ejemplo:
a = true;
b = false;
c = A and B; - falso
d = cero and nil; - falso
e = not b; - verdadero
Tenga en cuenta que sólo los valores nulos y falsos se consideran falsas, y
todos los demás valores son verdaderos.
Por ejemplo:
soyinvisible = nil;
if soyinvisible then
-- Las líneas de aquí no va a ocurrir
-- Porque soyinvisible se considera falsa
Dialog.Message ("Usted no puede verme!", "Yo soy invisible
!!!!");
end
if "Brett" then
-- Las líneas de aquí se ejecutaran, porque Brett no es
negativa, ni falsa
-- Se consideran falsas ... cualquier otra cosa,
incluyendo cadenas,
-- se consideran verdaderas.
Dialog.Message ("¿Qué pasa con las cadenas?", "Las cadenas
20
son verdaderas.");
end
Concatenación
En los script de AutoPlay, el operador de concatenación es de dos períodos
(..). Se utiliza para combinar (unir) dos o más cadenas de caracteres. Usted
no tiene que poner espacios antes y después de los períodos, pero se puede
si lo desea.
Por ejemplo:
and or
< > <= >= ~= ==
..
+ --
* /
not - (unario)
^
a + 1 < b/2 + 1
21
... es el mismo:
(a + 1) < ((b/2) + 1)
a + 1 < b/(2 + 1)
Estructuras de control
El motor de scripts soporta las siguientes estructuras de control: if, while,
repeat y for
If (Si)
Una declaración if evalúa su condición y a continuación, sólo ejecuta parte
del código después de “then” si la condición es verdadera. Una declaración
“if” es terminada por la palabra clave “end”. La sintaxis básica es la
siguiente:
if condición then
hacer algo aquí
end
Por ejemplo:
x = 50;
if x > 10 then
Dialog.Message ("resultado", "x es mayor que 10");
end
y = 3;
if ((35 * y) < 100) then
Dialog.Message ( "", "y es 35 veces inferior a 100");
end
También puede utilizar else y elseif para añadir más posibles retornos a la
declaración if:
x = 5;
if x > 10 then
Dialog.Message ("", "x es mayor que 10");
else
Dialog.Message ("", "x es igual o inferior a 10");
end
22
x = 5;
if x == 10 then
Dialog.Message ( "", "x es exactamente igual a 10");
elseif x == 11 then
Dialog.Message ( "", "x es exactamente igual a 11");
elseif x == 12 then
Dialog.Message ( "", "x es exactamente igual a12");
else
Dialog.Message ( "", "x no es igual a 10, 11 o 12");
end
While (Mientras)
La declaración While se utiliza para ejecutar el mismo "bloque" del script
una y otra vez hasta que se cumple una condición. Al igual que la
declaración “if”, la declaración “while” se finaliza con la palabra clave “end”.
La sintaxis básica es la siguiente:
while condición do
hacer algo aquí
end
Por ejemplo:
a = 1;
while a < 10 do
a = a + 1;
end
contador = 1;
while contador < 100 do
contador = contador + 1;
23
if contador == 50 then
break;
end
end
Repeat (Repita)
La declaración Repeat es similar a la declaración while, salvo que la
condición se comprueba al final de la estructura en lugar de al principio. La
sintaxis básica es la siguiente:
repeat
hacer algo aquí
until condición
Por ejemplo:
i = 1;
repeat
i = i + 1;
until i > 10
Esto es similar a uno de los anteriores bucles while, pero esta vez, el bucle
se realiza 10 veces. La expresión "i = i + 1; es ejecutado antes de que la
condición determina que 1 es ahora mayor que 10.
contador = 1;
repeat
contador = contador + 1;
if contador == 50 then
break;
end
until contador > 100
Una vez más, lo que provoca la salida del bucle es tan pronto como es
evaluado que contador es igual a 50.
For (Para)
La declaración For es usado para repetir un bloque de script de un número
específico de veces. La sintaxis básica es la siguiente:
Por ejemplo:
He aquí un ejemplo que utiliza el paso de un "-1" para hacer el bucle para
contar hacia atrás:
for i = 1, 100 do
if contar == 50 then
break;
end
end
Una vez más, lo que la salida del bucle tan pronto como fue igual a 50.
También hay una variación en el bucle para que funcione en los cuadros.
mi_tabla = {};
mi_tabla [1] = "manzana";
mi_tabla [2] = "naranja";
mi_tabla [3] = "melocotón";
asociar_tabla = {};
asociar_tabla.fruta = "manzana";
asociar_tabla.vegetal = "zanahoria";
Arrays numéricos
Uno de los usos más comunes de las tablas es como Matrices. Una Matriz es
una colección de valores que están indexados por llaves numéricas. En el
motor de scripting, las matrices numéricas son basadas en uno. Es decir,
que comienzan en el índice 1.
Ejemplo 1:
miMatriz ={255,0,255};
Dialog.Message ("Primer Número", miMatriz[1]);
Ejemplo 2:
alfabeto = {"a", "b", "c", "d", "e", "f", "g", "h", "i", "j",
"k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w",
"x","y","z"};
Dialog.Message ("Séptima Carta", alfabeto[7]);
Ejemplo 3:
miMatriz = {};
miMatriz [1] = "Opción Uno";
miMatriz [2] = "Opción Dos";
miMatriz [3] = "Opción Tres";
Arreglos asociativos
Arreglos asociativos son los mismos que los arreglos numéricos, salvo que
los índices pueden ser números, cadenas o incluso funciones.
Aquí está un ejemplo de una matriz asociativa que utiliza un apellido como
un índice y un nombre como el valor:
Por ejemplo:
El resultado sería de tres mensajes de diálogo en fila, una para cada uno de
los elementos en el arreglo miTabla, así:
28
a = {Uno=1,Dos=2,Tres=3};
for k in a do
Dialog.Message("Índice de la Tabla", k);
final
El script de arriba mostrará tres mensajes del array en una fila, con el texto
"Uno", "Tres", y a continuación, "Dos".
-- Modificar la copia
tabla_dos.temperatura = "fría";
Eso es más o menos cómo es con tablas, también. Con el fin de crear una
copia completa de una tabla, todos los contenidos y, lo que necesitas para
crear una nueva tabla y luego copiar todos los elementos, un elemento a la
vez.
-- Modificar la copia
tabla_dos.temperatura = "Fría";
Funciones
Una de las principales y más poderosas de las características del motor de
scripting son las funciones. Usted ya ha visto una gran cantidad de
funciones utilizadas a lo largo de este documento, tales como
"Dialog.Message." Las Funciones son simplemente trozos de código en el
script que puede definir, darle un nombre y a continuación, llamar desde
cualquier otro lugar.
function HolaMundo ()
Dialog.Message ( "Bienvenido", "Hola Mundo");
end
function HolaMundo()
Dialog.Message ( "Bienvenido", "Hola Mundo");
final
HolaMundo();
function HolaMundo(Mensaje)
Dialog.Message ("Bienvenido", Mensaje);
end
HolaMundo("Este es un argumento");
Esta vez, la definición de la función utiliza dos variables, una para cada uno
33
Valores de Retorno
El siguiente paso es hacer la función de valores de retorno de vuelta al ser
llamada por el script. Aquí esta una función que acepta un número como su
único argumento y a continuación, devuelve una cadena que contenga
todos los números de uno a ese número.
function Contador(n)
CadenaContador = Contador(10);
Dialog.Message ( "Contador", CadenaContador);
Las dos últimas líneas del script de arriba utilizan la función Contador para
construir una cadena a partir de 1 a 10, lo almacena en una variable
llamada CadenaContador y a continuación, muestra el contenido de esa
variable en un diálogo cuadro de mensaje.
end
end
El script de arriba crea una función llamada NumerosCortos que toma dos
argumentos y devuelve dos valores. El primer valor devuelto es el número
más pequeño, y el segundo valor devuelto es el más grande. Tenga en
cuenta que se especifican dos variables para recibir los valores de retorno
de la función llamada en la segunda última línea. La última línea del script
muestra los dos números en el orden en que fueron ordenados por la
función.
Redefinición de funciones
Otra cosa interesante acerca de las funciones es que se puede anular una
definición de función anterior simplemente por volver a definirla.
function HolaMundo()
Dialog.Message("Mensaje", "Hola Mundo");
end
function HolaMundo()
Dialog.Message("Mensaje", "Hola Tierra");
end
HolaMundo();
function HolaLuna()
Dialog.Message ("Mensaje", "Hola Luna");
end
Hola = {
Tierra = function() Dialog.Message("Mensaje", "Hola Tierra")
end,
Luna = function() Dialog.Message("Mensaje", "Hola Luna") end
};
Manipulación de cadenas
En esta sección vamos a cubrir brevemente algunas de las más comunes
técnicas de manipulación de cadenas, como la concatenación de cadenas y
comparaciones.
(Para obtener más información sobre las funciones de cadena que tiene a su
disposición en AutoPlay Media Studio, véase el Programa de Referencia /
Acciones / cadena en la ayuda en línea.)
Concatenar cadenas
Ya hemos cubierto la concatenación de cadenas, pero esta así vale la pena
repetir. El operador de concatenación de cadenas es de dos períodos en una
fila (..). Por ejemplo:
Tenga en cuenta que usted puede poner espacios a ambos lados de los
puntos, o por un lado, o no poner ningún espacio en absoluto. Por ejemplo,
las siguientes cuatro líneas logran la misma cosa:
Comparación de Cadenas
Junto a la concatenación, una de las cosas más comunes que se quiere
hacer con las cadenas es comparar una cadena a otra. Dependiendo de lo
que constituye un "match", esta puede ser muy simple, o simplemente un
poco difícil.
strUno = "Guatemala";
strDos = "Guatemala";
Por ejemplo:
strUno = "GUatEmaLa";
strDos = "Guatemala";
compara los resultados. (Nota: las dos cadenas originales siguen siendo lo
mismo.) De esta forma, no importa lo que en las cadenas originales tenían;
todo lo que importa es si las letras son las mismas.
Contar caracteres
Si alguna vez ha querido saber cuán larga es una cadena, se puede contar
el número de caracteres que contiene. Basta con utilizar la función
String.Length, así:
Buscar cadenas
Otra cosa que usted quiere hacer con las cadenas es buscar una cadena
dentro de otra. Esto es muy simple al hacer uso de la función String.Find.
Por ejemplo:
Reemplazar en Cadenas
Una de las cosas más poderosas que usted puede hacer con las cadenas es
llevar a cabo una operación para búsqueda y reemplazo sobre ellas. El
siguiente ejemplo muestra cómo puede utilizar la acción String.Replace para
sustituir a cada ocurrencia de una cadena con otro objetivo dentro de una
cadena.
Extracción en Cadenas
Hay tres funciones de cadena que le permiten "extraer" una parte de una
cadena, en lugar de copiar toda la cadena de sí mismo. Estas funciones son
String.Left, String.Right, y String.Mid.
39
Puede utilizar estas funciones para llevar a cabo todo tipo de operaciones
avanzadas en cadenas.
edad = "31";
if edad > 18 then
Dialog.Message("", "Eres mayor de 18 años.");
end
edad = "31";
if String.ToNumber(edad) > 18 then
Dialog.Message("", "Eres mayores de 18 años.");
end
edad = "31";
if (edad + 0) > 18 then
Dialog.Message("", "Eres mayor de 18 años.");
end
dofile
Carga y ejecuta un archivo de script. El contenido del archivo será
ejecutado como si fuera escrito directamente en el area de scripting. La
sintaxis es la siguiente:
dofile(direxion_archivo);
Dialog.Message("Hola", "Mundo");
dofile (_SourceFolder.."\\AutoPlay\\Scripts\\MiScript.lua");
... este archivo de script será leído y ejecutado de inmediato. En este caso,
usted vería un cuadro de mensaje con el titulo "Hola” y el mensaje
“Mundo".
42
require
Carga y ejecuta un archivo de script en el motor de scripting. Es similar a
dofile la salvedad de que sólo se carga un archivo de una vez por período de
sesiones, mientras que dofile volverá a la carga y volver a ejecutar el
archivo cada vez que se utiliza. La sintaxis es la siguiente:
require(direxion_archivo);
require("foo.lua");
require("foo.lua"); -- esta línea no hace nada
require("MiScript.lua");
...es el mismo:
require(_SourceFolder.."\\AutoPlay\\Scripts\\MiScript.lua");
Dado que sólo requieren una determinada carga de archivo de script una
vez por período de sesiones, que es el más adecuado para la carga de
scripts que contienen sólo las variables y funciones. Dado que las variables
y funciones son globales por defecto, sólo tendrá que "cargar" una vez, en
repetidas ocasiones la carga de la misma definición de función termina en
una pérdida de tiempo.
Esto hace que la función requiera una buena forma de cargar script de
bibliotecas externas. Cada script que necesita una función de un archivo
externo puede exigir condiciones de seguridad con require(), y el archivo en
realidad sólo se carga la primera vez que se necesita.
type
Esta función le dirá el tipo de valor que figura en una variable. Esta
devuelve una cadena con el nombre del tipo de variable. Los valores validos
de retorno son "nil", "number", "string", "boolean", "table" o "function". Por
ejemplo:
43
a = 989;
strTipo = type(a); --establece strType a "número"
a = "Hola";
strTipo = type(a); -- establece strType a la "cadena"
Acciones
AutoPlay Media Studio viene con un gran número de funciones
incorporadas. En la interfaz del programa, estas funciones incorporadas son
comúnmente denominadas acciones. Para efectos de scripting, acciones y
funciones son esencialmente los mismos, sin embargo, el término
"acciones" es generalmente reservado para las funciones que se construyen
en el programa y se incluyen en la lista por orden alfabético de las acciones
en la ayuda en línea. Al referirse a las funciones que han sido creados por
otros usuarios o usted mismo, el término "funciones" se prefiere.
Manipulación de Errores
Todas las acciones incorpordas de AutoPlay Media Studio utilizan las mismas
técnicas de manipulación de errores. Sin embargo, esto no es
necesariamente cierto en el caso de cualquier función, módulo, o scripts,
incluso scripts desarrollados por Indigo Rose Corporation que no están
construidas en el producto. Aunque estos scripts desarrollados
externamente pueden hacer uso de AutoPlay y manipular errores del
sistema, puede que no necesariamente deba hacerlo. Por lo tanto, usted
siempre debe consultar a un scripts o autor de modulo o la documentación
con el fin de averiguar cómo es el manejo de errores, y así manipulados.
Existen dos tipos de errores que puede tener en sus escrituras cuando se
llama a las acciones de AutoPlay Media Studio: errores de sintaxis, los
errores y funcional.
Errores de sintaxis
Los errores de sintaxis se producen cuando la sintaxis (o "gramática") de un
script es incorrecta, o una función recibe argumentos que no son
apropiadas. Algunos errores de sintaxis son capturados por AutoPlay Media
Studio cuando usted compile o de vista previa de su aplicación.
foo =
Dialog.Message("Hola");
Parece que no era tan bueno después de todo. Tenga en cuenta que el
mensaje dice que dos argumentos son necesarios para la función
Dialog.Message. Ah. Nuestro script sólo tiene un argumento.
Errores funcionales
Los errores funcionales son aquellos que se producen debido a la
funcionalidad si la acción propia falla. Ellos se producen cuando a una acción
se da información incorrecta, como la ruta de acceso a un archivo que no
existe. Por ejemplo, el siguiente código producirá un error funcional:
filecontents = TextFile.ReadToString("this_file_don't
exist.txt");
Si pone este script en un evento ahora mismo y lo prueba, verá que nada
parece suceder. Esto se debe a que en AutoPlay Media Studio los errores
funcionales no se muestran automáticamente como se muestran los errores
de sintaxis. Dejamos a ustedes para manejar (o a no manejar), tales
errores funcionales.
Por el contrario, puede haber ocasiones en las que es muy importante para
usted saber si una acción falla. Si, por ejemplo, usted desea copiar un
archivo muy importante:
File.Copy("C:\\Temp\\Mi Archivo.dat","C:\\Temp\\Mi
Archivo.bak");
En este caso, usted realmente quiere saber si falla y pueden querer incluso
salir del programa o informar al usuario. Aquí es donde las acciones de
depuración entran en escena.
Application.GetLastError
Esta es la acción más importante a utilizar cuando se trata de averiguar si
un problema se ha producido. En tiempo de ejecución siempre hay un valor
interno que almacena el estado de la última acción que fue ejecutada. En el
inicio de una acción, este valor se establece en 0 (el número cero). Esto
significa que todo está bien. Si un error se produce funcional dentro de la
acción, el valor se cambia a algunos no cero.
La sintaxis es la siguiente:
ultimo_codigo_error=Application.GetLastError();
los errores deben ser manejados, pero ilustra el punto. Usted puede hacer
lo que quieras cuando se produce un error, al igual que se pide una función
diferente o cualquier cosa que usted puede soñar.
Por ejemplo, aquí hay un script modificado para mostrar la cadena de error:
codigo_error = Application.GetLastError();
if (codigo_error ~= 0) then
-- Algún tipo de error ha ocurrido!
Dialog.Message("Error", "Error al copiar archivo:\n" ..
_tblErrorMessages[codigo_error]);
Application.Exit ();
end
Sólo recuerde que el valor del último error se restablece cada vez que una
acción es ejecutada. Por ejemplo, la siguiente secuencia de comandos no
produce un mensaje de error:
File.Copy("C:\\Temp\\Mi Archivo.dat",
48
"C:\\Temp\\Mi Archivo.bak");
codigo_error = Application.GetLastError();
if (codigo_error ~= 0) then
-- Algún tipo de error ha ocurrido!
Dialog.Message("Error",
"Error al copiar archivo:"..
_tblErrorMessages [codigo_error]);
Application.Exit ();
end
Debug.ShowWindow
AutoPlay Media Studio en tiempo de ejecución tiene la capacidad de mostrar
una ventana de depuración que se pueden utilizar para mostrar mensajes
de depuración. Esta ventana existe en toda la ejecución de su solicitud,
pero sólo es visible cuando usted le dice que sea.
La sintaxis es la siguiente:
Debug.ShowWindow(show_window);
Debug.Print
Esta acción imprime el texto de su elección en la ventana de depuración.
Por ejemplo, pruebe el siguiente script:
Debug.ShowWindow(true);
for i = 1, 10 do
49
Debug.SetTraceMode
AutoPlay Media Studio puede ejecutar un modo especial de "rastrear" en
tiempo de ejecución que se imprimirá la información sobre cada línea del
script que es ejecutado a la ventana de depuración, incluyendo el valor de
Application.GetLastError() si la línea implica llamar a una acción incorporda.
Usted puede rastrear a su vez, este modo de encendido o apagado
mediante el uso de la acción Debug.SetTraceMode:
Debug.SetTraceMode(turn_on);
Debug.ShowWindow(true);
50
Debug.SetTraceMode(true);
for i = 1, 3 do
Dialog.Message ( "Número ", i);
end
File.Copy("C:\\fake_file.ext", "C:\\fake_file.bak");
Observe que cada línea producida por la función de rastreo se inicia con el
modo de "Trace:" Esto es lo que les puedo decir aparte de todas las líneas
que va a enviar la ventana de depuración con Debug.Print. El número
después de la "Trace:" es el número de línea que está siendo ejecutado en
el script.
Debug.GetEventContext
Esta acción se utiliza para obtener una cadena descriptiva sobre el evento
que está siendo ejecutado. Esto puede ser útil si se define una función en
51
un solo lugar, pero lo llaman en algún otro lugar, y que desea estar en
condiciones de decir que la función se llama desde en un momento dado.
Por ejemplo, si se ejecuta este script de un botón en el evento Click sobre
Página1:
Dialog.Message
Esto nos lleva a una buena ole' Dialog.Message. Ustedes han visto esta
acción utiliza en este documento, y por una buena razón. Esta es una gran
acción de utilizar a lo largo de su código cuando se está tratando de
localizar un problema.
Consideraciones finales
Esperemos que este documento ha ayudado a comprender la programación
de scripting en AutoPlay Media Studio. Una vez que se cuelgue de la misma,
es una muy divertida y potente forma de hacer las cosas.
Otros recursos
Aquí está una lista de otros lugares que usted puede acudir para obtener
ayuda con scripting en AutoPlay Media Studio.
Archivos de ayuda
El archivo de ayuda de AutoPlay Media Studio está lleno de buenos
materiales de referencia para todos los eventos y acciones apoyadas por
AutoPlay Media Studio, y para el entorno de diseño propio. Puede acceder al
archivo de ayuda en cualquier momento seleccionando Ayuda> Ayuda de
AutoPlay Media Studio, en el menú Ayuda.
Una manera rápida de acceder a los foros en línea es elegir Ayuda> Foros
de usuarios de AutoPlay Media Studio en el menú Ayuda.
http://www.lua.org
Tenga en cuenta que puede haber otras funciones incorporadas que existen
en Lua y en AutoPlay Media Studio que no están soportadas de forma
oficial. Estas funciones, en su caso, están documentadas en el Lua 5.0
Manual de Referencia.