Adobe Guía de Consulta de ActionScript User Manual [es]

®

ma cromedia

FLASH™5

Guía de Consulta de ActionScript

Marcas comerciales

Macromedia, el logotipo de Macromedia, el logotipo de Made With Macromedia, Authorware, Backstage, Director, Extreme 3D y
Fontographer son marcas comerciales registradas. Afterburner, AppletAce, Authorware Interactive Studio, Backstage, Backstage Designer,
Backstage Desktop Studio, Backstage Enterprise Studio, Backstage Internet Studio, DECK II, Director Multimedia Studio, Doc Around
the Clock, Extreme 3D, Flash, FreeHand, FreeHand Graphics Studio, Lingo, Macromedia xRes, MAGIC, Power Applets, Priority Access,
SoundEdit, Shockwave, Showcase, Tools to Power Your Ideas y Xtra son marcas comerciales de Macromedia, Inc. Otros nombres de
productos, logotipos, diseños, títulos, palabras o frases mencionados en esta publicación pueden ser marcas comerciales, marcas de
servicio o nombres registrados de Macromedia, Inc. o de otras entidades y pueden estar registrados en ciertas jurisdicciones.

Limitación de garantías de Apple
APPLE COMPUTER, INC. NO GARANTIZA, DE FORMA EXPRESA NI IMPLÍCITA, LA COMERCIABILIDAD

O IDONEIDAD PARA UN FIN DETERMINADO DEL PAQUETE DE SOFTWARE INFORMÁTICO INCLUIDO.
LA EXCLUSIÓN DE GARANTÍAS IMPLÍCITAS NO ESTÁ PERMITIDA EN ALGUNOS ESTADOS. LA RESTRICCIÓN
ANTERIOR PUEDE NO AFECTARLE. ESTA GARANTÍA LE PROPORCIONA DERECHOS LEGALES ESPECÍFICOS.
PUEDE TENER OTROS DERECHOS QUE VARÍAN SEGÚN LA LEGISLACIÓN LOCAL.

Copyright © 2000 Macromedia, Inc. Todos los derechos reservados. No se permite la copia, fotocopia, reproducción, traducción
o conversión mediante ningún medio electrónico o mecánico, ya sea de forma total o parcial, sin la previa autorización por escrito
de Macromedia, Inc.
Nº de pieza ZFL50M200SP

Agradecimientos

Gestión del proyecto: Erick Vera

Redacción: Jody Bleyle, Mary Burger, Louis Dobrozensky, Stephanie Gowin, Marcelle Taylor y Judy Walthers Von Alten

Edición: Peter Fenczik, Rosana Francescato, Ann Szabla

Multimedia: George Brown, John “Zippy” Lehnus y Noah Zilberberg

Diseño de Ayuda e impresión: Chris Basmajian y Noah Zilberberg

Producción: Chris Basmajian y Rebecca Godbois

Gestión del proyecto de localización: Yuko Yagi

Producción de localización: Masayo “Noppe” Noda y Bowne Global Solutions

Agradecimiento especial a: Pablo Francisco Arrieta, Jeremy Clark, Brian Dister y todo el Grupo de Desarrollo de Flash, Michael
Dominguez, Margaret Dumas, Rosa Elva Elizondo, Sherri Harte, Yoshika Hedberg, Tim Hussey, Kipling Inscore, Alyn Kelley,
Pete Santangeli, Denise Seymour y todo el Grupo de Control de calidad de Flash, Cyn Taylor y Eric Wittman

Primera edición: Septiembre de 2000

Macromedia, Inc.
600 Townsend St.
San Francisco, CA 94103 (EE.UU.)

2

TABLE DES MATIÈRES

INTRODUCTION

Procedimientos iniciales . . . . . . . . . . . . . . . . . . . . . . . . 17

Novedades en el lenguaje ActionScript de Flash 5 . . . . . . . . . . . . . . . . 17

Diferencias entre ActionScript y JavaScript . . . . . . . . . . . . . . . . . 18

Edición de texto. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19

Sintaxis de punto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19

Tipos de datos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19

Variables locales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19

Funciones definidas por el usuario . . . . . . . . . . . . . . . . . . . . . . . . 19

Objetos predefinidos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20

Acciones de clip . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20

Acciones nuevas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20

Clips inteligentes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20

Depurador . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

Compatibilidad con XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

Optimización. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

Utilización de la Ayuda de Flash

para acciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

CAPÍTULO 1

El lenguaje ActionScript . . . . . . . . . . . . . . . . . . . . . . . .23

Creación de scripts en ActionScript. . . . . . . . . . . . . . . . . . . . . . . . . . . 24

Planificación y depuración de scripts . . . . . . . . . . . . . . . . . . . . . . 25

Creación de scripts orientados a objetos . . . . . . . . . . . . . . . . . . . 26

Objeto MovieClip . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27

Flujo de los scripts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28

Control de la ejecución de ActionScript . . . . . . . . . . . . . . . . . . . . 31

Terminología de ActionScript . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32

Análisis de un script de ejemplo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35

3

Utilización del panel Acciones. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .37

Modo Normal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .38

Modo Experto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .40

Cambio del modo de edición . . . . . . . . . . . . . . . . . . . . . . . . . . . .41

Utilización de un editor externo. . . . . . . . . . . . . . . . . . . . . . . . . . .42

Selección de opciones en el panel Acciones . . . . . . . . . . . . . . . . . .42

Realzado y comprobación de la sintaxis . . . . . . . . . . . . . . . . . . . . .44

Realzado de errores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .45

Asignación de acciones a los objetos . . . . . . . . . . . . . . . . . . . . . . . . . . .46

Asignación de acciones a fotogramas . . . . . . . . . . . . . . . . . . . . . . . . . .48

CAPÍTULO 2

Programación de Scripts en ActionScript. . . . . . . . 51

Utilización de la sintaxis de ActionScript. . . . . . . . . . . . . . . . . . . . . . . .52

Tipos de datos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .56

Acerca de las variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .59

Utilización de operadores para manipular los valores de las expresiones.64

Uso de acciones. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .71

Control de los scripts de flujo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .73

Utilización de las funciones predefinidas . . . . . . . . . . . . . . . . . . . . . . . .76

Creación de funciones personalizadas . . . . . . . . . . . . . . . . . . . . . . . . . .78

Utilización de objetos predefinidos . . . . . . . . . . . . . . . . . . . . . . . . . . . .81

Utilización de objetos personalizados. . . . . . . . . . . . . . . . . . . . . . . . . . .85

Apertura de archivos de Flash 4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .88

Utilización de Flash 5 para crear contenidos de Flash 4 . . . . . . . . . . . . .89

Table des Matières

4

CAPÍTULO 3

Interactividad con ActionScript . . . . . . . . . . . . . . . . . 91

Creación de un cursor personalizado . . . . . . . . . . . . . . . . . . . . . . . . . .92

Obtención de la posición del ratón . . . . . . . . . . . . . . . . . . . . . . . . . . . .94

Captura de presión de una tecla . . . . . . . . . . . . . . . . . . . . . . . . . . . . .95

Creación de un campo de texto desplazable . . . . . . . . . . . . . . . . . . . . .97

Establecimiento de los valores de color . . . . . . . . . . . . . . . . . . . . . . . .100

Creación de controles de sonido . . . . . . . . . . . . . . . . . . . . . . . . . . . . .102

Detección de colisiones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .105

CAPÍTULO 4

Trabajo con clips de película . . . . . . . . . . . . . . . . . . .109

Líneas de tiempo múltiples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .110

Relación jerárquica de las Líneas de tiempo . . . . . . . . . . . . . . . . .112

Envío de mensajes entre Líneas de tiempo . . . . . . . . . . . . . . . . . .114

Rutas de destino absolutas y relativas . . . . . . . . . . . . . . . . . . . . . .117

Especificación de rutas de destino . . . . . . . . . . . . . . . . . . . . . . . .121

Utilización de acciones y métodos para controlar Líneas de tiempo . .124

Acerca de métodos versus acciones . . . . . . . . . . . . . . . . . . . . . . . .125

Utilización de varios métodos o acciones para seleccionar como desti-

no a una Línea de tiempo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .126

Asignación de una acción o método . . . . . . . . . . . . . . . . . . . . . . .127

Carga y descarga de películas adicionales . . . . . . . . . . . . . . . . . . .128

Cambio de posición y aspecto de clips de película . . . . . . . . . . . .128

Clips de película que se pueden arrastrar . . . . . . . . . . . . . . . . . . .129

Duplicación y eliminación de clips de película . . . . . . . . . . . . . .130

Anexión de clips de película . . . . . . . . . . . . . . . . . . . . . . . . . . . .130

Creación de clips inteligentes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .131

Definición de los parámetros de clip . . . . . . . . . . . . . . . . . . . . . .132

CAPÍTULO 5

Integración de Flash con aplicaciones Web . . . . . 139

Envío y carga de variables a y desde un archivo remoto . . . . . . . . . . .140

Utilización de loadVariables, getURL y loadMovie . . . . . . . . . . .144

Lenguaje XML. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .145

Utilización del objeto XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . .146

Utilización del objeto XMLSocket . . . . . . . . . . . . . . . . . . . . . . . .150

Creación de formularios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .152

Creación de un formulario de búsqueda. . . . . . . . . . . . . . . . . . . .153

Utilización de variables en formularios. . . . . . . . . . . . . . . . . . . . .154

Verificación de datos introducidos . . . . . . . . . . . . . . . . . . . . . . . .155

Envío de mensajes desde y hasta el Reproductor de Flash. . . . . . . . . .156

Utilización de fscommand . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .156

Acerca de los métodos de Flash Player . . . . . . . . . . . . . . . . . . . . .159

Table des Matières

5

CAPÍTULO 6

Solución de problemas de ActionScript . . . . . . . . .161

Directrices para la creación y solución de problemas . . . . . . . . . . . . . .162

Utilización del Depurador. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .164

Habilitación de la depuración de películas . . . . . . . . . . . . . . . . . .165

La barra de estado . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .166

La lista de visualización . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .166

Visualización y modificación de variables. . . . . . . . . . . . . . . . . . .166

Utilización de la lista Observar. . . . . . . . . . . . . . . . . . . . . . . . . . .168

Visualización de las propiedades de las películas y modificación de las

propiedades editables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .169

Utilización de la ventana Salida . . . . . . . . . . . . . . . . . . . . . . . . . . . . .170

Utilización del comando Mostrar objetos . . . . . . . . . . . . . . . . . .171

Utilización del comando Mostrar variables . . . . . . . . . . . . . . . . .172

Utilización de la acción trace . . . . . . . . . . . . . . . . . . . . . . . . . . . .173

CAPÍTULO 7

Diccionario de ActionScript. . . . . . . . . . . . . . . . . . . . 175

Entrada de muestra para la mayoría de los elementos de ActionScript .176

Entrada de muestra para objetos . . . . . . . . . . . . . . . . . . . . . . . . . . . . .177

Contenido del diccionario. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .178

–– (disminución) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .191

++ (incremento) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .191

! (valor NOT lógico) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .193

!= (no igualdad). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .193

% (módulo) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .194

%= (asignación de módulo). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .195

& (operador AND como bit) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .195

&& (operador AND de cortocircuito) . . . . . . . . . . . . . . . . . . . . . . . .196

&= (operador de asignación AND como bit) . . . . . . . . . . . . . . . . . . .196

() (paréntesis) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .197

– (menos) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .198

* (multiplicación) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .199

*= (asignación de multiplicación) . . . . . . . . . . . . . . . . . . . . . . . . . . . .200

, (coma). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .200

. (operador punto). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .201

?: (condicional) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .202

/ (división) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .202

// (delimitador de comentario) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .203

Table des Matières

6

/* (delimitador de comentario) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .203

/= (asignación de división). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .204

[] (operador de acceso a matriz). . . . . . . . . . . . . . . . . . . . . . . . . . . . . .205

^(operador XOR como bit). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .206

^= (operador de asignación XOR como bit) . . . . . . . . . . . . . . . . . . . .206

{} (inicializador de objeto) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .207

| (operador OR como bit) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .208

|| (operador OR) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .209

|= (operador de asignación OR como bit) . . . . . . . . . . . . . . . . . . . . . .209

~ (operador NOT como bit) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .210

+ (suma) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .210

+= (asignación de suma) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .211

< (menor que) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .212

<< (desplazamiento a la izquierda como bit) . . . . . . . . . . . . . . . . . . . .213

<< (desplazamiento a la izquierda como bit y asignación) . . . . . . . . . .214

<= (menor o igual que) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .215

<> (no igualdad) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .215

= (asignación) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .216

-= (asignación de negación) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .217

== (igualdad). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .218

> (mayor que) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .218

>= (mayor o igual que) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .219

>> (desplazamiento a la derecha como bit) . . . . . . . . . . . . . . . . . . . . .220

>>= (desplazamiento a la derecha como bit y asignación) . . . . . . . . . .221

>>> (desplazamiento a la derecha como bit sin signo) . . . . . . . . . . . . .222

>>>= (desplazamiento a la derecha como bit sin signo y asignación) . .222

add . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .223

_alpha . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .224

and . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .224

Array (objeto) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .225

Array.concat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .227

Array.join . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .227

Array.length . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .228

Array.pop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .229

Array.push. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .229

Array.reverse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .230

Array.shift . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .230

Array.slice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .231

Array.sort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .231

Array.splice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .233

Table des Matières

7

Array.toString . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .233

Array.unshift . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .234

Boolean (función) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .234

Boolean (objeto) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .234

Boolean.toString . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .235

Boolean.valueOf . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .236

break. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .236

call . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .237

chr . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .237

Color (objeto) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .238

Color.getRGB . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .239

Color.getTransform. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .239

Color.setRGB . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .240

Color.setTransform . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .240

continue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .242

_currentframe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .242

Date (objeto). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .243

Date.getDate. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .246

Date.getDay . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .246

Date.getFullYear . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .247

Date.getHours. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .247

Date.getMilliseconds. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .248

Date.getMinutes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .248

Date.getMonth . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .248

Date.getSeconds . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .249

Date.getTime . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .249

Date.getTimezoneOffset . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .249

Date.getUTCDate . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .250

Date.getUTCDay . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .250

Date.getUTCFullYear . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .251

Date.getUTCHours . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .251

Date.getUTCMilliseconds . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .251

Date.getUTCMinutes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .252

Date.getUTCMonth. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .252

Date.getUTCSeconds . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .252

Date.getYear . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .253

Date.setDate . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .253

Date.setFullYear . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .253

Date.setHours. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .254

Date.setMilliseconds . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .254

Table des Matières

8

Date.setMinutes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .255

Date.setMonth . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .255

Date.setSeconds . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .255

Date.setTime. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .256

Date.setUTCDate. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .256

Date.setUTCFullYear . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .256

Date.setUTCHours. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .257

Date.setUTCMilliseconds. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .257

Date.setUTCMinutes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .258

Date.setUTCMonth . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .258

Date.setUTCSeconds . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .258

Date.setYear . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .259

Date.toString . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .259

Date.UTC. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .260

delete . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .260

do...while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .262

_droptarget . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .263

duplicateMovieClip. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .264

else . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .265

eq (equal—string specific) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .265

escape . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .266

eval . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .266

evaluate. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .267

_focusrect . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .268

for. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .268

for...in. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .270

_framesloaded . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .271

fscommand . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .272

function . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .272

ge (mayor o igual que, específico de cadena) . . . . . . . . . . . . . . . . . . . .274

getProperty . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .274

getTimer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .275

getURL. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .275

getVersion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .276

gotoAndPlay . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .277

gotoAndStop. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .277

gt (greater than —string specific) . . . . . . . . . . . . . . . . . . . . . . . . . . . .278

_height . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .278

_highquality . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .279

if . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .279

Table des Matières

9

ifFrameLoaded . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .280

#include . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .280

Infinity . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .281

int. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .281

isFinite . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .281

isNaN . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .282

Key (objeto) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .283

Key.BACKSPACE. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .285

Key.CAPSLOCK . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .285

Key.CONTROL. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .285

Key.DELETEKEY . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .286

Key.DOWN . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .286

Key.END . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .286

Key.ENTER . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .287

Key.ESCAPE. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .287

Key.getAscii. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .287

Key.getCode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .288

Key.HOME . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .288

Key.INSERT. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .288

Key.isDown. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .289

Key.isToggled . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .289

Key.LEFT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .289

Key.PGDN . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .290

Key.PGUP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .290

Key.RIGHT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .290

Key.SHIFT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .291

Key.SPACE. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .291

Key.TAB . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .291

Key.UP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .292

le (menor o igual que—específico de cadena) . . . . . . . . . . . . . . . . . . .292

length . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .292

_level. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .293

loadMovie. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .294

loadVariables. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .296

lt (menor que, específico de cadena) . . . . . . . . . . . . . . . . . . . . . . . . . .297

Matemáticas (objeto). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .297

Math.abs. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .299

Math.acos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .299

Math.asin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .300

Math.atan . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .300

Table des Matières

10

Math.atan2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .301

Math.ceil. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .301

Math.cos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .301

Math.E . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .302

Math.exp. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .302

Math.floor. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .303

Math.log . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .303

Math.LOG2E . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .303

Math.LOG10E . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .304

Math.LN2. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .304

Math.LN10. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .305

Math.max . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .305

Math.min . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .305

Math.PI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .306

Math.pow . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .306

Math.random . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .307

Math.round . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .307

Math.sin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .307

Math.sqrt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .308

Math.SQRT1_2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .308

Math.SQRT2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .309

Math.tan. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .309

maxscroll. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .309

mbchr . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .310

mblength . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .310

mbord. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .311

mbsubstring . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .311

Mouse (objeto) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .312

Mouse.hide . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .312

Mouse.show . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .313

MovieClip (objeto) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .313

MovieClip.attachMovie. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .315

MovieClip.duplicateMovieClip . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .315

MovieClip.getBounds . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .316

MovieClip.getBytesLoaded . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .317

MovieClip.getBytesTotal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .317

MovieClip.getURL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .318

MovieClip.globalToLocal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .318

MovieClip.gotoAndPlay . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .319

MovieClip.gotoAndStop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .319

Table des Matières

11

MovieClip.hitTest . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .320

MovieClip.loadMovie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .321

MovieClip.loadVariables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .322

MovieClip.localToGlobal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .323

MovieClip.nextFrame . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .324

MovieClip.play . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .324

MovieClip.prevFrame . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .324

MovieClip.removeMovieClip . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .325

MovieClip.startDrag . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .325

MovieClip.stop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .326

MovieClip.stopDrag . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .326

MovieClip.swapDepths. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .326

MovieClip.unloadMovie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .327

_name. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .327

NaN . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .328

ne (no igual, específico de cadena). . . . . . . . . . . . . . . . . . . . . . . . . . . .328

new . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .328

newline . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .329

nextFrame. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .330

nextScene . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .330

not . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .331

null . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .331

Number (función). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .332

Number (objeto). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .332

Number.MAX_VALUE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .334

Number.MIN_VALUE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .334

Number.NaN . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .335

Number.NEGATIVE_INFINITY . . . . . . . . . . . . . . . . . . . . . . . . . . .335

Number.POSITIVE_INFINITY . . . . . . . . . . . . . . . . . . . . . . . . . . . .335

Number.toString. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .336

Number.valueOf . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .336

Object (objeto) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .337

Object.toString . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .338

Object.valueOf . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .338

onClipEvent . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .338

on(mouseEvent) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .340

or . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .342

ord . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .342

_parent . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .342

parseFloat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .343

Table des Matières

12

parseInt. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .344

play. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .345

prevFrame. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .345

prevScene . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .346

print . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .346

printAsBitmap . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .348

_quality. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .349

random . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .350

removeMovieClip . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .350

return . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .351

_root. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .351

_rotation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .352

scroll . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .353

Selection (objeto) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .353

Selection.getBeginIndex . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .354

Selection.getCaretIndex. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .354

Selection.getEndIndex. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .355

Selection.getFocus. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .355

Selection.setFocus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .356

Selection.setSelection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .356

set . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .356

setProperty . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .357

Sound (objeto) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .358

Sound.attachSound. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .359

Sound.getPan . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .360

Sound.getTransform . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .360

Sound.getVolume . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .361

Sound.setPan. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .361

Sound.setTransform . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .362

Sound.setVolume . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .365

Sound.start . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .365

Sound.stop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .366

_soundbuftime . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .366

startDrag. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .367

stop. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .368

stopAllSounds . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .368

stopDrag. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .369

String (función). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .369

" " (delimitador de cadena) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .370

Cadena (objeto) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .371

Table des Matières

13

String.charAt. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .373

String.charCodeAt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .373

String.concat. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .373

String.fromCharCode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .374

String.indexOf . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .374

String.lastIndexOf. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .374

String.length . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .375

String.slice. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .375

String.split . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .376

String.substr . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .376

String.substring. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .377

String.toLowerCase. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .377

String.toUpperCase. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .378

substring . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .378

_target. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .378

targetPath . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .379

tellTarget. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .379

this . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .380

toggleHighQuality . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .381

_totalframes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .382

trace . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .382

typeof . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .383

unescape . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .384

unloadMovie. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .384

updateAfterEvent . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .385

_url. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .386

var. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .386

_visible . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .386

void. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .387

while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .387

_width . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .389

with . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .389

_x . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .392

XML (objeto) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .393

XML.appendChild . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .395

XML.attributes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .396

XML.childNodes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .397

XML.cloneNode. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .397

XML.createElement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .398

XML.createTextNode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .398

Table des Matières

14

XML.docTypeDecl . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .399

XML.firstChild . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .400

XML.haschildNodes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .400

XML.insertBefore . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .401

XML.lastChild . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .401

XML.load . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .402

XML.loaded . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .402

XML.nextSibling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .403

XML.nodeName. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .403

XML.nodeType. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .404

XML.nodeValue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .404

XML.onLoad . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .405

XML.parentNode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .406

XML.parseXML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .406

XML.previousSibling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .406

XML.removeNode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .407

XML.send. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .407

XML.sendAndLoad. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .407

XML.status . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .408

XML.toString . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .409

XML.xmlDecl. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .409

XMLSocket (objeto) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .410

XMLSocket.close . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .412

XMLSocket.connect . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .413

XMLSocket.onClose . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .414

XMLSocket.onConnect . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .415

XMLSocket.onXML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .416

XMLSocket.send. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .417

_xmouse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .418

_xscale. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .418

_y . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .419

_ymouse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .420

_yscale. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .420

Table des Matières

15

APÉNDICE A

Precedencia de operadores y asociatividad . . . . . 421

Lista de operadores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .421

APÉNDICE B

Teclas del teclado y valores de códigos de tecla 425

Letras de la A a la Z y números estándar del 0 al 9 . . . . . . . . . . . . . . .426

Teclas del teclado numérico. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .428

Teclas de función. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .429

Otras teclas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .430

APÉNDICE C

Mensajes de error . . . . . . . . . . . . . . . . . . . . . . . . . . . . 433

Table des Matières

16

INTRODUCTION

Procedimientos iniciales

.............................................................................................................

ActionScript es el lenguaje de creación de scripts de Flash. Puede utilizar
ActionScript para controlar objetos en las películas de Flash con el fin de
crear elementos interactivos y de navegación y para ampliar Flash con el fin
de crear películas altamente interactivas y aplicaciones Web.

Novedades en el lenguaje ActionScript
de Flash 5

El lenguaje ActionScript de Flash 5 ofrece nuevas funciones muy interesantes
para la creación de sitios Web interactivos con juegos, formularios, encuestas e
interactividad en tiempo real sofisticadas como los sistemas de chat.

ActionScript de Flash 5 tiene muchas funciones y convenciones de sintaxis nuevas
que lo hacen similar en lo fundamental al lenguaje de programación JavaScript.
En este manual se explicarán los conceptos básicos de programación como
funciones, variables, sentencias, operadores, condicionales y bucles. El Capítulo 7
de esta manual, “Diccionario de ActionScript”, contiene entradas detalladas para
cada elemento de ActionScript.

En este manual no se pretende enseñar programación en general. Existen muchos
recursos disponibles que proporcionan información sobre los conceptos generales
de programación y sobre el lenguaje JavaScript.

17

La Asociación de Fabricantes de PCs Europea (ECMA, European Computers
Manufacturers Association) publicó un documento llamado ECMA-262 que se
deriva de JavaScript y que sirve como el estándar internacional para el lenguaje
JavaScript. ActionScript está basado en la especificación ECMA-262 que se
encuentra disponible en http://www.ecma.ch.

Netscape DevEdge Online tiene un centro de desarrollo de JavaScript (JavaScript
Developer Central http://developer.netscape.com/tech/javascript/index.html) que
contiene documentación y artículos útiles para comprender ActionScript. El
recurso más valioso es el manual Core JavaScript Guide que se encuentra en la
dirección http://developer.netscape.com/docs/manuals/js/core/jsguide/index.htm.

Diferencias entre ActionScript y JavaScript

No es necesario que conozca JavaScript para utilizar y aprender ActionScript.
Sin embargo, si ya conoce JavaScript, ActionScript le parecerá familiar. Algunas
de las diferencias entre ActionScript y JavaScript se detallan a continuación:

•

ActionScript no admite objetos específicos de navegador como Documento,
Ventana y Ancla.

ActionScript no admite por completo todos los objetos predefinidos

•

de JavaScript.

•

ActionScript admite las construcciones sintácticas que no se permiten en
JavaScript (por ejemplo, las acciones

tellTarget

ifFrameLoaded

y

y la

sintaxis de barras).

•

ActionScript no admite algunas de las construcciones sintácticas de JavaScript,
como los rótulos

•

ActionScript no admite el constructor de JavaScript

•

En ActionScript, la acción
de variables

•

En JavaScript,
compatibilidad con Flash 4,

En JavaScript, evaluar

•

. En Flash 5, por compatibilidad con Flash 4 , evaluar

NaN

switch, continue, try, catch, throw

solamente puede realizar referencias

eval

.

toString

undefined

de

undefined
toString

es

de

undefined

en un contexto numérico da como resultado

undefined

statement

y

Function

.

. En Flash 5, para su

es

.

" "

undefined

da como

.

resultado 0.

ActionScript no admite Unicode; admite ISO-8859-1 y conjuntos de

•

caracteres Shift-JIS.

18

Introduction

Edición de texto

Puede introducir scripts directamente en el panel Acciones en Modo Experto.
También puede elegir elementos de un menú emergente o de una lista de la
Caja de herramientas como lo hacía en Flash 4.

Sintaxis de punto

Puede utilizar la sintaxis de punto para obtener y establecer las propiedades y los
métodos de un objeto, incluidas instancias y variables de clip de película. Puede
utilizar la sintaxis de punto en lugar de la sintaxis de barras que se utilizaba en
Flash 4. Ya no se utiliza la sintaxis de barras, pero aún la admite Flash Player.

Tipos de datos

El lenguaje ActionScript de Flash 5 admite los siguientes tipos de datos: cadena,
número, booleano, objeto y clip de película. Los distintos tipos de datos le
permiten utilizar diferentes tipos de información en ActionScript. Por ejemplo,
puede crear matrices y matrices asociativas.

Variables locales

Puede declarar variables locales que expiran al final de la lista de acciones o de la
llamada de función. Esto le permite gestionar la memoria y volver a utilizar los
nombres de variables. Todas las variables de Flash 4 eran permanentes; incluso las
variables temporales como los contadores de bucle que permanecían en la película
hasta que finalizaba.

Funciones definidas por el usuario

Puede definir funciones con parámetros que devuelven valores. Esto le permite
volver a utilizar los bloques de código en los scripts. En Flash 4, podía volver a
utilizar el código mediante la acción

pero no podía pasar parámetros ni

call

devolver valores.

Procedimientos iniciales

19

Objetos predefinidos

Puede utilizar los objetos predefinidos para acceder y manipular ciertos tipos de
información. A continuación se muestran algunos de los objetos predefinidos:

El objeto Math dispone de un complemento completo de constantes y

•

funciones matemáticas integradas como E (constante de Euler),
y

(arco tangente).

atan

El objeto Date le permite obtener información sobre la fecha y la hora del

•

(Coseno),

cos

sistema en el que se esté ejecutando Flash Player.

•

El objeto Sound le permite agregar sonidos a una película y controlar los
sonidos en una película a medida que se reproduce. Por ejemplo, puede ajustar
el volumen (

•

El objeto Mouse le permite ocultar el cursor estándar para que pueda utilizar

setVolume

), o el balance (

setPan

).

un cursor personalizado.

El objeto MovieClip le permite controlar clips de película sin utilizar una

•

acción envolvente como

loadMovie

, o

duplicateMovieClip

tellTarget

la sintaxis de punto (por ejemplo,

. Puede llamar a un método como

desde un nombre de instancia utilizando

myMovieClip.play()

).

play

Acciones de clip

Puede utilizar la acción

onClipEvent

para asignar acciones directamente a
instancias de clip de película en el Escenario. La acción onClipEvent dispone de
eventos como

load, enterFrame, mouseMove

, y

data

que le permiten crear

nuevas clases de interactividad avanzada.

,

20

Acciones nuevas

Puede utilizar acciones nuevas como do..while y for para crear bucles
complejos. Otras acciones nuevas se implementan como métodos del objeto
MovieClip; por ejemplo, getBounds, attachMovie, hitTest, swapDepths, y

globalToLocal.

Clips inteligentes

Los Clips inteligentes tienen scripts internos que el usuario, u otro autor, puede
cambiar sin utilizar el panel Acciones. Puede pasar valores a un Clip inteligente
por medio de los parámetros de clip que puede definir en la Biblioteca.

Introduction

Depurador

El Depurador le permite ver y cambiar los valores de variables y propiedades
cuando está reproduciendo una película en el modo de prueba de película, en el
reproductor Flash Player independiente o en un navegador Web. Esto le permite
encontrar fácilmente los problemas en su programación ActionScript.

Compatibilidad con XML

El objeto XML predefinido le permite convertir ActionScript en documentos
XML y pasarlos a las aplicaciones de servidor. También puede utilizar el objeto
XML para cargar documentos XML en una película de Flash e interpretarlos.
El objeto predefinido XMLSocket le permite crear una conexión continua con el
servidor para pasar datos XML para aplicaciones que se ejecutan en tiempo real.

Optimización

Flash 5 lleva a cabo optimizaciones en el código de ActionScript para mejorar
su desempeño y no aumentar el tamaño de archivo. Como resultado de estas
optimizaciones, Flash 5 con frecuencia producirá código de bytes de ActionScript
más pequeño que en Flash 4.

Utilización de la Ayuda de Flash para acciones

Flash 5 contiene ayuda sensible al contexto para cada acción disponible en el panel
Acciones. Mientras crea scripts, puede obtener información sobre las acciones que
está utilizando.

Para obtener ayuda sobre las acciones:

1 En el panel Acciones, seleccione una acción en la lista de la Caja de

herramientas.

2 Haga clic sobre el botón Ayuda en la parte superior del panel.

En el navegador aparecerá un tema relacionado con la acción.

Procedimientos iniciales 21

Introduction22

CAPÍTULO 1

El lenguaje ActionScript

.............................................................................................................

ActionScript, el lenguaje de creación de scripts de Flash, permite crear películas
con elementos interactivos. La película se puede configurar para que ejecute scripts
que respondan a eventos de usuario como pueden ser hacer clic en el botón del
ratón o presionar una tecla. Por ejemplo, se puede crear un script para indicar a
Flash que cargue una película específica en Flash Player como respuesta al botón
del navegador seleccionado por el usuario.

La filosofía de ActionScript es la de una herramienta que permite crear películas
que se comportan exactamente del modo establecido por el usuario. No es
necesario entender todos los posibles usos de la herramienta para empezar a crear
scripts; si parte de un objetivo claro, podrá empezar a crear scripts que incluyan
acciones sencillas. Puede incorporar nuevos elementos del lenguaje a medida que
aprenda a utilizarlos, para realizar tareas más complejas.

Este capítulo presenta ActionScript como un lenguaje de creación de scripts
orientado a objetos e introduce diferentes términos del mismo. También analiza
un script de ejemplo, de forma que el usuario desarrolle un marco de referencia
global respecto al mismo.

Este capítulo introduce además el panel Acciones, que permite construir scripts
mediante la selección de elementos de ActionScript o introducir texto en la
ventana Script.

1

23

Creación de scripts en ActionScript

Para empezar a escribir scripts sencillos no es necesario tener un conocimiento
profundo de ActionScript. Lo único que se necesita es un objetivo claro; lo demás
es sólo cuestión de seleccionar las acciones adecuadas. La mejor forma de descubrir
lo fácil que es ActionScript es creando un script. En el siguiente ejemplo se
presenta un script que ha sido asignado a un botón para cambiar el estado de
visibilidad de un clip de película.

Para cambiar la visibilidad de un clip de película:

1 Seleccione Ventana > Bibliotecas comunes > Botones y, a continuación,

seleccione Ventana > Bibliotecas comunes > Clips de película. Coloque
un botón y un clip de película en el Escenario.

2 Seleccione la instancia de clip de película en el Escenario, y seleccione

Ventana > Paneles > Propiedades de instancia.

3 Introduzca en el campo Nombre testMC.

4 Seleccione el botón en el Escenario, y elija Ventana > Acciones para abrir el

panel Acciones.

5 En el panel Acciones de objetos, haga clic en la categoría Acciones para abrirla.

6 Haga doble clic en la acción setProperty para agregarla a la lista Acciones.

7 En el menú emergente Propiedad, seleccione _visible (Visibilidad).

8 Especifique testMC como valor del parámetro Destino.

9 Especifique el valor 0 para el parámetro Valor.

El código resultante deberá ser similar al siguiente:

on (release) {
setProperty ("testMC", _visible, false);
}

10

Seleccione Control > Probar película y haga clic en el botón para ver cómo
desaparece el clip de película.

Capítulo 124

ActionScript es un lenguaje de creación de scripts orientado a objetos. Esto
significa que, cuando se dan determinados eventos, las acciones controlan objetos.
En este script, el evento es la acción del usuario de soltar el botón del ratón (lo que
se conoce como "mouse-up"), el objeto es la instancia de clip de película MC y la
acción es setProperty. Cuando el usuario hace clic en el botón que se muestra en
la pantalla, el evento release ejecuta un script que establece la propiedad

_visible del objeto MC al valor false lo cual hace que el objeto se vuelva

invisible.

El panel Acciones puede utilizarse como referencia para la configuración de scripts
sencillos. Para utilizar toda la potencia de ActionScript, es importante comprender
el funcionamiento del lenguaje: los conceptos, elementos y reglas del lenguaje para
organizar la información y crear películas interactivas.

Esta sección explica el flujo de trabajo de ActionScript, los conceptos
fundamentales para la creación de scripts orientados a objetos, los objetos de Flash
y el flujo de ejecución de scripts. También presenta información respecto a la
ubicación de los scripts en las películas de Flash.

Planificación y depuración de scripts

Lo más común cuando se programan scripts para una película completa es que
se trabaje con una gran cantidad y diversidad de scripts. Es importante planear
cuidadosamente qué acciones utilizar en un script, cómo estructurar las
instrucciones de forma efectiva y en qué elementos ubicarlos para asegurar el
mejor desempeño de los mismos, especialmente cuando la complejidad de la
película empieza a ser considerable.

Antes de empezar a programar scripts, es importante establecer un objetivo e
intentar clarificar con exactitud lo que se propone conseguir. Esto es tan
importante (y normalmente consume tanto tiempo) como el desarrollo de los
scripts para el proyecto que se desea realizar. Es recomendable empezar por escribir
las acciones que se desea sucedan en la película, como en el siguiente ejemplo:

• Deseo crear mi propio sitio Web utilizando Flash.

• A las personas que visiten el sitio se les pedirá su nombre, y éste se utilizará en

los mensajes que se generen en todo el sitio Web.

• El sitio contendrá una barra de navegación que puede arrastrarse, y sus botones

se vincularán con cada una de las secciones.

• Cuando se presione un botón, la nueva sección irá apareciendo

progresivamente en el centro del Escenario.

• Una escena dispondrá de un formulario de contacto, en el que se mostrará el

nombre del usuario.

El lenguaje ActionScript 25

Cuando tenga una idea clara de lo que desea, podrá construir los objetos
necesarios y escribir los scripts que controlen dichos objetos.

Para lograr que los scripts se comporten del modo deseado se tiene que invertir
una cantidad considerable de tiempo, en ocasiones es necesario pasar por más de
un ciclo de escritura, pruebas y depuración. La mejor forma de abordar un
problema suele ser empezar poco a poco y comprobar el trabajo a medida que se
avanza. Cuando haya conseguido que funcione una parte del script, seleccione
Guardar como, con el fin de guardar una versión del archivo (por ejemplo,
miPelic01.fla) y empiece a escribir la siguiente parte. Este modo de trabajar ayuda
a identificar errores de un modo eficiente y asegura que el código de ActionScript
es fiable antes de proceder a escribir scripts más complejos.

Creación de scripts orientados a objetos

En los scripts orientados a objetos la información se organiza en grupos
denominados clases. Pueden crearse varias instancias de una clase; a éstas se les
denomina objetos, y los objetos pueden emplearse en los scripts. El desarrollador
puede utilizar en sus scripts clases predefinidas de ActionScript y crear las
suyas propias.

Cuando se crea una clase, es preciso definir todas las propiedades (características) y
métodos (comportamientos) de cada objeto que ésta crea, de modo análogo a como
se definen los objetos en el mundo real. Una persona, por ejemplo, tiene ciertas
propiedades como el género, la altura y el color de pelo, así como ciertos métodos
como son hablar, caminar y lanzar. En este ejemplo “persona” es, genéricamente,
una clase y cada persona individual es un objeto, o una instancia de dicha clase.

Los objetos de ActionScript pueden contener datos o pueden representarse
gráficamente en el Escenario como clips de película. Todos los clips de película son
instancias de la clase predefinida MovieClip. Cada instancia de clip de película
contiene todas las propiedades (por ejemplo, _height, _rotation,

_totalframes) y todos los métodos (por ejemplo, gotoAndPlay, loadMovie,
startDrag) de la clase MovieClip.

Para definir una clase, debe crearse una función especial, denominada función
constructora; las clases predefinidas tienen funciones constructoras previamente

definidas. Por ejemplo, si se desea obtener información acerca de un ciclista que
aparece en la película, puede crearse una función constructora, Biker, con las
propiedades time y distance y el método rate, que indique la velocidad a la
que se desplaza el ciclista:

function Biker(t, d) {

this.time = t;

this.distance = d;
}
function Speed() {

return this.time / this.distance;
}
Biker.prototype.rate = Speed;

Capítulo 126

A continuación pueden crearse copias, es decir, instancias, de la clase. El siguiente
código crea instancias del objeto

emma = new Biker(30, 5);
hamish = new Biker(40, 5);

Biker denominadas emma y hamish.

Las instancias también pueden comunicarse entre sí. Para el objeto Biker, podría
crearse un método denominado shove que permita a un ciclista empujar a otro
(la instancia emma podría llamar a su método shove en caso de que hamish se
acercase demasiado). Para pasar información a un método se utilizan parámetros
(también denominados argumentos): por ejemplo, el método shove podría
aceptar los parámetros who y howFar. En este ejemplo emma empuja a hamish
10 píxeles:

emma.shove(hamish, 10);

En la creación de scripts orientados a objetos, las clases pueden recibir propiedades
y métodos unas de otras, de acuerdo a un orden determinado; esta funcionalidad
se denomina herencia. La herencia puede utilizarse para ampliar o redefinir las
propiedades y métodos de una clase. Una clase que hereda propiedades y métodos
de otra clase recibe el nombre de subclase. Una clase que pasa propiedades y
métodos a otra clase recibe el nombre de superclase. Una clase puede ser a la vez
subclase y superclase.

Objeto MovieClip

Las clases predefinidas de ActionScript reciben el nombre de Objetos. Cada objeto
permite acceder a un determinado tipo de información. Por ejemplo, el objeto
Date tiene dos métodos (por ejemplo, getFullYear, getMonth), que permiten
leer la información del reloj del sistema. El objeto Sound tiene métodos (por
ejemplo, setVolume, setPan) que permiten controlar el sonido en una película.
El objeto MovieClip tiene métodos que permiten controlar las instancias de los
clips de película (por ejemplo, play, stop y getURL) a la vez que obtienen y
definen información acerca de sus propiedades (por ejemplo, _alpha,

_framesloaded, _visible).

Los clips de película son los objetos más importantes de las películas de Flash
porque contienen líneas de tiempo que se ejecutan independientemente de las
demás. Por ejemplo, si la línea de tiempo principal sólo tiene un fotograma y en
una de las capas se incluye un clip de película que contiene a su vez10 fotogramas,
el clip de película presentará todo su contenido independientemente de que la
línea principal sólo se extienda un fotograma. Esto permite que cada instancia de
un clip de película se comporte como objeto autónomo con capacidad de
comunicación con los demás.

El lenguaje ActionScript 27

Cada instancia de un clip de película tiene un nombre único, de modo que es
posible controlarlas a través de acciones. Por ejemplo, si dispusiésemos de varias
instancias de un clip de película en el Escenario (por ejemplo, leftClip y

rightClip) podríamos asignar una acción para lograr que sólo una se reprodujese

en un momento dado. Para esto, basta asignar una acción que active a la instancia
a través del nombre de la misma. En el siguiente ejemplo, el nombre del clip de
película es leftClip:

leftClip.play();

Al momento de reproducción de una película también se pueden duplicar,
eliminar y arrastrar instancias de uno o varios clips de película utilizando su
nombre de instancia. El siguiente ejemplo duplica la instancia

cartItem para

llenar un carrito de compra con el número de artículos comprados:

onClipEvent(load) {
do {
duplicateMovieClip("cartItem", "cartItem" + i, i);
i = i + 1;
} while (i <= numberItemsPur);
}

Los clips de película poseen propiedades cuyos valores pueden establecerse y
recuperarse en forma dinámica mediante ActionScript. La modificación y lectura
de estas propiedades puede cambiar el aspecto e identidad de un clip de película y
es la clave para darle interactividad. Por ejemplo, el siguiente script utiliza la
acción setProperty para establecer la transparencia (parámetro alfa) de la
instancia navigationBar al valor 10:

setProperty("navigationBar", _alpha, 10);

Para obtener más información referente a otro tipos de objetos, consulte la sección
“Utilización de objetos predefinidos” a pagina 81.

Flujo de los scripts

ActionScript sigue un flujo lógico. Flash ejecuta las sentencias de ActionScript
empezando por la primera y continuando secuencialmente hasta llegar a la última
o a una sentencia que le indique una bifurcación a otro script u otra parte en el
mismo script.

A continuación se presentan algunas acciones que cambian el flujo de
ActionScript hacia una sentencia diferente a la que aparece después de ella:

Capítulo 128

La sentencia if, los bucles do...while, y la acción return.

El lenguaje ActionScript 29

Una sentencia if recibe el nombre de sentencia condicional o “bifurcación
lógica”, ya que controla el flujo de un script basándose en la evaluación de una
determinada condición. Por ejemplo, el siguiente código comprueba si el valor
de la variable number es menor o igual que 10. Si la comprobación devuelve true
(por ejemplo, el valor de number es 5), se establece la variable alert y muestra su
valor en un campo de entrada de texto, como el siguiente:

if (number <= 10) {
alert = "The number is less than or equal to 10";
}

También se pueden incluir sentencias else para crear sentencias condicionales
más complejas. En el ejemplo siguiente, si la condición devuelve true (por
ejemplo, el valor de number es 3), se ejecuta la sentencia encerrada entre el primer
conjunto de llaves y la variable alert se establece en la segunda línea. Si la
condición devuelve false (por ejemplo, el valor de number es 30), se ignora el
primer bloque de código y se ejecuta la sentencia encerrada entre llaves detrás de
la sentencia else, como a continuación:

if (number <= 10) {
alert = "The number is less than or equal to 10";
} else {
alert = "The number is greater than 10";
}

Si desea obtener más información, consulte “Utilización de las sentencias if” a
pagina 73.

Los bucles repiten una acción un determinado número de veces, o hasta que
se cumpla cierta condición. En el siguiente ejemplo se duplica cinco veces un
clip de película:

i = 0;
do {
duplicateMovieClip ("myMovieClip", "newMovieClip" + i, i);
newName = eval("newMovieClip" + i);
setProperty(newName, _x, getProperty("myMovieClip", _x) + (i *

5));
i = i + 1;
} while (i <= 5);

Para obtener información detallada, consulte “Repetición de una acción” a
pagina 74.

Capítulo 130

Control de la ejecución de ActionScript

Para escribir scripts se utiliza el panel Acciones. Dicho panel permite asignar el
script a un fotograma de la línea de tiempo principal o a la línea de tiempo de
cualquier clip de película, o bien a un botón o clip de película en el Escenario.

Flash ejecuta acciones en momentos diferentes, dependiendo del elemento al que
estén asociadas:

• Las acciones asociadas con fotogramas se ejecutan cuando la cabeza lectora

accede a dicho fotograma.

• Las acciones asociadas con botones se encuentran encerradas en acciones

controladorason.

• Las acciones asociadas con clips de película se encuentran encerradas en

acciones controladoras onClipEvent.

Las acciones onClipEvent y on reciben el nombre de controladoras porque
“controlan” o administran eventos. (Un evento es una incidencia, como un
movimiento del ratón, una pulsación de tecla o un clip de película que se carga).
Las acciones de botón y de clip de película se ejecutan cuando se produce el evento
especificado por el controlador. Es posible asociar más de un controlador a un
objeto para que éstos ejecuten acciones como respuesta a diferentes eventos. Para
obtener más información, consulte el Capítulo 3, “Interacción con ActionScript”.

Varios controladores onClipEvent asociados a un clip de película en el Escenario.

El lenguaje ActionScript 31

Terminología de ActionScript

Al igual que cualquier lenguaje de creación de scripts, ActionScript utiliza
terminología específica y está sujeta a determinadas reglas sintácticas. La siguiente
lista introduce términos importantes de ActionScript, en orden alfabético. En el
Capítulo 2, “Programación de scripts con ActionScript”, se estudian con mayor
detalle dichos términos y la sintaxis que los gobierna.

Acciones: son sentencias que ordenan a una película efectuar alguna acción

durante su reproducción. Por ejemplo, gotoAndStop envía la cabeza lectora a un
fotograma o etiqueta determinados. En este manual, los términos acción y
sentencia pueden emplearse indistintamente.

Argumentos: también llamados parámetros, actúan como contenedores que

permiten pasar valores a las funciones. Por ejemplo, la siguiente función,
denominada welcome, utiliza dos valores que recibe como argumentos

firstName y hobby:

function welcome(firstName, hobby) {

welcomeText = "Hello, " + firstName + "I see you enjoy " +
hobby;

}

Clases: son un tipo de datos que pueden emplearse para definir un nuevo tipo de

objeto. Para definir una clase de objeto, debe utilizarse una función constructora.

Constantes: son elementos cuyo valor no cambia. Por ejemplo, la constante

TAB tiene siempre el mismo significado. Las constantes son útiles para

comparar valores.

Constructores: son funciones que se utilizan para definir las propiedades y

métodos de una clase. Por ejemplo, el siguiente código crea un nueva clase
Circle mediante una función constructora denominada Circle:

function Circle(x, y, radius){

this.x = x;

this.y = y;

this.radius = radius;
}

Tipos de datos: son conjuntos de valores y las operaciones que pueden realizarse

sobre ellos, e incluyen cadenas, números, los valores booleanos true y false,
objetos y clips de película. Para conocer más detalles acerca de estos elementos
del lenguaje ActionScript, consulte la sección “Tipos de datos” a pagina 56.

Capítulo 132

Eventos: son acciones que ocurren durante la reproducción de una película.

Por ejemplo, cuando se carga un clip de película se generan diferentes eventos:
la cabeza lectora accede a un fotograma, el usuario hace clic en un botón o clip
de película, o el usuario introduce información mediante el teclado.

Expresiones: son las partes de una sentencia que generan valores. Por ejemplo,

2 + 2 es una expresión.

Funciones: son bloques de código reutilizables, que aceptan argumentos

(parámetros) y pueden devolver valores. Por ejemplo, la función getProperty
acepta como parámetro el nombre de una propiedad y el nombre de instancia de
un clip de película y como resultado devuelve el valor de la propiedad. La función

getVersion devuelve la versión de Flash Player que está reproduciendo la película

en un momento dado.

Controladores: son acciones especiales que “controlan” o administran un evento,

como mouseDown o load. Por ejemplo, on (onMouseEvent) y onClipEvent
son controladores de ActionScript.

Identificadores: son nombres que se utilizan para identificar una variable,

propiedad, objeto, función o método. El primer carácter debe ser una letra,
símbolo de subrayado (_) o símbolo de dólar ($). Los siguientes caracteres
pueden ser letras, números, símbolos de subrayado (_) o símbolos de dólar ($).
Por ejemplo, firstName es el nombre de una variable.

Instancias: son objetos que pertenecen a una determinada clase. Cada instancia

de una clase contiene todas las propiedades y métodos de dicha clase. Todos
los clips de película son instancias con propiedades (por ejemplo, _alpha
y _visible) y métodos (por ejemplo, gotoAndPlay y getURL) de la
clase MovieClip.

Nombres de instancias: son nombres únicos que permiten controlar instancias

de clips de película a través de scripts. Por ejemplo, un símbolo maestro de la
Biblioteca podría llamarse counter y las dos instancias de dicho símbolo que
se utilizan en la película podrían nombrarse instancia scorePlayer1 y

scorePlayer2. En el siguiente código se utilizan los nombres de instancia para

establecer una variable llamada score en cada instancia de un clip de película:

_root.scorePlayer1.score += 1
_root.scorePlayer2.score -= 1

El lenguaje ActionScript 33

Palabras clave: son palabras reservadas que tienen un significado especial. Por

ejemplo,

Métodos: son funciones que han sido asignadas a un objeto. Una vez que se ha

var es una palabra clave que se utiliza para declarar variables locales.

asignado una función se puede realizar un llamado a la misma como método de
ese objeto. Por ejemplo, en el siguiente código, clear se convierte en un método
del objeto controller:

function Reset(){

x_pos = 0;

x_pos = 0;
}
controller.clear = Reset;
controller.clear();

Objetos: son conjuntos de propiedades; cada objeto posee su propio nombre

y valor. Los objetos permiten acceder a un determinado tipo de información.
Por ejemplo, el objeto predefinido Date ofrece información procedente del reloj
del sistema.

Operadores: son términos que calculan un nuevo valor a partir de uno o más

valores. Por ejemplo, el operador suma (+) suma dos o más valores y arroja como
resultado un nuevo valor.

Rutas de destino: son direcciones jerárquicas de nombres de instancias de clips

de película, o bien variables y objetos en una película. Para asignar nombre a una
instancia de clip de película se utiliza el panel Instancia. El nombre de la Línea de
tiempo principal es siempre _root. Se puede usar una ruta de destino para dirigir
una acción a un clip de película, o para obtener o establecer el valor de una
variable. Por ejemplo, la siguiente sentencia establece una ruta de destino a la
variable volume dentro del clip de película stereoControl:

_root.stereoControl.volume

Propiedades: son atributos que definen a un objeto. Por ejemplo, _visible es

una propiedad de todos los clips de película que define si el clip está visible o si
se encuentra oculto.

Variables: son identificadores que almacenan valores de cualquier tipo de datos.

Las variables pueden crearse, modificarse y actualizarse. Los valores almacenados
en una variable pueden recuperarse para ser utilizados en scripts. En el siguiente
ejemplo, los identificadores situados a la izquierda de los signos igual son variables:

x = 5;
name = "Lolo";
customer.address = "66 7th Street";
c = new Color(mcinstanceName);

Capítulo 134

Análisis de un script de ejemplo

En la siguiente película de ejemplo, cuando un usuario arrastra el insecto hacia
el matamoscas, el insecto cambia de color al color negro y cae, y el matamoscas
parece parpadear. La película tiene una longitud de un fotograma y contiene dos
objetos, la instancia del clip de película del insecto y la instancia del clip de
película del matamoscas. Cada clip de película contiene asimismo un fotograma.

Las instancias de clip de película del insecto y del matamoscas en el Escenario en
el fotograma 1.

Controlador

Acción

Variable

Sentencia

condicional if

Else, sentencia

Sólo hay un script en la película y está asociado a la instancia del insecto, como
puede apreciarse en el panel Acciones de objetos que se muestra a continuación:

Evento

Función constructora

Operador new

Panel Acciones de objetos, que muestra el script asignado a la instancia del insecto.

El lenguaje ActionScript 35

Ambos objetos deben ser clips de película, de forma que sea posible asignarles
nombres de instancia en el panel Instancia y manipularlos mediante ActionScript.
El nombre de instancia del insecto es bug y el del matamoscas es zapper. En el
script, se hace referencia al insecto como this porque el script está anexado al
insecto y la palabra reservada this hace referencia al objeto que lo llama.

Hay dos controladores onClipEvent con dos eventos diferentes: load y

enterFrame. Las acciones de la sentencia onClipEvent(load) se ejecutan

sólo una vez, al cargarse la película. Las acciones de la sentencia

onClipEvent(enterFrame) se ejecutan cada vez que la cabeza lectora accede

a un fotograma. Incluso aunque se trate de películas de un solo fotograma,
la cabeza lectora accederá al fotograma reiterativamente y el script se ejecutará
de la misma forma. Dentro de cada controlador onClipEvent se llevan a cabo
las siguientes acciones:

onClipEvent(load) La acción startDrag hace posible que se pueda arrastrar el

clip de película del insecto. El operador new y la función constructora de color,

Color, crean una instancia del objeto Color y la asignan a la variable zap:

onClipEvent (load) {

startDrag (this, true);

zap = new Color(this);
}

onClipEvent(enterFrame) Una sentencia condicional if evalúa una acción

hitTest para comprobar si la instancia del insecto (this) está tocando a la

instancia del matamoscas (_root.zapper). La evaluación puede generar dos
posibles resultados, true o false:

onClipEvent (enterFrame) {

if (hitTest(_target, _root.zapper)) {

zap.setRGB(0);
setProperty (_target, _y, _y+50);
setProperty (_root.zapper, _alpha, 50);
stopDrag ();

} else {

setProperty (_root.zapper, _alpha, 100);

}
}

Si la acción hitTest devuelve true, el objeto zap creado por el evento load se
utilizará para cambiar el color del insecto a negro. La propiedad y (_y) del insecto
se establece a su valor más 50, de modo que el insecto caiga. La transparencia del
matamoscas (_alpha) se establece al valor 50, de modo que se atenúe. La acción

stopDrag impide que se arrastre el objeto.

Capítulo 136

Si la acción hitTest devuelve el valor false, se ejecutará la acción que sigue a
la sentencia

else y el valor _alpha del matamoscas se establecerá al valor 100.

Esto provocará que el matamoscas aparezca intermitentemente, ya que su valor

_alpha pasará de un estado inicial (100) a un estado activo (50), volviendo

posteriormente al estado inicial. La acción hitTest arroja como resultado el valor

false y las sentencias else se ejecutan una vez que se ha alcanzado y abatido al

insecto.

Para ver cómo se reproduce la película, consulte la Ayuda de Flash.

Utilización del panel Acciones

El panel Acciones permite crear y editar acciones de un objeto o fotograma
mediante el uso de dos modos de edición. Es posible seleccionar acciones
previamente escritas en la lista de la Caja de herramientas, arrastrar y colocar
acciones, así como utilizar botones para eliminar o reordenar acciones. El modo
Normal permite escribir acciones utilizando campos de parámetros (argumentos)
que solicitan los argumentos apropiados. El modo Experto permite escribir y
editar acciones directamente en un cuadro de texto, como si se escribiesen en un
procesador de texto.

Para mostrar el panel Acciones:

Seleccione Ventana > Acciones.

El panel Acciones se activa cuando se selecciona una instancia de un botón o clip
de película. El título del panel Acciones cambia a Acciones de objetos si algún
botón o clip de película se encuentra seleccionado, y a Acciones de fotograma si
se encuentra seleccionado hay un fotograma.

Para seleccionar un modo de edición:

1 Con el panel Acciones en pantalla, haga clic en la flecha de la esquina superior

derecha para que se muestre el menú emergente.

2 Seleccione Modo Normal o Modo Experto en el menú emergente.

Cada script conserva su propio modo. Por ejemplo, si se crea un
script para una instancia de un botón en modo Normal y otro en modo
Experto, posteriormente se cambiará el modo del panel al seleccionar
cada uno de los botones.

El lenguaje ActionScript 37

Modo Normal

El modo Normal permite crear acciones seleccionándolas de una lista situada en
la parte izquierda del panel, denominada lista de la Caja de herramientas. La lista
de la Caja de herramientas contiene las siguientes categorías: Acciones básicas,
Acciones, Operadores, Funciones, Propiedades y Objetos. La categoría Acciones
básicas contiene las acciones de Flash más simples y sólo está disponible en el
modo Normal. Las acciones seleccionadas se muestran en la parte derecha del
panel, en la lista Acciones. Es posible agregar, eliminar o modificar el orden de
las sentencias de acciones; también es posible especificar parámetros (argumentos)
para las acciones en los campos que se encuentran en la parte inferior del panel.

En modo Normal se pueden utilizar los controles del panel Acciones para
eliminar o cambiar el orden de las sentencias de la lista Acciones. Estos controles
resultan especialmente útiles para controlar acciones de botón o fotograma que
contienen varias sentencias.

Agregar una sentencia

Eliminar una sentencia

Lista de la Caja

de herramientas

panel Parámetros

Capítulo 138

Lista Acciones

Insertar ruta de destino, botón

Panel Acciones en modo Normal.

Para seleccionar una acción:

1 Haga clic en una categoría de acciones de la Caja de herramientas para acceder

a las acciones de dicha categoría.

2 Haga doble clic en una acción o arrástrela a la ventana de scripts.

Para utilizar los campos de parámetros:

1 Haga clic en el botón Parámetros, situado en la esquina inferior derecha del

panel Acciones, para mostrar los campos.

2 Seleccione la acción y especifique nuevos valores en los campos de parámetros,

si desea modificar los parámetros de las acciones existentes.

Para insertar una ruta de destino de clip de película:

1 Haga clic en el botón Ruta de destino, situado en la esquina inferior derecha

del panel Acciones; accederá al cuadro de diálogo Insertar ruta de destino.

2 Seleccione un clip de película de la lista de visualización.

Para desplazar una sentencia de la lista hacia arriba o hacia abajo:

1 Seleccione una sentencia en la lista Acciones.
2 Haga clic en los botones de flecha arriba o abajo.

Para eliminar una acción:

1 Seleccione una sentencia en la lista Acciones.
2 Haga clic en el botón Eliminar (-).

Para cambiar los parámetros de las acciones existentes:

1 Seleccione una sentencia en la lista Acciones.
2 Introduzca los nuevos valores en los campos de parámetros.

Para cambiar el tamaño de la Caja de herramientas o de la lista Acciones, utilice
uno de los siguientes procedimientos:

• Arrastre la barra separadora vertical que aparece entre la Caja de herramientas

y la lista Acciones.

•

Haga doble clic en la barra separadora para contraer la lista de la Caja de
herramientas; vuelva a hacer doble clic en la barra para mostrar la lista de nuevo.

• Haga clic en el botón de flecha izquierda o derecha de la barra separadora para

expandir o contraer la lista.

Aunque la Caja de herramientas esté oculta, es posible acceder a sus elementos
mediante el botón Agregar (+), que se encuentra en la parte superior izquierda del
panel Acciones.

El lenguaje ActionScript 39

Modo Experto

El modo Experto permite crear acciones introduciendo comandos de ActionScript
en el cuadro de texto situado en la parte derecha del panel, o bien seleccionado
acciones en la lista de la Caja de herramientas de la izquierda. Para editar acciones,
especificar parámetros de acciones o eliminar acciones se utiliza directamente el
cuadro de texto, como se haría si se estuviesen creando los scripts mediante un
procesador de texto.

El modo Experto permite a los usuarios experimentados de ActionScript
modificar sus propios scripts con un procesador de texto, como si se tratase de
JavaScript o VBScript. Las principales diferencias respecto al modo Normal son
las siguientes:

• Al seleccionar un elemento en el menú emergente Agregar o en la lista

de la Caja de herramientas, se introduce dicho elemento en el área de
edición de texto.

• No aparecen campos de parámetros.

• En el panel de botones, únicamente se encuentra activo el botón Agregar (+).

• Los botones de flecha arriba y abajo permanecen inactivos.

El panel Acciones en modo Experto.

Capítulo 140

Cambio del modo de edición

Si se cambia de modo de edición mientras se está creando un script, el formato
de éste podría alterarse. Por ese motivo, se recomienda utilizar un solo modo de
edición por script.

Al cambiar de modo Normal a Experto se conserva la sangría y el formato.
Aunque se pueden convertir scripts creados en modo Normal que contienen
errores a modo Experto, no podrán exportarse hasta que éstos hayan sido
corregidos.

El cambio de modo Experto a modo Normal es ligeramente más complejo:

• Cuando se cambia de modo Experto a modo Normal, Flash vuelve a asignar

formato al script y elimina los espacios en blanco y la sangría que hubiera
podido agregarse.

• Si se cambia a modo Normal y, seguidamente, a modo Experto, Flash vuelve a

asignar formato al script de acuerdo con el aspecto que tenía en modo Normal.

• Los scripts en modo Experto que contienen errores no pueden exportarse ni

convertirse al modo Normal; si se intenta, presentará un mensaje de error.

Para cambiar el modo de edición:

Seleccione Modo Normal o Modo Experto en el menú emergente situado en la
parte superior derecha del panel Acciones. Se indicará el modo seleccionado a
través de una marca de verificación.

Para establecer las preferencias de un modo de edición:

1 Seleccione Edición > Preferencias.

2 Seleccione la ficha General.

3 En la sección Panel Acciones, elija Modo Normal o Modo Experto en

el menú emergente.

El lenguaje ActionScript 41

Utilización de un editor externo

Aunque el modo Experto del panel Acciones proporciona un mayor control de
edición con ActionScript, también puede optar por editar scripts externamente
a Flash. Posteriormente puede hacer uso de la acción include para agregar los
scripts creados mediante el editor externo a un script de Flash.

Por ejemplo, la siguiente sentencia importa un archivo de script:

#include "externalfile.as"

El texto del archivo de script sustituye a la acción include. El archivo de texto
deberá estar presente cuando se exporte la película.

Para agregar los scripts creados con un editor externo a un script de Flash:

1 Arrastre la acción include desde la lista de la Caja de herramientas a la

ventana de scripts.

2 Especifique la ruta del archivo externo en el cuadro Ruta.

La ruta deberá ser relativa respecto al archivo FLA. Por ejemplo, si los archivos
mi_Pelicula.fla y archivo_externo.as estuviesen situados en la misma carpeta,
la ruta sería archivo_externo.as. Si archivo_externo.as se encontrase en una
subcarpeta denominada scripts, la ruta sería scripts/archivo_externo.as.

Selección de opciones en el panel Acciones

El panel Acciones permite manipular scripts de varias maneras. El tamaño de la
fuente puede modificarse en la ventana de scripts. Pueden importarse archivos de
texto que contengan comandos de ActionScript en el panel Acciones, así como
exportar acciones como archivos de texto, buscar y reemplazar texto en un script y
utilizar elementos para realzar la sintaxis para facilitar la identificación de los
scripts y la detección de errores. El panel Acciones muestra elementos de realzado
de tipo advertencia cuando existen errores sintácticos e incompatibilidades de
versiones con Flash Player. También realza elementos de ActionScript no aprobados
o no deseables.

Estas opciones del panel Acciones se encuentran disponibles tanto en modo
Normal como en modo Experto, a menos que se especifique lo contrario.

Para cambiar el tamaño de fuente en la ventana de scripts:

1 En el menú emergente situado a la derecha del panel Acciones, seleccione

Tamaño de fuente.

2 Seleccione Pequeño, Normal o Grande.

Capítulo 142

Para importar un archivo de texto que contenga comandos de ActionScript:

1 En el menú emergente situado en la parte superior derecha del panel Acciones,

seleccione Importar desde archivo.

2 Seleccione un archivo de texto que contenga comandos de ActionScript y haga

clic en Abrir.

Nota:

Los scripts que contienen errores sintácticos sólo pueden importarse en modo

Experto. En modo Normal se generará un mensaje de error.

Para exportar acciones como archivos de texto:

1 En el menú emergente situado en la parte superior derecha del panel Acciones

seleccione Exportar como archivo.

2 Elija una ubicación para el archivo y haga clic en Guardar.

Para imprimir acciones:

1 En el menú emergente situado en la parte superior derecha del panel Acciones,

seleccione Imprimir.

Se mostrará el cuadro de diálogo Imprimir.

2 Seleccione Opciones y haga clic en Imprimir.

Nota:

El archivo impreso no incluirá información respecto al archivo de Flash del que

procede. Es recomendable incluir esta información en una acción

comment en el script.

Para buscar texto en un script, seleccione una opción en el menú emergente
del panel Acciones:

• Seleccione Ir a línea para desplazarse a una línea determinada de un script.

• Seleccione Buscar para buscar texto.

• Seleccione Buscar otra vez para buscar una cadena de texto de nuevo.

• Seleccione Reemplazar para buscar y reemplazar texto.

En modo Experto, el comando Reemplazar busca en todo el cuerpo de texto de
un script. En modo Normal, el comando Reemplazar busca y reemplaza texto
únicamente en el campo de parámetros de cada acción. Por ejemplo, en modo
Normal no sería posible reemplazar todas las acciones gotoAndPlay por

gotoAndStop.

Nota:

Utilice los comandos Buscar o Reemplazar para buscar en la lista Acciones actual.
Para buscar texto en todos los script de una película, utilice el Explorador de películas. Para
obtener más información, consulte la sección

Utilización de Flash

El lenguaje ActionScript 43

.

Realzado y comprobación de la sintaxis

Los elementos de realzado de la sintaxis permiten identificar determinados
elementos de ActionScript y asignarles diferentes colores. De esto modo se evitan
errores sintácticos, como la incorrecta colocación de mayúsculas y minúsculas en
palabras clave. Por ejemplo, si la palabra clave typeof se escribiese como typeOf,
ésta no aparecería en color azul y esto ayudaría a que se detectase el error. Cuando
se encuentra activada la opción de realzado de sintaxis, el texto se destacará del
siguiente modo:

• Las palabras clave y los identificadores predefinidos (por ejemplo,

gotoAndStop, play y stop) aparecen en color azul.

• Las propiedades aparecen en verde.

• Los comentarios aparecen en color morado.

• Las cadenas encerradas entre comillas aparecen en color gris.

Para activar o desactivar el realzado de sintaxis:

Seleccione Sintaxis en color en el menú emergente situado en la parte superior
derecha del panel Acciones. Una marca de verificación indica que la opción está
activada. El realzado se aplicará a todos los scripts de la película.

Es recomendable comprobar que la sintaxis de los scripts es correcta antes de
exportar películas. Los errores se muestran en la Ventana de salida. Podrán
exportarse películas que contengan scripts con errores. No obstante, el usuario
recibirá una advertencia indicándole que los scripts con errores no se exportarán.

Para comprobar los errores sintácticos del script actual:

Seleccione Revisar sintaxis en el menú emergente situado en la parte superior
derecha del panel Acciones.

Capítulo 144

Realzado de errores

En modo Normal, todos los errores sintácticos se realzan utilizando un fondo de
color rojo sólido en la ventana de scripts. Esto ayuda a detectar problemas. Si
se desplaza el puntero de ratón sobre una acción sintácticamente incorrecta, se
mostrará el mensaje de error asociado en un cuadro de información. Cuando se
selecciona la acción, el mensaje de error se muestra también en el título del panel
del área de parámetros.

En modo Normal todas las posibles incompatibilidades de exportación de
ActionScript se realzan con un fondo de color amarillo sólido en la ventana de
scripts. Por ejemplo, si la versión de exportación de Flash Player se establece como
Flash 4, los comandos de ActionScript que sólo sean compatibles con Flash Player
5 se mostrarán realzados en color amarillo. La versión de exportación se determina
en el cuadro de diálogo Configuración de publicación.

Todas las acciones no aprobadas se realzan con fondo de color verde en la Caja
de herramientas. Las acciones no aprobadas sólo se realzan cuando la versión de
exportación de Flash se establece como Flash 5.

Para establecer la versión de exportación de Flash Player:

1 Seleccione Archivo > Configuración de publicación.

2 Haga clic en la ficha Flash.

3 Elija una versión de exportación en el menú emergente Versión.

Nota:

El realzado de errores sintácticos no puede desactivarse.

Para realzar la sintaxis no aprobada:

Seleccione Mostrar sintaxis no aprobada en el menú emergente del
panel Acciones.

Para desea obtener la relación completa de mensajes de error, consulte el
Apéndice C, “Mensajes de error”.

El lenguaje ActionScript 45

Asignación de acciones a los objetos

Se pueden asignar acciones a botones o a clips de película, de modo que la acción
se ejecute cuando el usuario haga clic en un botón o sitúe el puntero sobre él, o
bien cuando se cargue el clip de película o se alcance un determinado fotograma.
La acción se asigna a una instancia del botón o del clip de película; el resto
de instancias del símbolo no se verán afectadas (si desea asignar una acción a
un fotograma, consulte la sección “Asignación de acciones a fotogramas” a
pagina 48).

Cuando asigna una acción a un botón, debe anidarla dentro de un controlador

on(mouse event) y especificar los eventos de ratón o teclado que activan la

acción. Cuando asigna una acción a un botón en el Modo Normal, el controlador

on(mouse event) se inserta automáticamente.

Cuando asigna una acción a un clip de película, debe anidarla dentro de un
controlador onClipEvent y especificar el evento de clip que activa la acción.
Cuando asigna una acción a un clip de película en el Modo Normal, el
controlador on(mouse event) se inserta automáticamente.

Las siguientes instrucciones describen el modo de asignar acciones a objetos
mediante el panel Acciones utilizado en modo Normal.

Una vez asignada una acción, utilice el comando Control > Probar película
para verificar si funciona. La mayoría de las acciones no funcionan en el
modo de edición.

Para asignar una acción a un botón o clip de película:

1 Seleccione un botón o una instancia de clip de película y elija

Ventana > Acciones.

Si la selección no es un botón, una instancia de clip de película o un fotograma,
o si la selección incluye varios objetos, el panel Acciones aparecerá atenuado.

2 Seleccione Modo Normal en el menú emergente situado en la parte superior

derecha del panel Acciones de objetos.

3 Para asignar una acción utilice uno de los siguientes procedimientos:

• Haga clic en la carpeta Acciones, que se encuentra en la lista de la Caja de

herramientas, a la izquierda del panel Acciones. Haga doble clic en una acción
para agregarla a la lista Acciones situada a la derecha del panel.

• Arrastre una acción desde la lista de la Caja de herramientas hasta la

lista Acciones.

• Haga clic en el botón Agregar (+) y elija una acción en el menú emergente.

Capítulo 146

• Utilice el método abreviado de teclado situado junto a cada acción en

el menú emergente.

Selección de objetos de la Caja de herramientas en modo Normal

4 Seleccione los parámetros que se requieran para la acción en los campos de

parámetros, situados en la parte inferior del panel.

Los parámetros variarán dependiendo de la acción que se seleccione. Para
obtener información detallada acerca de los parámetros necesarios para cada
acción, consulte el Capítulo 7, “Diccionario de ActionScript”. Para insertar una
Ruta de destino para un clip de película en un campo de parámetros, haga clic
en el botón Ruta de destino, que se encuentra en la esquina inferior derecha del
panel Acciones. Para obtener más información, consulte el Capítulo 4,
“Utilización de clips de película”.

5 Repita los pasos 3 y 4 para asignar más acciones, si fuera necesario.

Para probar la acción de un objeto:

Seleccione Control > Probar película.

El lenguaje ActionScript 47

Asignación de acciones a fotogramas

Si se desea que una película realice un acción específica cuando alcance un
fotograma clave, basta con asignar una acción de fotograma al fotograma clave.
Por ejemplo, para crear un bucle entre los fotogramas 20 y 10 de la Línea de
tiempo, agregue la siguiente acción de fotograma al fotograma 20:

gotoAndPlay (10);

Es conveniente situar las acciones de fotograma en capas independientes. Los
fotogramas con acciones se indican con una pequeña a en la Línea de tiempo.

Una “a” en un fotograma clave indica una acción de fotograma.

Una vez asignada la acción, seleccione Control > Probar película para verificar si
funciona. La mayoría de las acciones no funcionan en el modo de edición.

Las siguientes instrucciones describen el modo de asignar acciones de fotograma
mediante el panel Acciones en modo Normal (para obtener información acerca de
la asignación de acciones a botones o clips de película, consulte la sección
“Asignación de una acción o método” a pagina 127).

Para asignar una acción a un fotograma clave:

1 Seleccione un fotograma clave en la Línea de tiempo y elija Ventana > Acciones.

Si el fotograma seleccionado no es un fotograma clave, la acción se asignará al
fotograma clave anterior. Si no se ha seleccionado ningún fotograma, o si la
selección incluye varios fotogramas clave, el panel Acciones aparecerá atenuado.

2 Seleccione Modo Normal en el menú emergente situado en la parte superior

derecha del panel Acciones de fotograma.

Capítulo 148

3

Para asignar una acción utilice uno de los siguientes procedimientos:

• Haga clic en la carpeta Acciones, que se encuentra en la lista de la Caja de

herramientas, a la izquierda del panel Acciones. Haga doble clic en una acción
para agregarla a la lista Acciones situada a la derecha del panel.

• Arrastre una acción desde la lista de la Caja de herramientas hasta la

lista Acciones.

• Haga clic en el botón Agregar (+) y elija una acción en el menú emergente.

• Utilice el método abreviado de teclado situado junto a cada acción en el

menú emergente.

• Seleccione los parámetros que se requieran para la acción en los campos

de parámetros, situados en la parte inferior del panel.

4 Para asignar acciones adicionales, seleccione otro fotograma clave y

repita el paso 3.

Para probar una acción de fotograma:

Seleccione Control > Probar película.

El lenguaje ActionScript 49

Capítulo 150

CAPÍTULO 2

Programación de Scripts en ActionScript

.............................................................................................................

Es posible crear scripts en ActionScript, optando por el nivel de detalle que se
desee utilizar. Para utilizar las acciones sencillas, puede acceder al panel Acciones
en Modo Normal y crear scripts eligiendo las opciones que desea utilizar de los
menús y de las listas. Sin embargo, si desea utilizar ActionScript para escribir
scripts más poderosos, es recomendable entender las bases del lenguaje
ActionScript.

Como otros lenguajes de scripts, ActionScript consta de componentes como
objetos predefinidos y funciones, y le permite crear sus propios objetos y
funciones. ActionScript tiene sus propias reglas sintácticas, se reserva palabras
clave, proporciona operadores y le permite utilizar variables para almacenar y
recuperar información.

La sintaxis y el estilo de ActionScript se parece mucho al de JavaScript.
Flash 5 convierte los scripts de ActionScript escritos en cualquier versión
anterior de Flash.

2

51

Utilización de la sintaxis de ActionScript

ActionScript sigue reglas gramaticales y de puntuación que determinan qué
caracteres y palabras se utilizan para dar significado a una sentencia y el orden en
que se deben escribir. Por ejemplo, en español, una oración termina con un punto.
En ActionScript, se utiliza un punto y coma para finalizar una sentencia.

A continuación se detallan las reglas generales que se aplican a todo el lenguaje
ActionScript. La mayoría de los términos de ActionScript tienen sus propios
requisitos; para conocer las reglas de un término específico, consúltelo en el
Capítulo 7, “Diccionario de ActionScript”.

Sintaxis de punto

En ActionScript, se utiliza un punto (.) para indicar las propiedades o métodos
relacionados con un objeto o un clip de película. También se utiliza para
identificar la ruta de destino a un clip de película o a una variable. Una expresión
de sintaxis de punto comienza con el nombre del objeto o del clip de película
seguido por un punto y finaliza con la propiedad, el método o la variable que
desee especificar.

Por ejemplo, la propiedad de clip de película _x indica la posición del clip de
película en el eje x en el Escenario. La expresión ballMC._x se refiere a la
propiedad _x de la instancia del clip de película ballMC.

Otro ejemplo, submit es una variable establecida en el clip de película form que
se encuentra anidado dentro del clip de película shoppingCart. La expresión

shoppingCart.form.submit = true establece la variable submit de la instancia
form en true.

La expresión de un método de un objeto o de un clip de película sigue el mismo
esquema. Por ejemplo, el método play de la instancia ballMC mueve la cabeza
lectora en la Línea de tiempo de ballMC, como en la siguiente sentencia:

ballMC.play();

La sintaxis de punto también utiliza dos alias especiales, _root y _parent. El
alias _root se refiere a la Línea de tiempo principal. Puede utilizar el alias _root
para crear una ruta de destino absoluta. Por ejemplo, la siguiente sentencia llama
a la función buildGameBoard en el clip de película functions en la Línea de
tiempo principal:

_root.functions.buildGameBoard();

Puede utilizar el alias _parent para referirse a un clip de película en el que está
anidado el clip de película actual. Puede utilizar _parent para crear una ruta
de destino relativa. Por ejemplo, si el clip de película dog se encuentra anidado
dentro del clip de película animal, la siguiente sentencia en la instancia dog
dice a animal que se detenga:

_parent.stop();

Consulte el Capítulo 4, “Trabajo con clips de películas”.

Capítulo 252

Sintaxis de barras

La sintaxis de barra se utilizó en Flash 3 y 4 para indicar la ruta de destino de
un clip de película o de una variable. Esta sintaxis aún se admite en Flash Player 5,
pero no se recomienda su utilización. En la sintaxis de barras inversas, éstas se
utilizan en lugar de los puntos para indicar la ruta a un clip de película o a una
variable. Para indicar una variable, debe anteponerle dos puntos como se
muestra a continuación:

myMovieClip/childMovieClip:myVariable

Puede escribir la misma ruta de destino en sintaxis de punto, como se muestra
a continuación:

myMovieClip.childMovieClip.myVariable

La sintaxis de barra inversa se utilizaba comúnmente con la acción tellTarget,
pero su utilización ya no se recomienda.

Nota:

Ahora es recomendable emplear la acción with en lugar de tellTarget debido a
que es más compatible con la sintaxis de punto. Para obtener más información, consulte el
Capítulo 7, “Diccionario de ActionScript”.

Llaves

Las sentencias de ActionScript se agrupan en bloques con llaves ({ }), como se
muestra en el script siguiente:

on(release) {
myDate = new Date();
currentMonth = myDate.getMonth();
}

Consulte “Uso de acciones” a pagina 71.

Puntos y coma

Una sentencia de ActionScript se termina con punto y coma, pero si omite el
punto y coma final, Flash compilará con éxito script. Por ejemplo, las siguientes
sentencias finalizan con punto y coma:

column = passedDate.getDay();
row = 0;

Las mismas sentencias podrían escribirse sin terminar en punto y coma:

column = passedDate.getDay()
row = 0

Programación de Scripts en ActionScript 53

Paréntesis

Cuando defina una función, coloque los argumentos entre paréntesis:

function myFunction (name, age, reader){

...

}

Cuando llame a una función, incluya cualquiera de los argumentos que se desean
pasar a la misma entre paréntesis, como se muestra a continuación:

myFunction ("Steve", 10, true);

También puede utilizar paréntesis para cancelar el orden de precedencia de
ActionScript o para hacer más legibles las sentencias de ActionScript. Consulte
“Precedencia de operadores” a pagina 65.

También puede utilizar los paréntesis para evaluar una expresión a la izquierda
de un punto en la sintaxis de punto. Por ejemplo, en el siguiente enunciado, los
paréntesis hacen que new color(this) evalúe y cree un nuevo objeto Color:

onClipEvent(enterFrame) {

(new Color(this)).setRGB(0xffffff));

}

Si no ha utilizado paréntesis, tendrá que agregar una sentencia al código
para evaluarlo:

onClipEvent(enterFrame) {

myColor = new Color(this);
myColor.setRGB(0xffffff);

}

Letras en mayúsculas y minúsculas

ActionScript solamente distingue el uso de mayúsculas y minúsculas en sus
palabras clave; con el resto de ActionScript puede utilizar mayúsculas y minúsculas
según desee. Por ejemplo, las siguientes sentencias son equivalentes:

cat.hilite = true;
CAT.hilite = true;

Sin embargo, es conveniente seguir convenciones coherentes en el uso de
mayúsculas y minúsculas, como las que se utilizan en este manual, para que sea
más fácil identificar los nombres de las funciones y de las variables cuando se lea el
código de ActionScript.

Si no utiliza el formato correcto de mayúsculas y minúsculas con las palabras clave,
puede que su script tenga errores. Cuando está activada la Sintaxis en color en el
panel de Acciones, las palabras clave escritas con el formato correcto de
mayúsculas y minúsculas aparecen en azul. Si desea obtener más información,
consulte las secciones “Palabras clave” a pagina 55 y “Realzado y comprobación de
la sintaxis” a pagina 44.

Capítulo 254

Comentarios

En el panel Acciones utilice la sentencia

comment para agregar notas a una acción

de botón o un fotograma que le faciliten el seguimiento de lo que desea que haga
una acción. Los comentarios también son útiles para pasar información a otros
desarrolladores cuando se trabaje en un entorno de colaboración o se
proporcionen ejemplos.

Cuando elija la acción

comment, los caracteres // se insertan en el script.

Incluso un script sencillo es más fácil de entender si documenta sus notas a
medida que lo crea:

on(release) {
// create new Date object
myDate = new Date();
currentMonth = myDate.getMonth();
// convert month number to month name
monthName = calcMonth(currentMonth);
year = myDate.getFullYear();
currentDate = myDate.getDat ();
}

Los comentarios aparecen en rosa color en la ventana Script. Pueden ser de
cualquier longitud sin afectar al tamaño del archivo exportado, y no necesitan
seguir las reglas de la sintaxis o palabras clave de ActionScript.

Palabras clave

ActionScript se reserva palabras para su uso específico en el lenguaje, de modo que
no se pueden utilizar como nombres de variables, de funciones ni de etiquetas. En
la siguiente tabla se muestra una lista de las palabras clave de ActionScript:

break for new var

continue function return void

delete if this while

else in typeof with

Si desea obtener más información acerca de una palabra clave concreta, consulte el
Capítulo 7, “Diccionario de ActionScript”.

Programación de Scripts en ActionScript 55

Constantes

Una constante es una propiedad cuyo valor nunca cambia. En la caja de
herramientas Acciones y en el Capítulo 7, “Diccionario de ActionScript”, se
muestra una lista de las constantes, todas en mayúsculas.

Por ejemplo, las constantes BACKSPACE, ENTER, QUOTE, RETURN, SPACE, y TAB son
propiedades del objeto Key y se refieren a las teclas del teclado. Para comprobar si
el usuario está presionando la tecla Intro, utilice la siguiente sentencia:

if(keycode() == Key.ENTER) {

alert = "Are you ready to play?"
controlMC.gotoAndStop(5);

}

Tipos de datos

Un tipo de datos describe la clase de información que puede contener una variable
o el elemento de ActionScript. Existen dos clases de tipo de datos: primitivos y de
referencia. Los datos de tipo primitivo (cadena, número y Booleano) tienen un
valor constante y por lo tanto pueden contener el valor real del elemento que
representan. El tipo de datos de referencia (clip de película y objeto) tienen valores
que pueden cambiar y por lo tanto contienen referencias al valor real del elemento.
Las variables que contienen datos de tipo primitivo se comportan de modo
diferente en ciertas situaciones que las que contienen datos de tipo referencia.
Consulte “Utilización de las variables en un script” a pagina 62.

Cada tipo de datos tiene sus propias reglas y aparece es esta lista. Se incluyen
referencias del tipo de datos que se explican con más detalle.

Cadena

Una cadena es una secuencia de caracteres tales como letras, números y signos
de puntuación. Las cadenas se introducen en una sentencia de ActionScript
incluyéndolas entre comillas simples o dobles. A las cadenas se les trata como
caracteres en lugar de como variables. Por ejemplo, en la siguiente sentencia,

"L7" es una cadena:

favoriteBand = "L7";

Puede utilizar el operador de suma (+) para concatenar, o unir, dos cadenas.
ActionScript trata los espacios del comienzo o del final de una cadena como parte
literal de la cadena. La siguiente expresión incluye un espacio después de la coma:

greeting = "Welcome, " + firstName;

Capítulo 256

Aunque ActionScript no distingue entre mayúsculas y minúsculas en las
referencias a variables, los nombres de instancia y las etiquetas de fotogramas,
en las cadenas literales sí las distingue. Por ejemplo, las dos siguientes sentencias
colocan texto diferente en las variables de campo de texto especificadas, ya que

"Hello" y "HELLO" son cadenas literales.

invoice.display = "Hello";
invoice.display = "HELLO";

Para incluir un signo de interrogación en una cadena, ponga delante el carácter de
barra inversa (\). A esto se le llama “escape” de un carácter. Hay otros caracteres
que no pueden representarse en ActionScript excepto por secuencias de escape
especiales. La siguiente tabla muestra todos los caracteres de escape de
ActionScript:

Secuencia de escape Carácter

\b

\f Carácter de salto de página (ASCII 12)

\n

\r

\t Carácter de tabulación (ASCII 9)

\"

\'

\\

\000 - \377

\x00 - \xFF

\u0000 - \uFFFF

Carácter de retroceso (ASCII 8)

Carácter de avance de línea (ASCII 10)

Carácter de retorno de carro (ASCII 13)

Comillas dobles

Comillas simples

Barra inversa

Un byte especificado en octal

Un byte especificado en hexadecimal

Un carácter Unicode de 16 bits especificado en
hexadecimal

Numérico

El tipo de datos numérico es un número en coma flotante de doble precisión.
Puede manipular los números utilizando los operadores aritméticos de suma (+),
resta (-), multiplicación, (*), división (/), módulo (%), incremento (++) y
decremento (--). También puede utilizar los métodos del objeto predefinido
Math para manipular los números. El siguiente ejemplo utiliza el método

sqrt

(raíz cuadrada) para devolver la raíz cuadrada del número 100:

Math.sqrt(100);

Consulte “Operadores numéricos” a pagina 66.

Programación de Scripts en ActionScript 57

Booleano

Un valor Booleano es uno que es
los valores

true y false en 1 y 0 cuando sea adecuado. Los valores booleanos se

true o false. ActionScript también convierte

usan con mayor frecuencia con los operadores lógicos en sentencias de
ActionScript que realizan comparaciones para controlar el flujo de un script.
Por ejemplo, en el siguiente script, la película se reproduce si la variable password
es true:

onClipEvent(enterFrame) {
if ((userName == true) && (password == true)){
play();
}
}

Consulte “Utilización de las sentencias if” a pagina 73 y “Operadores lógicos” a
pagina 67.

Objeto

Un objeto es un conjunto de propiedades. Cada propiedad tiene un nombre y un
valor. El valor de la propiedad puede ser cualquier tipo de datos de Flash, incluso
el tipo de datos de objeto. Esto le permite organizar los objetos unos dentro de
otros, o “anidarlos”. Para especificar objetos y sus propiedades, debe utilizar el
operador punto (.). Por ejemplo, en el siguiente código, hoursWorked es una
propiedad de weeklyStats, que a su vez es una propiedad de employee:

employee.weeklyStats.hoursWorked

Puede utilizar los objetos predefinidos de ActionScript para acceder y manipular
tipos de información específicos. Por ejemplo, el objeto Math tiene métodos que
realizan operaciones matemáticas con los números que le pasan. Este ejemplo
utiliza el método sqrt:

squareRoot = Math.sqrt(100);

El objeto MovieClip de ActionScript tiene métodos que le permiten controlar las
instancias del símbolo de clip de película en el Escenario. Este ejemplo, utiliza los
métodos play y nextFrame:

mcInstanceName.play();
mc2InstanceName.nextFrame();

También puede crear sus propios objetos de modo que pueda organizar la
información de su película. Para agregar interactividad a una película con
ActionScript, necesitará varios elementos de información diferentes: por ejemplo,
puede que necesite un nombre de usuario, la velocidad de una pelota, los nombres
de los elementos en un carrito de la compra, el número de fotogramas cargados, el
código postal del usuario y qué tecla se presionó en último lugar. La creación de
objetos personalizados le permite organizar esta información en grupos,
simplificando la creación de scripts y su reutilización. Si desea obtener más
información, consulte “Utilización de objetos personalizados” a pagina 85.

Capítulo 258

Clip de película

Los clips de película son símbolos que pueden contener y ejecutar una animación
en una película de Flash. Son el único tipo de datos que hacen referencia a
elementos gráficos. El tipo de datos de clip de película le permite controlar los
símbolos del clip de películas utilizando los métodos del objeto MovieClip.
Puede llamar a los métodos utilizando el operador punto (.) como se muestra
a continuación:

myClip.startDrag(true);
parentClip.childClip.getURL( "http://www.macromedia.com/support/"

+ product);

Acerca de las variables

Una variable es un contenedor que almacena información. El contenedor en sí
es siempre el mismo, pero el contenido puede cambiar. La modificación del valor
de una variable a medida que se reproduce la película permite registrar y guardar
información sobre las acciones del usuario, registrar valores que se modifican
conforme se reproduce la película o evaluar si una determinada condición es
verdadera o falsa.

Es bastante útil asignar a una variable un valor conocido la primera vez la defina.
Esto se llama inicializar una variable y a menudo se hace en el primer
fotograma de una película. Inicializar las variables hace que sea más sencillo
realizar el seguimiento y comparar el valor de la variable a medida que se
reproduce la película.

Las variables pueden contener cualquier tipo de datos: número, cadena, Booleano,
objeto o clip de película. El tipo de datos que contiene una variable afecta al modo
en el que cambia el valor de la variable cuando se le asigna en un script.

El tipo de información normal que suele guardarse en una variable incluye una
URL, un nombre de usuario, el resultado de una operación matemática, el
número de veces que ocurre un evento o si se ha hecho clic en un botón. Cada
película e instancia de clip de película tiene su propio conjunto de variables, cada
una de ellas con su propio valor independiente de otras variables definidas en otras
películas o clips de película.

Asignación de nombre para una variable

El nombre de una variable debe seguir estas reglas:

• Debe ser un identificador.

• No puede ser una palabra clave o un literal Booleano (true o false).

• Debe ser exclusivo dentro de su ámbito. (Consulte “Ámbito de una variable” a

pagina 61).

Programación de Scripts en ActionScript 59

Determinación del tipo de variable

En Flash, no tiene que definir explícitamente una variable de forma que contenga
un número, una cadena u otro tipo de datos. Flash determina el tipo de datos de
una variable cuando se asigna un valor a la misma:

x = 3;

En la expresión x = 3 Flash evalúa el elemento de la parte derecha del operador y
determina que es del tipo número. Una asignación posterior puede cambiar el tipo
de x; por ejemplo, x = "hello" cambia el tipo de x a una cadena. Una variable a
la que no se ha asignado un valor tiene el tipo de undefined.

ActionScript convierte los tipos de datos automáticamente cuando lo requiere
una expresión. Por ejemplo, cuando pasa un valor a la acción trace, trace
automáticamente convierte el valor en una cadena y la envía a la ventana Salida.
En las expresiones con operadores, ActionScript convierte los tipos de datos según
sea necesario; por ejemplo, cuando se utiliza con una cadena, el operador + espera
que el otro operando sea una cadena:

"Next in line, number " + 7

ActionScript convierte el número 7 en la cadena "7" y la agrega al final de la
primera cadena, lo que da como resultado la siguiente cadena:

"Next in line, number 7"

Cuando se depuran scripts, con frecuencia es muy útil determinar el tipo de datos
de una expresión o variable para entender por qué se comporta de cierta manera.
Puede realizar esto por medio del operador typeof como en el siguiente ejemplo:

trace(typeof(variableName));

Para convertir una cadena en un valor numérico, utilice la función Number. Para
convertir un valor numérico en una cadena, utilice la función String. Consulte el
Capítulo 7, “Diccionario de ActionScript” a pagina 175.

Capítulo 260

Ámbito de una variable

El “ámbito” de una variable se refiere al área en la que se conoce y se puede hacer
referencia a ella. Las variables en ActionScript pueden ser globales o locales.
Una variable global se comparte por todas las Líneas de tiempo, mientras que
una variable local sólo está disponible dentro de su propio bloque de código
(entre corchetes).

Puede utilizar la sentencia var para declarar una variable local dentro de un script.
Por ejemplo, las variables i y j con frecuencia se utilizan como contadores de
bucles. En el siguiente ejemplo, i se utiliza como la variable local, solamente
existe dentro de la función makeDays:

function makeDays(){

var i
for( i = 0; i < monthArray[month]; i++ ) {

_root.Days.attachMovie( "DayDisplay", i, i + 2000 );

_root.Days[i].num = i + 1;
_root.Days[i]._x = column * _root.Days[i]._width;
_root.Days[i]._y = row * _root.Days[i]._height;

column = column + 1;

if (column == 7 ) {

column = 0;
row = row + 1;

}

}

}

Las variables locales también pueden evitar los conflictos ocasionados por la
utilización de los mismos nombres en diferentes variables, que pueden originar
errores en su película. Por ejemplo, si utiliza name como una variable local, podría
utilizarla para almacenar un nombre de usuario en un contexto y el nombre de
una instancia de un clip de película en otro; como estas variables se ejecutarán
en ámbitos independientes, no se presentaría conflicto alguno.

Es usual y recomendable utilizar variables locales en el contexto de una función
de modo que ésta pueda actuar como un segmento de código independiente.
Una variable local solamente puede cambiar dentro de su propio bloque de
código. Si la expresión contenida en una función utiliza una variable global, algo
externo a la función podría modificar su valor, lo cual cambiaría la función.

Programación de Scripts en ActionScript 61

Declaración de variables

Para declarar variables globales, utilice la acción

setVariables o el operador de

asignación (=). Ambos métodos consiguen el mismo resultado.

Para declarar una variable local, utilice la sentencia

var dentro de una función. El

ámbito de las variables locales es el contexto del bloque de código y expiran al final
del mismo. Las variables locales que no han sido declaradas dentro de un bloque
de código expiran cuando finaliza el script en que se utilizan.

Nota:

La acción call también crea el ámbito de una nueva variable local y que está
constituido por el script al que llama. Cuando se sale del script que llamó, desaparece el
ámbito de esta variable local. Sin embargo, esto no es recomendable ya que la acción

call ha sido sustituida por la acción with que es más compatible con la sintaxis de punto.

Para comprobar el valor de una variable, utilice la acción trace para enviar el
valor a la ventana Salida. Por ejemplo, trace(hoursWorked) envía el valor de la
variable hoursWorked a la ventana Salida en el modo probar película. También
puede comprobar y establecer los valores de las variables en el Depurador en el
modo probar película. Para obtener más información, consulte el Capítulo 6,
“Resolución de problemas de ActionScript.”

Utilización de las variables en un script

Debe declarar una variable en un script antes de poder utilizarla en una expresión.
Si utiliza una variable que no ha sido declarada, como en el siguiente ejemplo, el
valor de la variable estará

getURL(myWebSite);
myWebSite = "http://www.shrimpmeat.net";

undefined y su script generará un error:

La sentencia que declara la variable myWebSite debe ir al principio de modo que la
variable de la acción getURL pueda ser sustituida por un valor.

El valor de una variable puede cambiar muchas veces en un script. El tipo de datos
que contiene la variable afecta a cómo y cuándo cambia la misma. Las variables
que contienen datos de tipo primitivo, como son las cadenas y números, se
pasan basados en su valor. Esto quiere decir se pasa a la variable el contenido
real de la misma.

En el siguiente ejemplo, x está establecida en 15 y ese valor se copia en y. Cuando

x se cambia a 30, el valor de y sigue siendo 15 ya que y no busca en x su valor, sino

que contiene el valor de x que se le pasó.

var x = 15;
var y = x;
var x = 30;

Capítulo 262

Otro ejemplo, es el caso en que la variable in contiene un valor primitivo de 9, de
modo que el valor real se pasa a la función

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

var in = 9;
var out = sqr(in);

sqrt y el valor que devuelve es 3:

El valor de la variable in no cambia.

Los datos de tipo objeto pueden contener una cantidad de información tan
compleja y grande que una variable cuyo contenido es este tipo de dato no
contiene el valor real, contiene una referencia al valor. Esta referencia es como un
alias que apunta al contenido de la variable. Cuando la variable necesita conocer
su valor, la referencia solicita el contenido y devuelve la respuesta sin transferir el
valor a la variable.

A continuación se muestra un ejemplo en el que se pasa un valor por referencia:

var myArray = ["tom", "dick"];
var newArray = myArray;
myArray[1] = "jack";
trace(newArray);

El código anterior crea un objeto Array llamado myArray que tiene dos
elementos. Se crea la variable newArray y se pasa una referencia a myArray.
Cuando el segundo elemento de myArray cambia, afectará a cualquier variable
que haga referencia al mismo. La acción trace enviaría ["tom", "jack"] a la
ventana Salida.

En el siguiente ejemplo, myArray contiene un objeto Array, de modo que se pasa a
la función zeroArray por referencia. La función zeroArray cambia el contenido
de la matriz en myArray.

function zeroArray (array){
var i;
for (i=0; i < array.length; i++) {
array[i] = 0;
}
}

var myArray = new Array();
myArray[0] = 1;
myArray[1] = 2;
myArray[2] = 3;

var out = zeroArray(myArray)

Programación de Scripts en ActionScript 63

La función zeroArray acepta como argumento un objeto Array y establece todos
los elementos del mismo en 0. Puede modificar la matriz ya que sus valores se
pasan a través de una referencia.

Las referencias a todos los objetos excepto a los clips de película reciben el nombre
de referencias fijas debido a que no se puede borrar el objeto al que se hace
referencia. Una referencia a un clip de película es un tipo especial de referencia
llamada una referencia variable. Las referencias variables no obligan a que exista el
objeto al que hacen referencia. Si se destruye un clip de película con una acción
como removeMovieClip, cualquier referencia a él ya no funcionará.

Utilización de operadores para manipular los valores de las expresiones

Una expresión es cualquier sentencia que Flash puede evaluar y que devuelve
un valor. Puede crear una expresión combinando operadores y valores, o bien
llamando a una función. Cuando escribe una expresión en el panel Acciones en
Modo Normal, asegúrese de que el cuadro Expresión se encuentra marcado en
el panel Parámetros, en caso contrario el campo contendrá el valor literal de
una cadena.

Cuadro Expresión

Capítulo 264

Los operadores son caracteres que especifican cómo combinar, comparar o
modificar los valores de una expresión. Los elementos sobre los que el operador
actúa se llaman operandos. Por ejemplo, en la siguiente sentencia, el operador +
agrega el valor de un literal numérico al valor de la variable foo; foo y 3 son
los operandos:

foo + 3

En esta sección se describen las reglas generales sobre los tipos de operadores
más comunes. Para obtener información detallada sobre cada operador que se
menciona aquí, y sobre los operadores especiales que no se cubren en esta sección,
consulte el Capítulo 7, “Diccionario de ActionScript”.

Precedencia de operadores

Cuando se utilizan dos o más operadores en la misma sentencia, algunos
operadores toman precedencia sobre otros. ActionScript sigue una jerarquía
muy estricta para determinar qué operadores deben ejecutarse en primer lugar.
Por ejemplo, la multiplicación siempre se realiza antes que la suma; sin embargo,
los elementos entre paréntesis tienen precedencia sobre la multiplicación. De
modo que, sin paréntesis, ActionScript realiza primero la multiplicación en el
ejemplo siguiente:

total = 2 + 4 * 3;

El resultado es 14.

Pero cuando la operación de suma está entre paréntesis, ActionScript realiza la
suma en primer lugar:

total = (2 + 4) * 3;

El resultado es 18.

Si desea ver una tabla con todos los operadores y su precedencia, consulte el
Apéndice B, “Precedencia de operadores y su asociatividad”.

Asociatividad de operadores

Cuando dos o más operadores comparten la misma precedencia, su asociatividad
determina el orden en el que se llevan a cabo. La asociatividad puede ser de
izquierda a derecha o de derecha a izquierda. Por ejemplo, el operador de
multiplicación tiene una asociatividad de izquierda a derecha, las dos sentencias
siguientes son equivalentes:

total = 2 * 3 * 4;
total = (2 * 3) * 4;

Si desea ver una tabla con todos los operadores y su asociatividad, consulte el
Apéndice B, “Precedencia de operadores y su asociatividad”.

Programación de Scripts en ActionScript 65

Operadores numéricos

Los operadores numéricos realizan sumas, restas, multiplicaciones, divisiones y
otras operaciones aritméticas. Los paréntesis y el signo menos son operadores
aritméticos. En la tabla siguiente se muestran los operadores numéricos de
ActionScript:

Operador Operación realizada

+ Suma

* Multiplicación

/ División

% Módulo

- Resta

++ Incremento

-- Decremento

Operadores de comparación

Los operadores de comparación comparan los valores de las expresiones y
devuelven un valor Booleano (true o false). Estos operadores se utilizan con
mayor frecuencia en los bucles y en las sentencias condicionales En el ejemplo
siguiente, si la variable score es 100, se carga cierta película; en caso contrario se
carga una película diferente:

if (score == 100){

loadMovie("winner.swf", 5);

} else {

loadMovie("loser.swf", 5);
}

En la tabla siguiente se muestran los operadores de comparación de ActionScript:

Operador Operación realizada

< Menor que

> Mayor que

<= Menor que o igual

>= Mayor que o igual

Capítulo 266

Operadores de cadena

El operador

+ tiene un efecto especial cuando se aplica sobre cadenas: concatena

los operandos de las dos cadenas. Por ejemplo, las sentencia siguiente agrega:

"Congratulations, " a "Donna!":
"Congratulations, " + "Donna!"

El resultado es "Congratulations, Donna!" Si solamente uno de los operandos
del operador + es una cadena, Flash convierte el otro operando en una cadena.

Los operadores de comparación, >, >=, <, y <= también tienen un efecto especial
cuando actúan sobre cadenas. Estos operadores comparan dos cadenas para
determinar cuál es la primera de acuerdo a su orden alfabético. Los operadores
de comparación solamente comparan cadenas si ambos operandos son cadenas.
Si solamente uno de los operandos es una cadena, ActionScript convierte los
números y realiza una comparación numérica.

Nota:

Los tipos de datos que maneja ActionScript de Flash 5 permite que se utilicen los
mismos operadores en diferentes tipos de datos. Ya no es necesario utilizar los operadores
de cadenas de Flash 4 (por ejemplo,
scripts como una película de Flash 4.

eq, ge, y lt) a no ser que se planee exportar los

Operadores lógicos

Los operadores lógicos comparan los valores Booleanos (true y false) y
devuelven un tercer valor Booleano. Por ejemplo, si ambos operandos evalúan
como true, el operador lógico AND (&&) devuelve true. Si uno o ambos
operandos evalúan como true, el operador lógico OR (||) devuelve false.
Los operadores lógicos se utilizan con frecuencia junto con los operadores de
comparación para determinar la condición de una acción if. Por ejemplo, en
el siguiente script, si ambas expresiones son verdaderas, la acción if se ejecutará:

if ((i > 10) && (_framesloaded > 50)){

play()

}

En la siguiente tabla se muestra una lista de los operadores lógicos de
ActionScript:

Operador Operación realizada

&& AND lógico

|| OR lógico

! NOT lógico

Programación de Scripts en ActionScript 67

Operadores como bit

Los operadores como bit manipulan internamente los números en coma flotante
para convertirlos en números enteros de 32 bits, con los que es más sencillo
trabajar. La operación precisa como bit que se realizará depende del operador,
pero todas las operaciones como bit evalúan cada dígito de un número en
coma flotante para calcular un nuevo valor.

En la siguiente tabla se muestran los operadores como bit de ActionScript:

Operador Operación realizada

& And como bit

| Or como bit

^ Xor como bit

~ Not como bit

<< Desplazamiento a la izquierda

>> Desplazamiento a la derecha

>>> Desplazamiento a la derecha rellenando con ceros

Operadores de igualdad y de asignación

Puede utilizar el operador de igualdad (==) para determinar si los valores o las
identidades de dos operandos son iguales. Esta comparación devuelve un valor
Booleano (true o false). Si los operandos son cadenas, números o valores
Booleanos, se comparan en base a su valor. Si los operandos son objetos o
matrices, se comparan por referencia.

Puede utilizar el operador de asignación (

=) para asignar un valor a una variable,

como se muestra a continuación:

contraseña = “Sk8tEr”;

También puede utilizar el operador de asignación para asignar valores a múltiples
variables en la misma expresión. En la siguiente sentencia, el valor de b se asigna a
las variables c y d:

a = b = c = d;

También puede utilizar operadores de asignación compuestos para combinar
operaciones. Los operadores compuestos actúan sobre los dos operandos y después
asignan un nuevo valor al primer operando. Por ejemplo, las dos siguientes
sentencias son equivalentes:

x += 15;
x = x + 15;

Capítulo 268

En la siguiente tabla se muestra una lista de los operadores de igualdad y de
asignación de ActionScript:

Operador Operación realizada

== Igualdad

!= No igualdad

= Asignación

+= Suma y asignación

-= Resta y asignación

*= Multiplicación y asignación

%= Módulo y asignación

/= División y asignación

<<= Desplazamiento a la izquierda como bit y asignación

>>= Desplazamiento a la derecha como bit y asignación

>>>= Desplazamiento a la derecha rellenando con ceros y asignación

^= Xor como bit y asignación

|= Or como bit y asignación

&= And como bit y asignación

Operadores punto y de acceso a una matriz

Puede utilizar el operador de punto (.) y el operador de acceso a una matriz ([])
para acceder a cualquiera de las propiedades del objeto predeterminadas o
personalizadas de ActionScript, incluyendo las de un clip de película.

El operador de punto utiliza el nombre de un objeto a su lado izquierdo y el
nombre de una propiedad o variable a su lado derecho. El nombre de la propiedad
o la variable no puede ser una cadena o una variable que evalúe en una cadena,
debe ser un identificador. A continuación se muestran ejemplos que utilizan el
operador de punto:

year.month = "June";
year.month.day = 9;

Programación de Scripts en ActionScript 69

El operador de punto y el operador de acceso a una matriz se comportan de
la misma manera, pero el

operador de punto toma un identificador como su

propiedad y el operador de acceso a una matriz evalúa su contenido respecto a
un nombre y después accede al valor de esa propiedad con nombre. Por ejemplo,
las siguientes dos líneas de código acceden a la misma variable

velocity en el clip

de película rocket:

rocket.velocity;
rocket["velocity"];

Puede utilizar el operador de acceso a una matriz para establecer y recuperar
dinámicamente nombres de instancias y variables. Por ejemplo, en el código
que se muestra a continuación, la expresión dentro del operador

[] se evalúa y

el resultado de la evaluación se utiliza como nombre de la variable que se va a
recuperar del clip de película name:

name["mc" + i ]

Si está familiarizado con la sintaxis de diagonal de ActionScript de Flash 4, puede
que haya hecho lo mismo utilizando la función eval, como se muestra a
continuación:

eval("mc" & i);

El operador de acceso a una matriz también puede utilizarse al lado izquierdo
de una sentencia de asignación. Esto le permite establecer dinámicamente los
nombres de sentencia, de variable y de objeto, como se muestra en el
ejemplo siguiente:

name[index] = "Gary";

De nuevo, esto es equivalente a la sintaxis de diagonal de ActionScript de Flash 4
que se muestra a continuación:

Set Variable: "name:" & index = "Gary"

El operador de acceso a una matriz también puede anidarse en sí mismo para
simular matrices multidimensionales.

chessboard[row][column]

Esto es equivalente a la sintaxis de barra que se muestra a continuación:

eval("chessboard/" & row & ":" & column)

Nota:

Si desea escribir un ActionScript que sea compatible con Flash Player 4, puede
utilizar la acción

Capítulo 270

eval con el operador add.

Uso de acciones

Las acciones son sentencias o comandos de ActionScript. Si se asignan varias
acciones al mismo fotograma u objeto se crea un script. Las acciones pueden
actuar independientemente unas de otras, como se muestra en las siguientes
sentencias:

swapDepths("mc1", "mc2");
gotoAndPlay(15);

También puede anidar acciones utilizando una acción dentro de otra, esto permite
que las acciones afecten unas a las otras. En el siguiente ejemplo, la acción if dice
a la acción gotoAndPlay cuándo debe ejecutarse:

if (i >= 25) {

gotoAndPlay(10);

}

Las acciones pueden mover la cabeza lectora en la Línea de tiempo
(gotoAndPlay), controlar el flujo de un script creando bucles (do while) o lógica
condicional (if), o crear nuevas funciones y variables (function, setVariable).
En la siguiente tabla se muestra una lista de las acciones de ActionScript:

Acciones

break evaluate include print stopDrag

call for loadMovie printAsBitmap swapDepths

comment for...in loadVariables removeMovieClip tellTarget

continue fsCommand nextFrame

nextScene

delete function on setVariable stopDrag

do...while getURL onClipEvent setProperty trace

duplicateMovie
Clip

else if prevFrame stop var

else if ifFrameLoaded prevScene stopAllSounds while

gotoAndPlay
gotoAndStop

play startDrag unloadMovie

return toggleHighQual

ity

Si desea ver ejemplos de la sintaxis y de la utilización de cada acción, consulte el
Capítulo 7, “Diccionario de ActionScript”.

Nota:

En este manual, el término action de ActionScript es sinónimo del término

statement de JavaScript.

Programación de Scripts en ActionScript 71

Programación de una ruta de destino

Para utilizar una acción a fin de controlar un clip de película o una película que
ha sido cargada, debe especificar su nombre y su dirección, llamada ruta de destino.
Las siguientes acciones toman una o más rutas de destino como argumentos:

• loadMovie

• loadVariables

• unloadMovie

• setProperty

• startDrag

• duplicateMovieClip

• removeMovieClip

• print

• printAsBitmap

• tellTarget

Por ejemplo, la acción loadMovie toma los argumentos URL, Location, y

Variables. La dirección URL es la ubicación en la Web de la película que desea

cargar. Location es la ruta de destino en la que se cargará la película.

loadMovie(URL, Location, Variables);

Nota:

El argumento Variables no es necesario para este ejemplo.

La siguiente sentencia carga la dirección URL http://www.mySite.com/

myMovie.swf en la instancia bar en la Línea de tiempo principal, _root;
_root.bar es la ruta de destino;

loadMovie("http://www.mySite.com/myMovie.swf", _root.bar);

En ActionScript se identifica a un clip de película por su nombre de instancia.
Por ejemplo, en la siguiente sentencia, la propiedad _alpha del clip de película
llamado star está establecida a un 50% de visibilidad:

star._alpha = 50;

Dar un nombre de instancia a un clip de película:

1 Seleccione el clip de película en el Escenario.

2 Seleccione Ventana > Paneles > Instancia.

3 Introduzca un nombre de instancia en el campo Nombre.

Capítulo 272

Para identificar una película que ha sido cargada:

Utilice _levelX donde X es el número de nivel especificado en la acción

loadMovie que cargó la película.

Por ejemplo, una película que ha sido cargada en el nivel 5 tiene el nombre de
instancia _level5. En el siguiente ejemplo, se carga una película en el nivel 5
y su visibilidad está establecida como falsa:

onClipEvent(load) {
loadMovie("myMovie.swf", 5);
}
onClipEvent(enterFrame) {

_level5._visible = false;

}

Para introducir una ruta de destino de película:

Haga clic sobre el botón Insertar ruta de destino en el panel Acciones y seleccione
un clip de película de la lista que se muestra.

Si desea obtener más información sobre cómo escribir rutas de destino, consulte
el Capítulo 4, “Trabajo con clips de película”.

Control de los scripts de flujo

ActionScript utiliza las acciones if, for, while, do...while, y for...in para
realizar una acción dependiendo de si se da una condición.

Utilización de las sentencias if

Las sentencias que comprueban si una condición es verdadera o falsa comienzan
con el término if. Si la condición se da, ActionScript ejecuta la sentencia que
aparece a continuación de la misma. Si la condición no se da, ActionScript salta
a la siguiente sentencia en el bloque de código.

Para optimizar el rendimiento de su código, compruebe primero las condiciones
más probables.

Las siguientes sentencias comprueban varias condiciones. El término else if
especifica comprobaciones alternativas que se deberán llevar a cabo si las
condiciones anteriores son falsas.

if ((password == null) || (email == null)){

gotoAndStop("reject");

} else {

gotoAndPlay("startMovie");

}

Programación de Scripts en ActionScript 73

Repetición de una acción

ActionScript puede repetir una acción un número especificado de veces o mientras
se dé una condición. Utilice las acciones while, do...while, for, y for...in
para crear bucles.

Para repetir una acción mientras se dé una condición:

Utilice la sentencia while.

Un bucle while evalúa una expresión y ejecuta el código del bucle si la expresión
es true. Después de que se ha ejecutado cada sentencia del bucle, la expresión
se evalúa de nuevo. En el siguiente ejemplo, el bucle se ejecuta cuatro veces:

i = 4
while (i > 0) {

myMC.duplicateMovieClip("newMC" + i, i );
i --;

}

Puede utilizar la sentencia do...while para crear el mismo tipo de bucle como el
de un bucle while. En un bucle do...while la expresión se evalúa al final del
segmento de código de modo que el bucle siempre se ejecuta al menos una vez,
como se muestra a continuación:

i = 4
do {

myMC.duplicateMovieClip("newMC" +i, i );
i --;

} while (i > 0);

Para repetir una acción utilizando un contador incorporado:

Utilice la sentencia for.

La mayoría de los bucles utilizan algún tipo de contador para controlar cuantas
veces se ejecuta el bucle. Puede declarar una variable y escribir una sentencia que
incremente o disminuya el valor de la variable cada vez que se ejecute el bucle. En
la acción for, el contador y la sentencia que incrementa el contador son parte de la
acción, como se muestra a continuación:

for (i = 4; i > 0; i--){

myMC.duplicateMovieClip("newMC" + i, i + 10);

}

Capítulo 274

Para que se realice el bucle a través de los subniveles de un clip de
película u objeto:

Utilice la sentencia for...in.

Los subniveles incluyen otros clips de películas, funciones, objetos y variables. El
siguiente ejemplo utiliza trace para imprimir sus resultados en la ventana Salida:

myObject = { name:'Joe', age:25, city:'San Francisco' };
for (propertyName in myObject) {
trace("myObject has the property: " + propertyName + ", with the

value: " + myObject[propertyName]);
}

Este ejemplo produce los siguientes resultados en la ventana Salida:

myObject has the property: name, with the value: Joe
myObject has the property: age, with the value: 25
myObject has the property: city, with the value: San Francisco

Puede que desee que su script se repita sobre un tipo de subnivel en particular:
por ejemplo, solamente sobre el clip de película secundario. Puede hacer esto
con for...in junto con el operador typeof.

for (name in myMovieClip) {
if (typeof (myMovieClip[name]) == "movieclip") {
trace("I have a movie clip child named " + name);
}
}

Nota:

La sentencia for...in se repite sobre las propiedades de los objetos que forman
parte de la cadena prototipo del objeto sobre el que se está efectuando la repetición.
Si el prototipo de un objeto secundario es
propiedades de

parent. Consulte “Definición de herencia” a pagina 86.

parent, for...in también se repetirá en las

Si desea obtener más información sobre cada acción, consulte el Capítulo 7,
“Diccionario de ActionScript”.

Programación de Scripts en ActionScript 75

Utilización de las funciones predefinidas

Una función es un bloque de código de ActionScript que puede volver a utilizarse
en cualquier parte de una película. Si pasa valores específicos llamados argumentos
a una función, la función actuará sobre esos valores. Una función también puede
devolver valores. Flash dispone de funciones predeterminadas que le permiten
acceder a cierta información y realizar ciertas tareas, como la detección de
choque (hitTest), la obtención del valor de la última tecla presionada
(keycode), y la obtención del número de versión de Flash Player que contiene
la película (getVersion).

Llamada a una función

Puede llamar a una función de cualquier Línea de tiempo desde cualquier Línea de
tiempo, incluida una película que ha sido cargada. Cada función tiene sus propias
características y algunas necesitan que se le pasen ciertos valores. Si se le pasan más
argumentos de los que necesita la función, los valores sobrantes se ignorarán. Si
no se le pasa un argumento necesario, los argumentos vacíos se asignarán al tipo
de datos undefined, que puede causar errores cuando exporte un script. Para
llamar a una función, ésta debe encontrase en un fotograma al que haya llegado
la cabeza lectora.

Las funciones predeterminadas de Flash se enumeran en la siguiente tabla:

Boolean getTimer isFinite newline scroll

escape getVersion isNaN number String

eval globalToLocal keycode parseFloat targetPath

false hitTest localToGlobal parseInt true

getProperty int maxscroll random unescape

Nota:

Las funciones de cadena no están aprobadas y no aparecen en la lista de la

anterior.

tabla

Para llamar a una función en Modo Experto:

Utilice el nombre de la función. Pase cualquiera de los argumentos necesarios
entre paréntesis.

El siguiente ejemplo llama a la función initialize que no requiere argumentos:

initialize();

Capítulo 276

Para llamar a una función en Modo Normal:

Utilice la acción evaluate. Introduzca el nombre de la función y cualquier
argumento necesario en el campo Expresión.

Utilice la acción evaluate para llamar a una función en Modo Normal

Para llamar a una función en otra Línea de tiempo utilice una ruta de destino. Por
ejemplo, para llamar a la función calculateTax que se declaró en la instancia

functionsMovieClip, utilice la siguiente ruta:

_root.functionsMovieClip.calculateTax(total);

Nota:

Pase cualquiera de los argumentos entre paréntesis.

Si desea obtener más información sobre cada función, incluidas las funciones de
cadena no aprobadas, consulte el Capítulo 7, “Diccionario de ActionScript”.

Programación de Scripts en ActionScript 77

Creación de funciones personalizadas

Puede definir funciones para que éstas ejecuten una serie de sentencias en función
de los valores que se le han pasado. Sus funciones también pueden devolver
valores. Una vez que se ha definido una función, podrá realizar una llama a la
misma desde cualquier Línea de tiempo, incluida la Línea de tiempo de una
película que ha sido cargada.

Se puede pensar en una función como si fuera una “caja negra”: al realizar una
llama a una función, se deberá proporcionar con entrada (argumentos).
La función realizará alguna operación y después generará un resultado (un valor
de retorno). Una función escrita correctamente debe incluir comentarios bien
situados acerca de los valores de entrada, su resultado y su propósito. De este
modo, el usuario de la función no tendrá que entender exactamente cómo
actúa la función.

Definición de una función

Las funciones, al igual que las variables, están vinculadas al clip de película que
las define. Cuando se vuelve a definir una función, la nueva definición sustituye
a la definición anterior.

Para definir una función, utilice la acción
la función, los argumentos que va a pasar a la función y las sentencias de
ActionScript que indican lo que hace la acción.

A continuación se muestra una función llamada Circle con el argumento

radius:

function Circle(radius) {

this.radius = radius;
this.area = Math.PI * radius * radius;

}

function seguida del nombre de

Nota:

La palabra clave this, utilizada en el cuerpo de una función, hace referencia al clip
de película al que pertenece la función.

También puede definir la función creando una expresión literal de función. Una
expresión literal de función es una función sin nombre que se declara en una
expresión en lugar de en una sentencia. Puede utilizar la expresión literal de una
función para definir una función, para devolver su valor y asignarlo a una variable
en una expresión, como se muestra a continuación:

area = (function () {return Math.PI * radius *radius;})(5);

Capítulo 278

Pasar argumentos a una función

Los argumentos son los elementos sobre los que una función ejecuta su código.
(En este manual, los términos argumento y parámetro pueden intercambiarse.)
Por ejemplo, la función siguiente toma los argumentos initials y finalScore:

function fillOutScorecard(initials, finalScore) {

scorecard.display = initials;
scorecard.score = finalScore;

}

Cuando se llama a la función, los argumentos que ésta necesita deberán pasarse
a la misma. La función sustituye los valores pasados por los argumentos en la
definición de la función. En este ejemplo, scorecard es el nombre de instancia
de un clip de película; display y score son campos de texto de entrada en la
instancia. La siguiente llamada a una función asigna a la variable display el
valor "JEB" y a la variable score el valor 45000:

fillOutScorecard("JEB", 45000);

El argumento initials en la función fillOutScorecard es similar a una
variable local, existe mientras que se llama a la función y deja de existir cuando se
sale de la función. Si omite los argumentos durante la llamada a una función, los
argumentos omitidos se pasan como undefined. Si introduce argumentos de más
en una llamada a una función que no son necesarios para la declaración de la
función, éstos se ignorarán.

Utilización de variables locales en una función

Las variables locales son herramientas muy valiosas para organizar el código y
hacer que sea más sencillo de entender. Cuando una función utiliza variables
locales, la función puede ocultar sus variables de todos los demás scripts de la
película, las variables locales tienen su ámbito en el cuerpo de la función y se
destruyen cuando se sale de la función. Cualquiera de los argumentos que se pasen
a una función también se tratarán como variables locales.

Nota:

Si modifica las variables locales de una función, utilice los comentarios de script
para documentar estas modificaciones.

Programación de Scripts en ActionScript 79

Devolución de valores de una función

Puede utilizar la función

return detiene la función y la sustituye con el valor de la acción return. Si Flash

return para devolver valores de las funciones. La acción

no encuentra una acción return antes del final de una función, devolverá una
cadena vacía. Por ejemplo, la siguiente función devuelve el cuadrado del
argumento x:

function sqr(x) {

return x * x;

}

Algunas funciones realizan una serie de tareas sin devolver un valor. Por ejemplo,
la siguiente función inicializa una serie de variables globales:

function initialize() {

boat_x = _root.boat._x;
boat_y = _root.boat._y;
car_x = _root.car._x;
car_y = _root.car._y;

}

Llamada a una función

Para invocar una función utilizando el panel Acciones en Modo Normal, utilice
la acción evaluate. Pase los argumentos necesarios entre paréntesis. Puede llamar
a una función de cualquier Línea de tiempo desde cualquier Línea de tiempo,
incluida una película que ha sido cargada. Por ejemplo, la siguiente sentencia
invoca a la función sqr del clip de película MathLib de la Línea de tiempo
principal, le pasa el argumento 3 y almacena el resultado en la variable temp:

var temp = _root.MathLib.sqr(3);

En Flash 4, para simular la llamada a una función podría escribir un script en un
fotograma después del final de la película e invocarle pasando el nombre de la
etiqueta del fotograma a la acción call. Por ejemplo, si el script que inicializó
las variables se encontraba en un fotograma con la etiqueta initialize, la
llamada se realizaría como se muestra a continuación:

call("initialize");

Este tipo de script no era una verdadera función ya que no podría aceptar
argumentos y no podría devolver un valor. Aunque la acción call aún funciona
en Flash 5, no se recomienda su utilización.

Capítulo 280

Utilización de objetos predefinidos

Puede utilizar los objetos predefinidos de Flash para acceder a ciertos tipos de
información. La mayoría de los objetos predefinidos tienen métodos (funciones
asignadas a un objeto) que puede llamar para devolver un valor o para realizar una
acción. Por ejemplo, el objeto Date devuelve información del reloj del sistema y el
objeto Sound le permite controlar los elementos de sonido de su película.

Algunos objetos predefinidos tienen propiedades cuyos valores pueden ser leídos
por la misma. Por ejemplo, el objeto Key tiene valores constantes que representan
teclas del teclado. Cada objeto tiene sus propias características y capacidades que
pueden utilizarse en su película.

A continuación se muestran los objetos predefinidos de Flash:

• Array

• Boolean

• Color

• Date

• Key

• Math

• MovieClip

• Number

• Object

• Selection

• Sound

• String

• XML

• XMLSocket

Las instancias de clip de película se representan como objetos en ActionScript.
Las llamadas a los métodos de clip de película predefinidos se pueden efectuar
del mismo modo que como llamaría a los métodos de cualquier otro objeto de
ActionScript.

Si desea obtener información detallada sobre cada objeto, consulte el Capítulo 7,
“Diccionario de ActionScript”.

Programación de Scripts en ActionScript 81

Creación de un objeto

Existen dos modos de crear un objeto: el operador
de objeto (

{}). Puede utilizar el operador new para crear un objeto desde una clase

new y el operador inicializador

de objetos predefinidos o desde una clase de objetos definidos personalizados.
Puede utilizar el operador inicializador de objeto ({}) para crear un objeto del tipo
genérico Object.

Para utilizar el operador new a fin de crear un objeto, deberá utilizarlo con una
función constructor. (Una función constructor es sencillamente una función
cuyo único propósito es crear un cierto tipo de objeto.) Los objetos predefinidos
de ActionScript son en esencia funciones constructor escritas previamente. El
objeto nuevo instancia, o crea, una copia del objeto y le asigna todas las
propiedades y métodos de ese objeto. Esto es similar a arrastrar un clip de película
desde la Biblioteca hasta el Escenario en una película. Por ejemplo, las siguientes
sentencias instancian un objeto Date:

currentDate = new Date();

Puede acceder a los métodos de algunos objetos predefinidos sin instanciarlos.
Por ejemplo, la siguiente sentencia llama al método del objeto Math random:

Math.random();

Cada objeto que necesite una función constructor tiene su elemento
correspondiente en la caja de herramientas del panel Acciones, por ejemplo,

new Color, new Date, new String, y así sucesivamente.

Para crear un objeto con el operador new en Modo Normal:

1 Seleccione setVariable

2 Introduzca un nombre de variable en el campo Nombre.

3 Introduzca new Object, new Color, y así sucesivamente en el campo Valor.

Introduzca cualquiera de los argumentos necesarios para la función constructor
entre paréntesis.

4 Marque el cuadro Expresión en el campo Valor.

Si no activa el cuadro Expresión, todo el valor será un literal de cadena.

En el siguiente código, el objeto c se crea desde el constructor Color:

c = new Color(this);

Nota:

Un nombre de objeto es una variable con el tipo de datos de objeto que se le
ha asignado.

Capítulo 282

Acceso a un método en Modo Normal:

1 Seleccione la acción evaluate.

2 Introduzca el nombre del objeto en el campo Expresión.

3 Introduzca una propiedad del objeto en el campo Expresión.

Utilización del operador inicializador de objeto ({}) en Modo Normal:

1 Seleccione la acción setVariable.

2 Introduzca el nombre en el campo Variable, este es el nombre del objeto nuevo.

3 Introduzca los pares nombre de propiedad y valor separados por dos puntos

dentro del operador inicializador de objeto ({}).

Por ejemplo, en esta sentencia los nombres de propiedad son radius y area y sus
valores son 5 y el valor de una expresión:

myCircle = {radius: 5, area:(pi * radius * radius)};

Los paréntesis hacen que la expresión se evalúe. El valor que se devuelve es el valor
de la variable area.

También puede anidar los inicializadores de matriz y de objeto, como en
esta sentencia:

newObject = {name: "John Smith", projects: ["Flash",
"Dreamweaver"]};

Si desea obtener información detallada sobre cada objeto, consulte el Capítulo 7,
“Diccionario de ActionScript”.

Acceso a las propiedades del objeto

Utilice el operador punto (.) para acceder al valor de las propiedades en un objeto.
El nombre del objeto se haya a la izquierda del punto y el nombre de la propiedad
a la derecha. Por ejemplo, en la siguiente sentencia, myObject es el objeto y name
es la propiedad:

myObject.name

Para asignar un valor a una propiedad en Modo Normal, utilice la acción

setVariable:

myObject.name = "Allen";

Para cambiar el valor de una propiedad, asigne un nuevo valor como se muestra a
continuación:

myObject.name = "Homer";

También puede utilizar el operador de acceso a una matriz ([]) para acceder a las
propiedades de un objeto. Consulte “Operadores punto y de acceso a una matriz”
a pagina 69.

Programación de Scripts en ActionScript 83

Llamada a métodos de objeto

Puede llamar al método de un objeto utilizando el operador punto seguido por el
método. Así, el siguiente ejemplo llama al método setVolume del objeto Sound:

s = new Sound(this);
s.setVolume(50);

Para llamar al método de un objeto predefinido en Modo Normal, utilice la
acción evaluate.

Utilización del objeto MovieClip

Puede utilizar los métodos del objeto predefinido MovieClip para controlar las
instancias del símbolo del clip de película en el Escenario. El siguiente ejemplo
dice a la instancia

dateCounter.play();

dateCounter que se ejecute:

Si desea obtener información detallada sobre el objeto MovieClip, consulte el
Capítulo 7, “Diccionario de ActionScript”.

Utilización del objeto Array

El objeto Array es un objeto de ActionScript predefinido utilizado con frecuencia
que almacena sus datos en propiedades numeradas en lugar de en propiedades
con nombre. El nombre de un elemento de matriz se llama índice. Esto es muy
útil para almacenar y recuperar ciertos tipos de información como una lista de
estudiantes o una secuencia de movimientos en un juego.

Puede asignar elementos del objeto Array del mismo modo en que lo haría con
la propiedad de cualquier objeto:

move[1] = "a2a4";
move[2] = "h7h5";
move[3] = "b1c3";
...
move[100] = "e3e4";

Para acceder al segundo elemento de la matriz, utilice la expresión move[2].

El objeto Array tiene una propiedad predefinida length que es el valor del
número de elementos de la matriz. Cuando se asigna un elemento del objeto Array
y el índice del elemento es un número entero positivo como index >= length,

length se actualiza automáticamente a index + 1.

Capítulo 284

Utilización de objetos personalizados

Puede crear objetos personalizados para organizar la información de sus scripts
con el fin de almacenarlos y acceder a ellos fácilmente; para ello es necesario
definir las propiedades y métodos del objeto. Después de crear un objeto maestro
o “clase”, puede utilizar o “instanciar” copias (es decir, instancias) de ese objeto en
una película. Esto le permite reutilizar el código y tener control sobre el tamaño
del archivo.

Un objeto es un tipo de datos complejo que contiene cero o más propiedades.
Cada propiedad tiene un nombre y un valor, como lo tiene una variable. Las
propiedades están vinculadas al objeto y contienen los valores que pueden
cambiarse y recuperarse. Estos valores pueden ser de cualquier tipo de datos:
cadena, número, Booleano, clip de película o
propiedades son varios tipos de datos:

customer.name = "Jane Doe"
customer.age = 30
customer.member = true
customer.account.currentRecord = 000609
customer.mcInstanceName._visible = true

La propiedad de un objeto también puede ser un objeto. En la línea 4 del ejemplo
anterior, account es una propiedad del objeto customer y currentRecord es una
propiedad del objeto account. El tipo de datos de la propiedad currentRecord
es numérico.

Creación de un objeto

Puede utilizar el operador new para crear un objeto desde una función constructor.
A una función constructor siempre se le da el mismo nombre que al tipo de objeto
que está creando. Por ejemplo, una función constructor que creara un objeto de
tipo cuenta se llamaría Account. La siguiente sentencia crea un nuevo objeto
desde la función llamada MyConstructorFunction:

new MyConstructorFunction (argument1, argument2, ... argumentN);

Cuando se llama a MyConstructorFunction, Flash le pasa el argumento oculto

this, que es una referencia al objeto que está creando MyConstructorFunction.

Cuando define una función constructor, this le permite hacer referencia a los
objetos que creará el constructor. Por ejemplo, a continuación se muestra una
función constructor que crea un círculo:

function Circle(radius) {

this.radius = radius;
this.area = Math.PI * radius * radius;

}

undefined. Las siguientes

Programación de Scripts en ActionScript 85

Las funciones constructor se usan con frecuencia para rellenar los métodos
de un objeto.

function Area() {

this.circleArea = Math.PI * radius * radius;

}

Para utilizar un objeto en un script, deberá asignarlo a una variable. Para crear un
nuevo objeto círculo con un radio de 5, utilice el operadornew para crear el objeto
y asignarle una variable local myCircle:

var myCircle = new Circle(5);

Nota:

Los objetos tienen el mismo ámbito que la variable a la están asignados. Consulte
“Ámbito de una variable” a pagina 61.

Definición de herencia

Todas las funciones tienen una propiedad prototype que se crea
automáticamente cuando se define la función. Cuando utiliza una función
constructor para crear un nuevo objeto, todas las propiedades y métodos de la
propiedad prototype del constructor se convierten en propiedades y métodos
de la propiedad __proto__ del nuevo objeto. La propiedad prototype indica
los valores de la propiedad predeterminados para los objetos creados con esa
función. Al hecho de pasar valores utilizando las propiedades __proto__ y

prototype se llama herencia.

La herencia se comporta de acuerdo a una jerarquía determinada. Cuando llama
a la propiedad o al método de un objeto, ActionScript busca en el objeto para
ver si existe tal elemento. Si no existe, ActionScript busca en la propiedad

__proto__ del objeto la información (object.__proto__). Si la propiedad

llamada no es una propiedad de objeto __proto__, Actionscript busca en

object.__proto__.__proto__.

Es bastante común asociar métodos a un objeto asignándolos a la propiedad

prototype del objeto. Los siguientes pasos describen cómo definir un método

de ejemplo:

1 Defina la función constructor Circle, como se detalla a continuación:

function Circle(radius) {

this.radius = radius

}

Capítulo 286

2

Defina el método area del objeto Circle. El método area calculará el área del
círculo. Puede utilizar un literal de función para definir el método

area y

establecer la propiedad área del objeto prototipo del círculo, como se detalla a
continuación:

Circle.prototype.area = function () {

return Math.PI * this.radius * this.radius

}

3

Cree una instancia del objeto Circle, como se detalla a continuación:

var myCircle = new Circle(4);

4

Llame al método area del nuevo objeto myCircle, como se detalla a
continuación:

var myCircleArea = myCircle.area()

ActionScript busca el objeto myCircle para el método area. Como el objeto
no tiene un método area, se busca su objeto prototipo Circle.prototype
para el métodoarea. ActionScript lo encuentra y lo llama.

También puede vincular un método a un objeto anexando el método a cada
instancia individual del objeto, como se muestra en este ejemplo:

function Circle(radius) {

this.radius = radius
this.area = function() {

return Math.PI * this.radius * this.radius

}

}

No se recomienda esta técnica. Es más eficiente utilizar el objeto prototype, ya
que solamente una definición de area es necesaria y esa definición se copia
automáticamente en todas las instancias creadas por la función Circle.

La propiedad prototype está admitida en la versión 5 de Flash Player y
posteriores. Si desea obtener más información, consulte el Capítulo 7,
“Diccionario de ActionScript”.

Programación de Scripts en ActionScript 87

Apertura de archivos de Flash 4

ActionScript ha cambiado substancialmente en la última versión de Flash 5. Ahora
se trata de un lenguaje orientado a objetos con múltiples tipos de datos y sintaxis
de punto. ActionScript de Flash4 solamente tenía un tipo de datos verdadero:
cadena. Utilizaba diferentes tipos de operadores en expresiones para indicar si el
valor debería ser tratado como una cadena o como un número. En Flash 5, puede
utilizar un conjunto de operadores sobre todos los tipos de datos.

Cuando utiliza Flash 5 para abrir un archivo creado en Flash 4, Flash
automáticamente convierte las expresiones de ActionScript para hacerlas
compatibles con la nueva sintaxis de Flash 5. Verá el siguiente tipo de datos y las
conversiones de operador en su código de ActionScript:

• El operador = en Flash 4 se utilizó para la igualdad numérica. En Flash 5, == es

el operador de igualdad y = es el operador asignado. Cualquiera de los
operadores = en los archivos de Flash 4 se convierte automáticamente en ==.

• Flash realiza automáticamente conversiones de tipo para asegurar que los

operadores se comportan del modo esperado. Debido a la introducción de
múltiples tipos de dato, los siguientes operadores tienen nuevos significados:

+, ==, !=, <>, <, >, >=, <=

• En ActionScript de Flash 4, estos operadores siempre eran operadores

numéricos. En Flash 5, se comportan de modo diferente dependiendo de los
tipos de datos de los operandos. Para evitar cualquier diferencia semántica en
los archivos importados, la función Number se inserta alrededor de todos los
operandos de estos operadores. (Los números constantes evidentemente ya
son números, de modo que no se incluyen entre Number).

• En Flash 4, la secuencia de escape\n generaba un carácter de retorno de carro

(ASCII 13). En Flash 5, para cumplir el estándar ECMA-262, \n genera un
carácter de avance de línea (ASCII 10). Una secuencia \n en los archivos FLA
de Flash 4 se convierte automáticamente en \r.

• El operador & en Flash 4 se utilizaba para la suma de cadenas. En Flash 5, & es

el operador AND como bit. El operador de suma de cadenas ahora se llama

add. Cualquiera de los operadores & en los archivos de Flash 4 se convierten

automáticamente en operadores add.

• Muchas de las funciones de Flash 4 no necesitan paréntesis de cierre, por

ejemplo, Get Timer, Set Variable, Stop y Play. Para crear una sintaxis
coherente, la función getTimer de Flash 5 y todas las acciones ahora requieren
paréntesis de cierre. Estos paréntesis se agregan automáticamente durante
la conversión.

Capítulo 288

• Cuando la función getProperty se ejecuta en un clip de película que no existe,

devuelve el valor

false en ActionScript de Flash 5. Flash soluciona este problema cuando

es
convierte los archivos de Flash 4 introduciendo funciones Number en las
comparaciones de igualdad. En el siguiente ejemplo, Number hace que

undefined se convierta en 0 de modo que la comparación sea efectiva:

getProperty("clip", _width) == 0
Number(getProperty("clip", _width)) == Number(0)

Nota:

Si ha utilizado cualquiera de las palabras clave de Flash 5 en el ActionScript de
Flash 4, la sintaxis devolverá un error en Flash 5. Para solucionarlo, cambie el nombre de
sus variables en todas las ubicaciones. Consulte “Palabras clave” a pagina 55.

undefined, no devuelve 0, en Flash 5. Y undefined == 0

Utilización de Flash 5 para crear
contenidos de Flash 4

Si está utilizando Flash 5 para crear contenidos para Flash Player 4 (exportándolo
como Flash 4), no podrá aprovechar las ventajas de las nuevas funciones presentes
en ActionScript de Flash 5. Sin embargo, muchas de las nuevas características de
ActionScript aún se encuentran disponibles. ActionScript de Flash 4 solamente
tiene un tipo de datos primitivo básico que se utiliza tanto para la manipulación
numérica como para manipulación de cadenas. Cuando es autor de una película
para Flash Player 4, necesitará utilizar los operadores de cadena no aprobados
situados en la categoría Operadores de cadena de la caja de herramientas.

Puede utilizar las siguientes características de Flash 5 cuando exporte al formato
de archivo SWF de Flash 4.

• El operador de acceso a objeto y a matriz ([]).

• El operador de punto (.).

• Los operadores lógicos, los operadores de asignación y los operadores de

incremento/decremento previo e incremento/decremento posterior.

• El operador módulo (%), todos los métodos y propiedades del objeto Math.

Flash Player 4 no admite estos operadores y funciones originalmente. Flash 5
debe exportarlos como aproximaciones de series. Esto quiere decir que los
resultados son solamente aproximados. Además, debido a la inclusión de
aproximaciones de series en el archivo SWF, estas funciones ocupan más
espacio en los archivos SWF de Flash 4 que en los archivos SWF de Flash 5.

• Las acciones for, while, do while, break y continue.

• Las acciones print y printAsBitmap.

Programación de Scripts en ActionScript 89

Las siguientes funciones de Flash 5 no pueden utilizarse en películas exportadas al
formato de archivo SWF de Flash 4:

• Funciones personalizadas

• Soporte XML

• Variables locales

• Objetos predefinidos (excepto objetos Math)

• Acciones de clip de película

• Tipos de datos múltiples

• eval con sintaxis de punto (por ejemplo,

eval("_root.movieclip.variable"))

• return

• new

• delete

• typeof

• for...in

• keycode

• targetPath

• escape

• globalToLocal y localToGlobal

• hitTest

• isFinite y inNaN

• parseFloat y parseInt

• tunescape

• _xmouse y _ymouse

• _quality

Capítulo 290

CAPÍTULO 3

Interactividad con ActionScript

.............................................................................................................

Una película interactiva toma en cuenta a la audiencia. Mediante el teclado,
el ratón o ambos, la audiencia puede acceder a distintas partes de las películas,
mover objetos, introducir información, hacer clic en botones y llevar a cabo
muchas otras operaciones interactivas.

Como desarrollador, usted crea su película interactiva con scripts, cuyas
especificaciones establecen que se deberán ejecutar cuando se presenten eventos
específicos. Los eventos que ocasionan que se accione un script se dan cuando la
cabeza lectora llega a un fotograma, cuando se carga o descarga un clip de película
o cuando el usuario hace clic con el ratón o presiona una tecla del teclado.
ActionScript se utiliza para crear scripts que indican a Flash la acción que debe
llevar a cabo cuando ocurra el evento.

Las siguientes acciones básicas son modos comunes de control de la navegación
e interacción del usuario en una película:

• Reproducción y detención de películas

• Ajuste de la calidad de visualización de una película

• Detención de todos los sonidos

• Salto a fotogramas o a escenas

• Salto a otras URL

• Comprobación de carga de fotogramas

• Carga y descarga de películas adicionales

Si desea obtener información detallada sobre estas acciones, consulte

Utilización de Flash.

3

91

Si desea crear una interactividad de mayor nivel de complejidad, es necesario que
comprenda las siguientes técnicas:

• Creación de un cursor personalizado

• Obtención de la posición del ratón

• Captura de presión de una tecla

• Creación de un campo de texto desplazable

• Establecimiento de los valores del color

• Creación de controles de sonido

• Detección de colisiones

Creación de un cursor personalizado

Para ocultar el cursor estándar (es decir, la representación en pantalla del
puntero del ratón), puede utilizar el método hide del objeto predefinido Mouse.
Para utilizar un clip de película como el cursor personalizado, puede utilizar la
acción startDrag.

Acciones asociadas a un clip de película para crear un cursor personalizado

Capítulo 392

Para crear un cursor personalizado:

1 Cree un clip de película para utilizarlo como cursor personalizado.

2 Seleccione el clip de película en el Escenario.

3 Seleccione Ventana > Acciones para abrir el panel Acciones de objeto.

4 En la lista de la Caja de herramientas, seleccione Objetos; después seleccione

Mouse y arrastre hide a la ventana Script.

El código deberá ser similar al siguiente:

onClipEvent(load){

Mouse.hide();

}

5

En la lista de la Caja de herramientas, seleccione Acciones; después arrastre

startDrag a la ventana Script.

6 Active el cuadro Bloquear ratón al centro.

El código deberá ser similar al siguiente:

onClipEvent(load){

Mouse.hide()
startDrag(this, true);

}

7

Seleccione Control > Probar película para utilizar el cursor personalizado.

Los botones seguirán funcionado cuando utilice un cursor personalizado. Es una
buena idea colocar el cursor personalizado en la capa superior de la Línea de
tiempo de modo que se mueva por encima de los botones y de otros objetos
cuando desplace el ratón por la película.

Si desea obtener más información sobre los métodos del objeto Mouse, consulte el
Capítulo 7, “Diccionario de ActionScript”.

Interactividad con ActionScript 93

Obtención de la posición del ratón

Puede utilizar las propiedades _xmouse e _ymouse para encontrar la ubicación
del puntero del ratón (cursor) en una película. Cada Línea de tiempo tiene una
propiedad _xmouse e _ymouse que devuelven la ubicación del ratón dentro de
su sistema de coordenadas.

Las propiedades _xmouse e _ymouse en la Línea de tiempo principal y en la Línea
de tiempo de un clip de película

La siguiente sentencia podría colocarse en cualquier Línea de tiempo de la película

_level0 para que devuelva la posición _xmouse en la Línea de tiempo principal:

x_pos = _root._xmouse;

Para determinar la posición del ratón dentro de un clip de película, puede utilizar
el nombre de instancia del clip de película. Por ejemplo, la siguiente sentencia
podría colocarse en cualquier Línea de tiempo de la película _level0 para que
devuelva la posición

y_pos = _root.myMovieClip._ymouse

Capítulo 394

_ymouse en la instancia myMovieClip:

También puede determinar la posición del ratón en un clip de película
utilizando las propiedades _xmouse e _ymouse en una acción de clip, como
se muestra a continuación:

onClipEvent(enterFrame){

xmousePosition = _xmouse;
ymousePosition = _ymouse;

}

Las variables x_pos e y_pos se utilizan como contenedores para guardar los
valores de las posiciones del ratón. Puede utilizar estas variables en cualquier script
de su película. En el siguiente ejemplo, los valores de x_pos e y_pos se actualizan
cada vez que el usuario mueve el ratón.

onClipEvent(mouseMove){

x_pos = _root._xmouse;
y_pos = _root._ymouse;

}

Si desea obtener más información sobre las propiedades _xmouse e _ymouse,
consulte el Capítulo 7, “Diccionario de ActionScript”.

Captura de presión de una tecla

Puede utilizar los métodos del objeto predefinido Key para detectar la ultima
tecla que ha sido presionada por el usuario. El objeto Key no requiere una función
constructora, para utilizar sus métodos, simplemente llame al propio objeto, como
se muestra en el siguiente ejemplo:

Key.getCode();

Puede obtener códigos de tecla virtuales o valores ASCII de la tecla que ha
sido presionada:

• Para obtener el código de tecla virtual de la última tecla presionada, utilice

el método getCode.

• Para obtener el valor ASCII de la última tecla presionada, utilice el

método getAscii.

Se asigna un código de tecla virtual a cada tecla física del teclado. Por ejemplo,
la tecla de flecha izquierda tiene el código virtual 37. Utilizando el código de tecla
virtual, puede asegurarse de que los controles de su película son los mismos en
cualquier teclado sin tener en cuenta el lenguaje o la plataforma.

Los valores ASCII (código americano estándar para intercambio de información)
se asignan a los primeros 127 caracteres de todos los conjuntos de caracteres.
Los valores ASCII proporcionan información sobre un carácter de la pantalla.
Por ejemplo, la letra “A” y la letra “a” tiene diferentes valores ASCII.

Interactividad con ActionScript 95

Comunmente se utiliza Key.getCode en un controlador onClipEvent. Pasando

keyDown como parámetro, el controlador ordena a ActionScript que compruebe el

valor de la última tecla presionada sólo cuando realmente se presiona la tecla. Este
ejemplo usa

Key.getCode en una sentencia if para crear controles de navegación

para la nave espacial.

Para crear controles de teclado para una película:

1 Decida qué teclas va a utilizar y determine sus códigos virtuales utilizando

alguno de los siguientes métodos:

• Consulte la lista de códigos de tecla del Apéndice B, “Teclas del teclado y

valores de códigos de tecla”.

• Utilice una constante de objeto Key. (En la lista de la Caja de herramientas,

seleccione Objetos y a continuación Key. Las constantes de la lista aparecen
en mayúsculas).

• Asigne la siguiente acción de clip, después seleccione Control > Probar película

y presione la tecla que desee.

onClipEvent(keyDown) {

trace(Key.getCode());

}

2

Seleccione un clip de película en el Escenario.

3 Seleccione Ventana > Acciones.

4 Haga doble clic sobre la acción onClipEvent en la categoría Acciones de la caja

de herramientas.

5 Seleccione el evento Key down en el panel de parámetros.

6 Haga doble clic sobre la acción if en la categoría Acciones de la caja

de herramientas.

7 Haga clic sobre el parámetro Condition, seleccione Objects y después

Key y getCode.

8 Haga doble clic sobre el operador de igualdad (==) en la categoría Operadores

de la caja de herramientas.

Capítulo 396

9

Introduzca el código de tecla virtual a la derecha del operador de igualdad.

El código deberá ser similar al siguiente:

onClipEvent(keyDown) {

if (Key.getCode() == 32) {
}

}

10

Seleccione una acción a llevar a cabo si se presiona la tecla correcta.

Por ejemplo, la siguiente acción hace que la Línea de tiempo principal vaya
al siguiente fotograma cuando se presiona la Barra espaciadora (32).

onClipEvent(keyDown) {

if (Key.getCode() == 32) {

nextFrame();

}

}

Si desea obtener más información sobre los métodos del objeto Key, consulte
el Capítulo 7, “Diccionario de ActionScript”.

Creación de un campo de texto desplazable

Puede utilizar las propiedades scroll y maxscroll para crear un campo de
texto desplazable.

En el panel Opciones de texto, puede asignar una variable a cualquier campo
de texto establecido como Introducción de texto o Texto dinámico. El campo
de texto actúa como una ventana que indica el valor de esa variable.

Cada variable asociada con un campo de texto tiene una propiedad scroll y
una propiedad maxscroll. Puede utilizar estas propiedades para desplazar texto
en un campo de texto. La propiedad scroll devuelve el número de la línea
superior visible en un campo de texto y puede establecerla o recuperarla. La
propiedad maxscroll devuelve la línea superior visible de un campo de texto
cuando la línea inferior está visible, puede leer, pero no establecer esta propiedad.

Interactividad con ActionScript 97

Por ejemplo, suponga que tiene un campo de texto que dispone de cuatro líneas.
Si este campo contiene la variable

speech que tiene nueve líneas de texto,

solamente cuatro de las líneas se visualizarían en el campo de texto, como se
muestra en el recuadro sólido:

Propiedad scroll

Propiedad maxscroll

Campo de texto visible

Puede acceder a estas propiedades utilizando la sintaxis de punto, como se muestra
a continuación:

textFieldVariable.scroll
myMovieClip.textFieldVariable.scroll
textFieldVariable.maxscroll
myMovieClip.textFieldVariable.maxscroll

Para crear un campo de texto con desplazable:

1 Arrastre un campo de texto al Escenario.

2 Seleccione Ventana > Paneles > Opciones de texto.

3 Elija Introducción de texto en el menú emergente.

4 Introduzca el nombre de variable text en el campo Variable.

5 Arrastre la esquina inferior derecha del campo de texto para cambiar el tamaño

del campo de texto.

6 Seleccione Ventana > Acciones.

Capítulo 398

7

Seleccione el fotograma 1 en la Línea de tiempo principal y asigne una acción

set variable que establezca el valor de text.

No aparecerá texto en el campo hasta que se haya establecido la variable. Por lo
tanto, aunque puede asignar esta acción a cualquier fotograma, botón o clip de
película, es buena idea asignar la acción al fotograma 1 en la Línea de tiempo
principal, como se muestra a continuación:

8 Seleccione Ventana > Bibliotecas comunes > Botones y arrastre un botón

hasta el Escenario.

9 Pulse Alt (en Windows) o bien Opción (en Macintosh) y arrastre el botón

para crear una copia.

10 Seleccione el botón superior y elija Ventana > Acciones.

11 Arrastre la acción set variables desde la caja de herramientas hasta la

ventana Script en el panel Acciones.

12 Introduzca text.scroll en el cuadro Variable.

13 Introduzca text.scroll -1 en el cuadro Valor y active la casilla de

verificación Expresión.

14 Seleccione el botón de flecha hacia abajo y asigne la siguiente acción

set variables:

text.scroll = text.scroll+1;

15

Seleccione Control > Probar película para comprobar el campo de
texto desplazable.

Si desea obtener más información sobre las propiedades scroll y maxscroll,
consulte el Capítulo 7, “Diccionario de ActionScript”.

Interactividad con ActionScript 99

Establecimiento de los valores de color

Puede utilizar los métodos del objeto predefinido Color para ajustar el color de un
clip de película. El método setRGB asigna valores hexadecimales RGB (rojo, verde,
azul) al objeto y el método setTransform establece el porcentaje de valores de
desplazamiento para los componentes rojo, verde, azul y transparencia (alfa) de
un color. El siguiente ejemplo utiliza setRGB para cambiar el color de un objeto
basándose en la información introducida por el usuario.

La acción del botón crea un objeto de color y cambia el color de la camiseta basándose
en la información introducida por el usuario.

Para utilizar el objeto Color, necesita crear una instancia del objeto y aplicarla a un
clip de película.

Para establecer el valor de color de un clip de película:

1 Seleccione un clip de película en el Escenario y elija Ventana >

Paneles > Instancia.

2 Introduzca el nombre de instancia colorTarget en el cuadro Nombre.
3 Arrastre un campo de texto al Escenario.
4 Seleccione Ventana > Paneles > Opciones de texto y asígnele el nombre

de variable input.

5 Arrastre un botón al Escenario y selecciónelo.

6 Seleccione Ventana > Acciones.

Capítulo 3100